@open-mercato/cli 0.6.8-develop.7099.1.7ba2771d06 → 0.7.0

package/src/lib/generators/__tests__/bootstrap-registrations.test.ts

@@ -1,176 +0,0 @@
-/**
- * Contract tests for `renderBootstrapRegistrationsFile`, the emitter behind
- * `bootstrap-registrations.generated.ts`.
- *
- * The file is always written — even when no generator plugin contributes a bootstrap
- * registration — so `bootstrap.ts` can import it unconditionally. These tests cover
- * that core-only case, one plugin, two plugins whose registration imports overlap
- * (de-duplication), and a malformed import statement, which must fail at generation
- * time with the offending statement named rather than emit a broken file.
- */
-import ts from 'typescript-js'
-import { renderBootstrapRegistrationsFile } from '../module-registry'
-
-const CORE_ENTRY_IMPORTS = [
-  'import { backendRoutes } from "./backend-routes.generated"',
-  'import { frontendRoutes } from "./frontend-routes.generated"',
-]
-const CORE_REGISTRATION_IMPORTS = [
-  "import { registerBackendRouteManifests, registerFrontendRouteManifests } from '@open-mercato/shared/modules/registry'",
-]
-const CORE_CALLS = [
-  'registerBackendRouteManifests(backendRoutes)',
-  'registerFrontendRouteManifests(frontendRoutes)',
-]
-
-function parseFile(content: string): ts.SourceFile {
-  return ts.createSourceFile('bootstrap-registrations.generated.ts', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-}
-
-function expectNoSyntaxErrors(content: string): void {
-  const sourceFile = parseFile(content)
-  const diagnostics = (sourceFile as unknown as { parseDiagnostics?: ts.Diagnostic[] }).parseDiagnostics ?? []
-  expect(diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, ' '))).toEqual([])
-}
-
-function parseImports(content: string): Array<{ moduleSpecifier: string; names: string[] }> {
-  return parseFile(content)
-    .statements.filter(ts.isImportDeclaration)
-    .map((declaration) => {
-      const bindings = declaration.importClause?.namedBindings
-      return {
-        moduleSpecifier: (declaration.moduleSpecifier as ts.StringLiteral).text,
-        names: bindings && ts.isNamedImports(bindings) ? bindings.elements.map((element) => element.name.text) : [],
-      }
-    })
-}
-
-function parseRegistrationCalls(content: string): string[] {
-  const sourceFile = parseFile(content)
-  const declaration = sourceFile.statements.find(
-    (statement): statement is ts.FunctionDeclaration =>
-      ts.isFunctionDeclaration(statement) && statement.name?.text === 'runBootstrapRegistrations',
-  )
-  if (!declaration) throw new Error('runBootstrapRegistrations declaration not found')
-  return (declaration.body?.statements ?? []).map((statement) => statement.getText(sourceFile).replace(/;$/, ''))
-}
-
-function isExportedVoidFunction(content: string): boolean {
-  const declaration = parseFile(content).statements.find(
-    (statement): statement is ts.FunctionDeclaration =>
-      ts.isFunctionDeclaration(statement) && statement.name?.text === 'runBootstrapRegistrations',
-  )
-  if (!declaration) return false
-  const isExported = declaration.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false
-  return isExported && declaration.type?.kind === ts.SyntaxKind.VoidKeyword
-}
-
-describe('renderBootstrapRegistrationsFile', () => {
-  it('emits the core route registrations when no plugin contributes one', () => {
-    const content = renderBootstrapRegistrationsFile({
-      entryImports: CORE_ENTRY_IMPORTS,
-      registrationImports: CORE_REGISTRATION_IMPORTS,
-      calls: CORE_CALLS,
-    })
-
-    expectNoSyntaxErrors(content)
-    expect(content.startsWith('// AUTO-GENERATED by mercato generate registry\n')).toBe(true)
-    expect(isExportedVoidFunction(content)).toBe(true)
-    expect(parseImports(content)).toEqual([
-      { moduleSpecifier: './backend-routes.generated', names: ['backendRoutes'] },
-      { moduleSpecifier: './frontend-routes.generated', names: ['frontendRoutes'] },
-      {
-        moduleSpecifier: '@open-mercato/shared/modules/registry',
-        names: ['registerBackendRouteManifests', 'registerFrontendRouteManifests'],
-      },
-    ])
-    expect(parseRegistrationCalls(content)).toEqual(CORE_CALLS)
-  })
-
-  it('appends a single plugin registration after the core ones', () => {
-    const content = renderBootstrapRegistrationsFile({
-      entryImports: [
-        ...CORE_ENTRY_IMPORTS,
-        'import { securityMfaProviderEntries } from "./security-mfa-providers.generated"',
-      ],
-      registrationImports: [
-        ...CORE_REGISTRATION_IMPORTS,
-        "import { registerMfaProviders } from '@open-mercato/core/modules/security/mfa'",
-      ],
-      calls: [...CORE_CALLS, 'registerMfaProviders(securityMfaProviderEntries)'],
-    })
-
-    expectNoSyntaxErrors(content)
-    expect(parseImports(content).map((parsed) => parsed.moduleSpecifier)).toEqual([
-      './backend-routes.generated',
-      './frontend-routes.generated',
-      './security-mfa-providers.generated',
-      '@open-mercato/shared/modules/registry',
-      '@open-mercato/core/modules/security/mfa',
-    ])
-    expect(parseRegistrationCalls(content)).toEqual([
-      ...CORE_CALLS,
-      'registerMfaProviders(securityMfaProviderEntries)',
-    ])
-  })
-
-  it('de-duplicates an identical registration import contributed by two plugins', () => {
-    const sharedRegistrationImport = "import { registerEntries } from '@open-mercato/core/modules/shared/registrations'"
-    const content = renderBootstrapRegistrationsFile({
-      entryImports: [
-        ...CORE_ENTRY_IMPORTS,
-        'import { firstPluginEntries } from "./first-plugin.generated"',
-        'import { secondPluginEntries } from "./second-plugin.generated"',
-      ],
-      registrationImports: [...CORE_REGISTRATION_IMPORTS, sharedRegistrationImport, sharedRegistrationImport],
-      calls: [...CORE_CALLS, 'registerEntries(firstPluginEntries)', 'registerEntries(secondPluginEntries)'],
-    })
-
-    expectNoSyntaxErrors(content)
-    expect(parseImports(content).filter((parsed) => parsed.names.includes('registerEntries'))).toHaveLength(1)
-    expect(parseRegistrationCalls(content)).toEqual([
-      ...CORE_CALLS,
-      'registerEntries(firstPluginEntries)',
-      'registerEntries(secondPluginEntries)',
-    ])
-  })
-
-  it('emits a valid module with an empty body when nothing registers at all', () => {
-    const content = renderBootstrapRegistrationsFile({ entryImports: [], registrationImports: [], calls: [] })
-
-    expectNoSyntaxErrors(content)
-    expect(isExportedVoidFunction(content)).toBe(true)
-    expect(parseImports(content)).toEqual([])
-    expect(parseRegistrationCalls(content)).toEqual([])
-  })
-
-  it('fails at generation time and names the statement when a plugin import is malformed', () => {
-    expect(() =>
-      renderBootstrapRegistrationsFile({
-        entryImports: CORE_ENTRY_IMPORTS,
-        registrationImports: [...CORE_REGISTRATION_IMPORTS, 'registerSomething from "./not-an-import"'],
-        calls: CORE_CALLS,
-      }),
-    ).toThrow('Expected import declaration, received: registerSomething from "./not-an-import"')
-  })
-
-  it('fails when a plugin import uses a non-literal module specifier', () => {
-    expect(() =>
-      renderBootstrapRegistrationsFile({
-        entryImports: CORE_ENTRY_IMPORTS,
-        registrationImports: [...CORE_REGISTRATION_IMPORTS, 'import { registerSomething } from `./templated`'],
-        calls: CORE_CALLS,
-      }),
-    ).toThrow('Unsupported import declaration: import { registerSomething } from `./templated`')
-  })
-
-  it('pins the emitted text so emitter changes surface as a reviewable diff', () => {
-    expect(
-      renderBootstrapRegistrationsFile({
-        entryImports: CORE_ENTRY_IMPORTS,
-        registrationImports: CORE_REGISTRATION_IMPORTS,
-        calls: CORE_CALLS,
-      }),
-    ).toMatchSnapshot()
-  })
-})

