@open-mercato/shared 0.8.1-develop.7296.1.2111d779db → 0.9.0

package/src/lib/crud/__tests__/crud-factory.test.ts

@@ -15,6 +15,10 @@ jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
 import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
 import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import { registerApiInterceptors } from '@open-mercato/shared/lib/crud/interceptor-registry'
+import {
+  findApiRouteManifestMatch,
+  type ApiRouteManifestEntry,
+} from '@open-mercato/shared/modules/registry'
 import {
   clearOptimisticLockReadersForTests,
   getAllOptimisticLockReaders,
@@ -185,17 +189,28 @@ const accessLogService = {
   log: jest.fn(async () => {}),
 }
 
+const crudCacheStore = new Map<string, unknown>()
+const crudCache = {
+  get: jest.fn(async (key: string) => crudCacheStore.get(key) ?? null),
+  set: jest.fn(async (key: string, value: unknown) => { crudCacheStore.set(key, value) }),
+  delete: jest.fn(async (key: string) => { crudCacheStore.delete(key) }),
+  deleteByTags: jest.fn(async () => 0),
+}
+
+const resolveContainerValue = jest.fn((name: string) => ({
+  em,
+  queryEngine,
+  cache: crudCache,
+  eventBus: mockEventBus,
+  dataEngine: mockDataEngine,
+  accessLogService,
+  commandBus,
+  crudMutationGuardService,
+} as any)[name])
+
 jest.mock('@open-mercato/shared/lib/di/container', () => ({
   createRequestContainer: async () => ({
-    resolve: (name: string) => ({
-      em,
-      queryEngine,
-      eventBus: mockEventBus,
-      dataEngine: mockDataEngine,
-      accessLogService,
-      commandBus,
-      crudMutationGuardService,
-    } as any)[name],
+    resolve: resolveContainerValue,
   })
 }))
 
@@ -235,6 +250,7 @@ describe('CRUD Factory', () => {
     idSeq = 1
     jest.clearAllMocks()
     accessLogService.log.mockClear()
+    crudCacheStore.clear()
     mockDataEngine.__pendingSideEffects = []
     mockDataEngine.__defaultIndexer = null
     mockDataEngine.__indexedDefaultEntityClass = false
@@ -309,6 +325,44 @@ describe('CRUD Factory', () => {
     }))
   })
 
