@open-mercato/cli 0.6.6-develop.6352.1.8eee7e1399 → 0.6.6-develop.6353.1.efc82affea

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.6-develop.6352.1.8eee7e1399",
+  "version": "0.6.6-develop.6353.1.efc82affea",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     "@mikro-orm/decorators": "^7.1.4",
     "@mikro-orm/migrations": "^7.1.4",
     "@mikro-orm/postgresql": "^7.1.4",
-    "@open-mercato/queue": "0.6.6-develop.6352.1.8eee7e1399",
-    "@open-mercato/shared": "0.6.6-develop.6352.1.8eee7e1399",
+    "@open-mercato/queue": "0.6.6-develop.6353.1.efc82affea",
+    "@open-mercato/shared": "0.6.6-develop.6353.1.efc82affea",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -71,10 +71,10 @@
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6352.1.8eee7e1399"
+    "@open-mercato/shared": "0.6.6-develop.6353.1.efc82affea"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6352.1.8eee7e1399",
+    "@open-mercato/shared": "0.6.6-develop.6353.1.efc82affea",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

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

@@ -196,6 +196,8 @@ function scaffoldFixture(): ModuleEntry[] {
   touchFile(pkgModulePath('orders', 'data', 'guards.ts'), `export const guards = [\n  { id: 'orders.prevent-duplicate', entity: 'orders:sales_order', event: 'create', description: 'Prevents duplicate orders', async validate(input: any) { return { ok: true } } },\n]\n`)
   touchFile(pkgModulePath('orders', 'api', 'interceptors.ts'), `export const interceptors = [\n  { id: 'orders.validate-total', targetRoute: 'orders', methods: ['POST', 'PUT'], priority: 100, async before(request: any) { return { ok: true } } },\n]\n`)
   touchFile(pkgModulePath('orders', 'commands', 'interceptors.ts'), `export const interceptors = [\n  { id: 'orders.audit-log', commandId: 'orders.create', phase: 'after', async handler(command: any) { return { ok: true } } },\n]\n`)
+  touchFile(pkgModulePath('orders', 'commands', 'create.ts'), `import { registerCommand } from '@open-mercato/shared/lib/commands'\nexport const ORDERS_CREATE_COMMAND_ID = 'orders.create'\nconst createOrderCommand = {\n  id: ORDERS_CREATE_COMMAND_ID,\n  async execute() { return { id: 'order-1' } },\n}\nregisterCommand(createOrderCommand)\n`)
+  touchFile(pkgModulePath('orders', 'commands', 'archive.ts'), `import { registerCommand } from '@open-mercato/shared/lib/commands'\nconst commandId = 'orders.archive'\nregisterCommand({\n  id: commandId,\n  async execute() { return { ok: true } },\n})\n`)
   touchFile(pkgModulePath('orders', 'acl.ts'), "export const features = ['orders.view', 'orders.create', 'orders.edit', 'orders.delete']\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', hashField: 'customer_email_hash' }] }]\nexport default defaultEncryptionMaps\n")
@@ -1177,6 +1179,27 @@ describe('search.generated.ts', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// command-loaders.generated.ts
+// ---------------------------------------------------------------------------
+
+describe('command-loaders.generated.ts', () => {
+  it('includes command ids declared through const variables', async () => {
+    const enabled = scaffoldFixture()
+    const resolver = createMockResolver(enabled)
+    await generateModuleRegistry({ resolver, quiet: true })
+    const content = readGenerated('command-loaders.generated.ts')
+
+    expectExports(content, ['commandLoaderEntries'], 'command-loaders.generated.ts')
+    expect(content).toContain('id: "orders.archive"')
+    expect(content).toContain('id: "orders.create"')
+    expect(content).toContain('key: "orders:commands:archive"')
+    expect(content).toContain('key: "orders:commands:create"')
+    expect(content).toContain('@open-mercato/core/modules/orders/commands/archive')
+    expect(content).toContain('@open-mercato/core/modules/orders/commands/create')
+  })
+})
+
 // ---------------------------------------------------------------------------
 // modules.app.generated.ts
 // ---------------------------------------------------------------------------

package/src/lib/generators/module-registry.ts

@@ -80,6 +80,13 @@ type DashboardWidgetEntry = {
   importPath: string
 }
 
+type CommandLoaderGenerationEntry = {
+  moduleId: string
+  key: string
+  importPath: string
+  ids: string[]
+}
+
 type RuntimeApiMethodMetadata = {
   requireAuth?: boolean
   requireRoles?: string[]
@@ -1031,6 +1038,164 @@ function buildDynamicImportExpression(importPath: string): string {
   return `import(${toLiteral(sanitizeGeneratedModuleSpecifier(importPath))})`
 }
 
+const COMMAND_SCAN_CONFIG = {
+  folder: 'commands',
+  include: (name: string) =>
+    ['.ts', '.js', '.tsx', '.jsx'].some((extension) => name.endsWith(extension)) &&
+    !name.endsWith('.d.ts') &&
+    !/\.(test|spec)\.[jt]sx?$/.test(name) &&
+    stripModuleCodeExtension(name) !== 'index',
+  sort: (a: string, b: string) => a.localeCompare(b),
+}
+
+function getStaticStringExpression(
+  expr: ts.Expression,
+  stringConstants: Map<string, string> = new Map(),
+): string | null {
+  const unwrapped = unwrapExpression(expr)
+  if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) return unwrapped.text
+  if (ts.isIdentifier(unwrapped)) {
+    const direct = stringConstants.get(unwrapped.text)
+    if (direct) return direct
+  }
+  return null
+}
+
+function getPropertyNameText(name: ts.PropertyName): string | null {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text
+  return null
+}
+
+function getObjectStringProperty(
+  object: ts.ObjectLiteralExpression,
+  propertyName: string,
+  stringConstants: Map<string, string> = new Map(),
+): string | null {
+  for (const property of object.properties) {
+    if (!ts.isPropertyAssignment(property)) continue
+    const name = getPropertyNameText(property.name)
+    if (name !== propertyName) continue
+    return getStaticStringExpression(property.initializer, stringConstants)
+  }
+  return null
+}
+
+function collectStringArrayElements(expr: ts.Expression, stringConstants: Map<string, string> = new Map()): string[] {
+  const unwrapped = unwrapExpression(expr)
+  if (!ts.isArrayLiteralExpression(unwrapped)) return []
+  const values: string[] = []
+  for (const element of unwrapped.elements) {
+    const value = getStaticStringExpression(element, stringConstants)
+    if (value) values.push(value)
+  }
+  return values
+}
+
+function extractCommandIdsFromSource(sourcePath: string): string[] {
+  const sourceText = fs.readFileSync(sourcePath, 'utf8')
+  const sourceFile = ts.createSourceFile(sourcePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+  const ids = new Set<string>()
+  const stringConstants = new Map<string, string>()
+  const variableCommandIds = new Map<string, string>()
+
+  const collectVariables = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+      const stringValue = getStaticStringExpression(node.initializer, stringConstants)
+      if (stringValue) {
+        stringConstants.set(node.name.text, stringValue)
+      }
+      if (ts.isObjectLiteralExpression(node.initializer)) {
+        const id = getObjectStringProperty(node.initializer, 'id', stringConstants)
+        if (id) variableCommandIds.set(node.name.text, id)
+      } else if (node.name.text === 'commandIds') {
+        for (const id of collectStringArrayElements(node.initializer, stringConstants)) ids.add(id)
+      }
+    }
+    ts.forEachChild(node, collectVariables)
+  }
+
+  const collectRegistrations = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const callName = node.expression.text
+      const firstArg = node.arguments[0]
+      if (callName === 'registerCommand' && firstArg) {
+        if (ts.isIdentifier(firstArg)) {
+          const id = variableCommandIds.get(firstArg.text)
+          if (id) ids.add(id)
+        } else if (ts.isObjectLiteralExpression(firstArg)) {
+          const id = getObjectStringProperty(firstArg, 'id', stringConstants)
+          if (id) ids.add(id)
+        }
+      }
+      if (callName === 'registerDictionaryEntryCommands' && firstArg && ts.isObjectLiteralExpression(firstArg)) {
+        const prefix = getObjectStringProperty(firstArg, 'commandPrefix', stringConstants)
+        if (prefix) {
+          ids.add(`${prefix}.create`)
+          ids.add(`${prefix}.update`)
+          ids.add(`${prefix}.delete`)
+        }
+      }
+    }
+    ts.forEachChild(node, collectRegistrations)
+  }
+
+  collectVariables(sourceFile)
+  collectRegistrations(sourceFile)
+  return Array.from(ids).sort((a, b) => a.localeCompare(b))
+}
+
+function collectCommandLoaderEntries(
+  roots: ModuleRoots,
+  imps: ModuleImports,
+  modId: string,
+): CommandLoaderGenerationEntry[] {
+  const files = scanModuleDir(roots, COMMAND_SCAN_CONFIG)
+  const entries: CommandLoaderGenerationEntry[] = []
+  for (const file of files) {
+    const relPath = `commands/${file.relPath}`
+    const resolved = resolveModuleFile(roots, imps, relPath)
+    if (!resolved) continue
+    const logicalKey = stripModuleCodeExtension(file.relPath)
+    const basename = path.basename(logicalKey)
+    if (basename === 'shared' || basename === 'factory') continue
+    entries.push({
+      moduleId: modId,
+      key: `${modId}:commands:${logicalKey}`,
+      importPath: resolved.importPath,
+      ids: extractCommandIdsFromSource(resolved.absolutePath),
+    })
+  }
+  return entries
+}
+
+function renderCommandLoadersFile(entries: CommandLoaderGenerationEntry[]): string {
+  const seenCommandIds = new Map<string, string>()
+  const rendered: string[] = []
+
+  for (const entry of entries) {
+    const loadExpr = `() => ${buildDynamicImportExpression(entry.importPath)}`
+    for (const id of entry.ids) {
+      const previous = seenCommandIds.get(id)
+      if (previous && previous !== entry.key) {
+        throw new Error(`[generate] Duplicate command id "${id}" discovered in "${previous}" and "${entry.key}"`)
+      }
+      seenCommandIds.set(id, entry.key)
+      rendered.push(`  { moduleId: ${toLiteral(entry.moduleId)}, id: ${toLiteral(id)}, key: ${toLiteral(entry.key)}, load: ${loadExpr} },`)
+    }
+    rendered.push(`  { moduleId: ${toLiteral(entry.moduleId)}, key: ${toLiteral(entry.key)}, load: ${loadExpr} },`)
+  }
+
+  return `// AUTO-GENERATED by mercato generate command-loaders
+import type { CommandLoader } from '@open-mercato/shared/lib/commands'
+
+export const commandLoaderEntries: CommandLoader[] = [
+${rendered.join('\n')}
+]
+
+export default commandLoaderEntries
+`
+}
+
 function serializeGeneratedImport(statement: GeneratedImportStatement): string {
   if (typeof statement === 'string') {
     return statement
@@ -2577,6 +2742,8 @@ export async function generateModuleRegistry(options: ModuleRegistryOptions): Pr
   const bootstrapRegsChecksumFile = path.join(outputDir, 'bootstrap-registrations.generated.checksum')
   const legacySubscribersOutFile = path.join(outputDir, 'subscribers.generated.ts')
   const legacySubscribersChecksumFile = path.join(outputDir, 'subscribers.generated.checksum')
+  const commandLoadersOutFile = path.join(outputDir, 'command-loaders.generated.ts')
+  const commandLoadersChecksumFile = path.join(outputDir, 'command-loaders.generated.checksum')
 
   const enabled = resolver.loadEnabledModules()
   for (const entry of enabled) {
@@ -2621,6 +2788,7 @@ export async function generateModuleRegistry(options: ModuleRegistryOptions): Pr
   const importIdRef = { value: 0 }
   const trackedRoots = new Set<string>()
   const requiresByModule = new Map<string, string[]>()
+  const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
   let hasRouteComponents = false
 
   // UMES conflict detection: collect file paths during module processing
@@ -2641,6 +2809,7 @@ export async function generateModuleRegistry(options: ModuleRegistryOptions): Pr
     const isAppModule = entry.from === '@app'
     const appImportBase = isAppModule ? `../../src/modules/${modId}` : rawImps.appBase
     const imps: ModuleImports = { appBase: appImportBase, pkgBase: rawImps.pkgBase }
+    commandLoaderEntries.push(...collectCommandLoaderEntries(roots, imps, modId))
 
     const frontendRoutes: string[] = []
     const backendRoutes: string[] = []
@@ -3124,6 +3293,8 @@ export async function generateModuleRegistry(options: ModuleRegistryOptions): Pr
   writeGeneratedFile({ outFile: backendRoutesOutFile, checksumFile: backendRoutesChecksumFile, content: backendRoutesOutput, structureChecksum, result, quiet })
   writeGeneratedFile({ outFile: apiRoutesOutFile, checksumFile: apiRoutesChecksumFile, content: apiRoutesOutput, structureChecksum, result, quiet })
   writeGeneratedFile({ outFile: legacySubscribersOutFile, checksumFile: legacySubscribersChecksumFile, content: legacySubscribersOutput, structureChecksum, result, quiet })
+  const commandLoadersOutput = renderCommandLoadersFile(commandLoaderEntries)
+  writeGeneratedFile({ outFile: commandLoadersOutFile, checksumFile: commandLoadersChecksumFile, content: commandLoadersOutput, structureChecksum, result, quiet })
 
   for (const extension of extensions) {
     const outputs = extension.generateOutput()
@@ -3200,6 +3371,8 @@ export async function generateModuleRegistryApp(options: ModuleRegistryOptions):
   const legacyChecksumFile = path.join(outputDir, 'bootstrap-modules.generated.checksum')
   const enabledIdsOutFile = path.join(outputDir, 'enabled-module-ids.generated.ts')
   const enabledIdsChecksumFile = path.join(outputDir, 'enabled-module-ids.generated.checksum')
+  const commandLoadersOutFile = path.join(outputDir, 'command-loaders.generated.ts')
+  const commandLoadersChecksumFile = path.join(outputDir, 'command-loaders.generated.checksum')
 
   const enabled = resolver.loadEnabledModules()
   for (const entry of enabled) {
@@ -3210,6 +3383,7 @@ export async function generateModuleRegistryApp(options: ModuleRegistryOptions):
   const importIdRef = { value: 0 }
   const trackedRoots = new Set<string>()
   const requiresByModule = new Map<string, string[]>()
+  const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
   let hasRouteComponents = false
 
   for (const entry of enabled) {
@@ -3222,6 +3396,7 @@ export async function generateModuleRegistryApp(options: ModuleRegistryOptions):
     const isAppModule = entry.from === '@app'
     const appImportBase = isAppModule ? `../../src/modules/${modId}` : rawImps.appBase
     const imps: ModuleImports = { appBase: appImportBase, pkgBase: rawImps.pkgBase }
+    commandLoaderEntries.push(...collectCommandLoaderEntries(roots, imps, modId))
 
     const frontendRoutes: WriterFunction[] = []
     const backendRoutes: WriterFunction[] = []
@@ -3514,6 +3689,9 @@ export async function generateModuleRegistryApp(options: ModuleRegistryOptions):
   const enabledIdsOutput = renderEnabledModuleIdsFile(enabled.map((entry) => entry.id))
   writeGeneratedFile({ outFile: enabledIdsOutFile, checksumFile: enabledIdsChecksumFile, content: enabledIdsOutput, structureChecksum, result, quiet })
 
+  const commandLoadersOutput = renderCommandLoadersFile(commandLoaderEntries)
+  writeGeneratedFile({ outFile: commandLoadersOutFile, checksumFile: commandLoadersChecksumFile, content: commandLoadersOutput, structureChecksum, result, quiet })
+
   return result
 }
 
@@ -3534,6 +3712,8 @@ export async function generateModuleRegistryCli(options: ModuleRegistryOptions):
   const checksumFile = path.join(outputDir, 'modules.cli.generated.checksum')
   const legacyOutFile = path.join(outputDir, 'cli-modules.generated.ts')
   const legacyChecksumFile = path.join(outputDir, 'cli-modules.generated.checksum')
+  const commandLoadersOutFile = path.join(outputDir, 'command-loaders.generated.ts')
+  const commandLoadersChecksumFile = path.join(outputDir, 'command-loaders.generated.checksum')
 
   const enabled = resolver.loadEnabledModules()
   for (const entry of enabled) {
@@ -3545,6 +3725,7 @@ export async function generateModuleRegistryCli(options: ModuleRegistryOptions):
   const importIdRef = { value: 0 }
   const trackedRoots = new Set<string>()
   const requiresByModule = new Map<string, string[]>()
+  const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
 
   for (const entry of enabled) {
     const modId = entry.id
@@ -3556,6 +3737,7 @@ export async function generateModuleRegistryCli(options: ModuleRegistryOptions):
     const isAppModule = entry.from === '@app'
     const appImportBase = isAppModule ? `../../src/modules/${modId}` : rawImps.appBase
     const imps: ModuleImports = { appBase: appImportBase, pkgBase: rawImps.pkgBase }
+    commandLoaderEntries.push(...collectCommandLoaderEntries(roots, imps, modId))
 
     let cliImportName: string | null = null
     const translations: GeneratedObjectEntry[] = []
@@ -3848,6 +4030,8 @@ export async function generateModuleRegistryCli(options: ModuleRegistryOptions):
   const structureChecksum = calculateStructureChecksum(Array.from(trackedRoots))
   writeGeneratedFile({ outFile, checksumFile, content: output, structureChecksum, result, quiet })
   writeGeneratedFile({ outFile: legacyOutFile, checksumFile: legacyChecksumFile, content: legacyOutput, structureChecksum, result, quiet })
+  const commandLoadersOutput = renderCommandLoadersFile(commandLoaderEntries)
+  writeGeneratedFile({ outFile: commandLoadersOutFile, checksumFile: commandLoadersChecksumFile, content: commandLoadersOutput, structureChecksum, result, quiet })
 
   return result
 }