@open-mercato/cli 0.6.7-develop.6566.1.15385fa179 → 0.6.7-develop.6568.1.9f57ffc393

package/package.json

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

package/src/__tests__/mercato.test.ts

@@ -531,7 +531,7 @@ describe('init command failure output', () => {
   })
 })
 
-describe('generate post-step structural cache purge', () => {
+describe('generate post-step structural invalidation', () => {
   beforeEach(() => {
     jest.restoreAllMocks()
     jest.resetModules()
@@ -540,11 +540,12 @@ describe('generate post-step structural cache purge', () => {
   afterEach(() => {
     jest.dontMock('../lib/generators')
     jest.dontMock('../lib/resolver')
+    jest.dontMock('../lib/post-generate-invalidation')
     jest.dontMock('@open-mercato/shared/lib/bootstrap/dynamicLoader')
     jest.resetModules()
   })
 
-  it('runs structural cache purge after successful generation when configs cache CLI is available', async () => {
+  it('uses the lightweight invalidation helper after successful generation', async () => {
     const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
     const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
     const generateEntityIds = jest.fn().mockResolvedValue({
@@ -559,7 +560,12 @@ describe('generate post-step structural cache purge', () => {
     const generateModuleDi = jest.fn().mockResolvedValue(undefined)
     const generateModulePackageSources = jest.fn().mockResolvedValue(undefined)
     const generateOpenApi = jest.fn().mockResolvedValue(undefined)
-    const cacheRun = jest.fn().mockResolvedValue(undefined)
+    const invalidate = jest.fn().mockResolvedValue({
+      cacheEntriesDeleted: 2,
+      generatedFilesTouched: ['/tmp/test-app/.mercato/generated/modules.generated.ts'],
+      cacheError: null,
+      generatedFilesError: null,
+    })
 
     jest.doMock('../lib/generators', () => ({
       generateEntityIds,
@@ -574,25 +580,22 @@ describe('generate post-step structural cache purge', () => {
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
         getAppDir: () => '/tmp/test-app',
+        loadEnabledModules: () => [{ id: 'configs', from: '@open-mercato/core' }],
       }),
     }))
-    jest.doMock('@open-mercato/shared/lib/bootstrap/dynamicLoader', () => ({
-      bootstrapFromAppRoot: jest.fn().mockResolvedValue({
-        modules: [
-          {
-            id: 'configs',
-            cli: [{ command: 'cache', run: cacheRun }],
-          },
-        ],
-      }),
+    jest.doMock('../lib/post-generate-invalidation', () => ({
+      runPostGenerateStructuralInvalidation: invalidate,
     }))
+    jest.doMock('@open-mercato/shared/lib/bootstrap/dynamicLoader', () => {
+      throw new Error('post-generation invalidation must not bootstrap generated modules')
+    })
 
     const mercato = await import('../mercato')
     const exitCode = await mercato.run(['node', 'mercato', 'generate'])
 
     expect(exitCode).toBe(0)
     expect(generateEntityIds).toHaveBeenCalled()
-    expect(cacheRun).toHaveBeenCalledWith(['structural', '--all-tenants', '--quiet'])
+    expect(invalidate).toHaveBeenCalledWith('/tmp/test-app')
 
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
@@ -616,32 +619,33 @@ describe('generate post-step structural cache purge', () => {
       generateModulePackageSources: jest.fn().mockResolvedValue(unchangedResult),
       generateOpenApi: jest.fn().mockResolvedValue(unchangedResult),
     }
-    const bootstrapFromAppRoot = jest.fn()
+    const invalidate = jest.fn()
 
     jest.doMock('../lib/generators', () => generators)
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
         getAppDir: () => '/tmp/test-app',
+        loadEnabledModules: () => [{ id: 'configs', from: '@open-mercato/core' }],
       }),
     }))
-    jest.doMock('@open-mercato/shared/lib/bootstrap/dynamicLoader', () => ({
-      bootstrapFromAppRoot,
+    jest.doMock('../lib/post-generate-invalidation', () => ({
+      runPostGenerateStructuralInvalidation: invalidate,
     }))
 
     const mercato = await import('../mercato')
     const exitCode = await mercato.run(['node', 'mercato', 'generate'])
 
     expect(exitCode).toBe(0)
-    expect(bootstrapFromAppRoot).not.toHaveBeenCalled()
+    expect(invalidate).not.toHaveBeenCalled()
     expect(consoleLogSpy).toHaveBeenCalledWith(
-      '[generate] Generated outputs unchanged; skipping structural cache purge.',
+      '[generate] Generated outputs unchanged; skipping structural invalidation.',
     )
 
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
 
-  it('keeps generation successful when the post-generate cache purge bootstrap fails', async () => {
+  it('keeps generation successful when lightweight invalidation fails', async () => {
     const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
     const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
     const generateEntityIds = jest.fn().mockResolvedValue({
@@ -656,6 +660,7 @@ describe('generate post-step structural cache purge', () => {
     const generateModuleDi = jest.fn().mockResolvedValue(undefined)
     const generateModulePackageSources = jest.fn().mockResolvedValue(undefined)
     const generateOpenApi = jest.fn().mockResolvedValue(undefined)
+    const invalidate = jest.fn().mockRejectedValue(new Error('cache maintenance unavailable'))
 
     jest.doMock('../lib/generators', () => ({
       generateEntityIds,
@@ -670,10 +675,11 @@ describe('generate post-step structural cache purge', () => {
     jest.doMock('../lib/resolver', () => ({
       createResolver: () => ({
         getAppDir: () => '/tmp/test-app',
+        loadEnabledModules: () => [{ id: 'configs', from: '@open-mercato/core' }],
       }),
     }))
-    jest.doMock('@open-mercato/shared/lib/bootstrap/dynamicLoader', () => ({
-      bootstrapFromAppRoot: jest.fn().mockRejectedValue(new Error('generated cli bootstrap unavailable')),
+    jest.doMock('../lib/post-generate-invalidation', () => ({
+      runPostGenerateStructuralInvalidation: invalidate,
     }))
 
     const mercato = await import('../mercato')
@@ -681,6 +687,42 @@ describe('generate post-step structural cache purge', () => {
 
     expect(exitCode).toBe(0)
     expect(generateEntityIds).toHaveBeenCalled()
+    expect(invalidate).toHaveBeenCalledWith('/tmp/test-app')
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  it('skips cache infrastructure entirely when configs is not enabled', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    const generate = jest.fn().mockResolvedValue(undefined)
+
+    jest.doMock('../lib/generators', () => ({
+      generateEntityIds: generate,
+      generateModuleRegistry: generate,
+      generateModuleRegistryApp: generate,
+      generateModuleRegistryCli: generate,
+      generateModuleEntities: generate,
+      generateModuleDi: generate,
+      generateModulePackageSources: generate,
+      generateOpenApi: generate,
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      createResolver: () => ({
+        getAppDir: () => '/tmp/test-app',
+        loadEnabledModules: () => [{ id: 'auth', from: '@open-mercato/core' }],
+      }),
+    }))
+    jest.doMock('../lib/post-generate-invalidation', () => {
+      throw new Error('cache infrastructure must stay unloaded without configs')
+    })
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'generate'])
+
+    expect(exitCode).toBe(0)
+    expect(generate).toHaveBeenCalled()
 
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()

package/src/lib/__tests__/post-generate-invalidation.test.ts

@@ -0,0 +1,81 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { purgeConfiguredCachePatternsAcrossTenantScopes } from '@open-mercato/shared/lib/cache/maintenance'
+import { runPostGenerateStructuralInvalidation } from '../post-generate-invalidation'
+
+jest.mock('@open-mercato/shared/lib/cache/maintenance', () => ({
+  purgeConfiguredCachePatternsAcrossTenantScopes: jest.fn(),
+}))
+
+const purgeCache = jest.mocked(purgeConfiguredCachePatternsAcrossTenantScopes)
+
+describe('runPostGenerateStructuralInvalidation', () => {
+  beforeEach(() => {
+    purgeCache.mockReset().mockResolvedValue(3)
+  })
+
+  it('purges structural cache patterns and refreshes only generated artifacts', async () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-generate-invalidation-'))
+    try {
+      const generatedDir = path.join(appDir, '.mercato', 'generated')
+      fs.mkdirSync(generatedDir, { recursive: true })
+      const generatedTs = path.join(generatedDir, 'modules.app.generated.ts')
+      const generatedChecksum = path.join(generatedDir, 'modules.app.generated.checksum')
+      const unrelated = path.join(generatedDir, 'README.md')
+      fs.writeFileSync(generatedTs, 'export const modules = []\n')
+      fs.writeFileSync(generatedChecksum, 'abc\n')
+      fs.writeFileSync(unrelated, 'keep\n')
+
+      const result = await runPostGenerateStructuralInvalidation(appDir)
+
+      expect(purgeCache).toHaveBeenCalledWith([
+        'nav:*',
+        'crud|*|*|*/admin/nav|*',
+        'crud|*|*|*/portal/nav|*',
+      ])
+      expect(result).toEqual({
+        cacheEntriesDeleted: 3,
+        generatedFilesTouched: [generatedChecksum, generatedTs],
+        cacheError: null,
+        generatedFilesError: null,
+      })
+      expect(fs.readFileSync(generatedTs, 'utf8')).toBe('export const modules = []\n')
+      expect(fs.readFileSync(unrelated, 'utf8')).toBe('keep\n')
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+
+  it('still refreshes generated artifacts when cache maintenance fails', async () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-generate-invalidation-failure-'))
+    const error = new Error('cache unavailable')
+    try {
+      const generatedDir = path.join(appDir, '.mercato', 'generated')
+      fs.mkdirSync(generatedDir, { recursive: true })
+      const generatedTs = path.join(generatedDir, 'modules.generated.ts')
+      fs.writeFileSync(generatedTs, 'export {}\n')
+      purgeCache.mockRejectedValueOnce(error)
+
+      const result = await runPostGenerateStructuralInvalidation(appDir)
+
+      expect(result.cacheEntriesDeleted).toBe(0)
+      expect(result.cacheError).toBe(error)
+      expect(result.generatedFilesTouched).toEqual([generatedTs])
+      expect(result.generatedFilesError).toBeNull()
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+
+  it('treats a missing generated directory as a successful no-op', async () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-generate-invalidation-empty-'))
+    try {
+      const result = await runPostGenerateStructuralInvalidation(appDir)
+      expect(result.generatedFilesTouched).toEqual([])
+      expect(result.generatedFilesError).toBeNull()
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/lib/post-generate-invalidation.ts

@@ -0,0 +1,62 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { purgeConfiguredCachePatternsAcrossTenantScopes } from '@open-mercato/shared/lib/cache/maintenance'
+
+const STRUCTURAL_CACHE_PATTERNS = [
+  'nav:*',
+  'crud|*|*|*/admin/nav|*',
+  'crud|*|*|*/portal/nav|*',
+]
+const TOUCHABLE_GENERATED_FILE_PATTERN = /\.generated(?:\.[a-z0-9]+)?(?:\.ts|\.checksum)$/i
+
+export type PostGenerateStructuralInvalidationResult = {
+  cacheEntriesDeleted: number
+  generatedFilesTouched: string[]
+  cacheError: unknown | null
+  generatedFilesError: unknown | null
+}
+
+function touchGeneratedFiles(appDir: string): string[] {
+  const generatedDir = path.join(appDir, '.mercato', 'generated')
+  if (!fs.existsSync(generatedDir) || !fs.statSync(generatedDir).isDirectory()) return []
+
+  const touched: string[] = []
+  const entries = fs.readdirSync(generatedDir, { withFileTypes: true })
+    .sort((left, right) => left.name.localeCompare(right.name))
+  for (const entry of entries) {
+    if (!entry.isFile() || !TOUCHABLE_GENERATED_FILE_PATTERN.test(entry.name)) continue
+    const filePath = path.join(generatedDir, entry.name)
+    const contents = fs.readFileSync(filePath)
+    fs.writeFileSync(filePath, contents)
+    touched.push(filePath)
+  }
+  return touched
+}
+
+export async function runPostGenerateStructuralInvalidation(
+  appDir: string,
+): Promise<PostGenerateStructuralInvalidationResult> {
+  let cacheEntriesDeleted = 0
+  let generatedFilesTouched: string[] = []
+  let cacheError: unknown | null = null
+  let generatedFilesError: unknown | null = null
+
+  try {
+    generatedFilesTouched = touchGeneratedFiles(appDir)
+  } catch (error) {
+    generatedFilesError = error
+  }
+
+  try {
+    cacheEntriesDeleted = await purgeConfiguredCachePatternsAcrossTenantScopes(STRUCTURAL_CACHE_PATTERNS)
+  } catch (error) {
+    cacheError = error
+  }
+
+  return {
+    cacheEntriesDeleted,
+    generatedFilesTouched,
+    cacheError,
+    generatedFilesError,
+  }
+}

package/src/mercato.ts

@@ -706,40 +706,40 @@ async function runModuleCommand(
   return true
 }
 
-async function runPostGenerateStructuralCachePurge(quiet: boolean): Promise<void> {
+async function runPostGenerateStructuralInvalidation(quiet: boolean): Promise<void> {
   try {
-    const [{ bootstrapFromAppRoot }, { createResolver }] = await Promise.all([
-      import('@open-mercato/shared/lib/bootstrap/dynamicLoader'),
-      import('./lib/resolver'),
-    ])
+    const { createResolver } = await import('./lib/resolver')
     const resolver = createResolver()
     const appDir = resolver.getAppDir()
-    const data = await bootstrapFromAppRoot(appDir)
-    registerCliModules(data.modules)
-    const configsModule = data.modules.find((mod) => mod.id === 'configs')
-    const hasCacheCommand = configsModule?.cli?.some((command) => command.command === 'cache') ?? false
+    const hasConfigsModule = resolver.loadEnabledModules().some((module) => module.id === 'configs')
 
-    if (!hasCacheCommand) {
+    if (!hasConfigsModule) {
       if (!quiet) {
-        console.log('[generate] Skipping structural cache purge: "configs cache" is not available in this app.')
+        console.log('[generate] Skipping structural invalidation: the "configs" module is not enabled in this app.')
       }
       return
     }
 
+    const { runPostGenerateStructuralInvalidation: invalidate } = await import('./lib/post-generate-invalidation')
     if (!quiet) {
-      console.log('[generate] Purging structural cache for all tenants...')
+      console.log('[generate] Invalidating generated structure...')
     }
-    await runModuleCommand(data.modules, 'configs', 'cache', ['structural', '--all-tenants', '--quiet'], {
-      optional: true,
-      silentOptional: quiet,
-    })
+    const result = await invalidate(appDir)
     if (!quiet) {
-      console.log('[generate] Structural cache purge completed.')
+      if (result.cacheError) {
+        console.log(`[generate] Structural cache purge skipped: ${formatCliFailureMessage('configs', 'cache', result.cacheError)}`)
+      }
+      if (result.generatedFilesError) {
+        console.log(`[generate] Generated artifact refresh skipped: ${formatCliFailureMessage('generate', 'refresh', result.generatedFilesError)}`)
+      }
+      console.log(
+        `[generate] Structural invalidation completed (${result.cacheEntriesDeleted} cache entr${result.cacheEntriesDeleted === 1 ? 'y' : 'ies'}, ${result.generatedFilesTouched.length} generated artifact${result.generatedFilesTouched.length === 1 ? '' : 's'} refreshed).`,
+      )
     }
   } catch (error) {
     if (!quiet) {
       const message = formatCliFailureMessage('configs', 'cache', error)
-      console.log(`[generate] Skipping structural cache purge: ${message}`)
+      console.log(`[generate] Skipping structural invalidation: ${message}`)
     }
   }
 }
@@ -780,11 +780,11 @@ async function runGeneratorSuiteWithStructuralInvalidation(quiet: boolean): Prom
   const generatedFilesChanged = await runGeneratorSuite(quiet)
   if (!generatedFilesChanged) {
     if (!quiet) {
-      console.log('[generate] Generated outputs unchanged; skipping structural cache purge.')
+      console.log('[generate] Generated outputs unchanged; skipping structural invalidation.')
     }
     return
   }
-  await runPostGenerateStructuralCachePurge(quiet)
+  await runPostGenerateStructuralInvalidation(quiet)
 }
 
 /**