@open-mercato/cli 0.6.7-develop.6553.1.2ec7246e04 → 0.6.7-develop.6565.1.1026d85fff

package/src/lib/generators/__tests__/entity-ids.test.ts

@@ -30,7 +30,10 @@ function createMockResolver(tmpRoot: string, enabled: ModuleEntry[]): PackageRes
       appBase: `@/modules/${entry.id}`,
       pkgBase: `@open-mercato/core/modules/${entry.id}`,
     }),
-    getPackageOutputDir: () => outputDir,
+    getPackageOutputDir: (packageName: string) =>
+      packageName === '@app'
+        ? outputDir
+        : path.join(tmpRoot, 'packages', 'core', 'generated'),
     getPackageRoot: () => path.join(tmpRoot, 'packages', 'core'),
   }
 }
@@ -75,6 +78,100 @@ afterEach(() => {
 })
 
 describe('generateEntityIds', () => {
+  it('does not rewrite generated entity outputs when inputs are unchanged', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n totalGross!: number\n}\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+
+    const first = await generateEntityIds({ resolver, quiet: true })
+    expect(first.filesWritten.length).toBeGreaterThan(0)
+
+    const appOutput = resolver.getOutputDir()
+    const packageOutput = resolver.getPackageOutputDir('@open-mercato/core')
+    const generatedFiles = [
+      path.join(appOutput, 'entities.ids.generated.ts'),
+      path.join(appOutput, 'entity-fields-registry.ts'),
+      path.join(appOutput, 'entities', 'sales_order', 'index.ts'),
+      path.join(packageOutput, 'entities.ids.generated.ts'),
+      path.join(packageOutput, 'entity-fields-registry.ts'),
+      path.join(packageOutput, 'entities', 'sales_order', 'index.ts'),
+    ]
+    const pinnedTime = new Date('2026-01-01T00:00:00.000Z')
+    for (const filePath of generatedFiles) {
+      fs.utimesSync(filePath, pinnedTime, pinnedTime)
+    }
+
+    const second = await generateEntityIds({ resolver, quiet: true })
+
+    expect(second.filesWritten).toEqual([])
+    for (const filePath of generatedFiles) {
+      expect(fs.statSync(filePath).mtimeMs).toBe(pinnedTime.getTime())
+    }
+  })
+
+  it('reports field-only generated changes without rewriting the entity id map', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n}\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+    const rootIds = path.join(resolver.getOutputDir(), 'entities.ids.generated.ts')
+    const pinnedTime = new Date('2026-01-01T00:00:00.000Z')
+    fs.utimesSync(rootIds, pinnedTime, pinnedTime)
+
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string\n status!: string\n}\n')
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(result.filesWritten).not.toContain(rootIds)
+    expect(fs.statSync(rootIds).mtimeMs).toBe(pinnedTime.getTime())
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entities', 'sales_order', 'index.ts'),
+    )
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entity-fields-registry.ts'),
+    )
+  })
+
+  it('keeps deletion changes visible while removing stale entity field output', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\nexport class SalesLine { id!: string }\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+    const staleDirectory = path.join(resolver.getOutputDir(), 'entities', 'sales_line')
+    expect(fs.existsSync(staleDirectory)).toBe(true)
+
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\n')
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(fs.existsSync(staleDirectory)).toBe(false)
+    expect(result.filesWritten).toContain(
+      path.join(resolver.getOutputDir(), 'entities.ids.generated.ts'),
+    )
+  })
+
+  it('reports stale entity directory cleanup when every generated file is unchanged', async () => {
+    const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
+    const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')
+    fs.mkdirSync(path.dirname(entitiesFile), { recursive: true })
+    fs.writeFileSync(entitiesFile, 'export class SalesOrder { id!: string }\n')
+    const resolver = createMockResolver(tmpDir, [moduleEntry])
+    await generateEntityIds({ resolver, quiet: true })
+
+    const staleDirectory = path.join(resolver.getOutputDir(), 'entities', 'sales_line')
+    fs.mkdirSync(staleDirectory, { recursive: true })
+    fs.writeFileSync(path.join(staleDirectory, 'index.ts'), 'export const id = "id"\n')
+
+    const result = await generateEntityIds({ resolver, quiet: true })
+
+    expect(fs.existsSync(staleDirectory)).toBe(false)
+    expect(result.filesWritten).toEqual([staleDirectory])
+  })
+
   it('writes an inline entity fields registry without generated entity imports', async () => {
     const moduleEntry: ModuleEntry = { id: 'orders', from: '@open-mercato/core' }
     const entitiesFile = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'orders', 'data', 'entities.ts')

package/src/lib/generators/__tests__/openapi.test.ts

@@ -42,6 +42,27 @@ describe('resolveOpenApiGeneratorProjectRoot', () => {
 describe('generateOpenApi', () => {
   let tmpDir: string
 
+  const sharedGeneratorSource = `
+export function buildOpenApiDocument(modules: any[], options: any) {
+  const paths: Record<string, any> = {}
+  for (const module of modules) {
+    for (const api of module.apis ?? []) {
+      const methods: Record<string, any> = {}
+      for (const [method, spec] of Object.entries(api.handlers.openApi ?? {})) {
+        methods[method.toLowerCase()] = spec
+      }
+      paths[api.path.replace(/\\[([^\\]]+)\\]/g, '{$1}')] = methods
+    }
+  }
+  return {
+    openapi: '3.1.0',
+    info: { title: options.title, version: options.version, description: options.description },
+    servers: options.servers,
+    paths,
+  }
+}
+`
+
   function touchFile(filePath: string, content: string): void {
     fs.mkdirSync(path.dirname(filePath), { recursive: true })
     fs.writeFileSync(filePath, content)
@@ -79,6 +100,14 @@ describe('generateOpenApi', () => {
 
   beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openapi-generator-test-'))
+    touchFile(
+      path.join(tmpDir, 'packages', 'shared', 'src', 'lib', 'openapi', 'generator.ts'),
+      sharedGeneratorSource,
+    )
+    touchFile(path.join(tmpDir, 'package.json'), '{"private":true}\n')
+    touchFile(path.join(tmpDir, 'yarn.lock'), '# test lockfile\n')
+    touchFile(path.join(tmpDir, 'app', 'package.json'), '{"private":true}\n')
+    touchFile(path.join(tmpDir, 'app', 'tsconfig.json'), '{"compilerOptions":{}}\n')
   })
 
   afterEach(() => {
@@ -130,4 +159,149 @@ describe('generateOpenApi', () => {
     expect(openApiDoc.paths['/api/demo/health']?.get?.summary).toBe('app health')
     expect(openApiDoc.paths['/api/demo/details']?.get?.summary).toBe('package details')
   })
+
+  it('skips route discovery and bundling when all tracked inputs are unchanged', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'health', 'route.ts'),
+      [
+        'export async function GET() { return new Response("ok") }',
+        "export const openApi = { GET: { summary: 'health' } }",
+        '',
+      ].join('\n'),
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+
+    await generateOpenApi({ resolver, quiet: true })
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation()
+    const result = await generateOpenApi({ resolver, quiet: false })
+
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    expect(result.filesWritten).toEqual([])
+    expect(result.filesUnchanged).toEqual([generatedPath])
+    expect(consoleSpy).toHaveBeenCalledWith(`[OpenAPI] Skipped (inputs unchanged): ${generatedPath}`)
+    expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining('[OpenAPI] Found'))
+    consoleSpy.mockRestore()
+  })
+
+  it('invalidates the early cache when a transitive route dependency changes', async () => {
+    const moduleRoot = path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo')
+    const schemaPath = path.join(moduleRoot, 'schema.ts')
+    touchFile(schemaPath, "export const summary = 'first schema'\n")
+    touchFile(
+      path.join(moduleRoot, 'api', 'health', 'route.ts'),
+      [
+        "import { summary } from '../../schema'",
+        'export async function GET() { return new Response("ok") }',
+        'export const openApi = { GET: { summary } }',
+        '',
+      ].join('\n'),
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    await generateOpenApi({ resolver, quiet: true })
+
+    touchFile(schemaPath, "export const summary = 'second schema'\n")
+    const result = await generateOpenApi({ resolver, quiet: true })
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+      paths: Record<string, { get?: { summary?: string } }>
+    }
+
+    expect(result.filesWritten).toEqual([generatedPath])
+    expect(openApiDoc.paths['/api/demo/health']?.get?.summary).toBe('second schema')
+  })
+
+  it('invalidates the early cache when enabled modules change', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'first', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'first' } }\n",
+    )
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'second', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'second' } }\n",
+    )
+    let enabled: ModuleEntry[] = [{ id: 'first', from: '@open-mercato/core' }]
+    const delegate = createMockResolver(enabled)
+    const resolver: PackageResolver = {
+      ...delegate,
+      loadEnabledModules: () => enabled,
+    }
+    await generateOpenApi({ resolver, quiet: true })
+
+    enabled = [{ id: 'second', from: '@open-mercato/core' }]
+    await generateOpenApi({ resolver, quiet: true })
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+      paths: Record<string, unknown>
+    }
+
+    expect(openApiDoc.paths['/api/first']).toBeUndefined()
+    expect(openApiDoc.paths['/api/second']).toBeDefined()
+  })
+
+  it('rebuilds when the generated document is missing or tampered with', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'health', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'health' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+    await generateOpenApi({ resolver, quiet: true })
+
+    fs.unlinkSync(generatedPath)
+    const restored = await generateOpenApi({ resolver, quiet: true })
+    expect(restored.filesWritten).toEqual([generatedPath])
+
+    fs.writeFileSync(generatedPath, '{"tampered":true}')
+    const repaired = await generateOpenApi({ resolver, quiet: true })
+    expect(repaired.filesWritten).toEqual([generatedPath])
+    expect(JSON.parse(fs.readFileSync(generatedPath, 'utf8'))).toHaveProperty('openapi', '3.1.0')
+  })
+
+  it('invalidates the early cache when the generated server URL changes', async () => {
+    const originalAppUrl = process.env.NEXT_PUBLIC_APP_URL
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'demo' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatedPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.json')
+
+    try {
+      process.env.NEXT_PUBLIC_APP_URL = 'https://first.example.test'
+      await generateOpenApi({ resolver, quiet: true })
+      process.env.NEXT_PUBLIC_APP_URL = 'https://second.example.test'
+      const result = await generateOpenApi({ resolver, quiet: true })
+      const openApiDoc = JSON.parse(fs.readFileSync(generatedPath, 'utf8')) as {
+        servers: Array<{ url: string }>
+      }
+
+      expect(result.filesWritten).toEqual([generatedPath])
+      expect(openApiDoc.servers[0]?.url).toBe('https://second.example.test')
+    } finally {
+      if (originalAppUrl === undefined) delete process.env.NEXT_PUBLIC_APP_URL
+      else process.env.NEXT_PUBLIC_APP_URL = originalAppUrl
+    }
+  })
+
+  it('does not cache a static fallback after a bundle failure', async () => {
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'demo', 'api', 'route.ts'),
+      "export async function GET() {}\nexport const openApi = { GET: { summary: 'demo' } }\n",
+    )
+    const resolver = createMockResolver([{ id: 'demo', from: '@open-mercato/core' }])
+    const generatorPath = path.join(tmpDir, 'packages', 'shared', 'src', 'lib', 'openapi', 'generator.ts')
+    const manifestPath = path.join(tmpDir, 'output', 'generated', 'openapi.generated.inputs.json')
+    await generateOpenApi({ resolver, quiet: true })
+
+    fs.unlinkSync(generatorPath)
+    const consoleSpy = jest.spyOn(console, 'log').mockImplementation()
+    await generateOpenApi({ resolver, quiet: false })
+    await generateOpenApi({ resolver, quiet: false })
+
+    expect(consoleSpy.mock.calls.filter(([message]) =>
+      typeof message === 'string' && message.startsWith('[OpenAPI] Found'),
+    )).toHaveLength(2)
+    expect(fs.existsSync(manifestPath)).toBe(false)
+    consoleSpy.mockRestore()
+  })
 })

