@open-mercato/cli 0.6.8-develop.6931.1.4a1e1c786b → 0.6.8-develop.6940.1.177ea30c6e

package/src/lib/generators/__tests__/module-override-targets.diagnostic-wiring.test.ts

@@ -0,0 +1,92 @@
+import { collectModuleOverrideTargets } from '../module-override-targets'
+import {
+  FIXTURE_MODULE_ID,
+  FIXTURE_SOURCE_ROOT,
+  OVERRIDE_TARGET_DIAGNOSTIC_FIXTURES,
+  catalogWith,
+  catalogWithout,
+  collectWithCatalogOperations,
+  fixtureFacts,
+  realCatalogOperations,
+} from './helpers/override-target-diagnostic-fixtures'
+
+function codesFor(
+  diagnostics: { code: string; domain: string }[],
+  domain: string,
+): string[] {
+  return diagnostics.filter((diagnostic) => diagnostic.domain === domain).map((diagnostic) => diagnostic.code)
+}
+
+describe('override-target diagnostic wiring — the published code names the real cause', () => {
+  it('publishes unknown-framework-mode when the catalog describes the host with an unusable operation', () => {
+    const { overrideTargets, overrideTargetDiagnostics } = collectWithCatalogOperations(
+      catalogWith('cli', 'merge-deep'),
+      fixtureFacts(),
+    )
+    const cliDiagnostics = overrideTargetDiagnostics.filter((diagnostic) => diagnostic.domain === 'cli')
+    expect(cliDiagnostics.map((diagnostic) => diagnostic.code)).toEqual(['unknown-framework-mode'])
+    expect(cliDiagnostics[0]).toEqual({
+      code: 'unknown-framework-mode',
+      moduleId: FIXTURE_MODULE_ID,
+      domain: 'cli',
+      candidatePath: ['cli', 'fixture:seed'],
+      source: { sourcePath: `${FIXTURE_SOURCE_ROOT}/cli.ts` },
+    })
+    expect(overrideTargets.some((target) => target.domain === 'cli')).toBe(false)
+  })
+
+  it('publishes unknown-framework-domain when the catalog does not describe the host at all', () => {
+    const { overrideTargets, overrideTargetDiagnostics } = collectWithCatalogOperations(
+      catalogWithout('cli'),
+      fixtureFacts(),
+    )
+    expect(codesFor(overrideTargetDiagnostics, 'cli')).toEqual(['unknown-framework-domain'])
+    expect(overrideTargets.some((target) => target.domain === 'cli')).toBe(false)
+  })
+
+  it('never collapses the two causes: one run emits a distinct code per failing domain', () => {
+    const operations = catalogWithout('cli')
+    operations.workers = 'merge-deep'
+    const { overrideTargetDiagnostics } = collectWithCatalogOperations(
+      operations,
+      fixtureFacts({
+        ownedContracts: {
+          worker: [
+            {
+              kind: 'worker',
+              id: 'fixture.worker',
+              source: { sourcePath: `${FIXTURE_SOURCE_ROOT}/workers/fixture.ts`, line: 1 },
+            },
+          ],
+        },
+      }),
+    )
+    expect(codesFor(overrideTargetDiagnostics, 'cli')).toEqual(['unknown-framework-domain'])
+    expect(codesFor(overrideTargetDiagnostics, 'workers')).toEqual(['unknown-framework-mode'])
+    expect(new Set(overrideTargetDiagnostics.map((diagnostic) => diagnostic.code)).size).toBe(2)
+  })
+
+  it('emits the target and no diagnostic when the real catalog describes the host', () => {
+    const stubbed = collectWithCatalogOperations(realCatalogOperations(), fixtureFacts())
+    const direct = collectModuleOverrideTargets(fixtureFacts())
+    expect(stubbed).toEqual(direct)
+    expect(direct.overrideTargetDiagnostics).toEqual([])
+    expect(direct.overrideTargets.map((target) => target.path)).toEqual([['cli', 'fixture:seed']])
+    expect(direct.overrideTargets[0].modes).toEqual(['disable-replace'])
+  })
+})
+
+describe('every negative-fixture diagnostic code is produced by a real fixture', () => {
+  it.each(OVERRIDE_TARGET_DIAGNOSTIC_FIXTURES.map((fixture) => [fixture.code, fixture] as const))(
+    '%s',
+    (code, fixture) => {
+      const diagnostics = fixture.run()
+      expect(diagnostics.map((diagnostic) => diagnostic.code)).toContain(code)
+    },
+  )
+
+  it('covers each code with exactly one fixture', () => {
+    const codes = OVERRIDE_TARGET_DIAGNOSTIC_FIXTURES.map((fixture) => fixture.code)
+    expect(new Set(codes).size).toBe(codes.length)
+  })
+})

package/src/lib/generators/__tests__/module-override-targets.test.ts

@@ -222,6 +222,30 @@ describe('module override targets — deterministic diagnostics (never a guessed
     expect(diag?.source).toBeUndefined()
   })
 
