@open-mercato/cli 0.7.1-develop.7123.1.25365e718d → 0.7.1-develop.7130.1.fef2396fd8

package/src/lib/generators/__tests__/entity-class-declarations.test.ts

@@ -0,0 +1,287 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { parseEntityClassNames } from '../entity-class-declarations'
+
+let tmpDir: string
+
+function writeSource(content: string, fileName = 'entities.ts'): string {
+  const filePath = path.join(tmpDir, fileName)
+  fs.writeFileSync(filePath, content)
+  return filePath
+}
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'entity-class-declarations-test-'))
+})
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe('parseEntityClassNames', () => {
+  it('collects exported classes decorated with @Entity()', () => {
+    const filePath = writeSource(`
+      import { Entity, PrimaryKey } from '@mikro-orm/decorators/legacy'
+
+      @Entity({ tableName: 'invoices' })
+      export class Invoice {
+        @PrimaryKey({ type: 'uuid' })
+        id!: string
+      }
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('looks past comments and stacked decorators', () => {
+    const filePath = writeSource(`
+      import { Entity, Index, Unique } from '@mikro-orm/decorators/legacy'
+
+      @Entity({ tableName: 'invoices' })
+      // The unique constraint bounds the lookup.
+      @Unique({ properties: ['number'] })
+      @Index({
+        name: 'invoices_number_idx',
+        expression: 'create index "invoices_number_idx" on "invoices" ("number")',
+      })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('ignores exported classes that are not entities', () => {
+    const filePath = writeSource(`
+      import { Entity } from '@mikro-orm/decorators/legacy'
+
+      export class InvoiceBuilder {}
+
+      @Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('ignores entity classes that are not exported', () => {
+    const filePath = writeSource(`
+      import { Entity } from '@mikro-orm/decorators/legacy'
+
+      @Entity({ tableName: 'invoices' })
+      class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('handles a local export list', () => {
+    const filePath = writeSource(`
+      import { Entity } from '@mikro-orm/decorators/legacy'
+
+      @Entity({ tableName: 'invoices' })
+      class Invoice {}
+
+      export { Invoice }
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('accepts a bare @Entity decorator', () => {
+    const filePath = writeSource(`
+      import { Entity } from '@mikro-orm/decorators/legacy'
+
+      @Entity
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('returns nothing for an unreadable file instead of throwing', () => {
+    expect(parseEntityClassNames(path.join(tmpDir, 'missing.ts'))).toEqual([])
+  })
+
+  it('recognises an aliased Entity import', () => {
+    const filePath = writeSource(`
+      import { Entity as OrmEntity } from '@mikro-orm/decorators/legacy'
+
+      @OrmEntity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('recognises a namespace-qualified Entity decorator', () => {
+    const filePath = writeSource(`
+      import * as orm from '@mikro-orm/decorators/legacy'
+
+      @orm.Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+
+  it('does not treat an unrelated decorator as an entity', () => {
+    const filePath = writeSource(`
+      @Injectable()
+      export class InvoiceService {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('ignores an Entity decorator imported from an unrelated library', () => {
+    // Any library may export an `Entity` decorator; only MikroORM's collides in the ORM
+    // metadata registry, so only a decorator bound to a @mikro-orm/* import counts.
+    const filePath = writeSource(`
+      import { Entity } from 'some-other-orm'
+
+      @Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('ignores a namespace-qualified Entity decorator from an unrelated library', () => {
+    const filePath = writeSource(`
+      import * as other from 'some-other-orm'
+
+      @other.Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('ignores an Entity decorator with no import to bind it', () => {
+    const filePath = writeSource(`
+      @Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `)
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('parses a .tsx entity file as JSX rather than dropping declarations', () => {
+    // MODULE_CODE_EXTENSIONS accepts .tsx, where `<T>` is JSX, not a type assertion.
+    const filePath = writeSource(`
+      import { Entity } from '@mikro-orm/decorators/legacy'
+
+      export const icon = () => <span>invoice</span>
+
+      @Entity({ tableName: 'invoices' })
+      export class Invoice {}
+    `, 'entities.tsx')
+
+    expect(parseEntityClassNames(filePath)).toEqual(['Invoice'])
+  })
+})
+
+describe('parseEntityClassNames on compiled package output', () => {
+  // A package that ships dist only hands the generator its built entity file, where a
+  // decorated class has become a class expression plus a decorator-helper call. Without
+  // this the standalone generator sees no entities at all and misses every collision.
+  it('reads an esbuild ESM emit', () => {
+    const filePath = writeSource(`
+      var __decorateClass = (decorators, target) => target;
+      import { Entity, PrimaryKey } from "@mikro-orm/decorators/legacy";
+      let ApiKey = class {
+      };
+      __decorateClass([
+        PrimaryKey({ type: "uuid" })
+      ], ApiKey.prototype, "id", 2);
+      ApiKey = __decorateClass([
+        Entity({ tableName: "api_keys" })
+      ], ApiKey);
+      export {
+        ApiKey
+      };
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual(['ApiKey'])
+  })
+
+  it('reads a tsc CommonJS emit', () => {
+    const filePath = writeSource(`
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.ApiKey = void 0;
+      const legacy_1 = require("@mikro-orm/decorators/legacy");
+      let ApiKey = class ApiKey {
+      };
+      ApiKey = __decorate([
+        (0, legacy_1.Entity)({ tableName: "api_keys" })
+      ], ApiKey);
+      exports.ApiKey = ApiKey;
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual(['ApiKey'])
+  })
+
+  it('reads a bundler export table', () => {
+    const filePath = writeSource(`
+      import { Entity } from "@mikro-orm/core";
+      var entities_exports = {};
+      __export(entities_exports, {
+        ApiKey: () => ApiKey
+      });
+      let ApiKey = class {
+      };
+      ApiKey = __decorateClass([
+        Entity({ tableName: "api_keys" })
+      ], ApiKey);
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual(['ApiKey'])
+  })
+
+  it('ignores a compiled class that is never exported', () => {
+    const filePath = writeSource(`
+      import { Entity } from "@mikro-orm/decorators/legacy";
+      let Internal = class {
+      };
+      Internal = __decorateClass([
+        Entity({ tableName: "internal" })
+      ], Internal);
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('ignores a compiled class decorated by an unrelated library', () => {
+    const filePath = writeSource(`
+      import { Entity } from "some-other-orm";
+      let Invoice = class {
+      };
+      Invoice = __decorateClass([
+        Entity({ tableName: "invoices" })
+      ], Invoice);
+      export {
+        Invoice
+      };
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+
+  it('ignores property decorators, which share the helper call', () => {
+    const filePath = writeSource(`
+      import { Entity, Property } from "@mikro-orm/decorators/legacy";
+      let Helper = class {
+      };
+      __decorateClass([
+        Property({ type: "text" })
+      ], Helper.prototype, "name", 2);
+      export {
+        Helper
+      };
+    `, 'entities.js')
+
+    expect(parseEntityClassNames(filePath)).toEqual([])
+  })
+})

package/src/lib/generators/__tests__/module-entities.test.ts

@@ -135,3 +135,222 @@ describe('generateModuleEntities', () => {
     expect(secondStat.mtimeMs).toBe(firstStat.mtimeMs)
   })
 })
+
+describe('generateModuleEntities duplicate entity class names', () => {
+  const entitySource = (className: string, tableName: string) =>
+    `import { Entity } from '@mikro-orm/decorators/legacy'\n\n@Entity({ tableName: '${tableName}' })\nexport class ${className} {}\n`
+
+  let warnSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+  })
+
+  function moduleWithEntities(id: string, content: string): ModuleEntry {
+    touchFile(path.join(tmpDir, 'packages', 'core', 'src', 'modules', id, 'data', 'entities.ts'), content)
+    return { id, from: '@open-mercato/core' }
+  }
+
+  it('warns when two modules declare the same entity class name, and still generates', async () => {
+    const modules = [
+      moduleWithEntities('billing', entitySource('Invoice', 'billing_invoices')),
+      moduleWithEntities('subscriptions', entitySource('Invoice', 'subscription_invoices')),
+    ]
+
+    const result = await generateModuleEntities({ resolver: createMockResolver(tmpDir, modules), quiet: true })
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    const message = warnSpy.mock.calls[0][0] as string
+    expect(message).toContain('[Entities Warning]')
+    expect(message).toContain('Invoice')
+    expect(message).toContain('billing')
+    expect(message).toContain('subscriptions')
+    // Warning-only by design: generation still succeeds.
+    expect(result.errors).toEqual([])
+    expect(readGenerated(tmpDir)).toContain('enhanceEntities')
+  })
+
+  it('stays silent when entity class names are unique', async () => {
+    const modules = [
+      moduleWithEntities('billing', entitySource('Invoice', 'billing_invoices')),
+      moduleWithEntities('subscriptions', entitySource('Subscription', 'subscriptions')),
+    ]
+
+    await generateModuleEntities({ resolver: createMockResolver(tmpDir, modules), quiet: true })
+
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+
+  it('reads the app override, not the package file, when an app supplies a package module\'s entities', async () => {
+    // The registry imports the app override for such a module, so the check must read the
+    // same file — parsing the package tree would report names that are never registered.
+    touchFile(
+      path.join(tmpDir, 'packages', 'core', 'src', 'modules', 'billing', 'data', 'entities.ts'),
+      entitySource('PackageInvoice', 'billing_invoices'),
+    )
+    touchFile(
+      path.join(tmpDir, 'app', 'src', 'modules', 'billing', 'data', 'entities.ts'),
+      entitySource('Invoice', 'billing_invoices'),
+    )
+    const modules: ModuleEntry[] = [
+      { id: 'billing', from: '@open-mercato/core' },
+      moduleWithEntities('subscriptions', entitySource('Invoice', 'subscription_invoices')),
+    ]
+
+    const result = await generateModuleEntities({ resolver: createMockResolver(tmpDir, modules), quiet: true })
+
+    expect(result.errors).toEqual([])
+    expect(readGenerated(tmpDir)).toContain('from "@/modules/billing/data/entities"')
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    const message = warnSpy.mock.calls[0][0] as string
+    expect(message).toContain('Invoice')
+    expect(message).toContain(path.join('app', 'src', 'modules', 'billing', 'data', 'entities.ts'))
+    expect(message).not.toContain('PackageInvoice')
+  })
+
+  it('stays silent when only one of the colliding classes is an entity', async () => {
+    const modules = [
+      moduleWithEntities('billing', entitySource('Invoice', 'billing_invoices')),
+      moduleWithEntities('subscriptions', 'export class Invoice {}\n'),
+    ]
+
+    await generateModuleEntities({ resolver: createMockResolver(tmpDir, modules), quiet: true })
+
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+})
+
+describe('generateModuleEntities duplicate detection in standalone installs', () => {
+  // A standalone install resolves a package module to its compiled dist tree, where a
+  // decorated class is no longer a class declaration. Published packages ship
+  // src/modules too, so parsing prefers that mirror and falls back to the compiled file.
+  const PACKAGE = '@open-mercato/core'
+
+  let warnSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+  })
+
+  function packageRoot(): string {
+    return path.join(tmpDir, 'app', 'node_modules', PACKAGE)
+  }
+
+  function createStandaloneResolver(enabled: ModuleEntry[]): PackageResolver {
+    const outputDir = path.join(tmpDir, 'app', '.mercato', 'generated')
+    fs.mkdirSync(outputDir, { recursive: true })
+
+    return {
+      isMonorepo: () => false,
+      getRootDir: () => path.join(tmpDir, 'app'),
+      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(packageRoot(), 'dist', 'modules', entry.id),
+      }),
+      getModuleImportBase: (entry: ModuleEntry) => ({
+        appBase: `@/modules/${entry.id}`,
+        pkgBase: `${PACKAGE}/modules/${entry.id}`,
+      }),
+      getPackageOutputDir: () => outputDir,
+      getPackageRoot: () => packageRoot(),
+    }
+  }
+
+  const compiledEntity = (className: string, tableName: string) => `
+import { Entity } from "@mikro-orm/decorators/legacy";
+let ${className} = class {
+};
+${className} = __decorateClass([
+  Entity({ tableName: "${tableName}" })
+], ${className});
+export {
+  ${className}
+};
+`
+
+  const sourceEntity = (className: string, tableName: string) =>
+    `import { Entity } from '@mikro-orm/decorators/legacy'\n\n@Entity({ tableName: '${tableName}' })\nexport class ${className} {}\n`
+
+  function distModule(id: string, className: string, tableName: string): ModuleEntry {
+    touchFile(path.join(packageRoot(), 'dist', 'modules', id, 'data', 'entities.js'), compiledEntity(className, tableName))
+    return { id, from: PACKAGE }
+  }
+
+  function withSourceMirror(id: string, className: string, tableName: string): void {
+    touchFile(path.join(packageRoot(), 'src', 'modules', id, 'data', 'entities.ts'), sourceEntity(className, tableName))
+  }
+
+  it('detects a package-to-package collision through the shipped source mirror', async () => {
+    const modules = [
+      distModule('billing', 'Invoice', 'billing_invoices'),
+      distModule('subscriptions', 'Invoice', 'subscription_invoices'),
+    ]
+    withSourceMirror('billing', 'Invoice', 'billing_invoices')
+    withSourceMirror('subscriptions', 'Invoice', 'subscription_invoices')
+
+    const result = await generateModuleEntities({ resolver: createStandaloneResolver(modules), quiet: true })
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    const message = warnSpy.mock.calls[0][0] as string
+    expect(message).toContain('Invoice')
+    expect(message).toContain(path.join('src', 'modules', 'billing', 'data', 'entities.ts'))
+    expect(result.errors).toEqual([])
+    // The runtime import still points at the compiled package entry.
+    expect(readGenerated(tmpDir)).toContain(`from "${PACKAGE}/modules/billing/data/entities"`)
+  })
+
+  it('detects the collision from compiled output when a package ships dist only', async () => {
+    const modules = [
+      distModule('billing', 'Invoice', 'billing_invoices'),
+      distModule('subscriptions', 'Invoice', 'subscription_invoices'),
+    ]
+
+    await generateModuleEntities({ resolver: createStandaloneResolver(modules), quiet: true })
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    const message = warnSpy.mock.calls[0][0] as string
+    expect(message).toContain('Invoice')
+    expect(message).toContain(path.join('dist', 'modules', 'subscriptions', 'data', 'entities.js'))
+  })
+
+  it('detects a package-to-app collision', async () => {
+    const modules = [
+      distModule('billing', 'Invoice', 'billing_invoices'),
+      { id: 'reporting', from: '@app' } as ModuleEntry,
+    ]
+    withSourceMirror('billing', 'Invoice', 'billing_invoices')
+    touchFile(
+      path.join(tmpDir, 'app', 'src', 'modules', 'reporting', 'data', 'entities.ts'),
+      sourceEntity('Invoice', 'reporting_invoices'),
+    )
+
+    await generateModuleEntities({ resolver: createStandaloneResolver(modules), quiet: true })
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    expect(warnSpy.mock.calls[0][0] as string).toContain('reporting')
+  })
+
+  it('stays silent when compiled package entity class names are unique', async () => {
+    const modules = [
+      distModule('billing', 'Invoice', 'billing_invoices'),
+      distModule('subscriptions', 'Subscription', 'subscriptions'),
+    ]
+
+    await generateModuleEntities({ resolver: createStandaloneResolver(modules), quiet: true })
+
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+})