package/src/lib/generators/entity-ids.ts

@@ -13,6 +13,7 @@ import {
   toSnake,
   rimrafDir,
   logGenerationResult,
+  writeIfChanged,
   type GeneratorResult,
   createGeneratorResult,
 } from '../utils'
@@ -240,7 +241,23 @@ function parseEntityFieldsFromFile(filePath: string, exportedClassNames: string[
   return result
 }
 
-function writePerEntityFieldFiles(outRoot: string, fieldsByEntity: EntityFieldMap): void {
+function writeTrackedFile(
+  filePath: string,
+  content: string,
+  result: GeneratorResult,
+): void {
+  if (writeIfChanged(filePath, content)) {
+    result.filesWritten.push(filePath)
+  } else {
+    result.filesUnchanged.push(filePath)
+  }
+}
+
+function writePerEntityFieldFiles(
+  outRoot: string,
+  fieldsByEntity: EntityFieldMap,
+  result: GeneratorResult,
+): void {
   fs.mkdirSync(outRoot, { recursive: true })
   const desiredEntities = new Set(Object.keys(fieldsByEntity))
   for (const [entity, fields] of Object.entries(fieldsByEntity)) {
@@ -259,18 +276,24 @@ function writePerEntityFieldFiles(outRoot: string, fieldsByEntity: EntityFieldMa
         ],
       })
     }
-    fs.writeFileSync(path.join(entDir, 'index.ts'), getSourceText(sourceFile))
+    writeTrackedFile(path.join(entDir, 'index.ts'), getSourceText(sourceFile), result)
   }
 
   const existingEntries = fs.existsSync(outRoot) ? fs.readdirSync(outRoot, { withFileTypes: true }) : []
   for (const entry of existingEntries) {
     if (!entry.isDirectory()) continue
     if (desiredEntities.has(entry.name)) continue
-    rimrafDir(path.join(outRoot, entry.name))
+    const staleDirectory = path.join(outRoot, entry.name)
+    rimrafDir(staleDirectory)
+    result.filesWritten.push(staleDirectory)
   }
 }
 
