@open-mercato/cli 0.6.1-develop.3287.1.450f4ffb56 → 0.6.1-develop.3306.1.9ad9ff2526

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.1-develop.3287.1.450f4ffb56",
+  "version": "0.6.1-develop.3306.1.9ad9ff2526",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -59,8 +59,8 @@
     "@mikro-orm/decorators": "^7.0.15",
     "@mikro-orm/migrations": "^7.0.15",
     "@mikro-orm/postgresql": "^7.0.15",
-    "@open-mercato/queue": "0.6.1-develop.3287.1.450f4ffb56",
-    "@open-mercato/shared": "0.6.1-develop.3287.1.450f4ffb56",
+    "@open-mercato/queue": "0.6.1-develop.3306.1.9ad9ff2526",
+    "@open-mercato/shared": "0.6.1-develop.3306.1.9ad9ff2526",
     "cross-spawn": "^7.0.6",
     "pg": "8.20.0",
     "semver": "^7.8.0",
@@ -70,10 +70,10 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.1-develop.3287.1.450f4ffb56"
+    "@open-mercato/shared": "0.6.1-develop.3306.1.9ad9ff2526"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.1-develop.3287.1.450f4ffb56",
+    "@open-mercato/shared": "0.6.1-develop.3306.1.9ad9ff2526",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.9"

package/src/__tests__/mercato.test.ts

@@ -62,6 +62,16 @@ const eventsWorkerFixture: Pick<Module, 'id' | 'workers'> = {
   ],
 }
 
