@open-mercato/shared 0.6.7-develop.6788.1.c2a1520a30 → 0.6.7-develop.6814.1.0627c7e9f1

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

@@ -0,0 +1,173 @@
+// 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)
+  })
+})

package/src/lib/di/container.ts

@@ -24,6 +24,8 @@ export type AppDiRegistrar = (container: AppContainer) => void | Promise<void>
 // file can be loaded as multiple module instances when mixing dynamic and static imports
 const GLOBAL_KEY = '__openMercatoDiRegistrars__'
 const APP_DI_REGISTRAR_KEY = '__openMercatoAppDiRegistrar__'
+const APP_DI_LOAD_WARNING_KEY = '__openMercatoAppDiLoadWarningEmitted__'
+const APP_DI_REGISTER_WARNING_KEY = '__openMercatoAppDiRegisterWarningEmitted__'
 // Phase 5 — process-scoped bootstrap cache. The cache/event-bus/encryption
 // services bootstrap() creates are inherently process-scoped (they hold
 // state across requests). Caching them on globalThis after the first
@@ -137,10 +139,35 @@ export function registerAppDiRegistrar(registrar: AppDiRegistrar | null): void {
   ;(globalThis as Record<string, unknown>)[APP_DI_REGISTRAR_KEY] = registrar
 }
 
