@open-mercato/shared 0.6.8-develop.6924.1.a8d208fcdc → 0.6.8-develop.6930.1.1e5976efc3

package/src/lib/commands/__tests__/command-bus.test.ts

@@ -124,6 +124,149 @@ describe('CommandBus', () => {
     expect(execute).toHaveBeenCalledTimes(1)
   })
 
+  it('merges command interceptor beforeExecute returned metadata.logContext into logged context with correct precedence', async () => {
+    const logMock = jest.fn(async () => ({ id: 'log-entry' }))
+    registerCommand({
+      id: 'test.command.interceptor-context',
+      execute: jest.fn(async () => ({ ok: true })),
+      buildLog: jest.fn(() => ({
+        actionLabel: 'Test',
+        resourceKind: 'test',
+        resourceId: '123',
+        context: {
+          original: 'buildlog-original-value',
+          interceptorOverridden: 'buildlog-takes-precedence',
+        },
+      })),
+    })
+
+    registerCommandInterceptors([
+      {
+        moduleId: 'test-module',
+        interceptors: [
+          {
+            id: 'test-interceptor-priority-2',
+            targetCommand: 'test.command.*',
+            priority: 60, // runs second
+            beforeExecute: async () => ({
+              ok: true,
+              metadata: {
+                logContext: {
+                  ip: '127.0.0.1',
+                  requestId: 'req-second',
+                  interceptorOverlap: 'second-wins',
+                },
+              },
+            }),
+          },
+          {
+            id: 'test-interceptor-priority-1',
+            targetCommand: 'test.command.*',
+            priority: 40, // runs first
+            beforeExecute: async () => ({
+              ok: true,
+              metadata: {
+                logContext: {
+                  requestId: 'req-first',
+                  interceptorOverlap: 'first-loss',
+                  baseOverridden: 'interceptor-wins-over-base',
+                  interceptorOverridden: 'interceptor-loss-to-buildlog',
+                },
+              },
+            }),
+          },
+        ],
+      },
+    ])
+
+    const container = createContainer({ injectionMode: InjectionMode.CLASSIC })
+    container.register({ actionLogService: asValue({ log: logMock }) })
+
+    const bus = new CommandBus()
+    const ctx = {
+      container,
+      auth: { sub: 'user-1', tenantId: 'tenant-1', orgId: null },
+      organizationScope: null,
+      selectedOrganizationId: null,
+      organizationIds: null,
+    }
+
+    await bus.execute('test.command.interceptor-context', {
+      input: {},
+      ctx,
+      metadata: {
+        context: {
+          original: 'base-original-value', // will be overridden by buildLog
+          baseOverridden: 'base-original-to-be-overridden',
+          untouched: 'base-untouched',
+        },
+      },
+    })
+
+    expect(logMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: {
+          untouched: 'base-untouched',
+          baseOverridden: 'interceptor-wins-over-base',
+          requestId: 'req-second',
+          interceptorOverlap: 'second-wins',
+          ip: '127.0.0.1',
+          original: 'buildlog-original-value',
+          interceptorOverridden: 'buildlog-takes-precedence',
+        },
+      })
+    )
+  })
+
+  it('does not promote a generic interceptor metadata.context key into the logged context', async () => {
+    const logMock = jest.fn(async () => ({ id: 'log-entry' }))
+    registerCommand({
+      id: 'test.command.private-metadata',
+      execute: jest.fn(async () => ({ ok: true })),
+      buildLog: jest.fn(() => ({
+        actionLabel: 'Test',
+        resourceKind: 'test',
+        resourceId: '123',
+      })),
+    })
+
+    registerCommandInterceptors([
+      {
+        moduleId: 'test-module',
+        interceptors: [
+          {
+            id: 'test-interceptor-private-metadata',
+            targetCommand: 'test.command.*',
+            beforeExecute: async () => ({
+              ok: true,
+              // `context` here is the interceptor's own after-hook state, not audit input.
+              metadata: { context: { internalHandle: 'must-stay-private' } },
+            }),
+          },
+        ],
+      },
+    ])
+
+    const container = createContainer({ injectionMode: InjectionMode.CLASSIC })
+    container.register({ actionLogService: asValue({ log: logMock }) })
+
+    await new CommandBus().execute('test.command.private-metadata', {
+      input: {},
+      ctx: {
+        container,
+        auth: { sub: 'user-1', tenantId: 'tenant-1', orgId: null },
+        organizationScope: null,
+        selectedOrganizationId: null,
+        organizationIds: null,
+      },
+      metadata: { context: { untouched: 'base-untouched' } },
+    })
+
+    expect(logMock).toHaveBeenCalledWith(
+      expect.objectContaining({ context: { untouched: 'base-untouched' } })
+    )
+  })
+
   describe('interceptor rejections', () => {
     const blockingInterceptor = (result: Record<string, unknown>): CommandInterceptor => ({
       id: 'test.block',

package/src/lib/commands/command-bus.ts

@@ -267,6 +267,30 @@ export class CommandBus {
     const snapshotsWithAfter = { ...snapshots, after: afterSnapshot }
     const logMeta = await this.buildLog(handler, effectiveOptions, result, snapshotsWithAfter)
     let mergedMeta = this.mergeMetadata(effectiveOptions.metadata, logMeta)
+    // Interceptors opt into audit-log enrichment with a reserved `logContext` key rather
+    // than the generic `context` one, so the metadata an interceptor already passes to its
+    // own afterExecute hook is never silently promoted into audit storage.
+    // Map iteration order is interceptor priority order (see collectMatching), so a
+    // later-priority interceptor overrides an earlier one on key collisions.
+    let interceptorContextMerged: Record<string, unknown> = {}
+    for (const meta of interceptorMetadata.values()) {
+      const logContextRecord = asRecord(asRecord(meta)?.logContext)
+      if (!logContextRecord) continue
+      interceptorContextMerged = {
+        ...interceptorContextMerged,
+        ...logContextRecord,
+      }
+    }
+    const baseContext = asRecord(effectiveOptions.metadata?.context) ?? {}
+    const logMetaContext = asRecord(logMeta?.context) ?? {}
+    if (Object.keys(interceptorContextMerged).length > 0 || Object.keys(baseContext).length > 0 || Object.keys(logMetaContext).length > 0) {
+      mergedMeta = mergedMeta ?? {}
+      mergedMeta.context = {
+        ...baseContext,
+        ...interceptorContextMerged,
+        ...logMetaContext,
+      }
+    }
     const undoable = this.isUndoable(handler)
     if (undoable) {
       mergedMeta = mergedMeta ?? {}

package/src/lib/commands/command-interceptor.ts

@@ -77,7 +77,15 @@ export interface CommandInterceptorBeforeResult {
   body?: Record<string, unknown>
   /** Modified input — shallow-merged into command input if ok:true */
   modifiedInput?: Record<string, unknown>
-  /** Metadata passed to the corresponding after hook */
+  /**
+   * Metadata passed to the corresponding after hook.
+   *
+   * Reserved key — `logContext`: a record here (e.g. `{ logContext: { ip: '...' } }`) is
+   * shallow-merged into the persisted `ActionLog.context_json`. Every other key stays
+   * private to the after hook. Contributed keys take precedence over
+   * `options.metadata.context` but yield to `buildLog().context` on conflicts; when two
+   * interceptors contribute the same key, the higher `priority` (later-running) one wins.
+   */
   metadata?: Record<string, unknown>
 }
 

package/src/lib/query/__tests__/engine.scope-and-or.test.ts

@@ -484,3 +484,97 @@ describe('BasicQueryEngine — multi-field $or grouping', () => {
     expect(hasNullTenant).toBe(true)
   })
 })
+
+describe('BasicQueryEngine — custom-field leaves inside an $or group (#5039)', () => {
+  const customFieldDb = () => createFakeKysely({
+    scheduled_jobs: [],
+    custom_field_defs: [
+      { key: 'priority', entity_id: 'scheduler:scheduled_job', is_active: true, tenant_id: null, kind: 'text' },
+    ],
+    custom_field_values: [],
+    'information_schema.columns': [
+      { table_name: 'scheduled_jobs', column_name: 'organization_id' },
+      { table_name: 'scheduled_jobs', column_name: 'tenant_id' },
+      { table_name: 'scheduled_jobs', column_name: 'scope_type' },
+    ],
+  })
+
+  test('two cf:* values joined by $or become one OR of two disjuncts, not two ANDed filters', async () => {
+    const fakeDb = customFieldDb()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', {
+      tenantId: 't1',
+      fields: ['id', 'cf:priority'],
+      omitAutomaticTenantOrgScope: true,
+      filters: {
+        $or: [
+          { 'cf:priority': { $eq: 'high' } },
+          { 'cf:priority': { $eq: 'low' } },
+        ],
+      },
+    })
+
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    expect(baseCall).toBeTruthy()
+
+    // Before the fix each value was applied as its own `.where()`, so the query asked
+    // for priority = 'high' AND priority = 'low' and could never match a row.
+    const orEntry = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'or')
+    expect(orEntry).toBeTruthy()
+    const orParts: Node[] = orEntry[1]
+    expect(orParts.length).toBe(2)
+
+    const values = orParts.flatMap((part) => flattenCmps(part)).map((cmp) => cmp.value)
+    expect(values).toEqual(expect.arrayContaining(['high', 'low']))
+
+    const standaloneCfFilters = baseCall._ops.wheres.filter(
+      (w: any) => Array.isArray(w) && w.length === 3 && (w[2] === 'high' || w[2] === 'low'),
+    )
+    expect(standaloneCfFilters).toHaveLength(0)
+  })
+
+  test('a base column OR a cf:* value unites both legs in the same disjunction', async () => {
+    const fakeDb = customFieldDb()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', {
+      tenantId: 't1',
+      fields: ['id', 'cf:priority'],
+      omitAutomaticTenantOrgScope: true,
+      filters: {
+        $or: [
+          { scope_type: { $eq: 'system' } },
+          { 'cf:priority': { $eq: 'high' } },
+        ],
+      },
+    })
+
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    const orEntry = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'or')
+    expect(orEntry).toBeTruthy()
+    const orParts: Node[] = orEntry[1]
+    expect(orParts.length).toBe(2)
+
+    const cmps = orParts.flatMap((part) => flattenCmps(part))
+    expect(cmps.some((cmp) => String(cmp.column).endsWith('scope_type') && cmp.value === 'system')).toBe(true)
+    expect(cmps.some((cmp) => cmp.value === 'high')).toBe(true)
+  })
+
+  test('an ungrouped cf:* filter still applies as its own AND predicate', async () => {
+    const fakeDb = customFieldDb()
+    const engine = new BasicQueryEngine({} as any, () => fakeDb as any)
+    await engine.query('scheduler:scheduled_job', {
+      tenantId: 't1',
+      fields: ['id', 'cf:priority'],
+      omitAutomaticTenantOrgScope: true,
+      filters: { 'cf:priority': { $eq: 'high' } },
+    })
+
+    const baseCall = fakeDb._calls.find((b: any) => b._ops.table === 'scheduled_jobs')
+    const orEntry = baseCall._ops.wheres.find((w: any) => Array.isArray(w) && w[0] === 'or')
+    expect(orEntry).toBeFalsy()
+    const directFilter = baseCall._ops.wheres.some(
+      (w: any) => Array.isArray(w) && w.length === 3 && w[1] === '=' && w[2] === 'high',
+    )
+    expect(directFilter).toBe(true)
+  })
+})

