@open-mercato/cli 0.6.7-develop.6631.1.9d64b49ddc → 0.6.7-develop.6646.1.be515f3d49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.7-develop.6631.1.9d64b49ddc",
+  "version": "0.6.7-develop.6646.1.be515f3d49",
   "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.6631.1.9d64b49ddc",
-    "@open-mercato/shared": "0.6.7-develop.6631.1.9d64b49ddc",
+    "@open-mercato/queue": "0.6.7-develop.6646.1.be515f3d49",
+    "@open-mercato/shared": "0.6.7-develop.6646.1.be515f3d49",
     "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.6631.1.9d64b49ddc"
+    "@open-mercato/shared": "0.6.7-develop.6646.1.be515f3d49"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6631.1.9d64b49ddc",
+    "@open-mercato/shared": "0.6.7-develop.6646.1.be515f3d49",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

package/src/lib/generators/__tests__/route-collision-guard.test.ts

@@ -0,0 +1,123 @@
+// Tests for the backend route-collision guard in `mercato generate`
+// (`assertUniqueBackendRoutePattern`): two modules emitting the same backend URL
+// must fail generation, while distinct patterns must keep generating unchanged.
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import type { PackageResolver, ModuleEntry } from '../../resolver'
+import { generateModuleRegistry, generateModuleRegistryApp } from '../module-registry'
+
+let tmpDir: string
+let outputDir: string
+
+function touchFile(filePath: string, content = ''): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, content)
+}
+
+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'),
+  }
+}
+
+// Minimal core module: index metadata + a single backend page at the given sub-path.
+function makeCoreModule(modId: string, backendPageSegments: string[]): ModuleEntry {
+  touchFile(pkgModulePath(modId, 'index.ts'), `export const metadata = { id: '${modId}', label: '${modId}' }\n`)
+  touchFile(
+    pkgModulePath(modId, 'backend', ...backendPageSegments, 'page.tsx'),
+    `export default function ${modId}Page() { return null }\n`,
+  )
+  return { id: modId, from: '@open-mercato/core' }
+}
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'route-collision-'))
+  outputDir = path.join(tmpDir, 'app', '.mercato', 'generated')
+  fs.mkdirSync(outputDir, { recursive: true })
+})
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('backend route-collision guard', () => {
+  it('throws when two modules generate the same backend pattern (string/registry path)', async () => {
+    // Both leave the detail page un-namespaced → both resolve to `/backend/[id]`.
+    const enabled = [
+      makeCoreModule('alpha', ['[id]']),
+      makeCoreModule('beta', ['[id]']),
+    ]
+    const resolver = createMockResolver(enabled)
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).rejects.toThrow(
+      /Duplicate backend route pattern "\/backend\/\[id\]"/,
+    )
+  })
+
+  it('throws for the same collision in the app (AST) generator', async () => {
+    const enabled = [
+      makeCoreModule('alpha', ['[id]']),
+      makeCoreModule('beta', ['[id]']),
+    ]
+    const resolver = createMockResolver(enabled)
+
+    await expect(generateModuleRegistryApp({ resolver, quiet: true })).rejects.toThrow(
+      /Duplicate backend route pattern/,
+    )
+  })
+
+  it('names both colliding modules in the error', async () => {
+    const enabled = [
+      makeCoreModule('alpha', ['[id]']),
+      makeCoreModule('beta', ['[id]']),
+    ]
+    const resolver = createMockResolver(enabled)
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).rejects.toThrow(/alpha/)
+    const resolver2 = createMockResolver(enabled)
+    await expect(generateModuleRegistry({ resolver: resolver2, quiet: true })).rejects.toThrow(/beta/)
+  })
+
+  it('does not throw when backend pages are namespaced under their module folder', async () => {
+    // Distinct patterns: `/backend/alpha/[id]` and `/backend/beta/[id]`.
+    const enabled = [
+      makeCoreModule('alpha', ['alpha', '[id]']),
+      makeCoreModule('beta', ['beta', '[id]']),
+    ]
+    const resolver = createMockResolver(enabled)
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).resolves.toBeDefined()
+
+    const generated = fs.readFileSync(path.join(outputDir, 'backend-routes.generated.ts'), 'utf8')
+    expect(generated).toContain('/backend/alpha/[id]')
+    expect(generated).toContain('/backend/beta/[id]')
+  })
+
+  it('does not throw for a single module owning a pattern (no false positive)', async () => {
+    const enabled = [makeCoreModule('alpha', ['[id]'])]
+    const resolver = createMockResolver(enabled)
+
+    await expect(generateModuleRegistry({ resolver, quiet: true })).resolves.toBeDefined()
+  })
+})

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

