@open-mercato/shared 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

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')
-  })
-})

package/src/lib/data/__tests__/consistency.test.ts

@@ -1,38 +0,0 @@
-import {
-  __resetAlwaysConsistentCacheForTests,
-  isReadProjectionAlwaysConsistent,
-  parseAlwaysConsistentEnv,
-} from '../consistency'
-
-describe('read projection consistency flag', () => {
-  const originalEnv = process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT
-    } else {
-      process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT = originalEnv
-    }
-    __resetAlwaysConsistentCacheForTests()
-  })
-
-  it.each([undefined, null, '', ' ', 'off', 'false', '0', 'no', 'disabled', 'none', 'unexpected'])(
-    'parses %p as OFF',
-    (raw) => {
-      expect(parseAlwaysConsistentEnv(raw)).toBe(false)
-    },
-  )
-
-  it.each(['on', 'true', '1', 'yes', 'enabled'])('parses %p as ON', (raw) => {
-    expect(parseAlwaysConsistentEnv(raw)).toBe(true)
-  })
-
-  it('memoizes the env value until reset for tests', () => {
-    process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT = 'on'
-    expect(isReadProjectionAlwaysConsistent()).toBe(true)
-    process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT = 'off'
-    expect(isReadProjectionAlwaysConsistent()).toBe(true)
-    __resetAlwaysConsistentCacheForTests()
-    expect(isReadProjectionAlwaysConsistent()).toBe(false)
-  })
-})

package/src/lib/data/consistency.ts

@@ -1,17 +0,0 @@
-import { parseBooleanWithDefault } from '../boolean'
-
-let alwaysConsistentFlag: boolean | null = null
-
-export function parseAlwaysConsistentEnv(raw: string | undefined | null): boolean {
-  return parseBooleanWithDefault(raw, false)
-}
-
-export function isReadProjectionAlwaysConsistent(): boolean {
-  if (alwaysConsistentFlag !== null) return alwaysConsistentFlag
-  alwaysConsistentFlag = parseAlwaysConsistentEnv(process.env.OM_CACHE_SAFETY_ALWAYS_CONSISTENT)
-  return alwaysConsistentFlag
-}
-
-export function __resetAlwaysConsistentCacheForTests(): void {
-  alwaysConsistentFlag = null
-}

package/src/lib/db/__tests__/entityMetadata.test.ts

@@ -1,38 +0,0 @@
-import { listEntityMetadata, listEntityMetadataFromRegistry } from '../entityMetadata'
-
-const personMeta = { className: 'Person', tableName: 'people' }
-const orderMeta = { className: 'Order', tableName: 'orders' }
-
-describe('listEntityMetadataFromRegistry', () => {
-  it('reads the MikroORM v7 Map returned by getAll()', () => {
-    const registry = { getAll: () => new Map([[Object, personMeta], [Array, orderMeta]]) }
-    expect(listEntityMetadataFromRegistry(registry)).toEqual([personMeta, orderMeta])
-  })
-
-  it('reads the MikroORM v6 dictionary returned by getAll()', () => {
-    const registry = { getAll: () => ({ Person: personMeta, Order: orderMeta }) }
-    expect(listEntityMetadataFromRegistry(registry)).toEqual([personMeta, orderMeta])
-  })
-
-  it('falls back to the metadata property when getAll() yields nothing', () => {
-    const registry = { getAll: () => new Map(), metadata: { Person: personMeta } }
-    expect(listEntityMetadataFromRegistry(registry)).toEqual([personMeta])
-  })
-
-  it('returns an empty array for a missing registry', () => {
-    expect(listEntityMetadataFromRegistry(null)).toEqual([])
-    expect(listEntityMetadataFromRegistry({})).toEqual([])
-  })
-})
-
-describe('listEntityMetadata', () => {
-  it('resolves the registry through getMetadata()', () => {
-    const em = { getMetadata: () => ({ getAll: () => new Map([[Object, personMeta]]) }) }
-    expect(listEntityMetadata(em)).toEqual([personMeta])
-  })
-
-  it('returns an empty array when the source exposes no registry', () => {
-    expect(listEntityMetadata({})).toEqual([])
-    expect(listEntityMetadata(undefined)).toEqual([])
-  })
-})

package/src/lib/db/__tests__/pg-errors.test.ts

