@open-mercato/shared 0.6.7-develop.6860.1.f796b22e80 → 0.6.7

package/src/lib/bootstrap/__tests__/dynamicLoader.appDi.test.ts

@@ -1,211 +0,0 @@
-/**
- * @jest-environment node
- *
- * Regression guard: the worker/CLI/scheduler bootstrap path (bootstrapFromAppRoot) must register
- * the app-level DI hook (`src/di.ts`) the same way the Next.js runtime does through its own
- * `src/bootstrap.ts`. Without it, `getAppDiRegistrar()` stays null in those processes, so the app's
- * registrations silently never run there and every request container falls back to a doomed
- * `import('@/di')` — the `@/` alias does not exist in a plain Node ESM process, so it throws
- * ERR_MODULE_NOT_FOUND once per created container (once per queued job).
- *
- * Like the #4327 guard next to it, this test authors both the `.ts` sources and fresh compiled
- * `.mjs` siblings so compileAndImport takes its cache path and never invokes esbuild. The `.mjs`
- * stubs use module.exports because Jest's CJS runtime handles the dynamic import().
- *
- * `bootstrapFromAppRoot` reaches the factory through `import('./factory.js')`, a specifier with no
- * on-disk counterpart under Jest's CJS resolver, so it is mocked virtually.
- */
-jest.mock('../../logger', () => {
-  const logger = {
-    debug: jest.fn(),
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    child: () => logger,
-  }
-  return { createLogger: () => logger }
-})
-
-const createBootstrapMock = jest.fn(() => () => {})
-
-jest.mock(
-  '../factory.js',
-  () => ({
-    createBootstrap: (...args: unknown[]) => createBootstrapMock(...(args as [])),
-    waitForAsyncRegistration: async () => {},
-  }),
-  { virtual: true },
-)
-
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import crypto from 'node:crypto'
-import { createLogger } from '../../logger'
-import { bootstrapFromAppRoot } from '../dynamicLoader'
-
-const mockedLogger = createLogger('shared') as unknown as {
-  debug: jest.Mock
-  error: jest.Mock
-}
-
-const APP_DI_CALL_COUNTER_KEY = '__omTestAppDiRegisterCalls__'
-
-const GENERATED_MODULES: Record<string, { ts: string; compiled: string }> = {
-  'entities.ids.generated': { ts: 'export const E = {}', compiled: 'module.exports = { E: {} }' },
-  'modules.cli.generated': { ts: 'export const modules = []', compiled: 'module.exports = { modules: [] }' },
-  'entities.generated': { ts: 'export const entities = []', compiled: 'module.exports = { entities: [] }' },
-  'di.generated': { ts: 'export const diRegistrars = []', compiled: 'module.exports = { diRegistrars: [] }' },
-}
-
-const APP_TSCONFIG = JSON.stringify({
-  compilerOptions: {
-    experimentalDecorators: true,
-    emitDecoratorMetadata: true,
-    useDefineForClassFields: false,
-    target: 'ES2022',
-  },
-})
-
-const APP_DI_TS = 'export function register() {}'
-
-const APP_DI_COMPILED = [
-  'module.exports = {',
-  '  register: () => {',
-  `    globalThis['${APP_DI_CALL_COUNTER_KEY}'] = (globalThis['${APP_DI_CALL_COUNTER_KEY}'] ?? 0) + 1`,
-  '  },',
-  '}',
-].join('\n')
-
-function hash(content: string): string {
-  return crypto.createHash('sha256').update(content).digest('hex')
-}
-
-function writeCompiledPair(
-  appRoot: string,
-  sourcePath: string,
-  compiledPath: string,
-  source: { ts: string; compiled: string },
-) {
-  fs.writeFileSync(sourcePath, source.ts)
-  fs.writeFileSync(compiledPath, source.compiled)
-  const sourceRelativePath = path.relative(appRoot, sourcePath).split(path.sep).join('/')
-  fs.writeFileSync(`${compiledPath}.cache.json`, JSON.stringify({
-    version: 4,
-    inputHash: hash(JSON.stringify({
-      version: 4,
-      sourceHash: hash(source.ts),
-      tsconfigHashes: {
-        'tsconfig.json': hash(APP_TSCONFIG),
-      },
-    })),
-    outputHash: hash(source.compiled),
-    dependencies: {
-      [sourceRelativePath]: hash(source.ts),
-    },
-  }))
-}
-
-const createdAppRoots: string[] = []
-
-function createAppRoot(appDi: { ts: string; compiled: string } | null): string {
-  const appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-app-di-'))
-  const generatedDir = path.join(appRoot, '.mercato', 'generated')
-  fs.mkdirSync(generatedDir, { recursive: true })
-  fs.writeFileSync(path.join(appRoot, 'tsconfig.json'), APP_TSCONFIG)
-
-  for (const [baseName, source] of Object.entries(GENERATED_MODULES)) {
-    writeCompiledPair(
-      appRoot,
-      path.join(generatedDir, `${baseName}.ts`),
-      path.join(generatedDir, `${baseName}.mjs`),
-      source,
-    )
-  }
-
-  if (appDi) {
-    fs.mkdirSync(path.join(appRoot, 'src'), { recursive: true })
-    writeCompiledPair(
-      appRoot,
-      path.join(appRoot, 'src', 'di.ts'),
-      path.join(generatedDir, 'app-di.compiled.mjs'),
-      appDi,
-    )
-  }
-
-  createdAppRoots.push(appRoot)
-  return appRoot
-}
-
-function appDiRegistrarArgument(): unknown {
-  const [, options] = createBootstrapMock.mock.calls[0] as unknown as [unknown, Record<string, unknown>]
-  return options?.appDiRegistrar
-}
-
-describe('bootstrapFromAppRoot — app-level DI reaches worker/CLI processes', () => {
-  afterAll(() => {
-    for (const root of createdAppRoots) {
-      fs.rmSync(root, { recursive: true, force: true })
-    }
-  })
-
-  beforeEach(() => {
-    createBootstrapMock.mockClear()
-    mockedLogger.debug.mockClear()
-    mockedLogger.error.mockClear()
-    delete (globalThis as Record<string, unknown>)[APP_DI_CALL_COUNTER_KEY]
-  })
-
-  it('passes the app DI register() from src/di.ts to createBootstrap', async () => {
-    const appRoot = createAppRoot({ ts: APP_DI_TS, compiled: APP_DI_COMPILED })
-
-    await bootstrapFromAppRoot(appRoot)
-
-    const registrar = appDiRegistrarArgument()
-    expect(typeof registrar).toBe('function')
-
-    await (registrar as (container: unknown) => unknown)({})
-    expect((globalThis as Record<string, unknown>)[APP_DI_CALL_COUNTER_KEY]).toBe(1)
-    expect(mockedLogger.error).not.toHaveBeenCalled()
-  })
-
-  it('bootstraps without an app DI registrar when src/di.ts is absent', async () => {
-    const appRoot = createAppRoot(null)
-
-    await bootstrapFromAppRoot(appRoot)
-
-    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
-    expect(appDiRegistrarArgument()).toBeUndefined()
-    expect(mockedLogger.error).not.toHaveBeenCalled()
-  })
-
-  it('reports an error and keeps bootstrapping when src/di.ts fails to load', async () => {
-    const appRoot = createAppRoot({
-      ts: APP_DI_TS,
-      compiled: "throw new Error('src/di.ts is broken')",
-    })
-
-    await bootstrapFromAppRoot(appRoot)
-
-    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
-    expect(appDiRegistrarArgument()).toBeUndefined()
-    expect(mockedLogger.error).toHaveBeenCalledTimes(1)
-    const [message, fields] = mockedLogger.error.mock.calls[0] as [string, Record<string, unknown>]
-    expect(message).toContain('Failed to load the app-level DI module')
-    expect((fields.err as Error).message).toContain('src/di.ts is broken')
-  })
-
-  it('reports an error and keeps bootstrapping when src/di.ts exports no register()', async () => {
-    const appRoot = createAppRoot({
-      ts: APP_DI_TS,
-      compiled: 'module.exports = {}',
-    })
-
-    await bootstrapFromAppRoot(appRoot)
-
-    expect(createBootstrapMock).toHaveBeenCalledTimes(1)
-    expect(appDiRegistrarArgument()).toBeUndefined()
-    expect(mockedLogger.error).toHaveBeenCalledTimes(1)
-    expect(mockedLogger.error.mock.calls[0][0]).toContain('exports no register()')
-  })
-})