@@ -144,6 +144,29 @@ type PageRouteGenerationResult = {
   eagerRoutes: string[]
   runtimeRoutes: string[]
   manifestRoutes: string[]
+  routePatterns: string[]
+}
+
+// Fail loud when two modules generate the same backend URL. Folder-derived
+// patterns collide only when a page is left un-namespaced (e.g. `backend/[id]`
+// instead of `backend/<mod>/[id]`), silently shadowing another module at runtime.
+// Mirrors the existing duplicate-command-id guard.
+function assertUniqueBackendRoutePattern(
+  seen: Map<string, string>,
+  moduleId: string,
+  pattern: string,
+): void {
+  if (!pattern.startsWith('/backend/')) return
+  const previous = seen.get(pattern)
+  if (previous && previous !== moduleId) {
+    throw new Error(
+      `[generate] Duplicate backend route pattern "${pattern}" generated by modules ` +
+      `"${previous}" and "${moduleId}". Each backend page must resolve to a unique URL — ` +
+      `nest the page under a module-specific folder (e.g. backend/${moduleId}/...) so it ` +
+      `does not silently shadow another module.`,
+    )
+  }
+  seen.set(pattern, moduleId)
 }
 
 type ApiRouteGenerationResult = {
@@ -1721,6 +1744,7 @@ async function processPageFiles(options: {
   const eagerRoutes: string[] = []
   const runtimeRoutes: string[] = []
   const manifestRoutes: string[] = []
+  const routePatterns: string[] = []
 
   // Next-style page.* files
   for (const { relPath, fromApp } of files.filter(({ relPath: f }) => isModulePageFile(path.basename(f)))) {
@@ -1792,6 +1816,7 @@ async function processPageFiles(options: {
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     manifestRoutes.push(`{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`)
+    routePatterns.push(routePath)
   }
 
   // Back-compat direct files (old-style pages like login.tsx instead of login/page.tsx)
@@ -1870,12 +1895,14 @@ async function processPageFiles(options: {
     eagerRoutes.push(`{ ${baseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     runtimeRoutes.push(`{ ${runtimeBaseProps}, Component: ${buildLazyRouteComponentExpression(importPath)} }`)
     manifestRoutes.push(`{ moduleId: ${toLiteral(modId)}, ${manifestBaseProps}, load: async () => { const mod = await ${buildDynamicImportExpression(importPath)}; return (mod.default ?? mod) as any } }`)
+    routePatterns.push(routePath)
   }
 
   return {
     eagerRoutes,
     runtimeRoutes,
     manifestRoutes,
+    routePatterns,
   }
 }
 
@@ -2540,7 +2567,7 @@ async function processPageFilesAst(options: {
   pkgImportBase: string
   imports: string[]
   importIdRef: { value: number }
-}): Promise<WriterFunction[]> {
+}): Promise<{ routes: WriterFunction[]; routePatterns: string[] }> {
   const {
     files,
     type,
@@ -2553,6 +2580,7 @@ async function processPageFilesAst(options: {
     importIdRef,
   } = options
   const routes: WriterFunction[] = []
+  const routePatterns: string[] = []
   const metaPrefix = type === 'frontend' ? 'MRuntime' : 'BMRuntime'
 
   const addRoute = (params: {
@@ -2569,6 +2597,7 @@ async function processPageFilesAst(options: {
         },
       ]),
     )
+    routePatterns.push(params.routePath)
   }
 
   for (const { relPath, fromApp } of files.filter(({ relPath: filePath }) => isModulePageFile(path.basename(filePath)))) {
@@ -2663,7 +2692,7 @@ async function processPageFilesAst(options: {
     })
   }
 
-  return routes
+  return { routes, routePatterns }
 }
 
 function processSubscribersAst(discovered: DiscoveredSubscriber[]): WriterFunction[] {
@@ -2866,6 +2895,8 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
     aclPath?: string
   }> = []
 
+  const seenBackendRoutePatterns = new Map<string, string>()
+
   for (const discovered of discovery.modules) {
     const { modId, roots, imps, appImportBase } = discovered
     commandLoaderEntries.push(...discovered.commandLoaderEntries)
@@ -3050,6 +3081,9 @@ async function generateModuleRegistryFromDiscovery(options: ModuleRegistryRender
         backendRoutes.push(...generatedBackendRoutes.eagerRoutes)
         runtimeBackendRoutes.push(...generatedBackendRoutes.runtimeRoutes)
         backendRouteManifestDecls.push(...generatedBackendRoutes.manifestRoutes)
+        for (const pattern of generatedBackendRoutes.routePatterns) {
+          assertUniqueBackendRoutePattern(seenBackendRoutePatterns, modId, pattern)
+        }
         hasRouteComponents = true
       }
     }
@@ -3431,6 +3465,7 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
   const requiresByModule = new Map<string, string[]>()
   const commandLoaderEntries: CommandLoaderGenerationEntry[] = []
   let hasRouteComponents = false
+  const seenBackendRoutePatterns = new Map<string, string>()
 
   for (const discovered of discovery.modules) {
     const { modId, roots, imps, appImportBase } = discovered
@@ -3519,7 +3554,7 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
       const fePkg = path.join(roots.pkgBase, 'frontend')
       const feFiles = discovered.frontendFiles
       if (feFiles.length > 0) {
-        frontendRoutes.push(...await processPageFilesAst({
+        const feAst = await processPageFilesAst({
           files: feFiles,
           type: 'frontend',
           modId,
@@ -3529,7 +3564,8 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
           pkgImportBase: imps.pkgBase,
           imports,
           importIdRef,
-        }))
+        })
+        frontendRoutes.push(...feAst.routes)
         hasRouteComponents = true
       }
     }
@@ -3539,7 +3575,7 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
       const bePkg = path.join(roots.pkgBase, 'backend')
       const beFiles = discovered.backendFiles
       if (beFiles.length > 0) {
-        backendRoutes.push(...await processPageFilesAst({
+        const beAst = await processPageFilesAst({
           files: beFiles,
           type: 'backend',
           modId,
@@ -3549,7 +3585,11 @@ async function generateModuleRegistryAppFromDiscovery(options: ModuleRegistryRen
           pkgImportBase: imps.pkgBase,
           imports,
           importIdRef,
-        }))
+        })
+        backendRoutes.push(...beAst.routes)
+        for (const pattern of beAst.routePatterns) {
+          assertUniqueBackendRoutePattern(seenBackendRoutePatterns, modId, pattern)
+        }
         hasRouteComponents = true
       }
     }