fix(run-scripts): load WorkflowLoader during db:migrate so workflow hooks are registered (#15260)

## What

Workflow hooks defined in `src/workflows/` (and plugin workflow directories) are silently skipped during `medusa db:migrate` execution.

Closes #14125

## Root Cause

`loadResources()` in `packages/medusa/src/commands/db/run-scripts.ts` calls `LinkLoader` and `MedusaAppLoader` but never calls `WorkflowLoader`. This means any hook registered on a built-in workflow (e.g. `createProductsWorkflow.hooks.productsCreated`) does not fire when that workflow is invoked from a migration script — even though the workflow itself runs successfully and no error is thrown.

Compare to `packages/medusa/src/loaders/index.ts` (lines 205–207), where `WorkflowLoader` is already called with all plugin paths. That call was simply missing from `run-scripts.ts`.

## Fix

Add a `WorkflowLoader` call in `loadResources()` after `onApplicationStart()`, mirroring the exact pattern already used in `loaders/index.ts`:

```ts
const workflowsSourcePaths = plugins.map((plugin) =>
  join(plugin.resolve, "workflows")
)
await new WorkflowLoader(workflowsSourcePaths, container).load()
```

`getResolvedPlugins()` already includes the application root directory as a plugin entry (via the third `true` argument), so no additional path handling is needed.

## Changes

| File | Change |
|---|---|
| `packages/medusa/src/commands/db/run-scripts.ts` | Import `WorkflowLoader`; call it after `onApplicationStart()` in `loadResources()` |
| `packages/medusa/src/commands/__tests__/run-scripts.spec.ts` | Add `WorkflowLoader` mock; add 4 new tests covering path derivation, `load()` invocation, call ordering, and zero-plugin edge case |

## Testing

Four new unit tests added in the existing `run-scripts.spec.ts` test suite:

- **path derivation** — verifies `WorkflowLoader` is constructed with `<plugin.resolve>/workflows` paths and the caller's container
- **load() called** — verifies `WorkflowLoader.load()` is invoked exactly once
- **call ordering** — verifies `WorkflowLoader` runs *after* `onApplicationStart()` so all module registrations are available
- **zero-plugin edge case** — verifies behaviour when `getResolvedPlugins` returns an empty array

## Impact / Risk

- ✅ **Purely additive** — no existing behaviour is changed
- ✅ **Consistent** with `loaders/index.ts` which already uses this exact pattern
- ✅ **No breaking changes** — `WorkflowLoader` is a no-op when the source paths contain no workflow files

Co-authored-by: Akib <2947572+akib@users.noreply.github.com>

Author: AKIBUZZAMAN AKIB

.changeset/big-teachers-cheat.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/medusa": patch
+---
+
+fix(medusa): load WorkflowLoader during db:migrate so workflow hooks are registered

packages/medusa/src/commands/__tests__/run-scripts.spec.ts

@@ -6,6 +6,7 @@ import {
   ContainerRegistrationKeys,
   getResolvedPlugins,
 } from "@medusajs/framework/utils"
+import { WorkflowLoader } from "@medusajs/framework/workflows"
 import { MedusaContainer } from "@medusajs/types"
 import { runMigrationScripts } from "../db/run-scripts"
 
@@ -19,6 +20,10 @@ jest.mock("@medusajs/framework/links", () => ({
   LinkLoader: jest.fn(),
 }))
 
+jest.mock("@medusajs/framework/workflows", () => ({
+  WorkflowLoader: jest.fn(),
+}))
+
 jest.mock("@medusajs/framework/migrations", () => ({
   MigrationScriptsMigrator: jest.fn(),
 }))
@@ -100,6 +105,11 @@ describe("runMigrationScripts", () => {
       getPendingMigrations: jest.fn().mockResolvedValue([]),
       run: jest.fn().mockResolvedValue(undefined),
     }))
+
+    // WorkflowLoader mock
+    ;(WorkflowLoader as jest.Mock).mockImplementation(() => ({
+      load: jest.fn().mockResolvedValue(undefined),
+    }))
   })
 
   describe("container forwarding to MedusaAppLoader", () => {
@@ -228,4 +238,96 @@ describe("runMigrationScripts", () => {
       expect(MedusaModule.clearInstances).toHaveBeenCalledTimes(1)
     })
   })