package/src/lib/query/engine.ts

@@ -316,6 +316,10 @@ export class BasicQueryEngine implements QueryEngine {
     }
     const { baseFilters, joinFilters } = partitionFilters(table, normalizedFilters, joinMap)
     const cfFilters = normalizedFilters.filter((filter) => String(filter.field).startsWith('cf:'))
+    // Custom-field leaves carrying an orGroup belong to an OR disjunct; applying them
+    // one `.where()` at a time would AND them onto every disjunct (#5039).
+    const regularCfFilters = cfFilters.filter((filter) => !filter.orGroup)
+    const orGroupCfFilters = cfFilters.filter((filter) => filter.orGroup)
     const searchConfig = resolveSearchConfig()
     const searchFilters = [...baseFilters, ...cfFilters].filter((filter) => isSearchFilterOp(filter.op))
     // Callers that opt out of automatic tenant/org scoping own the full
@@ -576,51 +580,41 @@ export class BasicQueryEngine implements QueryEngine {
       }
 
       // OR-grouped filters: AND within each group (one $or disjunct), OR between groups.
-      if (orGroupFilters.length > 0) {
-        const groups = new Map<string, typeof orGroupFilters>()
-        for (const f of orGroupFilters) {
+      // Resolution happens here (it needs async column lookups); the WHERE itself is
+      // applied further down, once the cf:* value expressions exist — an OR group may
+      // contain custom-field leaves whose SQL is only available then (#5039).
+      type ResolvedOrClause =
+        | { kind: 'column'; qualified: string; op: NormalizedFilter['op']; value: unknown }
+        | { kind: 'doc'; field: string; op: NormalizedFilter['op']; value: unknown }
+        | { kind: 'cf'; key: string; op: NormalizedFilter['op']; value: unknown }
+      const resolvedGroupFilters: ResolvedOrClause[][] = []
+      if (orGroupFilters.length > 0 || orGroupCfFilters.length > 0) {
+        const groups = new Map<string, NormalizedFilter[]>()
+        for (const f of [...orGroupFilters, ...orGroupCfFilters]) {
           const group = groups.get(f.orGroup!) ?? []
-          group.push(f)
+          group.push(f as NormalizedFilter)
           groups.set(f.orGroup!, group)
         }
-        type ResolvedOrClause =
-          | { kind: 'column'; qualified: string; op: NormalizedFilter['op']; value: unknown }
-          | { kind: 'doc'; field: string; op: NormalizedFilter['op']; value: unknown }
-        const resolvedGroupFilters: ResolvedOrClause[][] = []
         for (const [, groupFilters] of groups) {
           const resolved: ResolvedOrClause[] = []
           for (const filter of groupFilters) {
-            const column = await this.resolveBaseColumn(table, String(filter.field))
+            const field = String(filter.field)
+            if (field.startsWith('cf:')) {
+              resolved.push({ kind: 'cf', key: field.slice(3), op: filter.op, value: filter.value })
+              continue
+            }
+            const column = await this.resolveBaseColumn(table, field)
             if (column) {
               resolved.push({ kind: 'column', qualified: qualify(column), op: filter.op, value: filter.value })
             } else {
               // Field is not a base column — for custom-entity records it lives in
               // entity_indexes.doc. Build an EXISTS sub-filter so `$or` searches
               // across doc fields resolve instead of being silently dropped (#3229).
-              resolved.push({ kind: 'doc', field: String(filter.field), op: filter.op, value: filter.value })
+              resolved.push({ kind: 'doc', field, op: filter.op, value: filter.value })
             }
           }
           if (resolved.length > 0) resolvedGroupFilters.push(resolved)
         }
-        if (resolvedGroupFilters.length > 0) {
-          q = q.where((eb: any) => eb.or(
-            resolvedGroupFilters.map((group) => {
-              const parts = group.map((rf) => rf.kind === 'column'
-                ? this.buildColumnOpExpression(eb, rf.qualified, rf.op, rf.value)
-                : this.buildIndexDocOpExpression(eb, {
-                    entity: String(entity),
-                    field: rf.field,
-                    op: rf.op,
-                    value: rf.value,
-                    recordIdColumn,
-                    tenantId: opts.tenantId ?? null,
-                    organizationScope: orgScope,
-                    withDeleted: opts.withDeleted === true,
-                  }))
-              return parts.length === 1 ? parts[0] : eb.and(parts)
-            })
-          ))
-        }
       }
 
       q = await applyJoinFilters({
@@ -869,8 +863,9 @@ export class BasicQueryEngine implements QueryEngine {
         }
       }
 
-      // Apply cf:* filters (on raw expressions)
-      for (const f of cfFilters) {
+      // Apply cf:* filters (on raw expressions). OR-grouped ones are excluded here and
+      // combined with their disjunct's other leaves right below.
+      for (const f of regularCfFilters) {
         if (!f.field.startsWith('cf:')) continue
         const key = f.field.slice(3)
         const expr = cfValueExprByKey[key]
@@ -912,6 +907,43 @@ export class BasicQueryEngine implements QueryEngine {
         q = this.applyColumnOp(q, expr, f.op, f.value)
       }
 
+      // OR groups are applied here, after the cf:* value expressions exist, so a
+      // disjunct mixing base/doc and custom-field leaves is united rather than
+      // intersected. A cf leaf whose key resolved no value expression yields no
+      // predicate and is dropped; a disjunct left empty by that is dropped too,
+      // because an empty AND would read as TRUE and widen the result.
+      //
+      // Known limitation, shared with the `doc` clause kind above: a leaf inside an OR
+      // group compares against the stored value directly and does not route `like` /
+      // `ilike` through the search-token index the way the ungrouped path does. On a
+      // field covered by an encryption map such a leaf therefore compares against
+      // ciphertext and will not match.
+      const applicableGroupFilters = resolvedGroupFilters
+        .map((group) => group.filter((rf) => rf.kind !== 'cf' || Boolean(cfValueExprByKey[rf.key])))
+        .filter((group) => group.length > 0)
+      if (applicableGroupFilters.length > 0) {
+        q = q.where((eb: any) => {
+          const disjuncts = applicableGroupFilters.map((group) => {
+            const parts = group.map((rf) => {
+              if (rf.kind === 'column') return this.buildColumnOpExpression(eb, rf.qualified, rf.op, rf.value)
+              if (rf.kind === 'cf') return this.buildColumnOpExpression(eb, cfValueExprByKey[rf.key], rf.op, rf.value)
+              return this.buildIndexDocOpExpression(eb, {
+                entity: String(entity),
+                field: rf.field,
+                op: rf.op,
+                value: rf.value,
+                recordIdColumn,
+                tenantId: opts.tenantId ?? null,
+                organizationScope: orgScope,
+                withDeleted: opts.withDeleted === true,
+              })
+            })
+            return parts.length === 1 ? parts[0] : eb.and(parts)
+          })
+          return disjuncts.length === 1 ? disjuncts[0] : eb.or(disjuncts)
+        })
+      }
+
       // Entity extensions joins (no selection yet; enables future filters/projections)
       if (opts.includeExtensions) {
         const { getModules } = await import('@open-mercato/shared/lib/i18n/server')
@@ -1154,7 +1186,7 @@ export class BasicQueryEngine implements QueryEngine {
     }
   }
 
-  private buildColumnOpExpression(eb: any, column: string, op: string, value: unknown): any {
+  private buildColumnOpExpression(eb: any, column: string | RawBuilder<unknown>, op: string, value: unknown): any {
     switch (op) {
       case 'eq': return value === null ? eb(column, 'is', null) : eb(column, '=', value)
       case 'ne': return value === null ? eb(column, 'is not', null) : eb(column, '!=', value)