-function writeEntityFieldsRegistry(generatedRoot: string, fieldsByEntity: EntityFieldMap): void {
+function writeEntityFieldsRegistry(
+  generatedRoot: string,
+  fieldsByEntity: EntityFieldMap,
+  result: GeneratorResult,
+): void {
   const entities = Object.keys(fieldsByEntity).sort((a, b) => a.localeCompare(b))
   const registry: Record<string, Record<string, string>> = {}
   for (const entity of entities) {
@@ -302,8 +325,7 @@ function writeEntityFieldsRegistry(generatedRoot: string, fieldsByEntity: Entity
     statements: [returnStatement(elementAccess(identifier('entityFieldsRegistry'), identifier('slug')))],
   })
   const outPath = path.join(generatedRoot, 'entity-fields-registry.ts')
-  ensureDir(outPath)
-  fs.writeFileSync(outPath, getSourceText(sourceFile))
+  writeTrackedFile(outPath, getSourceText(sourceFile), result)
 }
 
 export async function generateEntityIds(options: EntityIdsOptions): Promise<GeneratorResult> {
@@ -472,9 +494,7 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
       type: 'typeof E',
     })
     const src = getSourceText(groupSourceFile)
-    ensureDir(out)
-    fs.writeFileSync(out, src)
-    result.filesWritten.push(out)
+    writeTrackedFile(out, src, result)
 
     const fieldsRoot = path.join(pkgOutputDir, 'entities')
     const fieldsByModule = fieldsByGroup[g] || {}
@@ -485,10 +505,10 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
         combined[entity] = Array.from(new Set([...(combined[entity] || []), ...fields]))
       }
     }
-    writePerEntityFieldFiles(fieldsRoot, combined)
+    writePerEntityFieldFiles(fieldsRoot, combined, result)
 
     // Generate static entity fields registry for Turbopack compatibility
-    writeEntityFieldsRegistry(pkgOutputDir, combined)
+    writeEntityFieldsRegistry(pkgOutputDir, combined, result)
   }
 
   // Write combined entity fields to root generated/ folder
@@ -500,8 +520,8 @@ export async function generateEntityIds(options: EntityIdsOptions): Promise<Gene
       }
     }
   }
-  writePerEntityFieldFiles(path.join(outputDir, 'entities'), combinedAll)
-  writeEntityFieldsRegistry(outputDir, combinedAll)
+  writePerEntityFieldFiles(path.join(outputDir, 'entities'), combinedAll, result)
+  writeEntityFieldsRegistry(outputDir, combinedAll, result)
 
   return result
 }