-/** Test-only helper to drop the process-scoped bootstrap cache. */
+/** Test-only helper to drop process-scoped request-container state. */
 export function resetBootstrapCache(): void {
   (globalThis as any)[BOOTSTRAP_CACHE_KEY] = null
   ;(globalThis as any)[ENCRYPTION_ENABLED_KEY] = undefined
+  ;(globalThis as Record<string, unknown>)[APP_DI_LOAD_WARNING_KEY] = undefined
+  ;(globalThis as Record<string, unknown>)[APP_DI_REGISTER_WARNING_KEY] = undefined
+}
+
+function isAppDiModuleNotFound(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false
+  const { code, message } = error as { code?: unknown; message?: unknown }
+  const text = typeof message === 'string' ? message : ''
+  const moduleNotFound =
+    code === 'MODULE_NOT_FOUND'
+    || code === 'ERR_MODULE_NOT_FOUND'
+    || text.startsWith('Cannot find module')
+    || text.startsWith('Cannot find package')
+  return moduleNotFound && /(?:module|package) ['"]@\/di['"]/.test(text)
+}
+
+function warnAppDiFailureOnce(
+  key: typeof APP_DI_LOAD_WARNING_KEY | typeof APP_DI_REGISTER_WARNING_KEY,
+  message: string,
+  error: unknown,
+): void {
+  const globalScope = globalThis as Record<string, unknown>
+  if (globalScope[key] === true) return
+  globalScope[key] = true
+  logger.warn(message, { err: error })
 }
 
 function isAwilixResolver(value: unknown): value is Resolver<unknown> {
@@ -249,11 +276,25 @@ export async function createRequestContainer(): Promise<AppContainer> {
         try {
           const maybe = appDi.register(container)
           if (maybe && typeof maybe.then === 'function') await maybe
-        } catch (error) {
-          logger.error('App-level DI registrar failed', { err: error })
+        } catch (err) {
+          warnAppDiFailureOnce(
+            APP_DI_REGISTER_WARNING_KEY,
+            'App-level DI override (src/di.ts register()) threw; its registrations are skipped',
+            err,
+          )
         }
       }
-    } catch {}
+    } catch (err) {
+      if (isAppDiModuleNotFound(err)) {
+        logger.debug('App-level DI override module (@/di) not resolvable; skipping', { err })
+      } else {
+        warnAppDiFailureOnce(
+          APP_DI_LOAD_WARNING_KEY,
+          'App-level DI override module (@/di) failed to load; its registrations are skipped',
+          err,
+        )
+      }
+    }
   }
   applyDiOverridesToContainer({
     register: (registrations) => container.register(toAwilixRegistrations(registrations)),

package/src/lib/email/__tests__/send.test.ts

@@ -1,4 +1,7 @@
 import React from 'react'
+import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
 import { sendEmail } from '../send'
 
 var sendMock: jest.Mock
@@ -15,6 +18,7 @@ jest.mock('resend', () => {
 
 describe('sendEmail', () => {
   const originalEnv = process.env
+  let tempDir: string | null = null
 
   beforeEach(() => {
     process.env = {
@@ -26,7 +30,11 @@ describe('sendEmail', () => {
     ResendMock.mockClear()
   })
 
-  afterEach(() => {
+  afterEach(async () => {
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true })
+      tempDir = null
+    }
     process.env = originalEnv
   })
 
@@ -158,4 +166,32 @@ describe('sendEmail', () => {
     expect(ResendMock).not.toHaveBeenCalled()
     expect(sendMock).not.toHaveBeenCalled()
   })
+
+  it('captures email links in OM_TEST_MODE without external delivery', async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'om-email-capture-'))
+    const capturePath = join(tempDir, 'emails.jsonl')
+    process.env.OM_TEST_MODE = '1'
+    process.env.OM_TEST_EMAIL_CAPTURE_PATH = capturePath
+    delete process.env.RESEND_API_KEY
+
+    await sendEmail({
+      to: 'user@example.com',
+      subject: 'Invite',
+      react: React.createElement('div', null, [
+        React.createElement('p', { key: 'text' }, 'Accept your invite'),
+        React.createElement('a', { key: 'link', href: 'https://example.com/portal/invite?token=raw' }, 'Accept'),
+      ]),
+    })
+
+    const rows = (await readFile(capturePath, 'utf8')).trim().split('\n')
+    expect(rows).toHaveLength(1)
+    expect(JSON.parse(rows[0])).toEqual(expect.objectContaining({
+      to: 'user@example.com',
+      subject: 'Invite',
+      links: ['https://example.com/portal/invite?token=raw'],
+      text: 'Accept your invite Accept',
+    }))
+    expect(ResendMock).not.toHaveBeenCalled()
+    expect(sendMock).not.toHaveBeenCalled()
+  })
 })

package/src/lib/email/send.ts

@@ -1,5 +1,8 @@
 import { Resend } from 'resend'
 import React from 'react'
+import { appendFile, mkdir } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
 import { parseBooleanWithDefault } from '../boolean'
 import { resolveDefaultEmailFromAddress } from './config'
 
@@ -16,10 +19,86 @@ export type SendEmailOptions = {
   }>
 }
 
+type CapturedEmail = {
+  to: string
+  subject: string
+  from: string | null
+  replyTo: string | null
+  links: string[]
+  text: string
+  capturedAt: string
+}
+
+type ReactElementProps = {
+  href?: unknown
+  children?: unknown
+}
+
+const DEFAULT_TEST_EMAIL_CAPTURE_PATH = join(tmpdir(), 'open-mercato-email-capture.jsonl')
+
+function resolveTestEmailCapturePath(): string {
+  return process.env.OM_TEST_EMAIL_CAPTURE_PATH?.trim() || DEFAULT_TEST_EMAIL_CAPTURE_PATH
+}
+
+function readElementProps(node: React.ReactElement): ReactElementProps {
+  return node.props as ReactElementProps
+}
+
+function collectEmailLinks(node: unknown, links: string[] = []): string[] {
+  if (node == null || typeof node === 'boolean') return links
+  if (Array.isArray(node)) {
+    for (const child of node) collectEmailLinks(child, links)
+    return links
+  }
+  if (React.isValidElement(node)) {
+    const props = readElementProps(node)
+    if (typeof props.href === 'string' && props.href.length > 0) links.push(props.href)
+    collectEmailLinks(props.children, links)
+  }
+  return links
+}
+
+function collectEmailText(node: unknown, parts: string[] = []): string[] {
+  if (node == null || typeof node === 'boolean') return parts
+  if (typeof node === 'string' || typeof node === 'number') {
+    parts.push(String(node))
+    return parts
+  }
+  if (Array.isArray(node)) {
+    for (const child of node) collectEmailText(child, parts)
+    return parts
+  }
+  if (React.isValidElement(node)) {
+    collectEmailText(readElementProps(node).children, parts)
+  }
+  return parts
+}
+
+async function captureEmailForTests(options: SendEmailOptions): Promise<void> {
+  if (!parseBooleanWithDefault(process.env.OM_TEST_MODE, false)) return
+
+  const capturePath = resolveTestEmailCapturePath()
+  const record: CapturedEmail = {
+    to: options.to,
+    subject: options.subject,
+    from: options.from ?? resolveDefaultEmailFromAddress() ?? null,
+    replyTo: options.replyTo ?? null,
+    links: collectEmailLinks(options.react),
+    text: collectEmailText(options.react).join(' ').replace(/\s+/g, ' ').trim(),
+    capturedAt: new Date().toISOString(),
+  }
+
+  await mkdir(dirname(capturePath), { recursive: true })
+  await appendFile(capturePath, `${JSON.stringify(record)}\n`, 'utf8')
+}
+
 export async function sendEmail({ to, subject, react, from, replyTo, attachments }: SendEmailOptions) {
   const emailDisabled =
     parseBooleanWithDefault(process.env.OM_DISABLE_EMAIL_DELIVERY, false) ||
     parseBooleanWithDefault(process.env.OM_TEST_MODE, false)
+
+  await captureEmailForTests({ to, subject, react, from, replyTo, attachments })
+
   if (emailDisabled) return
 
   const apiKey = process.env.RESEND_API_KEY

package/src/lib/i18n/__tests__/server-dictionary-cache.test.ts

@@ -0,0 +1,30 @@
+import { loadDictionary, registerModules } from '../server'
+import type { Module } from '../../../modules/registry'
+
+describe('loadDictionary memoization', () => {
+  it('returns a cached dictionary for repeated calls with the same locale', async () => {
+    registerModules([
+      { id: 'demo', translations: { en: { 'demo.hello': 'Hello' } } },
+    ] satisfies Module[])
+
+    const first = await loadDictionary('en')
+    const second = await loadDictionary('en')
+
+    expect(second).toBe(first)
+    expect(first['demo.hello']).toBe('Hello')
+  })
+
+  it('busts the cache when the registered module set changes', async () => {
+    registerModules([{ id: 'a', translations: { en: { 'a.k': 'A' } } }] satisfies Module[])
+    const before = await loadDictionary('en')
+
+    registerModules([
+      { id: 'a', translations: { en: { 'a.k': 'A' } } },
+      { id: 'b', translations: { en: { 'b.k': 'B' } } },
+    ] satisfies Module[])
+    const after = await loadDictionary('en')
+
+    expect(after).not.toBe(before)
+    expect(after['b.k']).toBe('B')
+  })
+})

package/src/lib/query/__tests__/engine.test.ts

@@ -1,6 +1,13 @@
 import { BasicQueryEngine } from '../engine'
 import { SortDir } from '../types'
 import { registerModules } from '../../i18n/server'
+import { clearSearchTokenPresenceCache } from '../../search/availability'
+
+// The token-presence answer is cached process-wide (TTL); without clearing it,
+// probe-count assertions would observe hits from earlier tests in this file.
+beforeEach(() => {
+  clearSearchTokenPresenceCache()
+})
 
 // Mock modules with one entity extension
 const mockModules = [
@@ -355,6 +362,8 @@ describe('BasicQueryEngine (Kysely)', () => {
     const fakeDb = createFakeKysely({
       customer_entities: [],
       customer_people: [],
+      search_tokens: [{ one: 1 }],
+      'information_schema.tables': [{ table_name: 'search_tokens' }],
       'information_schema.columns': [
         { table_name: 'customer_entities', column_name: 'tenant_id' },
         { table_name: 'customer_people', column_name: 'id' },
@@ -362,8 +371,6 @@ describe('BasicQueryEngine (Kysely)', () => {
       ],
     })
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
-    jest.spyOn(engine as any, 'tableExists').mockResolvedValue(true)
-    jest.spyOn(engine as any, 'hasSearchTokens').mockResolvedValue(true)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
 
     await engine.query('customers:customer_entity', {
@@ -409,7 +416,6 @@ describe('BasicQueryEngine (Kysely)', () => {
       ],
     })
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
-    jest.spyOn(engine as any, 'tableExists').mockResolvedValue(false)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
 
     await engine.query('customers:customer_entity', {
@@ -445,10 +451,10 @@ describe('BasicQueryEngine (Kysely)', () => {
   test('uses search tokens for index document fields on base entities', async () => {
     const fakeDb = createFakeKysely({
       todos: [],
+      search_tokens: [{ one: 1 }],
+      'information_schema.tables': [{ table_name: 'search_tokens' }],
     })
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
-    const tableExistsSpy = jest.spyOn(engine as any, 'tableExists').mockResolvedValue(true)
-    const hasSearchTokensSpy = jest.spyOn(engine as any, 'hasSearchTokens').mockResolvedValue(true)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
 
     await engine.query('example:todo', {
@@ -461,12 +467,15 @@ describe('BasicQueryEngine (Kysely)', () => {
       page: { page: 1, pageSize: 10 },
     })
 
-    expect(tableExistsSpy).toHaveBeenCalledWith('search_tokens')
-    expect(hasSearchTokensSpy).toHaveBeenCalledWith(
-      'example:todo',
-      't1',
-      expect.objectContaining({ ids: ['org1'] }),
-    )
+    const calls = fakeDb._calls as Array<{ _ops: { table: string; wheres: unknown[][] } }>
+    const tableProbe = calls.find((call) =>
+      call._ops.table === 'information_schema.tables' &&
+      call._ops.wheres.some((where) => where[0] === 'table_name' && where[2] === 'search_tokens'))
+    expect(tableProbe).toBeTruthy()
+    const tokenProbe = calls.find((call) =>
+      call._ops.table === 'search_tokens' &&
+      call._ops.wheres.some((where) => where[0] === 'entity_type' && where[2] === 'example:todo'))
+    expect(tokenProbe).toBeTruthy()
     expect(applySearchTokensSpy).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({
@@ -488,7 +497,6 @@ describe('BasicQueryEngine (Kysely)', () => {
       ],
     })
     const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
-    const hasSearchTokensSpy = jest.spyOn(engine as any, 'hasSearchTokens').mockResolvedValue(true)
     const applySearchTokensSpy = jest.spyOn(engine as any, 'applySearchTokens')
 
     await engine.query('example:todo', {
@@ -501,7 +509,8 @@ describe('BasicQueryEngine (Kysely)', () => {
       page: { page: 1, pageSize: 10 },
     })
 
-    expect(hasSearchTokensSpy).not.toHaveBeenCalled()
+    const calls = fakeDb._calls as Array<{ _ops: { table: string } }>
+    expect(calls.some((call) => call._ops.table === 'search_tokens')).toBe(false)
     expect(applySearchTokensSpy).not.toHaveBeenCalled()
     const baseCall = fakeDb._calls.find((builder: any) => builder._ops.table === 'todos')
     expect(baseCall?._ops.wheres).toContainEqual(['todos.search_text', 'ilike', '%avision%'])
@@ -933,4 +942,47 @@ describe('BasicQueryEngine (Kysely)', () => {
     expect(baseCall._ops.limits).toBe(10)
     expect(baseCall._ops.offsets).toBe(10)
   })
+
+  describe('search_tokens coverage probe (#4723 parity)', () => {
+    type ProbeDbLog = { _calls: Array<{ _ops: { table: string } }> }
+
+    const countProbes = (fakeDb: ProbeDbLog): number =>
+      fakeDb._calls.filter((call) => call._ops.table === 'search_tokens').length
+
+    const buildEngine = (fakeDb: unknown): BasicQueryEngine => new BasicQueryEngine(
+      {} as ConstructorParameters<typeof BasicQueryEngine>[0],
+      (() => fakeDb) as unknown as NonNullable<ConstructorParameters<typeof BasicQueryEngine>[1]>,
+    )
+
+    const buildDb = () => createFakeKysely({
+      users: [],
+      'information_schema.tables': [{ table_name: 'search_tokens' }],
+    })
+
+    test('is skipped when the query carries no like/ilike filter', async () => {
+      const fakeDb = buildDb()
+      const engine = buildEngine(fakeDb)
+
+      await engine.query('auth:user', {
+        tenantId: 't1',
+        organizationId: 'org1',
+        filters: { is_active: { $eq: true } },
+      })
+
+      expect(countProbes(fakeDb)).toBe(0)
+    })
+
+    test('still runs when the query actually searches', async () => {
+      const fakeDb = buildDb()
+      const engine = buildEngine(fakeDb)
+
+      await engine.query('auth:user', {
+        tenantId: 't1',
+        organizationId: 'org1',
+        filters: { email: { $ilike: '%abc%' } },
+      })
+
+      expect(countProbes(fakeDb)).toBeGreaterThan(0)
+    })
+  })
 })