package/src/lib/bootstrap/__tests__/dynamicLoader.generatedCacheRecovery.test.ts

@@ -1,192 +0,0 @@
-/**
- * @jest-environment node
- *
- * Integration guard for #4526/#4693: compileAndImport must await its dynamic
- * import so that an import-time rejection settles inside the try block.
- * Returning the promise unawaited let the rejection escape the surrounding try,
- * which made the MikroORM v7 generated-cache recovery in the catch dead code for
- * exactly the failure it exists to repair. The one-line fix shipped in #4540;
- * this file is the end-to-end coverage for it.
- *
- * Two sibling suites cover this area and neither subsumes the other:
- *
- * - dynamicLoader.cacheRecovery.test.ts mocks ../generatedCacheRecovery in full
- *   and asserts how the loader *reacts* to a rejecting import (recovery is
- *   invoked once, the retry is capped at one, the error propagates when no
- *   recovery applies).
- * - generatedCacheRecovery.test.ts exercises the recovery module directly,
- *   without going through the loader.
- * - This file runs the REAL recovery module from the loader's catch, so the
- *   loader ↔ recovery seam is covered end to end: the on-disk marker, its
- *   `runtime-import-error` reason and the deleted-file list are asserted against
- *   what the production module actually writes. Nothing else in the repository
- *   reaches that reason.
- *
- * The fixture reproduces the window the catch exists for: a stale compiled file
- * that the startup scan (ensureMikroOrmV7GeneratedCacheCompatibility) cannot see
- * because it appears only once loading is already under way. The staged .mjs
- * therefore carries no decorator import at scan time — it writes a stale sibling
- * and then rejects with the error Node raises for a v6 decorator import, which
- * is what the import-time recovery is meant to repair.
- *
- * The assertions stop at the recovery boundary on purpose. Jest's module
- * registry keeps serving a file it has already evaluated, so the guarded retry
- * re-runs the rejecting module from memory no matter what recovery wrote to
- * disk — the outcome of the retry is a property of the test runner, not of the
- * loader. What #4526 broke, and what this guards, is that the catch runs at
- * all: before the fix the rejection escaped the try, so no import-time recovery
- * ever happened.
- */
-import crypto from 'node:crypto'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { loadBootstrapData } from '../dynamicLoader'
-
-const STALE_SIBLING_BASENAME = 'stale-entity.generated.mjs'
-
-/**
- * The decorator import is assembled at runtime rather than written literally:
- * a literal would make this fixture itself match the startup scan's staleness
- * pattern, so the scan would delete the cache before the import ever runs and
- * the import-time path under test would never be exercised.
- */
-const REJECTING_COMPILED_SOURCE = [
-  "const nodeFs = require('node:fs')",
-  "const nodePath = require('node:path')",
-  "const quote = String.fromCharCode(39)",
-  "const staleImport = 'import { Entity, PrimaryKey } from ' + quote + '@mikro-orm/core' + quote",
-  `nodeFs.writeFileSync(nodePath.join(__dirname, ${JSON.stringify(STALE_SIBLING_BASENAME)}), staleImport + '\\nexport const stale = true\\n')`,
-  `throw new Error('The requested module ' + quote + '@mikro-orm/core' + quote + ' does not provide an export named ' + quote + 'Entity' + quote)`,
-].join('\n')
-
-/**
- * Jest resolves the loader's dynamic import through its own CommonJS registry,
- * so a staged .mjs has to be CommonJS to evaluate at all — esbuild's real ESM
- * output fails under the runner with "Unexpected token 'export'". The .ts
- * sources stay honest ESM: they are what the loader recompiles from once
- * recovery has deleted the cache.
- */
-const GENERATED_MODULES: Record<string, { ts: string; compiled: string }> = {
-  'entities.ids.generated': { ts: 'export const E = {}', compiled: 'module.exports = { E: {} }' },
-  'modules.cli.generated': { ts: 'export const modules = []', compiled: 'module.exports = { modules: [] }' },
-  'entities.generated': { ts: 'export const entities = []', compiled: 'module.exports = { entities: [] }' },
-  'di.generated': { ts: 'export const diRegistrars = []', compiled: 'module.exports = { diRegistrars: [] }' },
-}
-
-function contentHash(content: Buffer | string): string {
-  return crypto.createHash('sha256').update(content).digest('hex')
-}
-
-/**
- * Replace a compiled cache entry with staged content the runner can evaluate,
- * keeping the loader's own cache metadata authoritative.
- *
- * The loader validates a cache entry by hashing (#4724): it recompiles unless
- * the sibling `.cache.json` matches both the source and the compiled output.
- * Only `outputHash` is rewritten here — `version`, `inputHash` and
- * `dependencies` stay exactly as the loader wrote them, so the fixture models a
- * cache that is internally consistent and simply stale, and it cannot drift out
- * of step with the cache format the way a hand-built metadata file would.
- */
-function stageCompiledCache(generatedDir: string, baseName: string, compiled: string) {
-  const jsPath = path.join(generatedDir, `${baseName}.mjs`)
-  const metadataPath = `${jsPath}.cache.json`
-
-  fs.writeFileSync(jsPath, compiled)
-  const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'))
-  metadata.outputHash = contentHash(fs.readFileSync(jsPath))
-  fs.writeFileSync(metadataPath, JSON.stringify(metadata))
-}
-
-function hasCacheMetadata(generatedDir: string, baseName: string): boolean {
-  return fs.existsSync(path.join(generatedDir, `${baseName}.mjs.cache.json`))
-}
-
-describe('compileAndImport — generated-cache recovery is reachable (#4526)', () => {
-  let appRoot: string
-  let generatedDir: string
-  let warnSpy: jest.SpyInstance
-
-  /**
-   * Let the loader compile the generated sources so it writes real cache
-   * metadata for each of them, replacing each compiled output with the
-   * runner-evaluable staged content as it appears.
-   *
-   * The loader writes a module's metadata before importing it, so an import
-   * failing here (esbuild's ESM output under Jest's CommonJS registry) is
-   * expected and irrelevant — the metadata is the only thing this step is
-   * after. That failure does abort the rest of the load, though, so one pass
-   * only reaches the modules the loader got to: entities.ids first and alone,
-   * then the remainder together. Repeating the pass lets each newly staged
-   * module unblock the next batch, and the loop ends on the first pass that
-   * loads cleanly, which is precisely when every module is staged.
-   *
-   * jest.resetModules() between passes is load-bearing. Jest keys its registry
-   * on the resolved path and ignores the loader's `?cache=` query, so without
-   * the reset a module would keep being served from its first (ESM, failing)
-   * evaluation and no later pass could make progress.
-   *
-   * None of these failures carries a decorator-export error, so no recovery
-   * runs and no marker is written during setup; both tests below would fail
-   * loudly if one were.
-   */
-  async function primeAndStageCompiledCaches() {
-    const baseNames = Object.keys(GENERATED_MODULES)
-    for (let pass = 0; pass <= baseNames.length; pass += 1) {
-      let loadedCleanly = true
-      await loadBootstrapData(appRoot).catch(() => { loadedCleanly = false })
-      jest.resetModules()
-      if (loadedCleanly) return
-      for (const baseName of baseNames) {
-        if (!hasCacheMetadata(generatedDir, baseName)) continue
-        stageCompiledCache(generatedDir, baseName, GENERATED_MODULES[baseName].compiled)
-      }
-    }
-    throw new Error('[internal] loader never reached a fully staged generated cache')
-  }
-
-  beforeEach(async () => {
-    appRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'om-bootstrap-4526-'))
-    generatedDir = path.join(appRoot, '.mercato', 'generated')
-    fs.mkdirSync(generatedDir, { recursive: true })
-    fs.writeFileSync(
-      path.join(appRoot, 'tsconfig.json'),
-      JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'ESNext' } }),
-    )
-    for (const [baseName, source] of Object.entries(GENERATED_MODULES)) {
-      fs.writeFileSync(path.join(generatedDir, `${baseName}.ts`), source.ts)
-    }
-    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    await primeAndStageCompiledCaches()
-  })
-
-  afterEach(() => {
-    warnSpy.mockRestore()
-    fs.rmSync(appRoot, { recursive: true, force: true })
-  })
-
-  it('runs cache recovery when the compiled cache rejects on import', async () => {
-    const rejectingPath = path.join(generatedDir, 'entities.ids.generated.mjs')
-    stageCompiledCache(generatedDir, 'entities.ids.generated', REJECTING_COMPILED_SOURCE)
-
-    await loadBootstrapData(appRoot).catch(() => undefined)
-
-    const markerPath = path.join(generatedDir, '.mikro-orm-v7-cache-recovery.json')
-    expect(fs.existsSync(markerPath)).toBe(true)
-
-    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'))
-    expect(marker.reason).toBe('runtime-import-error')
-    expect(marker.deletedFiles).toContain(rejectingPath)
-    expect(marker.deletedFiles).toContain(path.join(generatedDir, STALE_SIBLING_BASENAME))
-
-    expect(fs.readFileSync(rejectingPath, 'utf8')).not.toContain('does not provide an export named')
-  })
-
-  it('does not run recovery when the compiled cache imports cleanly', async () => {
-    await loadBootstrapData(appRoot)
-
-    expect(fs.existsSync(path.join(generatedDir, '.mikro-orm-v7-cache-recovery.json'))).toBe(false)
-  })
-})

