@open-mercato/cli 0.7.1-develop.7136.1.0f76137a1d → 0.7.1-develop.7148.1.3076e5ccf7

package/src/lib/db/__tests__/commands.migrate-reindex.test.ts

@@ -0,0 +1,189 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { MikroORM } from '@mikro-orm/core'
+import { dbMigrate } from '../commands'
+import type { ModuleEntry, PackageResolver } from '../../resolver'
+
+const collectQueryIndexReindexEntityTypes = jest.fn<Promise<string[]>, [any, any]>()
+const requestQueryIndexReindex = jest.fn<Promise<{ requested: string[]; queued: boolean }>, [any, any]>()
+const isMigrationReindexEnabled = jest.fn<boolean, []>()
+
+jest.mock('../migration-reindex', () => ({
+  collectQueryIndexReindexEntityTypes: (...args: any[]) => collectQueryIndexReindexEntityTypes(...(args as [any, any])),
+  requestQueryIndexReindex: (...args: any[]) => requestQueryIndexReindex(...(args as [any, any])),
+  isMigrationReindexEnabled: () => isMigrationReindexEnabled(),
+}))
+
+// `MikroORM.init` is stubbed with a spy rather than a module mock: `@mikro-orm/sql` extends the
+// real `MikroORM` class at import time, so replacing the module export breaks the driver import.
+const ormInit = jest.fn()
+
+type PendingPlan = { pending: string[]; failOn?: string }
+
+const tempDirs: string[] = []
+const ormCloses: string[] = []
+
+function createTempModule(id: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `mercato-migrate-${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, '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',
+  }
+}
+
+/**
+ * `dbMigrate` calls `MikroORM.init` once per module, in `sortModules` order. Each fake ORM serves
+ * that module's plan and records its own `close()`, so a test can assert both the discharge wiring
+ * and that no connection pool leaks when a migration throws.
+ */
+function stubOrmsFor(plans: Record<string, PendingPlan>): void {
+  ormInit.mockImplementation(async (config: any) => {
+    const moduleId = Object.keys(plans).find((id) => String(config.migrations.path).includes(`-${id}-`))
+    const plan = moduleId ? plans[moduleId] : { pending: [] }
+    return {
+      migrator: {
+        getPending: async () => plan.pending.map((name) => ({ name, path: null })),
+        up: async (options: { migrations?: string[] } = {}) => {
+          const name = options.migrations?.[0]
+          if (plan.failOn && name === plan.failOn) throw new Error(`migration ${name} failed`)
+        },
+      },
+      close: async () => {
+        if (moduleId) ormCloses.push(moduleId)
+      },
+    }
+  })
+}
+
+describe('dbMigrate discharges query-index reindex declarations', () => {
+  let logSpy: jest.SpyInstance
+  let warnSpy: jest.SpyInstance
+  let initSpy: jest.SpyInstance
+  let stdoutSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    process.env.DATABASE_URL = process.env.DATABASE_URL || 'postgres://noop@localhost:5432/test'
+    ormCloses.length = 0
+    ormInit.mockReset()
+    initSpy = jest.spyOn(MikroORM, 'init').mockImplementation((...args: any[]) => ormInit(...args))
+    collectQueryIndexReindexEntityTypes.mockReset()
+    requestQueryIndexReindex.mockReset()
+    isMigrationReindexEnabled.mockReset()
+    isMigrationReindexEnabled.mockReturnValue(true)
+    collectQueryIndexReindexEntityTypes.mockResolvedValue(['customers:customer_dictionary_entry'])
+    requestQueryIndexReindex.mockResolvedValue({
+      requested: ['customers:customer_dictionary_entry'],
+      queued: true,
+    })
+    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+    stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true)
+  })
+
+  afterEach(() => {
+    initSpy.mockRestore()
+    logSpy.mockRestore()
+    warnSpy.mockRestore()
+    stdoutSpy.mockRestore()
+    for (const dir of tempDirs.splice(0)) {
+      try { fs.rmSync(dir, { recursive: true, force: true }) } catch {}
+    }
+  })
+
+  it('queues a reindex for the migrations it applied, after every module closed its ORM', async () => {
+    const moduleA = { id: 'alpha', dir: createTempModule('alpha') }
+    const moduleB = { id: 'beta', dir: createTempModule('beta') }
+    stubOrmsFor({
+      alpha: { pending: ['Migration20260901120000_reindex_alpha'] },
+      beta: { pending: [] },
+    })
+
+    await dbMigrate(createMockResolver([moduleA, moduleB]))
+
+    expect(ormCloses).toEqual(['alpha', 'beta'])
+    const [applied] = collectQueryIndexReindexEntityTypes.mock.calls[0]
+    expect(applied).toEqual([
+      expect.objectContaining({ moduleId: 'alpha', name: 'Migration20260901120000_reindex_alpha' }),
+    ])
+    expect(applied[0].migrationsPath).toContain('migrations')
+    expect(requestQueryIndexReindex).toHaveBeenCalledTimes(1)
+    expect(requestQueryIndexReindex.mock.calls[0][0]).toEqual(['customers:customer_dictionary_entry'])
+  })
+
+  it('still discharges the declarations it already collected when a later migration throws', async () => {
+    // The failure this guards: `customers` applies and commits, `sales` then fails. Without an
+    // unconditional discharge the customers declaration is lost for good — a re-run never sees it
+    // again, because that migration is no longer pending.
+    const moduleA = { id: 'alpha', dir: createTempModule('alpha') }
+    const moduleB = { id: 'beta', dir: createTempModule('beta') }
+    stubOrmsFor({
+      alpha: { pending: ['Migration20260901120000_reindex_alpha'] },
+      beta: { pending: ['Migration20260901130000_broken'], failOn: 'Migration20260901130000_broken' },
+    })
+
+    await expect(dbMigrate(createMockResolver([moduleA, moduleB]))).rejects.toThrow(
+      'migration Migration20260901130000_broken failed',
+    )
+
+    expect(collectQueryIndexReindexEntityTypes).toHaveBeenCalledTimes(1)
+    expect(collectQueryIndexReindexEntityTypes.mock.calls[0][0]).toEqual([
+      expect.objectContaining({ moduleId: 'alpha', name: 'Migration20260901120000_reindex_alpha' }),
+    ])
+    expect(requestQueryIndexReindex).toHaveBeenCalledTimes(1)
+    // Both ORMs must have been closed even though the second module threw.
+    expect(ormCloses).toEqual(['alpha', 'beta'])
+  })
+
+  it('never lets a discharge failure replace the migration error the operator needs to see', async () => {
+    const moduleA = { id: 'alpha', dir: createTempModule('alpha') }
+    stubOrmsFor({
+      alpha: {
+        pending: ['Migration20260901120000_reindex_alpha', 'Migration20260901130000_broken'],
+        failOn: 'Migration20260901130000_broken',
+      },
+    })
+    collectQueryIndexReindexEntityTypes.mockRejectedValue(new Error('container refused to build'))
+
+    await expect(dbMigrate(createMockResolver([moduleA]))).rejects.toThrow(
+      'migration Migration20260901130000_broken failed',
+    )
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('container refused to build'))
+  })
+
+  it('skips the discharge entirely when the opt-out is set', async () => {
+    const moduleA = { id: 'alpha', dir: createTempModule('alpha') }
+    stubOrmsFor({ alpha: { pending: ['Migration20260901120000_reindex_alpha'] } })
+    isMigrationReindexEnabled.mockReturnValue(false)
+
+    await dbMigrate(createMockResolver([moduleA]))
+
+    expect(collectQueryIndexReindexEntityTypes).not.toHaveBeenCalled()
+    expect(requestQueryIndexReindex).not.toHaveBeenCalled()
+  })
+})

package/src/lib/db/__tests__/migration-reindex.test.ts

@@ -0,0 +1,203 @@
+import path from 'node:path'
+import {
+  collectQueryIndexReindexEntityTypes,
+  formatManualReindexInstructions,
+  isMigrationReindexEnabled,
+  requestQueryIndexReindex,
+  resolveMigrationFilePath,
+  type AppliedMigration,
+} from '../migration-reindex'
+
+const MIGRATIONS_PATH = '/repo/packages/core/src/modules/customers/migrations'
+
+function migration(name: string, overrides: Partial<AppliedMigration> = {}): AppliedMigration {
+  return { moduleId: 'customers', migrationsPath: MIGRATIONS_PATH, name, ...overrides }
+}
+
+describe('resolveMigrationFilePath', () => {
+  const existing = new Set([path.join(MIGRATIONS_PATH, 'Migration20260901120000_reindex.ts')])
+  const fileExists = (filePath: string) => existing.has(filePath)
+
+  it('resolves a bare migration name to its source file', () => {
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, 'Migration20260901120000_reindex', null, fileExists))
+      .toBe(path.join(MIGRATIONS_PATH, 'Migration20260901120000_reindex.ts'))
+  })
+
+  it('accepts a name that already carries its extension', () => {
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, 'Migration20260901120000_reindex.js', null, fileExists))
+      .toBe(path.join(MIGRATIONS_PATH, 'Migration20260901120000_reindex.ts'))
+  })
+
+  it('prefers a path the migrator already resolved', () => {
+    const known = path.join(MIGRATIONS_PATH, 'Migration20260901120000_reindex.ts')
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, 'anything', known, fileExists)).toBe(known)
+  })
+
+  it('keeps a directory-qualified migration name inside the migrations directory', () => {
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, '../../../etc/passwd', null, () => true))
+      .toBe(path.join(MIGRATIONS_PATH, 'passwd.ts'))
+  })
+
+  it('refuses names that survive basename but are not a plausible file name', () => {
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, 'migration name; rm -rf /', null, () => true)).toBeNull()
+  })
+
+  it('returns null when no file backs the migration name', () => {
+    expect(resolveMigrationFilePath(MIGRATIONS_PATH, 'Migration20990101000000', null, fileExists)).toBeNull()
+  })
+})
+
+describe('collectQueryIndexReindexEntityTypes', () => {
+  const fileExists = () => true
+
+  it('collects declarations across modules and deduplicates them', async () => {
+    const modules: Record<string, unknown> = {
+      [path.join(MIGRATIONS_PATH, 'a.ts')]: { queryIndexReindexEntityTypes: ['customers:customer_dictionary_entry'] },
+      [path.join(MIGRATIONS_PATH, 'b.ts')]: {
+        queryIndexReindexEntityTypes: ['customers:customer_dictionary_entry', 'workflows:workflow_definition'],
+      },
+      [path.join(MIGRATIONS_PATH, 'c.ts')]: {},
+    }
+
+    const collected = await collectQueryIndexReindexEntityTypes(
+      [migration('a'), migration('b'), migration('c')],
+      { importModule: async (filePath) => modules[filePath], fileExists },
+    )
+
+    expect(collected).toEqual(['customers:customer_dictionary_entry', 'workflows:workflow_definition'])
+  })
+
+  it('warns and keeps going when a migration file cannot be imported', async () => {
+    const onWarn = jest.fn()
+    const collected = await collectQueryIndexReindexEntityTypes(
+      [migration('broken'), migration('good')],
+      {
+        fileExists,
+        onWarn,
+        importModule: async (filePath) => {
+          if (filePath.endsWith('broken.ts')) throw new Error('boom')
+          return { queryIndexReindexEntityTypes: ['dictionaries:dictionary_entry'] }
+        },
+      },
+    )
+
+    expect(collected).toEqual(['dictionaries:dictionary_entry'])
+    expect(onWarn).toHaveBeenCalledWith(expect.stringContaining('customers/broken'))
+  })
+
+  it('warns per invalid declaration entry, naming the migration that carries it', async () => {
+    const onWarn = jest.fn()
+    const collected = await collectQueryIndexReindexEntityTypes(
+      [migration('typo')],
+      {
+        fileExists,
+        onWarn,
+        // A migration author who writes the export by hand rather than through the helper gets no
+        // throw — without this warning the entry vanishes and `db migrate` still exits 0.
+        importModule: async () => ({
+          queryIndexReindexEntityTypes: ['customers:customerDictionaryEntry', 'customers:deal'],
+        }),
+      },
+    )
+
+    expect(collected).toEqual(['customers:deal'])
+    expect(onWarn).toHaveBeenCalledTimes(1)
+    const warning = onWarn.mock.calls[0][0] as string
+    expect(warning).toContain('customers/typo')
+    expect(warning).toContain('customers:customerDictionaryEntry')
+    expect(warning).toContain('module:entity')
+  })
+
+  it('skips migrations whose file is gone', async () => {
+    const importModule = jest.fn()
+    const collected = await collectQueryIndexReindexEntityTypes(
+      [migration('missing')],
+      { importModule, fileExists: () => false },
+    )
+
+    expect(collected).toEqual([])
+    expect(importModule).not.toHaveBeenCalled()
+  })
+})
+
+describe('isMigrationReindexEnabled', () => {
+  it('is on by default and opts out on an explicit falsy token', () => {
+    expect(isMigrationReindexEnabled({})).toBe(true)
+    expect(isMigrationReindexEnabled({ OM_MIGRATION_REINDEX: 'off' })).toBe(false)
+    expect(isMigrationReindexEnabled({ OM_MIGRATION_REINDEX: 'false' })).toBe(false)
+    expect(isMigrationReindexEnabled({ OM_MIGRATION_REINDEX: 'true' })).toBe(true)
+  })
+})
+
+describe('requestQueryIndexReindex', () => {
+  it('queues one persistent in-place reindex per entity type', async () => {
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const dispose = jest.fn().mockResolvedValue(undefined)
+
+    const result = await requestQueryIndexReindex(
+      ['customers:customer_dictionary_entry', 'workflows:workflow_definition'],
+      { createContainer: async () => ({ resolve: () => ({ emitEvent }), dispose }) },
+    )
+
+    expect(result).toEqual({
+      requested: ['customers:customer_dictionary_entry', 'workflows:workflow_definition'],
+      queued: true,
+    })
+    expect(emitEvent).toHaveBeenCalledTimes(2)
+    expect(emitEvent).toHaveBeenNthCalledWith(
+      1,
+      'query_index.reindex',
+      { entityType: 'customers:customer_dictionary_entry', allowAllTenants: true, force: false },
+      { persistent: true },
+    )
+    expect(dispose).toHaveBeenCalled()
+  })
+
+  it('does nothing when no migration declared a reindex', async () => {
+    const createContainer = jest.fn()
+    await expect(requestQueryIndexReindex([], { createContainer })).resolves.toEqual({ requested: [], queued: false })
+    expect(createContainer).not.toHaveBeenCalled()
+  })
+
+  it('degrades to a manual-command warning instead of failing the migration run', async () => {
+    const onWarn = jest.fn()
+
+    const result = await requestQueryIndexReindex(['customers:deal'], {
+      onWarn,
+      createContainer: async () => {
+        throw new Error('no event bus here')
+      },
+    })
+
+    expect(result).toEqual({ requested: [], queued: false })
+    expect(onWarn).toHaveBeenCalledTimes(1)
+    const warning = onWarn.mock.calls[0][0] as string
+    expect(warning).toContain('mercato query_index rebuild --entity customers:deal --global')
+    expect(warning).toContain('no event bus here')
+  })
+
+  it('names only the entity types that did not make it into the queue', async () => {
+    const onWarn = jest.fn()
+    const emitEvent = jest.fn(async (_event: string, payload: Record<string, unknown>) => {
+      if (payload.entityType === 'workflows:workflow_definition') throw new Error('queue went away')
+    })
+
+    const result = await requestQueryIndexReindex(
+      ['customers:deal', 'workflows:workflow_definition'],
+      { onWarn, createContainer: async () => ({ resolve: () => ({ emitEvent }) }) },
+    )
+
+    expect(result).toEqual({ requested: ['customers:deal'], queued: false })
+    const warning = onWarn.mock.calls[0][0] as string
+    expect(warning).toContain('mercato query_index rebuild --entity workflows:workflow_definition --global')
+    expect(warning).not.toContain('--entity customers:deal')
+  })
+})
+
+describe('formatManualReindexInstructions', () => {
+  it('lists one rebuild command per entity type', () => {
+    const message = formatManualReindexInstructions(['customers:deal', 'workflows:workflow_definition'])
+    expect(message).toContain('mercato query_index rebuild --entity customers:deal --global')
+    expect(message).toContain('mercato query_index rebuild --entity workflows:workflow_definition --global')
+  })
+})

package/src/lib/db/commands.ts

@@ -9,6 +9,12 @@ import { PostgreSqlDriver } from '@mikro-orm/postgresql'
 import { getSslConfig } from '@open-mercato/shared/lib/db/ssl'
 import type { PackageResolver, ModuleEntry } from '../resolver'
 import { quotePostgresIdentifier } from './identifiers'
+import {
+  collectQueryIndexReindexEntityTypes,
+  isMigrationReindexEnabled,
+  requestQueryIndexReindex,
+  type AppliedMigration,
+} from './migration-reindex'
 
 const QUIET_MODE = process.env.OM_CLI_QUIET === '1' || process.env.MERCATO_QUIET === '1'
 const PROGRESS_EMOJI = ''
@@ -338,87 +344,141 @@ export async function dbMigrate(resolver: PackageResolver, options: DbOptions =
   const modules = resolver.loadEnabledModules()
   const ordered = sortModules(modules)
   const results: string[] = []
+  const appliedMigrations: AppliedMigration[] = []
 
-  for (const entry of ordered) {
-    const modId = entry.id
-    const sanitizedModId = sanitizeModuleId(modId)
-    const entities = await loadModuleEntities(entry, resolver)
+  try {
+    for (const entry of ordered) {
+      const modId = entry.id
+      const sanitizedModId = sanitizeModuleId(modId)
+      const entities = await loadModuleEntities(entry, resolver)
+
+      const migrationsPath = getMigrationsPath(entry, resolver)
+
+      // Skip if no entities AND no migrations directory exists
+      // (allows @app modules to run migrations even if entities can't be dynamically imported)
+      if (!entities.length && !fs.existsSync(migrationsPath)) continue
+      fs.mkdirSync(migrationsPath, { recursive: true })
+
+      const tableName = `mikro_orm_migrations_${sanitizedModId}`
+      validateTableName(tableName)
+
+      // dbMigrate only runs existing migration files — entities are intentionally
+      // omitted so MikroORM does not compare them against the snapshot and
+      // auto-generate a phantom diff migration (that would duplicate tables
+      // already created by committed migrations).
+      const sslConfig = getSslConfig()
+      const orm = await MikroORM.init<PostgreSqlDriver>({
+        driver: PostgreSqlDriver,
+        clientUrl: getClientUrl(),
+        loggerFactory: () => createMinimalLogger(),
+        dynamicImportProvider,
+        entities: [],
+        metadataProvider: ReflectMetadataProvider,
+        discovery: { warnWhenNoEntities: false },
+        migrations: {
+          path: migrationsPath,
+          glob: '!(*.d).{ts,js}',
+          tableName,
+          snapshot: false,
+          dropTables: false,
+        },
+        schemaGenerator: {
+          disableForeignKeys: true,
+        },
+        pool: {
+          min: 1,
+          max: 3,
+          idleTimeoutMillis: 30000,
+          // acquireTimeoutMillis removed for v7 (pg.Pool doesn't support it; use connectionTimeoutMillis in driverOptions if needed)
+        },
+        driverOptions: sslConfig ? {
+          ssl: sslConfig,
+        } : undefined,
+      })
 
-    const migrationsPath = getMigrationsPath(entry, resolver)
+      try {
+        const migrator = orm.migrator as Migrator
+        const pending = await migrator.getPending()
+        if (!pending.length) {
+          results.push(formatResult(modId, 'no pending migrations', ''))
+        } else {
+          const renderProgress = createProgressRenderer(pending.length)
+          let applied = 0
+          if (!QUIET_MODE) {
+            process.stdout.write(`   ${PROGRESS_EMOJI} ${modId}: ${renderProgress(applied)}`)
+          }
+          for (const migration of pending) {
+            const migrationName =
+              typeof migration === 'string'
+                ? migration
+                : (migration as any).name ?? (migration as any).fileName
+            await migrator.up(migrationName ? { migrations: [migrationName] } : undefined)
+            if (migrationName) {
+              appliedMigrations.push({
+                moduleId: modId,
+                migrationsPath,
+                name: String(migrationName),
+                filePath: typeof migration === 'string' ? null : (migration as any).path ?? null,
+              })
+            }
+            applied += 1
+            if (!QUIET_MODE) {
+              process.stdout.write(`\r   ${PROGRESS_EMOJI} ${modId}: ${renderProgress(applied)}`)
+            }
+          }
+          if (!QUIET_MODE) process.stdout.write('\n')
+          results.push(
+            formatResult(modId, `${pending.length} migration${pending.length === 1 ? '' : 's'} applied`, '')
+          )
+        }
+      } finally {
+        await orm.close(true)
+      }
+    }
+  } finally {
+    console.log(results.join('\n'))
+    await dischargeQueryIndexReindexRequests(appliedMigrations)
+  }
+}
 
-    // Skip if no entities AND no migrations directory exists
-    // (allows @app modules to run migrations even if entities can't be dynamically imported)
-    if (!entities.length && !fs.existsSync(migrationsPath)) continue
-    fs.mkdirSync(migrationsPath, { recursive: true })
+/**
+ * Runs after every module migrated and after `orm.close()`, so the rewrites the declarations
+ * refer to are committed before the reindex is queued.
+ *
+ * Reached from a `finally`, so it also runs when a later migration threw: the migrations that
+ * did apply already committed, and their declarations are the only record that their projections
+ * are stale — a re-run cannot recover them, because `getPending()` no longer lists them. It must
+ * therefore never throw, or it would replace the migration failure the operator needs to see.
+ */
+export async function dischargeQueryIndexReindexRequests(
+  applied: readonly AppliedMigration[],
+): Promise<void> {
+  if (!applied.length || !isMigrationReindexEnabled()) return
 
-    const tableName = `mikro_orm_migrations_${sanitizedModId}`
-    validateTableName(tableName)
+  try {
+    const entityTypes = await collectQueryIndexReindexEntityTypes(applied, {
+      importModule: dynamicImportProvider,
+      onWarn: (message) => console.warn(message),
+    })
+    if (!entityTypes.length) return
 
-    // dbMigrate only runs existing migration files — entities are intentionally
-    // omitted so MikroORM does not compare them against the snapshot and
-    // auto-generate a phantom diff migration (that would duplicate tables
-    // already created by committed migrations).
-    const sslConfig = getSslConfig()
-    const orm = await MikroORM.init<PostgreSqlDriver>({
-      driver: PostgreSqlDriver,
-      clientUrl: getClientUrl(),
-      loggerFactory: () => createMinimalLogger(),
-      dynamicImportProvider,
-      entities: [],
-      metadataProvider: ReflectMetadataProvider,
-      discovery: { warnWhenNoEntities: false },
-      migrations: {
-        path: migrationsPath,
-        glob: '!(*.d).{ts,js}',
-        tableName,
-        snapshot: false,
-        dropTables: false,
-      },
-      schemaGenerator: {
-        disableForeignKeys: true,
+    await requestQueryIndexReindex(entityTypes, {
+      createContainer: async () => {
+        const { createRequestContainer } = await import('@open-mercato/shared/lib/di/container')
+        return (await createRequestContainer()) as any
       },
-      pool: {
-        min: 1,
-        max: 3,
-        idleTimeoutMillis: 30000,
-        // acquireTimeoutMillis removed for v7 (pg.Pool doesn't support it; use connectionTimeoutMillis in driverOptions if needed)
+      onInfo: (message) => {
+        if (!QUIET_MODE) console.log(message)
       },
-      driverOptions: sslConfig ? {
-        ssl: sslConfig,
-      } : undefined,
+      onWarn: (message) => console.warn(message),
     })
-
-    const migrator = orm.migrator as Migrator
-    const pending = await migrator.getPending()
-    if (!pending.length) {
-      results.push(formatResult(modId, 'no pending migrations', ''))
-    } else {
-      const renderProgress = createProgressRenderer(pending.length)
-      let applied = 0
-      if (!QUIET_MODE) {
-        process.stdout.write(`   ${PROGRESS_EMOJI} ${modId}: ${renderProgress(applied)}`)
-      }
-      for (const migration of pending) {
-        const migrationName =
-          typeof migration === 'string'
-            ? migration
-            : (migration as any).name ?? (migration as any).fileName
-        await migrator.up(migrationName ? { migrations: [migrationName] } : undefined)
-        applied += 1
-        if (!QUIET_MODE) {
-          process.stdout.write(`\r   ${PROGRESS_EMOJI} ${modId}: ${renderProgress(applied)}`)
-        }
-      }
-      if (!QUIET_MODE) process.stdout.write('\n')
-      results.push(
-        formatResult(modId, `${pending.length} migration${pending.length === 1 ? '' : 's'} applied`, '')
-      )
-    }
-
-    await orm.close(true)
+  } catch (error) {
+    console.warn(
+      `[query_index] Could not determine which projections the migrations invalidated: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
   }
-
-  console.log(results.join('\n'))
 }
 
 export async function dbGreenfield(resolver: PackageResolver, options: GreenfieldOptions): Promise<void> {