@open-mercato/cli 0.6.7 → 0.6.8-canary.320.1.bf889f49e4

package/src/lib/__tests__/generate-watch-events.test.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import {
   createGenerateWatchChangeSignal,
@@ -26,6 +28,7 @@ function createWatchHarness(initialTargets: GenerateWatchTarget[]) {
   const signal = createGenerateWatchChangeSignal({
     getWatchTargets: () => targets,
     watchDirectory,
+    directoryExists: () => true,
   })
 
   return {
@@ -37,6 +40,78 @@ function createWatchHarness(initialTargets: GenerateWatchTarget[]) {
 }
 
 describe('createGenerateWatchChangeSignal', () => {
+  it('skips missing directories without falling back and retries them on refresh', async () => {
+    const present = path.resolve('./modules-present')
+    const delayed = path.resolve('./modules-delayed')
+    const existing = new Set([present])
+    const registered: GenerateWatchTarget[] = []
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => [
+        { directory: present, recursive: true },
+        { directory: delayed, recursive: true },
+      ],
+      directoryExists: (directory) => existing.has(directory),
+      watchDirectory: (target) => {
+        registered.push(target)
+        return { close: jest.fn() }
+      },
+    })
+
+    await signal.refresh()
+    expect(registered.map((target) => target.directory)).toEqual([present])
+    expect(signal.hasSkippedTargets?.()).toBe(true)
+    expect(signal.usesPollingFallback()).toBe(false)
+
+    existing.add(delayed)
+    await signal.refresh()
+    expect(registered.map((target) => target.directory)).toEqual([present, delayed])
+    expect(signal.hasSkippedTargets?.()).toBe(false)
+    expect(signal.usesPollingFallback()).toBe(false)
+  })
+
+  it('reports a missing directory once while it remains skipped', async () => {
+    const missing = path.resolve('./modules-missing')
+    const onSkippedDirectory = jest.fn()
+    const options = {
+      getWatchTargets: () => [{ directory: missing, recursive: true }],
+      directoryExists: () => false,
+      watchDirectory: jest.fn(() => ({ close: jest.fn() })),
+      onSkippedDirectory,
+    }
+    const signal = createGenerateWatchChangeSignal(options)
+
+    await signal.refresh()
+    await signal.refresh()
+
+    expect(onSkippedDirectory).toHaveBeenCalledTimes(1)
+    expect(onSkippedDirectory).toHaveBeenCalledWith(missing)
+  })
+
+  it('uses filesystem existence checks by default', async () => {
+    const present = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-generate-watch-'))
+    const missing = path.join(present, 'missing')
+    const registered: string[] = []
+    const signal = createGenerateWatchChangeSignal({
+      getWatchTargets: () => [
+        { directory: present, recursive: true },
+        { directory: missing, recursive: true },
+      ],
+      watchDirectory: (target) => {
+        registered.push(target.directory)
+        return { close: jest.fn() }
+      },
+    })
+
+    try {
+      await signal.refresh()
+      expect(registered).toEqual([present])
+      expect(signal.usesPollingFallback()).toBe(false)
+    } finally {
+      await signal.close()
+      fs.rmSync(present, { recursive: true, force: true })
+    }
+  })
+
   it('deduplicates targets and increments its version on filesystem events', async () => {
     const target = { directory: './modules', recursive: true }
     const { signal, registered, watchDirectory } = createWatchHarness([target, target])
@@ -80,6 +155,7 @@ describe('createGenerateWatchChangeSignal', () => {
         { directory: './modules-b', recursive: true },
       ],
       watchDirectory,
+      directoryExists: () => true,
     })
 
     await signal.refresh()

package/src/lib/__tests__/in-process-generate-watcher.test.ts

@@ -14,15 +14,26 @@ async function flushAsync(times = 5): Promise<void> {
 function createFakeChangeSignal() {
   let version = 0
   let fallback = false
+  let skippedTargets = false
+  let discoverSkippedTargets = false
+  const refresh = jest.fn(async () => {
+    if (discoverSkippedTargets) {
+      skippedTargets = false
+      discoverSkippedTargets = false
+    }
+  })
   const signal: GenerateWatcherChangeSignal = {
     currentVersion: () => version,
-    refresh: jest.fn(async () => undefined),
+    refresh,
     usesPollingFallback: () => fallback,
+    hasSkippedTargets: () => skippedTargets,
     close: jest.fn(async () => undefined),
   }
   return {
     signal,
     markChanged: () => { version += 1 },
+    markSkippedTarget: () => { skippedTargets = true },
+    discoverSkippedTargetOnNextRefresh: () => { discoverSkippedTargets = true },
     usePollingFallback: () => { fallback = true },
   }
 }
@@ -142,6 +153,46 @@ describe('startInProcessGenerateWatcher', () => {
     await handle.close()
   })
 
+  it('discovers skipped roots during event-gated idle polling', async () => {
+    const runGenerators = jest.fn(async () => undefined)
+    const computeStructureChecksum = jest.fn()
+      .mockResolvedValueOnce('before')
+      .mockResolvedValue('after')
+    const {
+      signal,
+      markSkippedTarget,
+      discoverSkippedTargetOnNextRefresh,
+    } = createFakeChangeSignal()
+    markSkippedTarget()
+    const handle = startInProcessGenerateWatcher({
+      pollMs: 1000,
+      skipInitial: true,
+      quiet: true,
+      logger: silentLogger,
+      changeSignal: signal,
+      computeStructureChecksum,
+      runGenerators,
+    })
+
+    await flushAsync(8)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(1)
+
+    jest.advanceTimersByTime(1000)
+    await flushAsync(12)
+
+    expect(signal.refresh).toHaveBeenCalledTimes(2)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(1)
+    discoverSkippedTargetOnNextRefresh()
+
+    jest.advanceTimersByTime(1000)
+    await flushAsync(12)
+
+    expect(signal.refresh).toHaveBeenCalledTimes(3)
+    expect(computeStructureChecksum).toHaveBeenCalledTimes(2)
+    expect(runGenerators).toHaveBeenCalledWith('structure change')
+    await handle.close()
+  })
+
   it('coalesces filesystem event bursts into one checksum and regeneration', async () => {
     let currentChecksum = 'before'
     const runGenerators = jest.fn(async () => undefined)

package/src/lib/__tests__/injection-widget-id-validation.test.ts

@@ -0,0 +1,184 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createInjectionWidgetsExtension } from '../generators/extensions/injection-widgets'
+import type { ModuleScanContext } from '../generators/extension'
+
+// A widget's `metadata.id` and the `widgetId` that mounts it are two hand-typed literals in two
+// different files. Nothing linked them, so a typo in either failed silently — the widget was never
+// mounted, or the table entry resolved to nothing. These cases drive the real scan → generate seam
+// (real filesystem fixtures, real AST extraction) and assert the reconciliation warnings.
+
+let tmpRoot: string
+
+beforeEach(() => {
+  tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-injection-widgets-'))
+})
+
+afterEach(() => {
+  fs.rmSync(tmpRoot, { recursive: true, force: true })
+  jest.restoreAllMocks()
+})
+
+function widgetSource(id: string): string {
+  return [
+    "import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'",
+    "import Impl from './widget.client'",
+    '',
+    'const widget: InjectionWidgetModule = {',
+    '  metadata: {',
+    `    id: '${id}',`,
+    "    title: 'Fixture widget',",
+    '  },',
+    '  Widget: Impl,',
+    '}',
+    '',
+    'export default widget',
+  ].join('\n')
+}
+
+function tableSource(widgetIds: string[]): string {
+  const entries = widgetIds
+    .map((id, index) => `  'detail:fixture:tab${index}': [{ widgetId: '${id}', kind: 'tab' }],`)
+    .join('\n')
+  return [
+    "import type { ModuleInjectionTable } from '@open-mercato/shared/modules/widgets/injection'",
+    '',
+    'export const injectionTable: ModuleInjectionTable = {',
+    entries,
+    '}',
+    '',
+    'export default injectionTable',
+  ].join('\n')
+}
+
+/**
+ * Lays out one module on disk in the shape the scanner expects and returns a scan context for it.
+ * `declaredIds` each get `widgets/injection/<name>/widget.ts`; `referencedIds` go into the module's
+ * `widgets/injection-table.ts` (omitted entirely when the list is empty).
+ */
+function makeModule(moduleId: string, declaredIds: string[], referencedIds: string[]): ModuleScanContext {
+  const base = path.join(tmpRoot, moduleId)
+  const injectionDir = path.join(base, 'widgets', 'injection')
+  fs.mkdirSync(injectionDir, { recursive: true })
+
+  declaredIds.forEach((id, index) => {
+    const dir = path.join(injectionDir, `w${index}`)
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(path.join(dir, 'widget.ts'), widgetSource(id))
+  })
+
+  const tablePath = path.join(base, 'widgets', 'injection-table.ts')
+  if (referencedIds.length > 0) fs.writeFileSync(tablePath, tableSource(referencedIds))
+
+  const roots = { appBase: base, pkgBase: base }
+  return {
+    moduleId,
+    roots,
+    imps: { appBase: `@fixture/${moduleId}`, pkgBase: `@fixture/${moduleId}` },
+    importIdRef: { value: 0 },
+    sharedImports: [],
+    resolveModuleFile: (() =>
+      referencedIds.length > 0
+        ? { absolutePath: tablePath, importPath: `@fixture/${moduleId}/widgets/injection-table` }
+        : null) as unknown as ModuleScanContext['resolveModuleFile'],
+    resolveFirstModuleFile: (() => null) as unknown as ModuleScanContext['resolveFirstModuleFile'],
+    processStandaloneConfig: () => null,
+    sanitizeGeneratedModuleSpecifier: (importPath: string) => importPath,
+  }
+}
+
+function runGenerate(contexts: ModuleScanContext[]): string[] {
+  const warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  const extension = createInjectionWidgetsExtension()
+  for (const ctx of contexts) extension.scanModule(ctx)
+  extension.generateOutput()
+  return warn.mock.calls.map((call) => String(call[0]))
+}
+
+describe('injection widget id reconciliation at generate time', () => {
+  it('stays silent when every declared widget is referenced and vice versa', () => {
+    const warnings = runGenerate([makeModule('alpha', ['alpha.one', 'alpha.two'], ['alpha.one', 'alpha.two'])])
+
+    expect(warnings).toEqual([])
+  })
+
+  it('warns when an injection table references a widget id nothing declares', () => {
+    const warnings = runGenerate([makeModule('alpha', ['alpha.one'], ['alpha.one', 'alpha.typo'])])
+
+    expect(warnings).toHaveLength(1)
+    expect(warnings[0]).toContain('alpha.typo')
+    expect(warnings[0]).toContain('references widget id')
+    expect(warnings[0]).toContain('alpha')
+  })
+
+  it('stays silent about a declared widget that no table references', () => {
+    // The mirror check is deliberately not implemented: `extractInjectionTableWidgetIds` reads only
+    // statically-analyzable literals, so a table built by composition or computation exposes no ids
+    // and every widget in such a module would be reported as unreferenced. Pinned so the omission is
+    // a decision rather than an oversight.
+    const warnings = runGenerate([makeModule('alpha', ['alpha.one', 'alpha.orphan'], ['alpha.one'])])
+
+    expect(warnings).toEqual([])
+  })
+
+  it('reports only the unresolvable reference when the two sides disagree entirely', () => {
+    const warnings = runGenerate([makeModule('alpha', ['alpha.declared'], ['alpha.referenced'])])
+
+    expect(warnings).toHaveLength(1)
+    expect(warnings[0]).toContain('alpha.referenced')
+  })
+
+  it('does not warn about a table assembled by composition, whose ids are invisible statically', () => {
+    // Mirrors the real `example` module: `cond ? { ...a, ...b } : a`. The extractor sees no ids, so
+    // there is nothing to reconcile — and critically, no false warning.
+    const base = path.join(tmpRoot, 'composed')
+    fs.mkdirSync(path.join(base, 'widgets', 'injection', 'w0'), { recursive: true })
+    fs.writeFileSync(path.join(base, 'widgets', 'injection', 'w0', 'widget.ts'), widgetSource('composed.one'))
+    const tablePath = path.join(base, 'widgets', 'injection-table.ts')
+    fs.writeFileSync(
+      tablePath,
+      [
+        "import type { ModuleInjectionTable } from '@open-mercato/shared/modules/widgets/injection'",
+        "const a: ModuleInjectionTable = { 'detail:x:tab': [{ widgetId: 'composed.one' }] }",
+        "const b: ModuleInjectionTable = { 'detail:y:tab': [{ widgetId: 'composed.two' }] }",
+        'export const injectionTable: ModuleInjectionTable = process.env.FLAG ? { ...a, ...b } : a',
+        'export default injectionTable',
+      ].join('\n'),
+    )
+
+    const ctx: ModuleScanContext = {
+      ...makeModule('composed', [], []),
+      resolveModuleFile: (() => ({
+        absolutePath: tablePath,
+        importPath: '@fixture/composed/widgets/injection-table',
+      })) as unknown as ModuleScanContext['resolveModuleFile'],
+    }
+
+    expect(runGenerate([ctx])).toEqual([])
+  })
+
+  it('accepts a table in one module referencing a widget declared in another', () => {
+    const warnings = runGenerate([
+      makeModule('alpha', ['alpha.shared'], []),
+      makeModule('beta', [], ['alpha.shared']),
+    ])
+
+    expect(warnings).toEqual([])
+  })
+
+  it('does not warn for the single-widget id inference', () => {
+    // A lone widget whose metadata.id cannot be extracted adopts the table's single id; that
+    // convenience path must not then report itself as a mismatch.
+    const ctx = makeModule('gamma', [], ['gamma.inferred'])
+    const dir = path.join(tmpRoot, 'gamma', 'widgets', 'injection', 'solo')
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(path.join(dir, 'widget.ts'), 'export default { Widget: () => null }\n')
+
+    expect(runGenerate([ctx])).toEqual([])
+  })
+
+  it('stays silent for a module with no injection widgets and no table', () => {
+    expect(runGenerate([makeModule('delta', [], [])])).toEqual([])
+  })
+})

package/src/lib/__tests__/load-env.test.ts

@@ -0,0 +1,65 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import os from 'node:os'
+import { loadAppEnv } from '../load-env'
+
+/**
+ * Regression: bin.ts must load the app's `.env` before initTelemetry(), so
+ * TELEMETRY_BACKEND set only in `.env` reaches worker and scheduler processes
+ * (ensureEnvLoaded in run() happens after init — too late).
+ */
+
+describe('loadAppEnv', () => {
+  const TEST_KEY = 'OM_LOAD_ENV_TEST_BACKEND'
+  let tmpDir: string
+  let cwd: string
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'load-env-'))
+    cwd = process.cwd()
+    process.chdir(tmpDir)
+    delete process.env[TEST_KEY]
+  })
+
+  afterEach(() => {
+    process.chdir(cwd)
+    delete process.env[TEST_KEY]
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('loads .env from the app directory into process.env', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"env-test-app"}\n')
+    fs.mkdirSync(path.join(tmpDir, 'src'))
+    fs.writeFileSync(path.join(tmpDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+    fs.writeFileSync(path.join(tmpDir, '.env'), `${TEST_KEY}=console\n`)
+
+    await loadAppEnv()
+
+    expect(process.env[TEST_KEY]).toBe('console')
+  })
+
+  it('does not override values already set in the real process env', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"env-test-app"}\n')
+    fs.writeFileSync(path.join(tmpDir, '.env'), `${TEST_KEY}=from-dotenv\n`)
+    process.env[TEST_KEY] = 'from-shell'
+
+    await loadAppEnv()
+
+    expect(process.env[TEST_KEY]).toBe('from-shell')
+  })
+
+  it('is a safe no-op when no .env exists', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"env-test-app"}\n')
+    await expect(loadAppEnv()).resolves.toBeUndefined()
+    expect(process.env[TEST_KEY]).toBeUndefined()
+  })
+
+  it('bin.ts awaits loadAppEnv() before initTelemetry() (the guarded ordering)', () => {
+    const binSource = fs.readFileSync(path.resolve(__dirname, '../../bin.ts'), 'utf8')
+    const loadEnvCall = binSource.indexOf('await loadAppEnv()')
+    const initTelemetryCall = binSource.indexOf('await initTelemetry()')
+    expect(loadEnvCall).toBeGreaterThan(-1)
+    expect(initTelemetryCall).toBeGreaterThan(-1)
+    expect(loadEnvCall).toBeLessThan(initTelemetryCall)
+  })
+})

