@open-mercato/cli 0.6.7-develop.6686.1.bdda5ed397 → 0.6.7-develop.6688.1.4426ef7fa7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.7-develop.6686.1.bdda5ed397",
+  "version": "0.6.7-develop.6688.1.4426ef7fa7",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     "@mikro-orm/decorators": "^7.1.5",
     "@mikro-orm/migrations": "^7.1.5",
     "@mikro-orm/postgresql": "^7.1.5",
-    "@open-mercato/queue": "0.6.7-develop.6686.1.bdda5ed397",
-    "@open-mercato/shared": "0.6.7-develop.6686.1.bdda5ed397",
+    "@open-mercato/queue": "0.6.7-develop.6688.1.4426ef7fa7",
+    "@open-mercato/shared": "0.6.7-develop.6688.1.4426ef7fa7",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -72,10 +72,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6686.1.bdda5ed397"
+    "@open-mercato/shared": "0.6.7-develop.6688.1.4426ef7fa7"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6686.1.bdda5ed397",
+    "@open-mercato/shared": "0.6.7-develop.6688.1.4426ef7fa7",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

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/generators/extensions/injection-widgets.ts

@@ -183,9 +183,52 @@ function resolveScannedWidgetPath(roots: ModuleRoots, fromApp: boolean, relPath:
   return path.join(base, 'widgets', 'injection', ...relPath.split('/'))
 }
 
+/**
+ * A widget's `metadata.id` and the injection-table entry that mounts it are two hand-typed string
+ * literals in two different files, and nothing links them. A typo in either fails silently: the spot
+ * resolves to no widget and nothing is logged, so it only surfaces as "why isn't my widget
+ * rendering" during manual QA.
+ *
+ * Reports table entries whose `widgetId` no scanned widget declares. Diagnostics only — generated
+ * output is unchanged and the build is not failed, since a table entry may legitimately point at a
+ * widget supplied by a module that is not enabled in this app.
+ *
+ * Deliberately one-directional. The mirror check ("a widget nothing references is never mounted")
+ * cannot be done reliably yet: `extractInjectionTableWidgetIds` only reads statically-analyzable
+ * object literals, so a table assembled by composition or computation contributes **no** visible
+ * ids — `example` exports `cond ? { ...a, ...b } : a` and `translations` exports
+ * `buildInjectionTable()`, and both would have every one of their widgets reported as unreferenced.
+ * Under-reporting is harmless in the direction implemented here (a reference the extractor never saw
+ * cannot produce a warning) but fatal in the other. Teaching the extractor to resolve spreads,
+ * conditionals and call expressions is the prerequisite for adding it.
+ */
+function reportUnresolvableWidgetReferences(
+  widgetEntries: Map<string, InjectionWidgetEntry>,
+  tableWidgetRefs: Map<string, Set<string>>,
+): void {
+  const declaredIds = new Set<string>()
+  for (const entry of widgetEntries.values()) {
+    if (entry.widgetId) declaredIds.add(entry.widgetId)
+  }
+
+  for (const [widgetId, modules] of Array.from(tableWidgetRefs.entries()).sort(([a], [b]) => a.localeCompare(b))) {
+    if (declaredIds.has(widgetId)) continue
+    const owners = Array.from(modules).sort((left, right) => left.localeCompare(right)).join(', ')
+    console.warn(
+      `[generate] ⚠ Injection table in "${owners}" references widget id "${widgetId}", but no scanned ` +
+        'widget declares it — that spot will render nothing. Check the id against the widget\'s ' +
+        'metadata.id, and that the widget lives in a file the scanner reads ' +
+        '(widgets/injection/**/widget.ts|tsx — note that widget.client.tsx alone is not scanned).',
+    )
+  }
+}
+
 export function createInjectionWidgetsExtension(): GeneratorExtension {
   const widgetEntries = new Map<string, InjectionWidgetEntry>()
   const tableEntries: InjectionTableEntry[] = []
+  // widgetId -> module ids whose injection table references it. Collected across every module so a
+  // table may legitimately reference a widget another module owns.
+  const tableWidgetRefs = new Map<string, Set<string>>()
 
   return {
     id: 'registry.injection-widgets',
@@ -217,6 +260,12 @@ export function createInjectionWidgetsExtension(): GeneratorExtension {
         moduleWidgetEntries[0].widgetId = tableWidgetIds[0]
       }
 
+      for (const widgetId of tableWidgetIds) {
+        const modules = tableWidgetRefs.get(widgetId) ?? new Set<string>()
+        modules.add(ctx.moduleId)
+        tableWidgetRefs.set(widgetId, modules)
+      }
+
       for (const entry of moduleWidgetEntries) {
         const existing = widgetEntries.get(entry.key)
         if (!existing || (existing.source !== 'app' && entry.source === 'app')) {
@@ -233,6 +282,8 @@ export function createInjectionWidgetsExtension(): GeneratorExtension {
       }
     },
     generateOutput() {
+      reportUnresolvableWidgetReferences(widgetEntries, tableWidgetRefs)
+
       const widgetDecls = Array.from(widgetEntries.entries())
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([, entry]) =>