package/src/lib/bootstrap/clientOnlyModules.ts

@@ -1,85 +0,0 @@
-/**
- * Client-only modules (`*.client.tsx`) hold browser components and must never enter the
- * CLI bundle graph. App modules are bundled from source by `compileAndImport`, and esbuild
- * inlines dynamic imports into the single output file, hoisting the client file's static
- * imports to the top of the bundle. A wrapper such as `@open-mercato/ui/backend/charts`
- * would then execute on every CLI start and fail on bare Next.js specifiers that Node's
- * ESM resolver cannot resolve.
- *
- * Resolving these files to an inert stub keeps the owning `widget.ts` importable (the CLI
- * reads its metadata when seeding dashboards) while cutting the browser-only subgraph.
- *
- * Only `import()` expressions are stubbed. That is the documented way a server-side
- * `widget.ts` reaches its browser component (`lazyDashboardWidget(() => import('./widget.client'))`),
- * and its result is consumed as a namespace object, so a default-only stub is sufficient.
- * Static imports are left to the bundler: they may request named bindings the stub cannot
- * provide, which esbuild rejects with `No matching export`, failing the whole CLI bundle —
- * the exact class of breakage this module exists to prevent. Restricting the rewrite to
- * dynamic imports also keeps server-side helpers that merely follow a `*.client.ts` naming
- * convention working untouched.
- */
-
-export const CLIENT_ONLY_STUB_NAMESPACE = 'om-client-only-stub'
-
-const LOCAL_IMPORT_PATTERN = /^(\.{1,2}\/|@\/)/
-const CLIENT_ONLY_SUFFIX_PATTERN = /(^|[\\/])[^\\/]+\.client(\.[cm]?[jt]sx?)?$/
-
-/**
- * Local (relative or `@/` aliased) imports of a `*.client` module. Bare package specifiers
- * are left alone because the bundler already marks them external, so they never get inlined.
- */
-export function isClientOnlyModulePath(importPath: string): boolean {
-  if (!LOCAL_IMPORT_PATTERN.test(importPath)) return false
-  return CLIENT_ONLY_SUFFIX_PATTERN.test(importPath)
-}
-
-/**
- * Render a value as a JavaScript string literal safe to embed in generated source.
- * Everything outside printable ASCII is escaped to a `\uXXXX` sequence, so no character
- * of the input can terminate the literal or be re-interpreted as code — `JSON.stringify`
- * alone is a JSON encoder, not a JavaScript-source escaper.
- */
-export function encodeJsStringLiteral(value: string): string {
-  let encoded = ''
-  for (let index = 0; index < value.length; index += 1) {
-    const char = value[index]
-    if (char === '"' || char === '\\') {
-      encoded += `\\${char}`
-      continue
-    }
-    const code = value.charCodeAt(index)
-    if (code < 0x20 || code > 0x7e) {
-      encoded += `\\u${code.toString(16).padStart(4, '0')}`
-      continue
-    }
-    encoded += char
-  }
-  return `"${encoded}"`
-}
-
-export function renderClientOnlyModuleStub(importPath: string): string {
-  const message =
-    `[internal] Client-only module ${importPath} is not available in the CLI runtime. ` +
-    'It is excluded from the CLI bundle because it renders browser components.'
-  return [
-    `function clientOnlyModuleUnavailable() { throw new Error(${encodeJsStringLiteral(message)}) }`,
-    'export default clientOnlyModuleUnavailable',
-  ].join('\n')
-}
-
-export function createClientOnlyStubPlugin(): import('esbuild').Plugin {
-  return {
-    name: 'client-only-stub',
-    setup(build) {
-      build.onResolve({ filter: CLIENT_ONLY_SUFFIX_PATTERN }, (args) => {
-        if (args.kind !== 'dynamic-import') return null
-        if (!isClientOnlyModulePath(args.path)) return null
-        return { path: args.path, namespace: CLIENT_ONLY_STUB_NAMESPACE }
-      })
-      build.onLoad({ filter: /.*/, namespace: CLIENT_ONLY_STUB_NAMESPACE }, (args) => ({
-        contents: renderClientOnlyModuleStub(args.path),
-        loader: 'js',
-      }))
-    },
-  }
-}