+
+  describe("WorkflowLoader", () => {
+    it("instantiates WorkflowLoader with the resolved plugin workflow paths", async () => {
+      const plugins = [
+        { resolve: "/app" },
+        { resolve: "/plugins/my-plugin" },
+      ]
+      ;(getResolvedPlugins as jest.Mock).mockResolvedValue(plugins)
+
+      const container = buildContainer()
+
+      await runMigrationScripts({
+        directory: "/app",
+        container,
+        logger: mockLogger as any,
+      })
+
+      expect(WorkflowLoader).toHaveBeenCalledTimes(1)
+      const [paths, resolvedContainer] = (WorkflowLoader as jest.Mock).mock
+        .calls[0]
+      expect(paths).toEqual(["/app/workflows", "/plugins/my-plugin/workflows"])
+      expect(resolvedContainer).toBe(container)
+    })
+
+    it("calls WorkflowLoader.load() to register workflow hooks", async () => {
+      const container = buildContainer()
+      const mockLoad = jest.fn().mockResolvedValue(undefined)
+      ;(WorkflowLoader as jest.Mock).mockImplementation(() => ({
+        load: mockLoad,
+      }))
+
+      await runMigrationScripts({
+        directory: "/app",
+        container,
+        logger: mockLogger as any,
+      })
+
+      expect(mockLoad).toHaveBeenCalledTimes(1)
+    })
+
+    it("loads WorkflowLoader after MedusaAppLoader so module registrations are available", async () => {
+      const callOrder: string[] = []
+
+      ;(MedusaAppLoader as jest.Mock).mockImplementation(() => ({
+        load: jest.fn().mockImplementation(async () => {
+          callOrder.push("MedusaAppLoader.load")
+          return {
+            onApplicationPrepareShutdown: jest.fn().mockResolvedValue(undefined),
+            onApplicationShutdown: jest.fn().mockResolvedValue(undefined),
+            onApplicationStart: jest.fn().mockImplementation(async () => {
+              callOrder.push("onApplicationStart")
+            }),
+          }
+        }),
+      }))
+
+      ;(WorkflowLoader as jest.Mock).mockImplementation(() => ({
+        load: jest.fn().mockImplementation(async () => {
+          callOrder.push("WorkflowLoader.load")
+        }),
+      }))
+
+      const container = buildContainer()
+
+      await runMigrationScripts({
+        directory: "/app",
+        container,
+        logger: mockLogger as any,
+      })
+
+      const appStartIdx = callOrder.indexOf("onApplicationStart")
+      const wfLoaderIdx = callOrder.indexOf("WorkflowLoader.load")
+      expect(appStartIdx).toBeGreaterThanOrEqual(0)
+      expect(wfLoaderIdx).toBeGreaterThan(appStartIdx)
+    })
+
+    it("produces no workflow paths when there are no plugins", async () => {
+      ;(getResolvedPlugins as jest.Mock).mockResolvedValue([])
+
+      const container = buildContainer()
+
+      await runMigrationScripts({
+        directory: "/app",
+        container,
+        logger: mockLogger as any,
+      })
+
+      expect(WorkflowLoader).toHaveBeenCalledTimes(1)
+      const [paths] = (WorkflowLoader as jest.Mock).mock.calls[0]
+      expect(paths).toEqual([])
+    })
+  })
 })

packages/medusa/src/commands/db/run-scripts.ts

@@ -1,6 +1,7 @@
 import { MedusaAppLoader } from "@medusajs/framework"
 import { LinkLoader } from "@medusajs/framework/links"
 import { MigrationScriptsMigrator } from "@medusajs/framework/migrations"
+import { WorkflowLoader } from "@medusajs/framework/workflows"
 import {
   ContainerRegistrationKeys,
   getResolvedPlugins,
@@ -115,6 +116,16 @@ async function loadResources(
   const onApplicationShutdown = medusaAppResources.onApplicationShutdown
   await medusaAppResources.onApplicationStart()
 
+  // Load workflow hooks from all plugins (including the app directory,
+  // which getResolvedPlugins already includes as a plugin entry).
+  // Without this, workflow hooks defined in src/workflows/ are never
+  // registered during `medusa db:migrate`, causing them to silently
+  // skip execution even though the workflows themselves run successfully.
+  const workflowsSourcePaths = plugins.map((plugin) =>
+    join(plugin.resolve, "workflows")
+  )
+  await new WorkflowLoader(workflowsSourcePaths, container).load()
+
   return {
     onApplicationPrepareShutdown,
     onApplicationShutdown,