package/src/lib/__tests__/queue-worker-supervisor.test.ts

@@ -65,6 +65,39 @@ async function flushAsync(times = 5): Promise<void> {
 }
 
 describe('startLazyWorkerSupervisor', () => {
+  it('accepts lightweight worker descriptors without importing handlers', async () => {
+    const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
+    const probeFn = jest.fn(async (queueName, strategy) =>
+      emptyProbe(queueName, strategy),
+    ) as jest.MockedFunction<LazySupervisorProbeFn>
+
+    const handle = startLazyWorkerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      workers: [
+        {
+          id: 'events:workers:dispatch',
+          moduleId: 'events',
+          queue: 'events',
+          concurrency: 1,
+        },
+      ],
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      strategy: 'local',
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(probeFn).toHaveBeenCalledWith('events', 'local')
+    expect(spawnFn).not.toHaveBeenCalled()
+
+    await handle.close()
+  })
+
   it('does not spawn any worker while every queue is idle', async () => {
     const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
     const probeFn = jest.fn(async (queueName, strategy) =>

package/src/lib/__tests__/resolver.enterprise.test.ts

@@ -67,6 +67,33 @@ if (enabledModules.some((entry) => entry.id === 'example')) {
   )
 }
 
+function writeModulesConfigWithSupervisorOverrides(rootDir: string) {
+  const srcDir = path.join(rootDir, 'src')
+  fs.mkdirSync(srcDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(srcDir, 'modules.ts'),
+    `
+const supervisorPolicy = { workers: { 'events:dispatch': null } }
+export const enabledModules = [
+  {
+    id: 'events',
+    from: '@open-mercato/events',
+    overrides: {
+      workers: {
+        'events:dispatch': null,
+        'events:replacement': { id: 'events:replacement', queue: 'events-v2', concurrency: 2, handler() {} },
+      },
+      cli: { start: null },
+    },
+  },
+  { id: 'scheduler', overrides: supervisorPolicy },
+  { id: 'queue', overrides: { ...supervisorPolicy } },
+]
+`,
+    'utf8',
+  )
+}
+
 describe('resolver enterprise module toggle', () => {
   const originalEnv = process.env.OM_ENABLE_ENTERPRISE_MODULES
   const originalResolverMarker = (globalThis as Record<string, unknown>).__resolver_evaluated__
@@ -140,4 +167,27 @@ describe('resolver enterprise module toggle', () => {
       ]),
     )
   })
+
+  it('marks inline worker and CLI overrides for the full dev bootstrap', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'resolver-supervisor-overrides-'))
+    writeModulesConfigWithSupervisorOverrides(tempDir)
+
+    expect(createResolver(tempDir).loadEnabledModules()).toEqual([
+      {
+        id: 'events',
+        from: '@open-mercato/events',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+      {
+        id: 'scheduler',
+        from: '@open-mercato/core',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+      {
+        id: 'queue',
+        from: '@open-mercato/core',
+        devSupervisorRequiresFullBootstrap: true,
+      },
+    ])
+  })
 })