+  it('GET returns an empty page before hooks, cache, query engine, EM, RBAC, or data engine for explicit empty scope', async () => {
+    const beforeList = jest.fn()
+    const emptyScopeRoute = makeCrudRoute({
+      metadata: { GET: { requireAuth: true } },
+      orm: { entity: Todo, idField: 'id', orgField: 'organizationId', tenantField: 'tenantId' },
+      indexer: { entityType: 'example.todo' },
+      list: {
+        schema: querySchema,
+        entityId: 'example.todo',
+        fields: ['id', 'title'],
+        buildFilters: () => ({} as any),
+      },
+      hooks: { beforeList },
+    })
+    mockOrganizationScopeOverride = {
+      tenantId: defaultTenantId,
+      selectedId: defaultOrganizationId,
+      filterIds: [],
+      allowedIds: [defaultOrganizationId],
+    }
+
+    const response = await emptyScopeRoute.GET(new Request('http://x/api/example/todos?page=4&pageSize=15'))
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      items: [],
+      total: 0,
+      page: 4,
+      pageSize: 15,
+      totalPages: 0,
+    })
+    expect(beforeList).not.toHaveBeenCalled()
+    expect(resolveContainerValue).not.toHaveBeenCalled()
+    expect(crudCache.get).not.toHaveBeenCalled()
+    expect(queryEngine.query).not.toHaveBeenCalled()
+    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
+    expect(accessLogService.log).not.toHaveBeenCalled()
+  })
+
   it('GET spreads totalIsCapped only when the engine reports a capped count', async () => {
     queryEngine.query.mockResolvedValueOnce({
       items: [{ id: 'id-1', title: 'A', is_done: false }],
@@ -1213,7 +1267,7 @@ describe('CRUD Factory', () => {
     expect(db[created.id].deletedAt).toBeInstanceOf(Date)
   })
 
-  it('trims padded selected organization ids when scope resolution falls back from empty filter ids', async () => {
+  it('denies mutations instead of falling back from empty filter ids', async () => {
     const created = em.create(Todo, { title: 'Scoped', organizationId: defaultOrganizationId, tenantId: defaultTenantId }) as Rec
     created.id = '123e4567-e89b-12d3-a456-426614174052'
     await em.persist(created).flush()
@@ -1230,27 +1284,41 @@ describe('CRUD Factory', () => {
       headers: { 'content-type': 'application/json' },
     }))
 
-    expect(updateResponse.status).toBe(200)
-    expect(mockDataEngine.updateOrmEntity).toHaveBeenLastCalledWith(expect.objectContaining({
-      where: {
-        id: created.id,
-        organizationId: defaultOrganizationId,
-        tenantId: defaultTenantId,
-        deletedAt: null,
-      },
-    }))
+    expect(updateResponse.status).toBe(403)
+    expect(mockDataEngine.updateOrmEntity).not.toHaveBeenCalled()
 
     const deleteResponse = await route.DELETE(new Request(`http://x/api/example/todos?id=${created.id}`, { method: 'DELETE' }))
 
-    expect(deleteResponse.status).toBe(200)
-    expect(mockDataEngine.deleteOrmEntity).toHaveBeenLastCalledWith(expect.objectContaining({
-      where: {
-        id: created.id,
-        organizationId: defaultOrganizationId,
-        tenantId: defaultTenantId,
-        deletedAt: null,
-      },
+    expect(deleteResponse.status).toBe(403)
+    expect(mockDataEngine.deleteOrmEntity).not.toHaveBeenCalled()
+  })
+
+  it('does not call data services when the resolved organization scope is explicitly empty', async () => {
+    mockOrganizationScopeOverride = {
+      selectedId: null,
+      filterIds: [],
+      allowedIds: [],
+      tenantId: defaultTenantId,
+    }
+
+    const listResponse = await route.GET(new Request('http://x/api/example/todos?page=1&pageSize=10'))
+    expect(listResponse.status).toBe(200)
+    await expect(listResponse.json()).resolves.toEqual({
+      items: [],
+      total: 0,
+      page: 1,
+      pageSize: 10,
+      totalPages: 0,
+    })
+    expect(queryEngine.query).not.toHaveBeenCalled()
+
+    const createResponse = await route.POST(new Request('http://x/api/example/todos', {
+      method: 'POST',
+      body: JSON.stringify({ title: 'Blocked' }),
+      headers: { 'content-type': 'application/json' },
     }))
+    expect(createResponse.status).toBe(403)
+    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
   })
 
   it('PUT mutation guard uses route resource identity instead of spoofed lock headers', async () => {
@@ -1965,6 +2033,135 @@ describe('CRUD Factory', () => {
     expect(body._interceptor).toEqual({ ok: true, count: 1 })
   })
 
+  it('preserves exact and prefix interceptor identity through cloned and reconstructed aliases', async () => {
+    const beforeCalls: string[] = []
+    const afterCalls: string[] = []
+    registerApiInterceptors([
+      {
+        moduleId: 'example',
+        interceptors: [
+          {
+            id: 'example.canonical-prefix-policy',
+            targetRoute: 'example/*',
+            methods: ['GET', 'POST'],
+            priority: 100,
+            async before(request) {
+              beforeCalls.push(`prefix:${request.url}`)
+              return { ok: true }
+            },
+            async after(request) {
+              afterCalls.push(`prefix:${request.url}`)
+              return { merge: { canonicalPrefixPolicyApplied: true } }
+            },
+          },
+          {
+            id: 'example.canonical-route-policy',
+            targetRoute: 'example/todos',
+            methods: ['GET', 'POST'],
+            async before(request) {
+              beforeCalls.push(`exact:${request.url}`)
+              if (request.method === 'POST') {
+                return { ok: false, statusCode: 451, message: 'Denied by canonical policy' }
+              }
+              return { ok: true }
+            },
+            async after(request) {
+              afterCalls.push(`exact:${request.url}`)
+              return { merge: { canonicalPolicyApplied: true } }
+            },
+          },
+        ],
+      },
+    ])
+
+    const manifest: ApiRouteManifestEntry[] = [{
+      moduleId: 'example',
+      kind: 'route-file',
+      path: '/example/todos',
+      methods: ['GET', 'POST'],
+      load: async () => ({}),
+    }]
+    const aliases = [
+      { urlPath: '/api/example/todos', dispatcherPath: '/example/todos', transform: (request: Request) => request },
+      { urlPath: '/api/EXAMPLE/TODOS', dispatcherPath: '/EXAMPLE/TODOS', transform: (request: Request) => request.clone() },
+      { urlPath: '/api/%65xample/%74odos', dispatcherPath: '/example/todos', transform: (request: Request) => new Request(request.url, request) },
+    ]
+
+    for (const alias of aliases) {
+      const postRequest = new Request(`http://x${alias.urlPath}?source=alias`, {
+        method: 'POST',
+        body: JSON.stringify({ title: 'Must not be created' }),
+        headers: { 'content-type': 'application/json' },
+      })
+      expect(findApiRouteManifestMatch(manifest, 'POST', alias.dispatcherPath, postRequest)).toBeDefined()
+      const denied = await route.POST(alias.transform(postRequest))
+      expect(denied.status).toBe(451)
+      await expect(denied.json()).resolves.toMatchObject({ error: 'Denied by canonical policy' })
+
+      const getRequest = new Request(`http://x${alias.urlPath}?page=1&pageSize=10`)
+      expect(findApiRouteManifestMatch(manifest, 'GET', alias.dispatcherPath, getRequest)).toBeDefined()
+      const allowed = await route.GET(alias.transform(getRequest))
+      expect(allowed.status).toBe(200)
+      await expect(allowed.json()).resolves.toMatchObject({
+        canonicalPolicyApplied: true,
+        canonicalPrefixPolicyApplied: true,
+      })
+    }
+
+    expect(beforeCalls).toHaveLength(12)
+    expect(afterCalls).toHaveLength(6)
+    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
+  })
+
+  it('fails a malformed unbound request before interceptor selection or mutation', async () => {
+    const before = jest.fn(async () => ({ ok: true }))
+    registerApiInterceptors([{
+      moduleId: 'example',
+      interceptors: [{
+        id: 'example.malformed-path-probe',
+        targetRoute: 'example/*',
+        methods: ['POST'],
+        before,
+      }],
+    }])
+
+    const response = await route.POST(new Request('http://x/api/example/%ZZ', {
+      method: 'POST',
+      body: JSON.stringify({ title: 'Must not be created' }),
+      headers: { 'content-type': 'application/json' },
+    }))
+
+    expect(response.status).toBe(400)
+    expect(before).not.toHaveBeenCalled()
+    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
+  })
+
+  it('fails closed for an attacker-supplied route identity header', async () => {
+    const before = jest.fn(async () => ({ ok: true }))
+    registerApiInterceptors([{
+      moduleId: 'example',
+      interceptors: [{
+        id: 'example.forged-identity-probe',
+        targetRoute: 'example/*',
+        methods: ['POST'],
+        before,
+      }],
+    }])
+
+    const response = await route.POST(new Request('http://x/api/example/todos', {
+      method: 'POST',
+      body: JSON.stringify({ title: 'Must not be created' }),
+      headers: {
+        'content-type': 'application/json',
+        'x-open-mercato-route-identity': 'attacker-controlled',
+      },
+    }))
+
+    expect(response.status).toBe(400)
+    expect(before).not.toHaveBeenCalled()
+    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
+  })
+
   // The command DELETE path used to hand before-interceptors the body only, so a
   // guard reading `?id=` saw nothing to object to and the delete went through
   // with a 200 (issue #4842).

package/src/lib/crud/__tests__/enricher-runner.test.ts

@@ -1,6 +1,271 @@
-import type { EnricherContext, ResponseEnricher } from '../response-enricher'
+import { createLogger } from '../../logger'
+import {
+  registerTelemetryRuntime,
+  resetTelemetryRuntime,
+  type TelemetryRuntime,
+} from '../../telemetry/runtime'
 import { registerResponseEnrichers } from '../enricher-registry'
-import { applyResponseEnricherToRecord } from '../enricher-runner'
+import {
+  applyResponseEnricherToRecord,
+  applyResponseEnrichers,
+} from '../enricher-runner'
+import type {
+  EnricherContext,
+  EnricherRegistryEntry,
+  ResponseEnricher,
+} from '../response-enricher'
+
+jest.mock('../../logger', () => {
+  const mocked = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  }
+  mocked.child.mockImplementation(() => mocked)
+  return { createLogger: jest.fn(() => mocked) }
+})
+
+const logger = createLogger('shared').child({ component: 'umes' })
+const loggerDebug = logger.debug as jest.Mock
+const loggerWarn = logger.warn as jest.Mock
+const loggerError = logger.error as jest.Mock
+
+const context: EnricherContext = {
+  organizationId: 'org-1',
+  tenantId: 'tenant-1',
+  userId: 'user-1',
+  em: {},
+  container: {},
+}
+
+function makeEntry(id: string): EnricherRegistryEntry {
+  const enricher: ResponseEnricher<Record<string, unknown>, Record<string, unknown>> = {
+    id,
+    targetEntity: 'customers.person',
+    enrichOne: async (record) => record,
+    enrichMany: async (records) => records,
+  }
+  return { moduleId: 'test', enricher }
+}
+
+function makeCriticalEnrichingEntry(id: string): EnricherRegistryEntry {
+  const entry = makeEntry(id)
+  entry.enricher.critical = true
+  entry.enricher.enrichMany = async (records) =>
+    records.map((record) => ({ ...record, enriched: true }))
+  entry.enricher.enrichOne = async (record) => ({ ...record, enriched: true })
+  return entry
+}
+
+function mockNow(values: number[]): jest.SpyInstance<number, []> {
+  let index = 0
+  return jest.spyOn(Date, 'now').mockImplementation(() => {
+    const value = values[index]
+    if (value === undefined) {
+      throw new Error('[internal] Missing mocked Date.now() value')
+    }
+    index += 1
+    return value
+  })
+}
+
+function makeRuntime(recordHistogram: jest.Mock): TelemetryRuntime {
+  return {
+    canUseGlobalTracePropagation: () => false,
+    captureTraceContext: () => ({}),
+    continueTrace: (_carrier, _name, fn) => fn(),
+    recordHistogram,
+    recordHttpDuration: () => {},
+    reportError: () => {},
+    shutdown: async () => {},
+  }
+}
+
+beforeEach(() => {
+  jest.useFakeTimers({ doNotFake: ['Date'] })
+  loggerDebug.mockClear()
+  loggerWarn.mockClear()
+  loggerError.mockClear()
+  resetTelemetryRuntime()
+})
+
+afterEach(() => {
+  jest.restoreAllMocks()
+  jest.useRealTimers()
+  resetTelemetryRuntime()
+})
+
+describe('enricher performance reporting', () => {
+  it('throttles terminal slow logs per enricher and reports suppressed observations', async () => {
+    const entry = makeEntry('test.throttle')
+    mockNow([0, 600, 1_000, 1_700, 2_000, 2_900, 31_000, 31_800])
+
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      await applyResponseEnrichers([{ id: 'person-1' }], 'customers.person', context, [entry])
+    }
+
+    expect(loggerError).toHaveBeenCalledTimes(2)
+    expect(loggerError).toHaveBeenNthCalledWith(1, 'Enricher exceeded slow threshold', {
+      enricherId: 'test.throttle',
+      elapsedMs: 600,
+      thresholdMs: 500,
+      suppressedCount: 0,
+      maxElapsedMs: 600,
+    })
+    expect(loggerError).toHaveBeenNthCalledWith(2, 'Enricher exceeded slow threshold', {
+      enricherId: 'test.throttle',
+      elapsedMs: 800,
+      thresholdMs: 500,
+      suppressedCount: 2,
+      maxElapsedMs: 900,
+    })
+    expect(loggerWarn).not.toHaveBeenCalled()
+  })
+
+  it('routes the diagnostic threshold to debug and the terminal threshold to error', async () => {
+    mockNow([0, 100, 1_000, 1_150, 2_000, 2_600])
+
+    await applyResponseEnrichers(
+      [{ id: 'person-1' }],
+      'customers.person',
+      context,
+      [makeEntry('test.fast')],
+    )
+    await applyResponseEnrichers(
+      [{ id: 'person-1' }],
+      'customers.person',
+      context,
+      [makeEntry('test.diagnostic')],
+    )
+    await applyResponseEnrichers(
+      [{ id: 'person-1' }],
+      'customers.person',
+      context,
+      [makeEntry('test.terminal')],
+    )
+
+    expect(loggerDebug).toHaveBeenCalledTimes(1)
+    expect(loggerDebug).toHaveBeenCalledWith('Enricher exceeded slow threshold', {
+      enricherId: 'test.diagnostic',
+      elapsedMs: 150,
+      thresholdMs: 100,
+    })
+    expect(loggerError).toHaveBeenCalledTimes(1)
+    expect(loggerError).toHaveBeenCalledWith(
+      'Enricher exceeded slow threshold',
+      expect.objectContaining({
+        enricherId: 'test.terminal',
+        elapsedMs: 600,
+        thresholdMs: 500,
+      }),
+    )
+    expect(loggerWarn).not.toHaveBeenCalled()
+  })
+
+  it('emits list and record duration histograms only through an active runtime', async () => {
+    const recordHistogram = jest.fn()
+    registerTelemetryRuntime(makeRuntime(recordHistogram))
+    mockNow([0, 250, 1_000, 1_050])
+
+    await applyResponseEnrichers(
+      [{ id: 'person-1' }],
+      'customers.person',
+      context,
+      [makeEntry('test.metric-list')],
+    )
+    await applyResponseEnricherToRecord(
+      { id: 'person-1' },
+      'customers.person',
+      context,
+      [makeEntry('test.metric-record')],
+    )
+
+    expect(recordHistogram).toHaveBeenNthCalledWith(
+      1,
+      'om.enricher.duration',
+      0.25,
+      { 'enricher.id': 'test.metric-list' },
+      's',
+    )
+    expect(recordHistogram).toHaveBeenNthCalledWith(
+      2,
+      'om.enricher.duration',
+      0.05,
+      { 'enricher.id': 'test.metric-record' },
+      's',
+    )
+  })
+
+  it('preserves successful critical enrichment and throttles the warning per enricher when histogram recording fails', async () => {
+    const entry = makeCriticalEnrichingEntry('test.metric-failure')
+    const otherEntry = makeCriticalEnrichingEntry('test.metric-failure-other')
+    const telemetryError = new Error('[internal] Telemetry provider failed')
+    const recordHistogram = jest.fn(() => {
+      throw telemetryError
+    })
+    registerTelemetryRuntime(makeRuntime(recordHistogram))
+    mockNow([0, 25, 1_000, 1_010, 2_000, 2_020, 31_000, 31_030])
+
+    const listResult = await applyResponseEnrichers(
+      [{ id: 'person-1' }],
+      'customers.person',
+      context,
+      [entry],
+    )
+    const recordResult = await applyResponseEnricherToRecord(
+      { id: 'person-1' },
+      'customers.person',
+      context,
+      [entry],
+    )
+
+    expect(listResult).toEqual({
+      items: [{ id: 'person-1', enriched: true }],
+      _meta: { enrichedBy: ['test.metric-failure'] },
+    })
+    expect(recordResult).toEqual({
+      record: { id: 'person-1', enriched: true },
+      _meta: { enrichedBy: ['test.metric-failure'] },
+    })
+    expect(recordHistogram).toHaveBeenCalledTimes(2)
+    expect(loggerWarn).toHaveBeenCalledTimes(1)
+    expect(loggerWarn).toHaveBeenCalledWith('Enricher duration metric recording failed', {
+      enricherId: 'test.metric-failure',
+      metric: 'om.enricher.duration',
+      err: telemetryError,
+    })
+
+    const otherRecordResult = await applyResponseEnricherToRecord(
+      { id: 'person-1' },
+      'customers.person',
+      context,
+      [otherEntry],
+    )
+
+    expect(otherRecordResult).toEqual({
+      record: { id: 'person-1', enriched: true },
+      _meta: { enrichedBy: ['test.metric-failure-other'] },
+    })
+    expect(loggerWarn).toHaveBeenCalledTimes(2)
+    expect(loggerWarn).toHaveBeenNthCalledWith(2, 'Enricher duration metric recording failed', {
+      enricherId: 'test.metric-failure-other',
+      metric: 'om.enricher.duration',
+      err: telemetryError,
+    })
+
+    await applyResponseEnrichers([{ id: 'person-1' }], 'customers.person', context, [entry])
+
+    expect(recordHistogram).toHaveBeenCalledTimes(4)
+    expect(loggerWarn).toHaveBeenCalledTimes(3)
+    expect(loggerWarn).toHaveBeenNthCalledWith(3, 'Enricher duration metric recording failed', {
+      enricherId: 'test.metric-failure',
+      metric: 'om.enricher.duration',
+      err: telemetryError,
+    })
+  })
+})
 
 describe('enricher runner', () => {
   it('partitions wildcard read-through cache entries by concrete entity', async () => {
@@ -29,7 +294,7 @@ describe('enricher runner', () => {
     }
     registerResponseEnrichers([{ moduleId: 'test', enrichers: [enricher] }])
 
-    const context: EnricherContext = {
+    const cacheContext: EnricherContext = {
       organizationId: 'org-1',
       tenantId: 'tenant-1',
       userId: 'user-1',
@@ -40,12 +305,12 @@ describe('enricher runner', () => {
     const personResult = await applyResponseEnricherToRecord(
       { id: 'shared-id' },
       'customers.person',
-      context,
+      cacheContext,
     )
     const orderResult = await applyResponseEnricherToRecord(
       { id: 'shared-id' },
       'sales.order',
-      context,
+      cacheContext,
     )
 
     expect(personResult.record).toMatchObject({ enrichedFrom: 'customers.person' })