package/src/lib/generators/__tests__/command-loaders.test.ts

@@ -1,239 +0,0 @@
-/**
- * Contract tests for `renderCommandLoadersFile`, the emitter behind
- * `command-loaders.generated.ts`.
- *
- * The emitter is exercised directly rather than through a full generate run so the
- * assertions stay readable and fast. Expectations are structural — the file is parsed
- * and its exported array is inspected — so they survive the formatting differences a
- * ts-morph emitter introduces. One inline snapshot pins the emitted text as well, so a
- * reviewer can see the formatting delta of any future emitter change in the diff.
- */
-import ts from 'typescript-js'
-import { renderCommandLoadersFile, type CommandLoaderGenerationEntry } from '../module-registry'
-
-type ParsedLoaderEntry = {
-  moduleId?: string
-  id?: string
-  key?: string
-  loadImportPath?: string
-  propertyOrder: string[]
-}
-
-function parseFile(content: string): ts.SourceFile {
-  return ts.createSourceFile('command-loaders.generated.ts', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-}
-
-function expectNoSyntaxErrors(content: string): void {
-  const sourceFile = parseFile(content)
-  const diagnostics = (sourceFile as unknown as { parseDiagnostics?: ts.Diagnostic[] }).parseDiagnostics ?? []
-  expect(diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, ' '))).toEqual([])
-}
-
-function findExportedArray(sourceFile: ts.SourceFile, exportName: string): ts.ArrayLiteralExpression {
-  let found: ts.ArrayLiteralExpression | null = null
-  const visit = (node: ts.Node): void => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === exportName) {
-      if (node.initializer && ts.isArrayLiteralExpression(node.initializer)) {
-        found = node.initializer
-      }
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(sourceFile)
-  if (!found) throw new Error(`Exported array "${exportName}" not found`)
-  return found
-}
-
-function readStringLiteral(node: ts.Expression): string | undefined {
-  return ts.isStringLiteralLike(node) ? node.text : undefined
-}
-
-function parseTypeOnlyImports(sourceFile: ts.SourceFile): Array<{ moduleSpecifier: string; names: string[] }> {
-  return sourceFile.statements
-    .filter(ts.isImportDeclaration)
-    .filter((declaration) => declaration.importClause?.isTypeOnly === true)
-    .map((declaration) => {
-      const bindings = declaration.importClause?.namedBindings
-      return {
-        moduleSpecifier: (declaration.moduleSpecifier as ts.StringLiteral).text,
-        names: bindings && ts.isNamedImports(bindings) ? bindings.elements.map((element) => element.name.text) : [],
-      }
-    })
-}
-
-function readExportedArrayTypeAnnotation(sourceFile: ts.SourceFile, exportName: string): string | undefined {
-  let annotation: string | undefined
-  const visit = (node: ts.Node): void => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === exportName) {
-      annotation = node.type?.getText(sourceFile)
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(sourceFile)
-  return annotation
-}
-
-function readDefaultExportedIdentifier(sourceFile: ts.SourceFile): string | undefined {
-  const assignment = sourceFile.statements.find(ts.isExportAssignment)
-  if (!assignment || assignment.isExportEquals) return undefined
-  return ts.isIdentifier(assignment.expression) ? assignment.expression.text : undefined
-}
-
-function readLoadImportPath(node: ts.Expression): string | undefined {
-  if (!ts.isArrowFunction(node)) return undefined
-  const body = node.body
-  if (ts.isBlock(body)) return undefined
-  if (!ts.isCallExpression(body) || body.expression.kind !== ts.SyntaxKind.ImportKeyword) return undefined
-  const [specifier] = body.arguments
-  return specifier ? readStringLiteral(specifier) : undefined
-}
-
-function parseLoaderEntries(content: string): ParsedLoaderEntry[] {
-  const sourceFile = parseFile(content)
-  const array = findExportedArray(sourceFile, 'commandLoaderEntries')
-  return array.elements.map((element) => {
-    if (!ts.isObjectLiteralExpression(element)) throw new Error('Expected an object literal entry')
-    const parsed: ParsedLoaderEntry = { propertyOrder: [] }
-    for (const property of element.properties) {
-      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) continue
-      const name = property.name.text
-      parsed.propertyOrder.push(name)
-      if (name === 'moduleId') parsed.moduleId = readStringLiteral(property.initializer)
-      if (name === 'id') parsed.id = readStringLiteral(property.initializer)
-      if (name === 'key') parsed.key = readStringLiteral(property.initializer)
-      if (name === 'load') parsed.loadImportPath = readLoadImportPath(property.initializer)
-    }
-    return parsed
-  })
-}
-
-function entry(overrides: Partial<CommandLoaderGenerationEntry> = {}): CommandLoaderGenerationEntry {
-  return {
-    moduleId: 'catalog',
-    key: 'catalog:commands:products',
-    importPath: '@open-mercato/core/modules/catalog/commands/products',
-    ids: ['catalog.products.create'],
-    ...overrides,
-  }
-}
-
-describe('renderCommandLoadersFile', () => {
-  it('emits a parseable module with the documented exports', () => {
-    const content = renderCommandLoadersFile([entry()])
-
-    expectNoSyntaxErrors(content)
-    expect(content.startsWith('// AUTO-GENERATED by mercato generate command-loaders\n')).toBe(true)
-    expect(content.endsWith('\n')).toBe(true)
-
-    const sourceFile = parseFile(content)
-    expect(parseTypeOnlyImports(sourceFile)).toEqual([
-      { moduleSpecifier: '@open-mercato/shared/lib/commands', names: ['CommandLoader'] },
-    ])
-    expect(readExportedArrayTypeAnnotation(sourceFile, 'commandLoaderEntries')).toBe('CommandLoader[]')
-    expect(readDefaultExportedIdentifier(sourceFile)).toBe('commandLoaderEntries')
-  })
-
-  it('emits one id-scoped entry per command id followed by the module-scoped fallback entry', () => {
-    const content = renderCommandLoadersFile([
-      entry({ ids: ['catalog.products.create', 'catalog.products.delete'] }),
-    ])
-
-    expect(parseLoaderEntries(content)).toEqual([
-      {
-        moduleId: 'catalog',
-        id: 'catalog.products.create',
-        key: 'catalog:commands:products',
-        loadImportPath: '@open-mercato/core/modules/catalog/commands/products',
-        propertyOrder: ['moduleId', 'id', 'key', 'load'],
-      },
-      {
-        moduleId: 'catalog',
-        id: 'catalog.products.delete',
-        key: 'catalog:commands:products',
-        loadImportPath: '@open-mercato/core/modules/catalog/commands/products',
-        propertyOrder: ['moduleId', 'id', 'key', 'load'],
-      },
-      {
-        moduleId: 'catalog',
-        id: undefined,
-        key: 'catalog:commands:products',
-        loadImportPath: '@open-mercato/core/modules/catalog/commands/products',
-        propertyOrder: ['moduleId', 'key', 'load'],
-      },
-    ])
-  })
-
-  it('keeps entries from several modules in input order', () => {
-    const content = renderCommandLoadersFile([
-      entry(),
-      entry({
-        moduleId: 'sales',
-        key: 'sales:commands:orders',
-        importPath: '@open-mercato/core/modules/sales/commands/orders',
-        ids: ['sales.orders.create'],
-      }),
-    ])
-
-    expect(parseLoaderEntries(content).map((parsed) => [parsed.key, parsed.id])).toEqual([
-      ['catalog:commands:products', 'catalog.products.create'],
-      ['catalog:commands:products', undefined],
-      ['sales:commands:orders', 'sales.orders.create'],
-      ['sales:commands:orders', undefined],
-    ])
-  })
-
-  it('emits the module-scoped entry only when a module declares no command ids', () => {
-    const content = renderCommandLoadersFile([entry({ ids: [] })])
-
-    expectNoSyntaxErrors(content)
-    expect(parseLoaderEntries(content)).toEqual([
-      {
-        moduleId: 'catalog',
-        id: undefined,
-        key: 'catalog:commands:products',
-        loadImportPath: '@open-mercato/core/modules/catalog/commands/products',
-        propertyOrder: ['moduleId', 'key', 'load'],
-      },
-    ])
-  })
-
-  it('emits a valid module with an empty array when no module contributes commands', () => {
-    const content = renderCommandLoadersFile([])
-
-    expectNoSyntaxErrors(content)
-    expect(parseLoaderEntries(content)).toEqual([])
-  })
-
-  it('rejects the same command id contributed by two different modules', () => {
-    expect(() =>
-      renderCommandLoadersFile([
-        entry(),
-        entry({
-          moduleId: 'sales',
-          key: 'sales:commands:products',
-          importPath: '@open-mercato/core/modules/sales/commands/products',
-        }),
-      ]),
-    ).toThrow(
-      '[generate] Duplicate command id "catalog.products.create" discovered in "catalog:commands:products" and "sales:commands:products"',
-    )
-  })
-
-  it('tolerates the same command id repeated within one module key', () => {
-    const content = renderCommandLoadersFile([
-      entry({ ids: ['catalog.products.create', 'catalog.products.create'] }),
-    ])
-
-    expect(parseLoaderEntries(content)).toHaveLength(3)
-  })
-
-  it('rejects an unsafe import path instead of emitting it', () => {
-    expect(() => renderCommandLoadersFile([entry({ importPath: '' })])).toThrow(
-      'Unsafe generated module specifier',
-    )
-  })
-
-  it('pins the emitted text so emitter changes surface as a reviewable diff', () => {
-    expect(renderCommandLoadersFile([entry()])).toMatchSnapshot()
-  })
-})

