@open-mercato/cli 0.7.0 → 0.7.1-develop.7102.1.b41f7e3e51

package/src/lib/generators/__tests__/registry-variant-parity.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Cross-implementation parity between the two module registry variants.
+ *
+ * `generateModuleRegistry` (modules.generated.ts / modules.runtime.generated.ts) and
+ * `generateModuleRegistryApp` (modules.app.generated.ts) describe the same modules from
+ * the same discovery input. Nothing asserted that they agree, which is what let the two
+ * emitters drift far enough apart to need this migration in the first place.
+ *
+ * These tests generate every variant from one fixture, parse the emitted module entries,
+ * and assert that for each module id the properties both variants are expected to carry
+ * are present or absent identically. Properties only one variant is supposed to carry are
+ * asserted explicitly as known, intentional divergences, so a future change that erases or
+ * widens one of them fails here rather than silently.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import ts from 'typescript-js'
+import type { PackageResolver, ModuleEntry } from '../../resolver'
+import { generateModuleRegistry, generateModuleRegistryApp } from '../module-registry'
+
+/** Properties both registry variants must agree on, per module. */
+const SHARED_PROPERTIES = [
+  'id',
+  'info',
+  'frontendRoutes',
+  'backendRoutes',
+  'translations',
+  'subscribers',
+  'workers',
+  'entityExtensions',
+  'customFieldSets',
+  'features',
+  'customEntities',
+  'setup',
+  'defaultEncryptionMaps',
+  'integrations',
+  'bundles',
+] as const
+
+let tmpDir: string
+let outputDir: string
+let fileMtimeNonce = 0
+
+function touchFile(filePath: string, content = ''): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, content)
+  const mtime = new Date(Date.now() + fileMtimeNonce)
+  fileMtimeNonce += 1
+  fs.utimesSync(filePath, mtime, mtime)
+}
+
+function pkgModulePath(modId: string, ...segments: string[]): string {
+  return path.join(tmpDir, 'packages', 'core', 'src', 'modules', modId, ...segments)
+}
+
+function createMockResolver(enabled: ModuleEntry[]): PackageResolver {
+  return {
+    isMonorepo: () => true,
+    getRootDir: () => tmpDir,
+    getAppDir: () => path.join(tmpDir, 'app'),
+    getOutputDir: () => outputDir,
+    getModulesConfigPath: () => path.join(tmpDir, 'app', 'src', 'modules.ts'),
+    discoverPackages: () => [],
+    loadEnabledModules: () => enabled,
+    getModulePaths: (entry: ModuleEntry) => ({
+      appBase: path.join(tmpDir, 'app', 'src', 'modules', entry.id),
+      pkgBase: path.join(tmpDir, '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(tmpDir, 'packages', 'core'),
+  } as unknown as PackageResolver
+}
+
+/**
+ * A module carrying every optional property, plus a deliberately bare one, so the
+ * parity assertions cover both the "present in both" and "absent in both" directions.
+ */
+function scaffoldFixture(): ModuleEntry[] {
+  touchFile(pkgModulePath('orders', 'index.ts'), "export const metadata = { id: 'orders', label: 'Orders' }\n")
+  touchFile(pkgModulePath('orders', 'frontend', 'page.tsx'), 'export default function OrdersPage() { return null }\n')
+  touchFile(pkgModulePath('orders', 'backend', 'page.tsx'), 'export default function OrdersBackendPage() { return null }\n')
+  touchFile(
+    pkgModulePath('orders', 'api', 'orders', 'route.ts'),
+    "export const metadata = { path: '/orders' }\nexport function GET() { return new Response('ok') }\n",
+  )
+  touchFile(
+    pkgModulePath('orders', 'subscribers', 'on-created.ts'),
+    "export const metadata = { event: 'orders.order.created', persistent: true }\nexport default async function handler() {}\n",
+  )
+  touchFile(
+    pkgModulePath('orders', 'workers', 'sync-job.ts'),
+    "export const metadata = { queue: 'orders.sync', concurrency: 2 }\nexport default async function handler() {}\n",
+  )
+  touchFile(
+    pkgModulePath('orders', 'data', 'extensions.ts'),
+    "export const extensions = [{ sourceEntity: 'orders:sales_order', targetEntity: 'customers:person', foreignKey: 'customer_id' }]\n",
+  )
+  touchFile(pkgModulePath('orders', 'acl.ts'), "export const features = ['orders.view', 'orders.create']\n")
+  touchFile(pkgModulePath('orders', 'setup.ts'), "export const setup = { defaultRoleFeatures: ['orders.view'] }\n")
+  touchFile(
+    pkgModulePath('orders', 'encryption.ts'),
+    "export const defaultEncryptionMaps = [{ entityId: 'orders:sales_order', fields: [{ field: 'customer_email' }] }]\nexport default defaultEncryptionMaps\n",
+  )
+  touchFile(
+    pkgModulePath('orders', 'integration.ts'),
+    "export const integration = { id: 'orders.shipping', label: 'Shipping' }\nexport const bundle = { id: 'orders.bundle', label: 'Bundle' }\n",
+  )
+  touchFile(pkgModulePath('orders', 'ce.ts'), "export const entities = [{ id: 'orders:custom', fields: [{ id: 'note', kind: 'text' }] }]\n")
+  touchFile(pkgModulePath('orders', 'i18n', 'en.json'), JSON.stringify({ orders: { title: 'Orders' } }))
+  touchFile(pkgModulePath('orders', 'cli.ts'), 'export default { command: "orders", run: async () => {} }\n')
+
+  touchFile(pkgModulePath('bare', 'index.ts'), "export const metadata = { id: 'bare', label: 'Bare' }\n")
+
+  return [
+    { id: 'orders', from: '@open-mercato/core' },
+    { id: 'bare', from: '@open-mercato/core' },
+  ]
+}
+
+function readGenerated(fileName: string): string {
+  const filePath = path.join(outputDir, fileName)
+  if (!fs.existsSync(filePath)) throw new Error(`Expected generated file not found: ${fileName}`)
+  return fs.readFileSync(filePath, 'utf8')
+}
+
+/** Maps module id → the set of property names that module's entry declares. */
+function parseModulePropertiesById(content: string, fileName: string): Map<string, Set<string>> {
+  const sourceFile = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+
+  let modulesArray: ts.ArrayLiteralExpression | null = null
+  const visit = (node: ts.Node): void => {
+    if (
+      !modulesArray
+      && ts.isVariableDeclaration(node)
+      && ts.isIdentifier(node.name)
+      && node.name.text === 'modules'
+      && node.initializer
+      && ts.isArrayLiteralExpression(node.initializer)
+    ) {
+      modulesArray = node.initializer
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(sourceFile)
+  if (!modulesArray) throw new Error(`No exported "modules" array literal found in ${fileName}`)
+
+  const byId = new Map<string, Set<string>>()
+  for (const element of (modulesArray as ts.ArrayLiteralExpression).elements) {
+    if (!ts.isObjectLiteralExpression(element)) {
+      throw new Error(`Non-object module entry in ${fileName}`)
+    }
+    const names = new Set<string>()
+    let moduleId: string | null = null
+    for (const property of element.properties) {
+      if (!ts.isPropertyAssignment(property)) continue
+      const name = ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)
+        ? property.name.text
+        : null
+      if (!name) continue
+      names.add(name)
+      if (name === 'id' && ts.isStringLiteralLike(property.initializer)) {
+        moduleId = property.initializer.text
+      }
+    }
+    if (!moduleId) throw new Error(`Module entry without a literal id in ${fileName}`)
+    byId.set(moduleId, names)
+  }
+  return byId
+}
+
+function restrictTo(names: Set<string>, allowed: readonly string[]): string[] {
+  return allowed.filter((name) => names.has(name)).sort()
+}
+
+describe('module registry variant parity', () => {
+  let mainVariant: Map<string, Set<string>>
+  let runtimeVariant: Map<string, Set<string>>
+  let appVariant: Map<string, Set<string>>
+
+  beforeAll(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'registry-parity-'))
+    outputDir = path.join(tmpDir, 'app', '.mercato', 'generated')
+    fs.mkdirSync(outputDir, { recursive: true })
+
+    const resolver = createMockResolver(scaffoldFixture())
+    const mainResult = await generateModuleRegistry({ resolver, quiet: true })
+    const appResult = await generateModuleRegistryApp({ resolver, quiet: true })
+    expect(mainResult.errors).toEqual([])
+    expect(appResult.errors).toEqual([])
+
+    mainVariant = parseModulePropertiesById(readGenerated('modules.generated.ts'), 'modules.generated.ts')
+    runtimeVariant = parseModulePropertiesById(
+      readGenerated('modules.runtime.generated.ts'),
+      'modules.runtime.generated.ts',
+    )
+    appVariant = parseModulePropertiesById(readGenerated('modules.app.generated.ts'), 'modules.app.generated.ts')
+  })
+
+  afterAll(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('discovers the same module ids in every variant', () => {
+    const ids = [...mainVariant.keys()].sort()
+    expect(ids).toEqual(['bare', 'orders'])
+    expect([...runtimeVariant.keys()].sort()).toEqual(ids)
+    expect([...appVariant.keys()].sort()).toEqual(ids)
+  })
+
+  it.each(['orders', 'bare'])('main and app variants agree on the shared properties of "%s"', (moduleId) => {
+    const main = mainVariant.get(moduleId)
+    const app = appVariant.get(moduleId)
+    expect(main).toBeDefined()
+    expect(app).toBeDefined()
+    expect(restrictTo(main!, SHARED_PROPERTIES)).toEqual(restrictTo(app!, SHARED_PROPERTIES))
+  })
+
+  it.each(['orders', 'bare'])('main and runtime variants agree on the shared properties of "%s"', (moduleId) => {
+    const main = mainVariant.get(moduleId)
+    const runtime = runtimeVariant.get(moduleId)
+    expect(main).toBeDefined()
+    expect(runtime).toBeDefined()
+    expect(restrictTo(main!, SHARED_PROPERTIES)).toEqual(restrictTo(runtime!, SHARED_PROPERTIES))
+  })
+
+  it('carries every optional property for the fully-featured module', () => {
+    expect(restrictTo(mainVariant.get('orders')!, SHARED_PROPERTIES)).toEqual([...SHARED_PROPERTIES].sort())
+  })
+
+  it('omits every optional property for the bare module', () => {
+    expect(restrictTo(mainVariant.get('bare')!, SHARED_PROPERTIES)).toEqual(['customFieldSets', 'id', 'info'])
+  })
+
+  describe('known, intentional divergences', () => {
+    it('only the main variant carries eager api handlers and the cli entry point', () => {
+      expect(mainVariant.get('orders')!.has('apis')).toBe(true)
+      expect(mainVariant.get('orders')!.has('cli')).toBe(true)
+      expect(appVariant.get('orders')!.has('apis')).toBe(false)
+      expect(appVariant.get('orders')!.has('cli')).toBe(false)
+    })
+
+    it('the runtime variant carries api handlers but not the cli entry point', () => {
+      expect(runtimeVariant.get('orders')!.has('apis')).toBe(true)
+      expect(runtimeVariant.get('orders')!.has('cli')).toBe(false)
+    })
+
+    it('only the main and app variants carry dashboardWidgets, and only the app variant emits it unconditionally', () => {
+      expect(mainVariant.get('bare')!.has('dashboardWidgets')).toBe(false)
+      expect(appVariant.get('bare')!.has('dashboardWidgets')).toBe(true)
+      expect(runtimeVariant.get('orders')!.has('dashboardWidgets')).toBe(false)
+    })
+  })
+})

package/src/lib/generators/__tests__/route-manifest-shards.test.ts

@@ -47,6 +47,21 @@ describe('route manifest shards', () => {
     expect(loader).toContain(`const ROUTE_SHARD_KEYS = ["customers","__dynamic","customers","__root"]`)
   })
 
+  it('indents every line of a multi-line declaration inside the shard array', () => {
+    const declaration = ['{', '  moduleId: "customers",', '  path: "/customers"', '} as any'].join('\n')
+    const outputs = renderRouteManifestShardOutputs('api', [{ path: '/customers', declaration }])
+    const shard = outputs.find((entry) => entry.fileName.includes('route-shard.'))?.content ?? ''
+
+    expect(shard).toContain([
+      'export const routes: ApiRouteManifestEntry[] = [',
+      '  {',
+      '    moduleId: "customers",',
+      '    path: "/customers"',
+      '  } as any',
+      ']',
+    ].join('\n'))
+  })
+
   it('renders metadata without load functions while retaining metadata imports', () => {
     const output = renderRouteMetadataOutput('backend', [{
       path: '/backend/settings',

package/src/lib/generators/__tests__/structural-contracts.test.ts

@@ -186,6 +186,7 @@ function scaffoldFixture(): ModuleEntry[] {
   touchFile(pkgModulePath('orders', 'subscribers', 'on-created.ts'), "export const metadata = { event: 'orders.order.created', persistent: true }\nexport default async function handler() {}\n")
   touchFile(pkgModulePath('orders', 'subscribers', 'on-payment.ts'), "export const metadata = { event: 'payments.payment.completed', persistent: true }\nexport default async function handler() {}\n")
   touchFile(pkgModulePath('orders', 'workers', 'sync-job.ts'), "export const metadata = { queue: 'orders.sync', concurrency: 2 }\nexport default async function handler() {}\n")
+  touchFile(pkgModulePath('orders', 'workers', 'safe-job.ts'), "export const metadata = { queue: 'orders.safe', schedulerSafe: true }\nexport default async function handler() {}\n")
   touchFile(pkgModulePath('orders', 'widgets', 'dashboard', 'revenue', 'widget.tsx'), 'export default function RevenueWidget() { return null }\n')
   touchFile(pkgModulePath('orders', 'widgets', 'injection', 'sidebar', 'widget.tsx'), 'export default function SidebarWidget() { return null }\n')
   touchFile(pkgModulePath('orders', 'widgets', 'injection-table.ts'), `export const injectionTable = {\n  'crud-form:orders:sales_order:fields': [{ widgetId: 'orders.sidebar', kind: 'section', priority: 50 }],\n}\nexport default injectionTable\n`)
@@ -507,8 +508,8 @@ describe('modules.generated.ts', () => {
   })
 
   it('modules include translation locale keys', () => {
-    expect(content).toContain("'en':")
-    expect(content).toContain("'pl':")
+    expect(content).toMatch(/['"]en['"]:/)
+    expect(content).toMatch(/['"]pl['"]:/)
   })
 
   it('modules include customFieldSets reference from ce.ts', () => {
@@ -635,7 +636,7 @@ describe('api-routes.generated.ts', () => {
 
   it('products API route has all 4 methods', () => {
     expect(content).toContain('path: "/products"')
-    expect(content).toMatch(/methods:.*GET.*POST.*PUT.*DELETE/)
+    expect(content).toMatch(/methods:\s*\[\s*"GET",\s*"POST",\s*"PUT",\s*"DELETE",?\s*\]/)
   })
 
   it('keeps API handler imports lazy in route entries', () => {
@@ -1265,6 +1266,9 @@ describe('modules.bootstrap.generated.ts', () => {
     expect(content).toContain('orders.order.created')
     expect(content).toContain('setup:')
     expect(content).toContain('features:')
+    // worker metadata flags must survive into the registry the server registers
+    expect(content).toContain("queue: \"orders.safe\"")
+    expect(content).toContain('schedulerSafe: true')
 
     expect(content).not.toContain('frontendRoutes:')
     expect(content).not.toContain('backendRoutes:')

package/src/lib/generators/ast/index.ts

@@ -1,5 +1,5 @@
 export { addImportSpec, addImportSpecs, addImportStatement, addImportStatements, type GeneratedImportSpec } from './imports'
-export { addAutoGeneratedComment, createGeneratedSourceFile, getSourceText } from './source-file'
+export { addAutoGeneratedComment, createGeneratedSourceFile, getSourceText, renderGeneratedValue } from './source-file'
 export {
   arrayLiteral,
   assignmentStatement,
@@ -11,6 +11,7 @@ export {
   callExpression,
   conditionalExpression,
   elementAccess,
+  escapeGeneratedJsonLiteral,
   expressionStatement,
   forOfStatement,
   identifier,

package/src/lib/generators/ast/source-file.ts

@@ -1,4 +1,5 @@
 import { IndentationText, Project, type SourceFile } from 'ts-morph'
+import { writeValue, type GeneratedValue } from './writers'
 
 let sharedProject: Project | null = null
 
@@ -26,6 +27,18 @@ export function createGeneratedSourceFile(fileName: string): SourceFile {
   return project.createSourceFile(fileName, '', { overwrite: true })
 }
 
+/**
+ * Renders a single generated value to source text, outside of any source file. Generators
+ * that hand a pre-rendered expression to a consumer expecting a string (route manifest
+ * shards) use this instead of concatenating the expression by hand, so the AST writers stay
+ * the one place an expression is constructed.
+ */
+export function renderGeneratedValue(value: GeneratedValue): string {
+  const writer = getProject().createWriter()
+  writeValue(writer, value)
+  return writer.toString()
+}
+
 export function addAutoGeneratedComment(sourceFile: SourceFile, generator: string): void {
   sourceFile.insertText(0, `// AUTO-GENERATED by mercato generate ${generator}\n`)
 }

package/src/lib/generators/ast/writers.ts

@@ -22,6 +22,31 @@ export interface SpreadPropertyWriter {
 export type GeneratedObjectEntry = ObjectPropertyWriter | SpreadPropertyWriter
 export type StatementWriter = WriterFunction
 
+/**
+ * Escapes the characters that are legal inside a JSON string but hazardous inside a
+ * generated JavaScript source file: `<` and `>` so an emitted value can never close a
+ * surrounding script context, and U+2028 / U+2029 which older JavaScript parsers reject
+ * inside a string literal. The escape sequences denote the same runtime string, so this
+ * only ever changes the emitted text, never the emitted value.
+ */
+export function escapeGeneratedJsonLiteral(json: string): string {
+  return json
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+}
+
+/**
+ * The single point where a string value becomes source text on the AST path. The string
+ * paths that are still emitted as templates share the escaping step above rather than
+ * this function, because they also serialize objects, whose nested strings need the same
+ * hardening.
+ */
+export function stringLiteral(value: string): string {
+  return escapeGeneratedJsonLiteral(JSON.stringify(value))
+}
+
 export function writeLiteral(writer: CodeBlockWriter, value: Exclude<GeneratedValue, WriterFunction>): void {
   if (value === undefined) {
     writer.write('undefined')
@@ -34,7 +59,7 @@ export function writeLiteral(writer: CodeBlockWriter, value: Exclude<GeneratedVa
   }
 
   if (typeof value === 'string') {
-    writer.write(JSON.stringify(value))
+    writer.write(stringLiteral(value))
     return
   }