package/src/lib/crud/__tests__/crud-factory.cache-user-scope.test.ts

@@ -1,171 +0,0 @@
-// Regression coverage for the CRUD list cache key missing a caller-identity
-// segment: two callers in the same tenant/org scope requesting the identical
-// URL must NOT share cache entries, because list payloads can vary per caller —
-// buildFilters may narrow by ctx.auth (e.g. ?mine=true on staff time-projects,
-// the isSuperAdmin branch on scheduler jobs), before-interceptor query rewrites
-// are feature-gated per user, and afterList/after-interceptor output is
-// embedded in the stored payload.
-
-jest.mock('@open-mercato/cache', () => ({
-  runWithCacheTenant: async (_tenantId: string | null, fn: () => Promise<unknown>) => fn(),
-}), { virtual: true })
-
-import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
-import { registerApiInterceptors } from '@open-mercato/shared/lib/crud/interceptor-registry'
-import { z } from 'zod'
-
-const defaultOrganizationId = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
-const defaultTenantId = '123e4567-e89b-12d3-a456-426614174000'
-
-let mockAuthSub = 'user-a'
-let mockAuthKeyId: string | null = null
-
-const em = {}
-
-// Returns rows derived from the per-caller filter buildFilters produced, so a
-// cross-user cache hit is observable as one user's rows in another's response.
-const queryEngine = {
-  query: jest.fn(async (_entity: string, opts: Record<string, any>) => {
-    const owner = opts?.filters?.owner_user_id?.$eq ?? 'unfiltered'
-    return {
-      items: [{ id: `todo-of-${owner}`, title: `Owned by ${owner}`, organization_id: defaultOrganizationId, tenant_id: defaultTenantId }],
-      total: 1,
-    }
-  }),
-}
-
-const store = new Map<string, unknown>()
-const cache = {
-  get: jest.fn(async (key: string) => (store.has(key) ? store.get(key) : null)),
-  set: jest.fn(async (key: string, value: unknown) => { store.set(key, value) }),
-  delete: jest.fn(async (key: string) => { store.delete(key) }),
-  deleteByTags: jest.fn(async () => 0),
-}
-
-const accessLogService = { log: jest.fn(async () => {}) }
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({
-    resolve: (name: string) => ({
-      em,
-      queryEngine,
-      cache,
-      accessLogService,
-    } as any)[name],
-  }),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => {
-  const buildAuth = () => ({
-    sub: mockAuthSub,
-    keyId: mockAuthKeyId ?? undefined,
-    orgId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-    tenantId: '123e4567-e89b-12d3-a456-426614174000',
-    roles: ['admin'],
-  })
-  return {
-    getAuthFromCookies: async () => buildAuth(),
-    getAuthFromRequest: async () => buildAuth(),
-  }
-})
-
-jest.mock('@open-mercato/core/modules/directory/utils/organizationScope', () => ({
-  resolveOrganizationScopeForRequest: jest.fn(async () => ({
-    selectedId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-    filterIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-    allowedIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-    tenantId: '123e4567-e89b-12d3-a456-426614174000',
-  })),
-}))
-
-jest.mock('@open-mercato/core/modules/entities/lib/helpers', () => ({
-  setRecordCustomFields: jest.fn(async () => {}),
-}))
-
-class Todo {}
-
-const querySchema = z.object({
-  page: z.coerce.number().default(1),
-  pageSize: z.coerce.number().default(50),
-  sortField: z.string().default('id'),
-  sortDir: z.enum(['asc', 'desc']).default('asc'),
-})
-
-const route = makeCrudRoute({
-  metadata: { GET: { requireAuth: true } },
-  orm: { entity: Todo, idField: 'id', orgField: 'organizationId', tenantField: 'tenantId', softDeleteField: 'deletedAt' },
-  indexer: { entityType: 'example.todo' },
-  list: {
-    schema: querySchema,
-    entityId: 'example.todo',
-    fields: ['id', 'title'],
-    sortFieldMap: { id: 'id', title: 'title' },
-    buildFilters: (_query: any, ctx: any) => ({ owner_user_id: { $eq: ctx.auth?.sub ?? null } } as any),
-    transformItem: (i: any) => ({ id: i.id, title: i.title }),
-  },
-})
-
-const url = 'http://x/api/example/todos?page=1&pageSize=10&sortField=id&sortDir=asc'
-
-describe('CRUD Factory — list cache is partitioned per caller identity', () => {
-  const previousCacheFlag = process.env.ENABLE_CRUD_API_CACHE
-
-  beforeAll(() => {
-    process.env.ENABLE_CRUD_API_CACHE = 'true'
-  })
-
-  afterAll(() => {
-    if (previousCacheFlag === undefined) delete process.env.ENABLE_CRUD_API_CACHE
-    else process.env.ENABLE_CRUD_API_CACHE = previousCacheFlag
-  })
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    store.clear()
-    mockAuthSub = 'user-a'
-    mockAuthKeyId = null
-    registerApiInterceptors([])
-  })
-
-  it('caches per user and still serves same-user repeat requests from cache', async () => {
-    const first = await route.GET(new Request(url))
-    expect(first.status).toBe(200)
-    expect(first.headers.get('x-om-cache')).toBe('miss')
-    expect((await first.json()).items[0].id).toBe('todo-of-user-a')
-
-    const second = await route.GET(new Request(url))
-    expect(second.headers.get('x-om-cache')).toBe('hit')
-    expect((await second.json()).items[0].id).toBe('todo-of-user-a')
-    expect(queryEngine.query).toHaveBeenCalledTimes(1)
-  })
-
-  it('does not serve one user\'s cached rows to another user on the identical URL', async () => {
-    mockAuthSub = 'user-a'
-    const aRes = await route.GET(new Request(url))
-    expect((await aRes.json()).items[0].id).toBe('todo-of-user-a')
-    expect(store.size).toBe(1)
-
-    mockAuthSub = 'user-b'
-    const bRes = await route.GET(new Request(url))
-    expect(bRes.headers.get('x-om-cache')).toBe('miss')
-    expect((await bRes.json()).items[0].id).toBe('todo-of-user-b')
-    expect(store.size).toBe(2)
-
-    mockAuthSub = 'user-a'
-    const aAgain = await route.GET(new Request(url))
-    expect(aAgain.headers.get('x-om-cache')).toBe('hit')
-    expect((await aAgain.json()).items[0].id).toBe('todo-of-user-a')
-  })
-
-  it('keys every entry with an identity segment, preferring the API key id over the user id', async () => {
-    await route.GET(new Request(url))
-    const userKey = Array.from(store.keys())[0] as string
-    expect(userKey).toContain('user:user-a')
-
-    store.clear()
-    mockAuthKeyId = 'api-key-9'
-    await route.GET(new Request(url))
-    const apiKeyKey = Array.from(store.keys())[0] as string
-    expect(apiKeyKey).toContain('user:api-key-9')
-  })
-})