package/src/lib/generators/__tests__/generated-registry-imports.test.ts

@@ -1,128 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import os from 'node:os'
-import type { PackageResolver, ModuleEntry } from '../../resolver'
-import { generateModuleRegistry, generateModuleRegistryApp, generateModuleRegistryCli } from '../module-registry'
-
-/**
- * The generator's output, not its helpers.
- *
- * A worker declaring `metadata.onJobAbandoned` makes the registry emit
- * `createLazyModuleWorkerAbandonHook(...)`, and the import for it used to be opted into per render
- * site. Forgetting it at one of the six sites produced a file referencing an undeclared name, which
- * type-checks nowhere and surfaces only at `build:app` — every unit test stayed green because no
- * fixture declared such a worker.
- *
- * These assertions are driven off the files the generators actually wrote, so a renderer added later
- * is covered without anyone remembering to extend this test.
- */
-
-let tmpDir: string
-
-function touchFile(filePath: string, content = ''): void {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true })
-  fs.writeFileSync(filePath, content)
-}
-
-function createMockResolver(dir: string, enabled: ModuleEntry[]): PackageResolver {
-  const outputDir = path.join(dir, 'output', 'generated')
-  fs.mkdirSync(outputDir, { recursive: true })
-  return {
-    isMonorepo: () => true,
-    getRootDir: () => dir,
-    getAppDir: () => path.join(dir, 'app'),
-    getOutputDir: () => outputDir,
-    getModulesConfigPath: () => path.join(dir, 'app', 'src', 'modules.ts'),
-    discoverPackages: () => [],
-    loadEnabledModules: () => enabled,
-    getModulePaths: (entry: ModuleEntry) => ({
-      appBase: path.join(dir, 'app', 'src', 'modules', entry.id),
-      pkgBase: path.join(dir, 'packages', 'core', 'src', 'modules', entry.id),
-    }),
-    getModuleImportBase: (entry: ModuleEntry) => ({
-      appBase: `@/modules/${entry.id}`,
-      pkgBase: `@open-mercato/core/modules/${entry.id}`,
-    }),
-    getPackageOutputDir: () => outputDir,
-    getPackageRoot: () => path.join(dir, 'packages', 'core'),
-  }
-}
-
-function scaffoldWorkerModule(dir: string, modId: string, workerSource: string): void {
-  touchFile(path.join(dir, 'packages', 'core', 'src', 'modules', modId, 'workers', 'sync.ts'), workerSource)
-}
-
-function generatedFiles(dir: string): Array<{ name: string; content: string }> {
-  const outputDir = path.join(dir, 'output', 'generated')
-  if (!fs.existsSync(outputDir)) return []
-  return fs.readdirSync(outputDir)
-    .filter((name) => name.endsWith('.ts'))
-    .map((name) => ({ name, content: fs.readFileSync(path.join(outputDir, name), 'utf8') }))
-}
-
-const ABANDON_HOOK_FACTORY = 'createLazyModuleWorkerAbandonHook'
-
-const WORKER_WITH_HOOK = `
-import { failAbandonedRun } from '../lib/abandoned-run'
-export const metadata = {
-  queue: 'demo-queue',
-  id: 'demo:worker',
-  concurrency: 2,
-  onJobAbandoned: failAbandonedRun,
-}
-export default async function handle() {}
-`
-
-const WORKER_WITHOUT_HOOK = `
-export const metadata = {
-  queue: 'demo-queue',
-  id: 'demo:worker',
-  concurrency: 2,
-}
-export default async function handle() {}
-`
-
-async function generateAll(resolver: PackageResolver): Promise<void> {
-  await generateModuleRegistry({ resolver, quiet: true })
-  await generateModuleRegistryApp({ resolver, quiet: true })
-  await generateModuleRegistryCli({ resolver, quiet: true })
-}
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'generated-registry-imports-'))
-})
-
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true })
-})
-
-describe('generated registries — emitted identifiers are imported', () => {
-  it('imports the abandon-hook helper in every file that calls it', async () => {
-    scaffoldWorkerModule(tmpDir, 'demo', WORKER_WITH_HOOK)
-    const resolver = createMockResolver(tmpDir, [{ id: 'demo', from: 'pkg' } as ModuleEntry])
-
-    await generateAll(resolver)
-
-    const files = generatedFiles(tmpDir)
-    const callers = files.filter(({ content }) => content.includes(`${ABANDON_HOOK_FACTORY}(`))
-    // The fixture must actually exercise the path, or this test passes vacuously — which is exactly
-    // how the missing import survived every existing suite.
-    expect(callers.length).toBeGreaterThan(0)
-
-    for (const { name, content } of callers) {
-      expect(`${name}: ${content.includes(`import { `) && new RegExp(`import \\{[^}]*\\b${ABANDON_HOOK_FACTORY}\\b[^}]*\\} from`, 's').test(content)}`)
-        .toBe(`${name}: true`)
-    }
-  })
-
-  it('leaves output untouched for a module set whose workers declare no hook', async () => {
-    scaffoldWorkerModule(tmpDir, 'demo', WORKER_WITHOUT_HOOK)
-    const resolver = createMockResolver(tmpDir, [{ id: 'demo', from: 'pkg' } as ModuleEntry])
-
-    await generateAll(resolver)
-
-    for (const { name, content } of generatedFiles(tmpDir)) {
-      expect(`${name}: ${content.includes(ABANDON_HOOK_FACTORY)}`).toBe(`${name}: false`)
-    }
-  })
-})