+  it('never guesses a mode: the framework catalog describes every adapter host', () => {
+    const { overrideTargets, overrideTargetDiagnostics } = collectModuleOverrideTargets(baseFacts())
+    expect(overrideTargetDiagnostics.filter((diagnostic) => diagnostic.code === 'unknown-framework-domain')).toEqual([])
+    expect(overrideTargets.length).toBeGreaterThan(0)
+    for (const target of overrideTargets) {
+      expect(target.modes).toHaveLength(1)
+      expect(['disable-replace', 'replace', 'additive']).toContain(target.modes[0])
+    }
+  })
+
+  it('routes every widget contribution by its own kind/payload discriminant', () => {
+    const { overrideTargets } = collectModuleOverrideTargets(baseFacts())
+    const widgets = overrideTargets
+      .filter((target) => target.domain === 'widgets')
+      .map((target) => `${target.path.slice(0, 2).join('/')} ${target.key}`)
+      .sort()
+    expect(widgets).toEqual([
+      'widgets/components section:demo.login',
+      'widgets/dashboard demo.card',
+      'widgets/injection demo.table-widget',
+      'widgets/injection demo.widget',
+    ])
+  })
+
   it('emits missing-source when an acl feature has no indexed provenance', () => {
     const facts = baseFacts({ factSources: [] })
     const { overrideTargets, overrideTargetDiagnostics } = collectModuleOverrideTargets(facts)

package/src/lib/generators/__tests__/module-override-targets.unknown-mode.test.ts

@@ -0,0 +1,117 @@
+import type { ModuleExtensionHostFact } from '@open-mercato/shared/modules/widgets/extension-points'
+import { getFrameworkOverrideHostOperations, getFrameworkOverrideModes } from '../module-extension-facts'
+import {
+  MODULE_OVERRIDE_MODES,
+  MODULE_OVERRIDE_TARGET_DIAGNOSTIC_CODES,
+  resolveFrameworkOverrideModes,
+} from '../module-override-targets'
+
+/**
+ * A catalog host declaring an operation this generator does not know. Every real
+ * catalog host declares a valid mode today, so a stub is the only way to observe
+ * what the raw operation map does with one — which is the whole point of the map
+ * existing beside the validated mode map.
+ */
+const CATALOG_HOST_WITH_UNRECOGNIZED_OPERATION: ModuleExtensionHostFact = {
+  key: 'framework.module-override.fixture.aheadOfGenerator',
+  id: 'module-override:fixture.aheadOfGenerator',
+  resolution: 'framework',
+  family: 'module-override',
+  ownerModule: 'framework',
+  capabilities: ['module-override'],
+  operations: ['merge-deep'],
+  bound: true,
+  stability: 'stable',
+  source: {
+    kind: 'framework',
+    path: 'packages/shared/src/modules/overrides.ts',
+    symbol: 'ModuleOverrides.fixture.aheadOfGenerator',
+  },
+}
+
+describe('unknown-framework-mode override-target diagnostic', () => {
+  it('is part of the closed diagnostic-code set', () => {
+    expect([...MODULE_OVERRIDE_TARGET_DIAGNOSTIC_CODES]).toEqual([
+      'missing-owned-fact',
+      'missing-source',
+      'unsupported-dynamic-key',
+      'unknown-framework-domain',
+      'unknown-framework-mode',
+    ])
+  })
+
+  it('distinguishes an absent catalog host from a host whose declared mode is unrecognized', () => {
+    expect(resolveFrameworkOverrideModes(undefined)).toEqual({ outcome: 'unknown-framework-domain' })
+    expect(resolveFrameworkOverrideModes('merge-deep')).toEqual({
+      outcome: 'unknown-framework-mode',
+      operation: 'merge-deep',
+    })
+  })
+
+  it('resolves every public mode and nothing else', () => {
+    for (const mode of MODULE_OVERRIDE_MODES) {
+      expect(resolveFrameworkOverrideModes(mode)).toEqual({ outcome: 'resolved', modes: [mode] })
+    }
+    expect(resolveFrameworkOverrideModes('')).toEqual({ outcome: 'unknown-framework-mode', operation: '' })
+    expect(resolveFrameworkOverrideModes('DISABLE-REPLACE')).toEqual({
+      outcome: 'unknown-framework-mode',
+      operation: 'DISABLE-REPLACE',
+    })
+  })
+
+  it('never guesses a target: an unrecognized mode yields no modes at all', () => {
+    const resolution = resolveFrameworkOverrideModes('replace-all')
+    expect(resolution.outcome).toBe('unknown-framework-mode')
+    expect('modes' in resolution).toBe(false)
+  })
+})
+
+describe('framework override host operations', () => {
+  const operations = getFrameworkOverrideHostOperations()
+
+  it('exposes the raw declared operation for every catalog host, unfiltered', () => {
+    expect(Object.keys(operations).length).toBeGreaterThan(0)
+    expect(operations['routes.api']).toBe('disable-replace')
+    expect(operations['setup']).toBe('replace')
+    expect(operations['ai.extensions']).toBe('additive')
+    expect(operations['nav.groupOrder']).toBe('additive')
+    expect(operations['no.such.host']).toBeUndefined()
+  })
+
+  it('keeps the validated mode map a strict subset of the raw operations', () => {
+    const modes = getFrameworkOverrideModes()
+    for (const [host, mode] of Object.entries(modes)) {
+      expect(operations[host]).toBe(mode)
+      expect(MODULE_OVERRIDE_MODES).toContain(mode)
+    }
+    for (const [host, operation] of Object.entries(operations)) {
+      const resolution = resolveFrameworkOverrideModes(operation)
+      expect(resolution.outcome === 'resolved').toBe(host in modes)
+    }
+  })
+})
+
+describe('a catalog operation the generator does not recognize', () => {
+  const hosts = [CATALOG_HOST_WITH_UNRECOGNIZED_OPERATION]
+  const dottedHost = 'fixture.aheadOfGenerator'
+
+  it('survives the raw operation map unfiltered', () => {
+    expect(getFrameworkOverrideHostOperations(hosts)).toEqual({ [dottedHost]: 'merge-deep' })
+  })
+
+  it('is dropped from the validated mode map, which is exactly why the raw map must not filter', () => {
+    expect(getFrameworkOverrideModes(hosts)).toEqual({})
+  })
+
+  it('reads as a catalog this generator has fallen behind, never as a host that does not exist', () => {
+    const rawOperations = getFrameworkOverrideHostOperations(hosts)
+    const filteredOperations = getFrameworkOverrideModes(hosts)
+    expect(resolveFrameworkOverrideModes(rawOperations[dottedHost])).toEqual({
+      outcome: 'unknown-framework-mode',
+      operation: 'merge-deep',
+    })
+    expect(resolveFrameworkOverrideModes(filteredOperations[dottedHost])).toEqual({
+      outcome: 'unknown-framework-domain',
+    })
+  })
+})

package/src/lib/generators/__tests__/module-subset.test.ts

@@ -1908,6 +1908,66 @@ describe('all generated files are valid with varying subsets', () => {
     expect(sudoTargets).toContain('sudoTargets')
   })
 
+  it('rejects generator plugins that declare the same output file', async () => {
+    scaffoldModule(tmpDir, 'security_ext', 'pkg', ['security.mfa-providers.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'security_ext', 'generators.ts'),
+      SECURITY_GENERATORS_CONTENT.replace(
+        "outputFileName: 'security-sudo.generated.ts'",
+        "outputFileName: 'security-mfa-providers.generated.ts'",
+      ),
+    )
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'security_ext', from: '@open-mercato/core' },
+    ])
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).rejects.toThrow(
+      "declare the same output file 'security-mfa-providers.generated.ts'",
+    )
+  })
+
+  it('rejects runtime imports in generators.ts before loading the plugin', async () => {
+    scaffoldModule(tmpDir, 'security_ext', 'pkg', ['security.mfa-providers.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'security_ext', 'generators.ts'),
+      `import { randomUUID } from 'node:crypto'\n${SECURITY_GENERATORS_CONTENT}`,
+    )
+    const resolver = createMockResolver(tmpDir, [
+      { id: 'security_ext', from: '@open-mercato/core' },
+    ])
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).rejects.toThrow(
+      'generators.ts may use only `import type`',
+    )
+  })
+
+  it('repairs stale plugin output and removes it when the declaring module is disabled', async () => {
+    scaffoldModule(tmpDir, 'security_ext', 'pkg', ['security.mfa-providers.ts'])
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'security_ext', 'generators.ts'),
+      SECURITY_GENERATORS_CONTENT,
+    )
+    const activeResolver = createMockResolver(tmpDir, [
+      { id: 'security_ext', from: '@open-mercato/core' },
+    ])
+    await generateModuleRegistry({ resolver: activeResolver, quiet: true })
+
+    const outputPath = path.join(tmpDir, 'output', 'generated', 'security-mfa-providers.generated.ts')
+    const checksumPath = path.join(tmpDir, 'output', 'generated', 'security-mfa-providers.generated.checksum')
+    const manifestPath = path.join(tmpDir, 'output', 'generated', '.generator-plugin-outputs.json')
+    const expected = fs.readFileSync(outputPath, 'utf8')
+    fs.writeFileSync(outputPath, 'stale output\n')
+
+    await generateModuleRegistry({ resolver: activeResolver, quiet: true })
+    expect(fs.readFileSync(outputPath, 'utf8')).toBe(expected)
+
+    const disabledResolver = createMockResolver(tmpDir, [])
+    await generateModuleRegistry({ resolver: disabledResolver, quiet: true })
+    expect(fs.existsSync(outputPath)).toBe(false)
+    expect(fs.existsSync(checksumPath)).toBe(false)
+    expect(fs.existsSync(manifestPath)).toBe(false)
+  })
+
   it('notifications.generated.ts uses typed fallback for legacy "types" export', async () => {
     scaffoldModule(tmpDir, 'notif_mod', 'pkg', ['notifications.ts'])
     const resolver = createMockResolver(tmpDir, [