@@ -1,48 +0,0 @@
-import { isTransientDbError, isUniqueViolation } from '../pg-errors'
-
-describe('isTransientDbError', () => {
-  it('is true for the max_connections SQLSTATE', () => {
-    expect(isTransientDbError({ code: '53300' })).toBe(true)
-  })
-
-  it('is true for connection-family SQLSTATEs', () => {
-    for (const code of ['53400', '57P01', '57P02', '57P03', '08000', '08001', '08003', '08006']) {
-      expect(isTransientDbError({ code })).toBe(true)
-    }
-  })
-
-  it('is true for driver/ORM-wrapped connection messages that drop the SQLSTATE', () => {
-    expect(isTransientDbError(new Error('sorry, too many clients already'))).toBe(true)
-    expect(isTransientDbError(new Error('Knex: Timeout acquiring a connection. The pool is probably full.'))).toBe(true)
-    expect(isTransientDbError(new Error('Unable to acquire a connection'))).toBe(true)
-    expect(isTransientDbError(new Error('Connection terminated unexpectedly'))).toBe(true)
-    expect(isTransientDbError(new Error('the database system is starting up'))).toBe(true)
-  })
-
-  it('is false for bare socket errors with no Postgres signal (avoids false positives)', () => {
-    // Generic socket failures can come from any outbound connection (HTTP, cache,
-    // queue), so they must NOT be attributed to the database.
-    expect(isTransientDbError({ code: 'ECONNREFUSED' })).toBe(false)
-    expect(isTransientDbError({ code: 'ETIMEDOUT' })).toBe(false)
-    expect(isTransientDbError(Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' }))).toBe(false)
-  })
-
-  it('is false for a unique violation and other query-level errors', () => {
-    expect(isTransientDbError({ code: '23505' })).toBe(false)
-    expect(isTransientDbError({ code: '40P01' })).toBe(false) // deadlock — not a connection failure
-    expect(isTransientDbError({ code: '40001' })).toBe(false) // serialization — not a connection failure
-  })
-
-  it('is false for non-DB and empty errors', () => {
-    expect(isTransientDbError(new Error('something unrelated broke'))).toBe(false)
-    expect(isTransientDbError(null)).toBe(false)
-    expect(isTransientDbError(undefined)).toBe(false)
-    expect(isTransientDbError('a string')).toBe(false)
-  })
-
-  it('does not overlap with isUniqueViolation', () => {
-    const uniqueErr = { code: '23505', message: 'duplicate key value violates unique constraint' }
-    expect(isUniqueViolation(uniqueErr)).toBe(true)
-    expect(isTransientDbError(uniqueErr)).toBe(false)
-  })
-})

package/src/lib/db/entityMetadata.ts

@@ -1,43 +0,0 @@
-import type { EntityMetadata } from '@mikro-orm/core'
-
-type MetadataRegistryLike = {
-  getAll?: () => unknown
-  metadata?: unknown
-}
-
-type MetadataHolder = {
-  getMetadata?: () => unknown
-}
-
-/**
- * MikroORM v7 returns a `Map` from `MetadataStorage.getAll()`; v6 returned a plain
- * dictionary. `Object.values(someMap)` evaluates to `[]`, so a v6-era read of the
- * registry silently reports zero entities instead of failing loudly.
- */
-function toMetadataList(value: unknown): EntityMetadata[] {
-  if (!value) return []
-  if (value instanceof Map) return Array.from(value.values()) as EntityMetadata[]
-  if (Array.isArray(value)) return value as EntityMetadata[]
-  if (typeof value === 'object') return Object.values(value as Record<string, EntityMetadata>)
-  return []
-}
-
-export function listEntityMetadataFromRegistry(registry: unknown): EntityMetadata[] {
-  const source = registry as MetadataRegistryLike | null | undefined
-  if (!source) return []
-  if (typeof source.getAll === 'function') {
-    const entries = toMetadataList(source.getAll())
-    if (entries.length) return entries
-  }
-  return toMetadataList(source.metadata)
-}
-
-/**
- * List every discovered entity metadata from an `EntityManager` or `MikroORM` instance.
- * Returns an empty array when the source exposes no metadata registry.
- */
-export function listEntityMetadata(source: unknown): EntityMetadata[] {
-  const holder = source as MetadataHolder | null | undefined
-  if (!holder || typeof holder.getMetadata !== 'function') return []
-  return listEntityMetadataFromRegistry(holder.getMetadata())
-}

package/src/lib/di/__tests__/container-app-di-absent.test.ts

@@ -1,155 +0,0 @@
-// The app-level DI override module (`@/di`) is OPTIONAL: most apps ship no
-// src/di.ts, and packages contexts cannot resolve the alias at all. Its
-// absence must not produce warnings — only real load/register failures do
-// (covered in container-app-di.test.ts). This file deliberately does NOT
-// mock '@/di', so the import fails with module-not-found, exercising the
-// quiet branch.
-
-jest.mock(
-  '@open-mercato/shared/lib/db/mikro',
-  () => {
-    const baseEm: any = {
-      fork: () => baseEm,
-      getRepository: () => ({ find: async () => [], findOne: async () => null }),
-    }
-    return {
-      __esModule: true,
-      getOrm: async () => ({ em: baseEm }),
-      getOrmEntities: () => [],
-      registerOrmEntities: () => {},
-    }
-  },
-  { virtual: false },
-)
-
-jest.mock(
-  '@mikro-orm/core',
-  () => ({
-    __esModule: true,
-    RequestContext: { getEntityManager: () => null },
-  }),
-  { virtual: true },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/query/engine',
-  () => ({ __esModule: true, BasicQueryEngine: class {} }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/data/engine',
-  () => ({ __esModule: true, DefaultDataEngine: class {} }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/commands',
-  () => ({
-    __esModule: true,
-    commandRegistry: {},
-    CommandBus: class { constructor() {} },
-  }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/modules/overrides',
-  () => ({
-    __esModule: true,
-    applyDiOverridesToContainer: () => {},
-  }),
-  { virtual: false },
-)
-
-// Keep this suite hermetic: without this mock the REAL core bootstrap module
-// loads (and runs its module-level side effects) whenever generated files
-// exist on disk, polluting globalThis state shared with sibling test files.
-jest.mock(
-  '@open-mercato/core/bootstrap',
-  () => ({
-    __esModule: true,
-    bootstrap: async () => {},
-  }),
-  { virtual: true },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/encryption/subscriber',
-  () => ({
-    __esModule: true,
-    registerTenantEncryptionSubscriber: () => {},
-  }),
-  { virtual: true },
-)
-
-const mockWarn = jest.fn()
-const mockDebug = jest.fn()
-jest.mock('../../logger', () => ({
-  createLogger: () => ({
-    debug: (...args: unknown[]) => mockDebug(...args),
-    info: jest.fn(),
-    warn: (...args: unknown[]) => mockWarn(...args),
-    error: jest.fn(),
-    child() { return this },
-  }),
-}))
-
-const {
-  createRequestContainer,
-  registerAppDiRegistrar,
-  registerDiRegistrars,
-  resetBootstrapCache,
-} = require('@open-mercato/shared/lib/di/container')
-
-describe('app-level DI override hook when @/di is absent', () => {
-  beforeEach(() => {
-    resetBootstrapCache()
-    registerAppDiRegistrar(null)
-    registerDiRegistrars([])
-    mockWarn.mockClear()
-    mockDebug.mockClear()
-  })
-
-  it('creates the container without warning', async () => {
-    const firstContainer = await createRequestContainer()
-    const secondContainer = await createRequestContainer()
-    expect(firstContainer).toBeDefined()
-    expect(secondContainer).toBeDefined()
-    expect(mockWarn).not.toHaveBeenCalled()
-  })
-
-  // Worker and CLI processes create one request container per job against built package
-  // output, where the app's `@/` alias does not exist. Retrying the doomed import per
-  // container repeats a failed module resolution — and its log line — once per job.
-  it('stops retrying the unresolvable @/di import after the first container', async () => {
-    await createRequestContainer()
-    await createRequestContainer()
-    await createRequestContainer()
-
-    const unresolvableLogs = mockDebug.mock.calls.filter(
-      ([message]) => message === 'App-level DI override module (@/di) not resolvable; skipping',
-    )
-    expect(unresolvableLogs).toHaveLength(1)
-  })
-
-  it('warns once when @/di fails because a nested app alias is missing', async () => {
-    const nestedAliasError = Object.assign(new Error("Cannot find module '@/di/helpers'"), {
-      code: 'MODULE_NOT_FOUND',
-    })
-    jest.doMock('@/di', () => {
-      throw nestedAliasError
-    }, { virtual: true })
-
-    const firstContainer = await createRequestContainer()
-    const secondContainer = await createRequestContainer()
-
-    expect(firstContainer).toBeDefined()
-    expect(secondContainer).toBeDefined()
-    expect(mockWarn).toHaveBeenCalledTimes(1)
-    expect(mockWarn).toHaveBeenCalledWith(
-      'App-level DI override module (@/di) failed to load; its registrations are skipped',
-      { err: nestedAliasError },
-    )
-  })
-})

package/src/lib/di/__tests__/container-app-di.test.ts

@@ -1,173 +0,0 @@
-// Tests for the app-level DI override hook (`src/di.ts` → `@/di`) in
-// `createRequestContainer()`. The hook used to swallow EVERY failure with
-// bare `catch {}` blocks, so a src/di.ts whose register() threw — or a @/di
-// module that failed to load for any reason other than being absent — was
-// skipped without a trace and the documented override point silently did
-// nothing. Absence of the optional module must stay quiet; real failures
-// must be logged.
-
-import { asValue } from 'awilix'
-
-jest.mock(
-  '@open-mercato/shared/lib/db/mikro',
-  () => {
-    const baseEm: any = {
-      fork: () => baseEm,
-      getRepository: () => ({ find: async () => [], findOne: async () => null }),
-    }
-    return {
-      __esModule: true,
-      getOrm: async () => ({ em: baseEm }),
-      getOrmEntities: () => [],
-      registerOrmEntities: () => {},
-    }
-  },
-  { virtual: false },
-)
-
-jest.mock(
-  '@mikro-orm/core',
-  () => ({
-    __esModule: true,
-    RequestContext: { getEntityManager: () => null },
-  }),
-  { virtual: true },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/query/engine',
-  () => ({ __esModule: true, BasicQueryEngine: class {} }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/data/engine',
-  () => ({ __esModule: true, DefaultDataEngine: class {} }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/commands',
-  () => ({
-    __esModule: true,
-    commandRegistry: {},
-    CommandBus: class { constructor() {} },
-  }),
-  { virtual: false },
-)
-
-jest.mock(
-  '@open-mercato/shared/modules/overrides',
-  () => ({
-    __esModule: true,
-    applyDiOverridesToContainer: () => {},
-  }),
-  { virtual: false },
-)
-
-// Keep this suite hermetic: without this mock the REAL core bootstrap module
-// loads (and runs its module-level side effects) whenever generated files
-// exist on disk, polluting globalThis state shared with sibling test files.
-jest.mock(
-  '@open-mercato/core/bootstrap',
-  () => ({
-    __esModule: true,
-    bootstrap: async () => {},
-  }),
-  { virtual: true },
-)
-
-jest.mock(
-  '@open-mercato/shared/lib/encryption/subscriber',
-  () => ({
-    __esModule: true,
-    registerTenantEncryptionSubscriber: () => {},
-  }),
-  { virtual: true },
-)
-
-const mockWarn = jest.fn()
-jest.mock('../../logger', () => ({
-  createLogger: () => ({
-    debug: jest.fn(),
-    info: jest.fn(),
-    warn: (...args: unknown[]) => mockWarn(...args),
-    error: jest.fn(),
-    child() { return this },
-  }),
-}))
-
-const mockAppDiRegister = jest.fn()
-jest.mock(
-  '@/di',
-  () => ({
-    __esModule: true,
-    register: (...args: unknown[]) => mockAppDiRegister(...args),
-  }),
-  { virtual: true },
-)
-
-const {
-  createRequestContainer,
-  registerAppDiRegistrar,
-  registerDiRegistrars,
-  resetBootstrapCache,
-} = require('@open-mercato/shared/lib/di/container')
-
-describe('app-level DI override hook (@/di)', () => {
-  beforeEach(() => {
-    resetBootstrapCache()
-    registerAppDiRegistrar(null)
-    registerDiRegistrars([])
-    mockWarn.mockClear()
-    mockAppDiRegister.mockReset()
-  })
-
-  it('calls register() with the request container and applies its registrations', async () => {
-    mockAppDiRegister.mockImplementation((container: any) => {
-      container.register({ appOverrideProbe: asValue('from-app-di') })
-    })
-    const container = await createRequestContainer()
-    expect(mockAppDiRegister).toHaveBeenCalledTimes(1)
-    expect(mockAppDiRegister).toHaveBeenCalledWith(container)
-    expect(container.resolve('appOverrideProbe')).toBe('from-app-di')
-    expect(mockWarn).not.toHaveBeenCalled()
-  })
-
-  it('awaits an async register()', async () => {
-    mockAppDiRegister.mockImplementation(async (container: any) => {
-      await Promise.resolve()
-      container.register({ appOverrideProbe: asValue('async-app-di') })
-    })
-    const container = await createRequestContainer()
-    expect(container.resolve('appOverrideProbe')).toBe('async-app-di')
-    expect(mockWarn).not.toHaveBeenCalled()
-  })
-
-  it('warns instead of silently swallowing when register() throws', async () => {
-    mockAppDiRegister.mockImplementation(() => {
-      throw new Error('boom from app di')
-    })
-    const firstContainer = await createRequestContainer()
-    const secondContainer = await createRequestContainer()
-    expect(firstContainer).toBeDefined()
-    expect(secondContainer).toBeDefined()
-    expect(mockAppDiRegister).toHaveBeenCalledTimes(2)
-    expect(mockWarn).toHaveBeenCalledTimes(1)
-    const [message, fields] = mockWarn.mock.calls[0]
-    expect(String(message)).toContain('register()')
-    expect((fields as { err: Error }).err.message).toBe('boom from app di')
-  })
-
-  it('warns when an async register() rejects', async () => {
-    mockAppDiRegister.mockImplementation(async () => {
-      throw new Error('async boom from app di')
-    })
-    const firstContainer = await createRequestContainer()
-    const secondContainer = await createRequestContainer()
-    expect(firstContainer).toBeDefined()
-    expect(secondContainer).toBeDefined()
-    expect(mockAppDiRegister).toHaveBeenCalledTimes(2)
-    expect(mockWarn).toHaveBeenCalledTimes(1)
-  })
-})