+const schedulerCliFixture: Pick<Module, 'id' | 'cli'> = {
+  id: 'scheduler',
+  cli: [
+    {
+      command: 'start',
+      run: jest.fn(),
+    },
+  ],
+}
+
 describe('mercato CLI module registration', () => {
   beforeEach(() => {
     // Reset module state by re-importing
@@ -620,6 +630,7 @@ describe('server dev managed process exits', () => {
   const originalAutoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER
   const originalAutoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS
   const originalLazy = process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+  const originalLazyScheduler = process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
 
   beforeEach(() => {
     jest.restoreAllMocks()
@@ -627,6 +638,7 @@ describe('server dev managed process exits', () => {
     process.env.AUTO_SPAWN_SCHEDULER = 'false'
     process.env.AUTO_SPAWN_WORKERS = 'true'
     delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+    delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
   })
 
   afterEach(() => {
@@ -636,8 +648,10 @@ describe('server dev managed process exits', () => {
     jest.dontMock('../lib/generators')
     jest.dontMock('../lib/resolver')
     jest.dontMock('../lib/queue-worker-supervisor')
+    jest.dontMock('../lib/scheduler-supervisor')
     jest.resetModules()
     delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+    delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
   })
 
   afterAll(() => {
@@ -645,6 +659,8 @@ describe('server dev managed process exits', () => {
     process.env.AUTO_SPAWN_WORKERS = originalAutoSpawnWorkers
     if (originalLazy === undefined) delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
     else process.env.OM_AUTO_SPAWN_WORKERS_LAZY = originalLazy
+    if (originalLazyScheduler === undefined) delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
+    else process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY = originalLazyScheduler
   })
 
   it('skips scheduler auto-start when the module is not enabled', async () => {
@@ -801,12 +817,79 @@ describe('server dev managed process exits', () => {
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
+
+  it('starts the lazy scheduler supervisor instead of the scheduler process when OM_AUTO_SPAWN_SCHEDULER_LAZY=true', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_SCHEDULER = 'true'
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+    process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY = 'true'
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          candidate.includes('next/dist/bin/next') || candidate.includes('@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+      }
+    })
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+
+    const schedulerClose = jest.fn().mockResolvedValue(undefined)
+    const startLazySchedulerSupervisor = jest.fn(() => ({
+      started: false,
+      getActiveChild: () => undefined,
+      close: schedulerClose,
+      done: Promise.resolve(),
+    }))
+    jest.doMock('../lib/scheduler-supervisor', () => ({
+      startLazySchedulerSupervisor,
+    }))
+
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) =>
+        args[0]?.includes('next/dist/bin/next') ? { code: null, signal: 'SIGTERM' } : undefined,
+      ),
+    )
+
+    const mercado = await import('../mercato')
+    mercado.registerCliModules([schedulerCliFixture as Module])
+
+    const exitCode = await mercado.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(0)
+    expect(startLazySchedulerSupervisor).toHaveBeenCalledTimes(1)
+    const supervisorCall = startLazySchedulerSupervisor.mock.calls[0][0]
+    expect(supervisorCall.pollMs).toBe(1000)
+    expect(supervisorCall.restartOnUnexpectedExit).toBe(true)
+    expect(schedulerClose).toHaveBeenCalled()
+
+    const { spawn } = await import('child_process')
+    const allSpawnCalls = (spawn as jest.Mock).mock.calls.map((call) => call[1] as string[])
+    const schedulerSpawn = allSpawnCalls.find((args) => args.slice(1).join(' ') === 'scheduler start')
+    expect(schedulerSpawn).toBeUndefined()
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
 })
 
 describe('server start managed process exits', () => {
   const originalAutoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER
   const originalAutoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS
   const originalLazy = process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+  const originalLazyScheduler = process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
 
   beforeEach(() => {
     jest.restoreAllMocks()
@@ -814,6 +897,7 @@ describe('server start managed process exits', () => {
     process.env.AUTO_SPAWN_SCHEDULER = 'false'
     process.env.AUTO_SPAWN_WORKERS = 'true'
     delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+    delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
   })
 
   afterEach(() => {
@@ -822,8 +906,10 @@ describe('server start managed process exits', () => {
     jest.dontMock('../lib/resolver')
     jest.dontMock('../lib/server-start-lock')
     jest.dontMock('../lib/queue-worker-supervisor')
+    jest.dontMock('../lib/scheduler-supervisor')
     jest.resetModules()
     delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
+    delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
   })
 
   afterAll(() => {
@@ -831,6 +917,8 @@ describe('server start managed process exits', () => {
     process.env.AUTO_SPAWN_WORKERS = originalAutoSpawnWorkers
     if (originalLazy === undefined) delete process.env.OM_AUTO_SPAWN_WORKERS_LAZY
     else process.env.OM_AUTO_SPAWN_WORKERS_LAZY = originalLazy
+    if (originalLazyScheduler === undefined) delete process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY
+    else process.env.OM_AUTO_SPAWN_SCHEDULER_LAZY = originalLazyScheduler
   })
 
   it('skips scheduler auto-start when the module is not enabled', async () => {

package/src/lib/__tests__/auto-spawn-scheduler.test.ts

@@ -0,0 +1,63 @@
+import {
+  resolveAutoSpawnSchedulerEnabled,
+  resolveAutoSpawnSchedulerLazy,
+  resolveAutoSpawnSchedulerMode,
+  resolveLazySchedulerPollMs,
+  resolveLazySchedulerRestart,
+} from '../auto-spawn-scheduler'
+
+describe('auto scheduler spawn env resolution', () => {
+  it('defaults to eager scheduler auto-spawn', () => {
+    expect(resolveAutoSpawnSchedulerMode({})).toBe('eager')
+    expect(resolveAutoSpawnSchedulerEnabled({})).toBe(true)
+    expect(resolveAutoSpawnSchedulerLazy({})).toBe(false)
+  })
+
+  it('returns off when AUTO_SPAWN_SCHEDULER=false', () => {
+    expect(resolveAutoSpawnSchedulerMode({ AUTO_SPAWN_SCHEDULER: 'false' })).toBe('off')
+  })
+
+  it('returns off when OM_AUTO_SPAWN_SCHEDULER=false and legacy unset', () => {
+    expect(resolveAutoSpawnSchedulerMode({ OM_AUTO_SPAWN_SCHEDULER: 'false' })).toBe('off')
+  })
+
+  it('legacy AUTO_SPAWN_SCHEDULER=true wins over OM_AUTO_SPAWN_SCHEDULER=false', () => {
+    expect(resolveAutoSpawnSchedulerMode({
+      AUTO_SPAWN_SCHEDULER: 'true',
+      OM_AUTO_SPAWN_SCHEDULER: 'false',
+    })).toBe('eager')
+  })
+
+  it('returns lazy when scheduler is enabled and OM_AUTO_SPAWN_SCHEDULER_LAZY=true', () => {
+    expect(resolveAutoSpawnSchedulerMode({
+      AUTO_SPAWN_SCHEDULER: 'true',
+      OM_AUTO_SPAWN_SCHEDULER_LAZY: 'true',
+    })).toBe('lazy')
+  })
+
+  it('lazy is ignored when AUTO_SPAWN_SCHEDULER=false', () => {
+    expect(resolveAutoSpawnSchedulerMode({
+      AUTO_SPAWN_SCHEDULER: 'false',
+      OM_AUTO_SPAWN_SCHEDULER_LAZY: 'true',
+    })).toBe('off')
+  })
+
+  it('treats invalid AUTO_SPAWN_SCHEDULER values as default', () => {
+    expect(resolveAutoSpawnSchedulerMode({ AUTO_SPAWN_SCHEDULER: 'maybe' })).toBe('eager')
+  })
+
+  it('resolves and clamps the lazy scheduler poll interval', () => {
+    expect(resolveLazySchedulerPollMs({})).toBe(1000)
+    expect(resolveLazySchedulerPollMs({ OM_AUTO_SPAWN_SCHEDULER_LAZY_POLL_MS: '500' })).toBe(500)
+    expect(resolveLazySchedulerPollMs({ OM_AUTO_SPAWN_SCHEDULER_LAZY_POLL_MS: '50' })).toBe(250)
+    expect(resolveLazySchedulerPollMs({ OM_AUTO_SPAWN_SCHEDULER_LAZY_POLL_MS: 'abc' })).toBe(1000)
+    expect(resolveLazySchedulerPollMs({ OM_AUTO_SPAWN_SCHEDULER_LAZY_POLL_MS: '0' })).toBe(1000)
+  })
+
+  it('defaults lazy scheduler restart to enabled', () => {
+    expect(resolveLazySchedulerRestart({})).toBe(true)
+    expect(resolveLazySchedulerRestart({ OM_AUTO_SPAWN_SCHEDULER_LAZY_RESTART: 'false' })).toBe(false)
+    expect(resolveLazySchedulerRestart({ OM_AUTO_SPAWN_SCHEDULER_LAZY_RESTART: 'true' })).toBe(true)
+    expect(resolveLazySchedulerRestart({ OM_AUTO_SPAWN_SCHEDULER_LAZY_RESTART: 'maybe' })).toBe(true)
+  })
+})

package/src/lib/__tests__/scheduler-supervisor.test.ts

@@ -0,0 +1,199 @@
+import { EventEmitter } from 'node:events'
+import type { ChildProcess } from 'node:child_process'
+import {
+  startLazySchedulerSupervisor,
+  type LazySchedulerSupervisorProbeFn,
+  type LazySchedulerSupervisorSpawnFn,
+} from '../scheduler-supervisor'
+
+type FakeChild = ChildProcess & {
+  triggerExit: (code: number | null, signal?: NodeJS.Signals | null) => void
+}
+
+function createFakeChild(): FakeChild {
+  const child = new EventEmitter() as unknown as FakeChild
+  ;(child as any).stdout = null
+  ;(child as any).stderr = null
+  ;(child as any).pid = Math.floor(Math.random() * 100000) + 1
+  ;(child as any).killed = false
+  ;(child as any).exitCode = null
+  ;(child as any).signalCode = null
+  ;(child as any).kill = jest.fn((signal: NodeJS.Signals = 'SIGTERM') => {
+    if ((child as any).killed) return true
+    ;(child as any).killed = true
+    ;(child as any).signalCode = signal
+    process.nextTick(() => child.emit('exit', null, signal))
+    return true
+  })
+  child.triggerExit = (code, signal = null) => {
+    ;(child as any).exitCode = code
+    ;(child as any).signalCode = signal
+    child.emit('exit', code, signal)
+  }
+  return child
+}
+
+const silentLogger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() }
+
+async function flushAsync(times = 5): Promise<void> {
+  for (let i = 0; i < times; i++) {
+    // eslint-disable-next-line no-await-in-loop
+    await Promise.resolve()
+  }
+}
+
+describe('startLazySchedulerSupervisor', () => {
+  it('does not spawn the scheduler while no enabled schedules exist', async () => {
+    const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySchedulerSupervisorSpawnFn>
+    const probeFn = jest.fn(async () => ({
+      enabledSchedules: 0,
+      dueSchedules: 0,
+      error: false,
+    })) as jest.MockedFunction<LazySchedulerSupervisorProbeFn>
+
+    const handle = startLazySchedulerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(probeFn).toHaveBeenCalled()
+    expect(spawnFn).not.toHaveBeenCalled()
+    expect(handle.started).toBe(false)
+
+    await handle.close()
+  })
+
+  it('spawns the existing scheduler command after an enabled schedule appears', async () => {
+    const child = createFakeChild()
+    const spawnFn = jest.fn(() => child) as unknown as jest.MockedFunction<LazySchedulerSupervisorSpawnFn>
+    const probeFn = jest.fn(async () => ({
+      enabledSchedules: 1,
+      dueSchedules: 0,
+      error: false,
+    })) as jest.MockedFunction<LazySchedulerSupervisorProbeFn>
+
+    const handle = startLazySchedulerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      pollMs: 250,
+      restartOnUnexpectedExit: false,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+
+    expect(spawnFn).toHaveBeenCalledTimes(1)
+    const [command, args] = spawnFn.mock.calls[0]
+    expect(command).toBe('node')
+    expect(args).toEqual(['/tmp/mercato', 'scheduler', 'start'])
+    expect(handle.started).toBe(true)
+
+    await flushAsync(20)
+    expect(spawnFn).toHaveBeenCalledTimes(1)
+
+    await handle.close()
+  })
+
+  it('does not spawn when the probe reports an error', async () => {
+    const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySchedulerSupervisorSpawnFn>
+    const probeFn = jest.fn(async () => ({
+      enabledSchedules: 0,
+      dueSchedules: 0,
+      error: true,
+      errorMessage: 'database unavailable',
+    })) as jest.MockedFunction<LazySchedulerSupervisorProbeFn>
+
+    const handle = startLazySchedulerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(spawnFn).not.toHaveBeenCalled()
+
+    await handle.close()
+  })
+
+  it('terminates the scheduler child on close()', async () => {
+    const child = createFakeChild()
+    const spawnFn = jest.fn(() => child) as unknown as jest.MockedFunction<LazySchedulerSupervisorSpawnFn>
+    const probeFn = jest.fn(async () => ({
+      enabledSchedules: 1,
+      dueSchedules: 1,
+      error: false,
+    })) as jest.MockedFunction<LazySchedulerSupervisorProbeFn>
+
+    const handle = startLazySchedulerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    await handle.close()
+
+    expect((child as any).kill).toHaveBeenCalledWith('SIGTERM')
+  })
+
+  it('restarts an unexpectedly exited scheduler only while schedules still exist', async () => {
+    const firstChild = createFakeChild()
+    const secondChild = createFakeChild()
+    const spawnFn = jest
+      .fn()
+      .mockImplementationOnce(() => firstChild)
+      .mockImplementationOnce(() => secondChild) as unknown as jest.MockedFunction<LazySchedulerSupervisorSpawnFn>
+
+    let enabledSchedules = 1
+    const probeFn = jest.fn(async () => ({
+      enabledSchedules,
+      dueSchedules: enabledSchedules,
+      error: false,
+    })) as jest.MockedFunction<LazySchedulerSupervisorProbeFn>
+
+    const handle = startLazySchedulerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(spawnFn).toHaveBeenCalledTimes(1)
+
+    firstChild.triggerExit(1, null)
+    await flushAsync(40)
+    expect(spawnFn).toHaveBeenCalledTimes(2)
+
+    enabledSchedules = 0
+    secondChild.triggerExit(1, null)
+    await flushAsync(40)
+    expect(spawnFn).toHaveBeenCalledTimes(2)
+
+    await handle.close()
+  })
+})

package/src/lib/auto-spawn-scheduler.ts

@@ -0,0 +1,39 @@
+import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
+
+export type AutoSpawnSchedulerMode = 'off' | 'eager' | 'lazy'
+
+export type AutoSpawnSchedulerEnvSource = Pick<NodeJS.ProcessEnv, string> | Record<string, string | undefined>
+
+const DEFAULT_LAZY_SCHEDULER_POLL_MS = 1000
+const MIN_LAZY_SCHEDULER_POLL_MS = 250
+
+export function resolveAutoSpawnSchedulerEnabled(env: AutoSpawnSchedulerEnvSource = process.env): boolean {
+  const legacy = parseBooleanToken(env.AUTO_SPAWN_SCHEDULER)
+  if (legacy !== null) return legacy
+  const aliased = parseBooleanToken(env.OM_AUTO_SPAWN_SCHEDULER)
+  if (aliased !== null) return aliased
+  return true
+}
+
+export function resolveAutoSpawnSchedulerLazy(env: AutoSpawnSchedulerEnvSource = process.env): boolean {
+  return parseBooleanToken(env.OM_AUTO_SPAWN_SCHEDULER_LAZY) === true
+}
+
+export function resolveAutoSpawnSchedulerMode(env: AutoSpawnSchedulerEnvSource = process.env): AutoSpawnSchedulerMode {
+  if (!resolveAutoSpawnSchedulerEnabled(env)) return 'off'
+  if (resolveAutoSpawnSchedulerLazy(env)) return 'lazy'
+  return 'eager'
+}
+
+export function resolveLazySchedulerPollMs(env: AutoSpawnSchedulerEnvSource = process.env): number {
+  const raw = env.OM_AUTO_SPAWN_SCHEDULER_LAZY_POLL_MS
+  if (typeof raw !== 'string' || raw.trim() === '') return DEFAULT_LAZY_SCHEDULER_POLL_MS
+  const parsed = Number(raw)
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_LAZY_SCHEDULER_POLL_MS
+  return Math.max(MIN_LAZY_SCHEDULER_POLL_MS, Math.floor(parsed))
+}
+
+export function resolveLazySchedulerRestart(env: AutoSpawnSchedulerEnvSource = process.env): boolean {
+  const parsed = parseBooleanToken(env.OM_AUTO_SPAWN_SCHEDULER_LAZY_RESTART)
+  return parsed === null ? true : parsed
+}

package/src/lib/db/__tests__/commands.test.ts

@@ -5,11 +5,14 @@ import {
   getMigrationSnapshotName,
   shouldCreateInitialModuleMigration,
   resolveGeneratedMigrationPath,
+  dbGenerate,
   dbGreenfield,
 } from '../commands'
+import { MetadataStorage } from '@mikro-orm/core'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import type { ModuleEntry, PackageResolver } from '../../resolver'
 
 describe('db commands security', () => {
   describe('sanitizeModuleId', () => {
@@ -245,3 +248,102 @@ describe('db commands', () => {
     })
   })
 })
+
+describe('dbGenerate metadata isolation (issue #1911)', () => {
+  // Regression test for https://github.com/open-mercato/open-mercato/issues/1911.
+  // Without per-iteration MetadataStorage.clear(), every module's migration
+  // accumulated the @Entity() decorator registrations from previously-loaded
+  // modules and therefore produced polluted CREATE TABLE statements. The fix
+  // is a single MetadataStorage.clear() call at the top of every iteration of
+  // the dbGenerate loop. The test verifies that the clear is invoked once per
+  // iteration and that it actually wipes any pre-existing global metadata
+  // entries (the practical pollution vector that caused the bug).
+
+  const tempDirs: string[] = []
+  let clearSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    process.env.DATABASE_URL = process.env.DATABASE_URL || 'postgres://noop@localhost:5432/test'
+    MetadataStorage.clear()
+    clearSpy = jest.spyOn(MetadataStorage, 'clear')
+  })
+
+  afterEach(() => {
+    clearSpy.mockRestore()
+    for (const dir of tempDirs.splice(0)) {
+      try { fs.rmSync(dir, { recursive: true, force: true }) } catch {}
+    }
+    MetadataStorage.clear()
+  })
+
+  function createTempModule(id: string): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `mercato-mod-${id}-`))
+    tempDirs.push(dir)
+    fs.mkdirSync(path.join(dir, 'data'), { recursive: true })
+    fs.mkdirSync(path.join(dir, 'migrations'), { recursive: true })
+    fs.writeFileSync(path.join(dir, 'migrations', '.snapshot-open-mercato.json'), '{}', 'utf8')
+    fs.writeFileSync(
+      path.join(dir, 'data', 'entities.ts'),
+      `export class TestEntity_${id} {}\n`,
+      'utf8',
+    )
+    return dir
+  }
+
+  function createMockResolver(modules: { id: string; dir: string }[]): PackageResolver {
+    const entries: ModuleEntry[] = modules.map((m) => ({ id: m.id, from: '@app' as const }))
+    const byId = new Map(modules.map((m) => [m.id, m.dir]))
+    return {
+      isMonorepo: () => true,
+      getRootDir: () => '/tmp/test-root',
+      getAppDir: () => '/tmp/test-app',
+      getOutputDir: () => '/tmp/test-out',
+      getModulesConfigPath: () => '/tmp/test-root/modules.ts',
+      discoverPackages: () => [],
+      loadEnabledModules: () => entries,
+      getModulePaths: (entry: ModuleEntry) => {
+        const dir = byId.get(entry.id) ?? '/nonexistent'
+        return { appBase: dir, pkgBase: dir }
+      },
+      getModuleImportBase: (entry: ModuleEntry) => ({
+        appBase: `@/modules/${entry.id}`,
+        pkgBase: `@open-mercato/core/modules/${entry.id}`,
+      }),
+      getPackageOutputDir: () => '/tmp/test-out',
+      getPackageRoot: () => '/tmp/test-root',
+    }
+  }
+
+  it('calls MetadataStorage.clear() at the start of every module iteration', async () => {
+    const moduleA = { id: 'modulealpha', dir: createTempModule('modulealpha') }
+    const moduleB = { id: 'modulebeta', dir: createTempModule('modulebeta') }
+    const resolver = createMockResolver([moduleA, moduleB])
+
+    await dbGenerate(resolver)
+
+    // The fix adds one MetadataStorage.clear() at the top of every iteration of
+    // the dbGenerate loop. With two modules, clear must be invoked at least
+    // twice. Without the fix (the regression introduced by 3b0b8eb6a), clear is
+    // never invoked from dbGenerate at all.
+    expect(clearSpy.mock.calls.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('wipes pre-existing global metadata entries before processing each module', async () => {
+    // Simulate the @Entity decorator side effect from a previously-loaded
+    // module by manually registering a metadata entry. Without the fix, this
+    // entry would persist into the next module's MikroORM.init() and end up
+    // in its generated migration as an unrelated CREATE TABLE statement.
+    MetadataStorage.getMetadata('LingeringEntity', '/stale/path/lingering')
+    expect(Object.keys(MetadataStorage.getMetadata())).toHaveLength(1)
+
+    const moduleA = { id: 'modulealpha', dir: createTempModule('modulealpha') }
+    const resolver = createMockResolver([moduleA])
+
+    await dbGenerate(resolver)
+
+    // After dbGenerate runs, the clear must have wiped the stale entry. We
+    // observe the registry state at clear time AND after dbGenerate exits.
+    expect(clearSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+    expect(Object.keys(MetadataStorage.getMetadata())).toHaveLength(0)
+  })
+})

package/src/lib/db/commands.ts

@@ -2,7 +2,7 @@ import path from 'node:path'
 import fs from 'node:fs'
 import { pathToFileURL } from 'node:url'
 import ts from 'typescript'
-import { MikroORM, type Logger } from '@mikro-orm/core'
+import { MikroORM, MetadataStorage, type Logger } from '@mikro-orm/core'
 import { ReflectMetadataProvider } from '@mikro-orm/decorators/legacy'
 import { Migrator } from '@mikro-orm/migrations'
 import { PostgreSqlDriver } from '@mikro-orm/postgresql'
@@ -234,18 +234,19 @@ export async function dbGenerate(resolver: PackageResolver, options: DbOptions =
   const ordered = sortModules(modules)
   const results: string[] = []
 
-  const moduleClasses = new Map<string, any[]>()
-  for (const entry of ordered) {
-    moduleClasses.set(entry.id, await loadModuleEntities(entry, resolver))
-  }
-
   const sslConfig = getSslConfig()
   const usedFileNames = new Set<string>()
 
   for (const entry of ordered) {
+    // Clear the global @Entity() decorator registry before loading this module's
+    // entities. MikroORM's migrator reads MetadataStorage at createMigration()
+    // time, so without this clear, every module's migration would include every
+    // previously-loaded module's tables (see issue #1911).
+    MetadataStorage.clear()
+
     const modId = entry.id
     const sanitizedModId = sanitizeModuleId(modId)
-    const entities = moduleClasses.get(modId) ?? []
+    const entities = await loadModuleEntities(entry, resolver)
     if (!entities.length) {
       if (entry.from === '@app') {
         results.push(formatResult(modId, 'no entities discovered', ''))