@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/query_index/__tests__/hybrid-engine.test.ts

@@ -1,365 +0,0 @@
-import { HybridQueryEngine } from '../../query_index/lib/engine'
-
-function createFakeKnex(config: {
-  baseTable: string
-  hasIndexAny: boolean
-  baseCount: number
-  indexCount: number
-  customFieldKeys?: Record<string, string[]>
-}) {
-  const defaultCustomFieldKeys: Record<string, string[]> = {
-    'example:todo': ['priority'],
-    'customers:customer_entity': ['sector'],
-    'customers:customer_person_profile': ['birthday'],
-    'customers:customer_company_profile': ['industry'],
-  }
-  const customFieldKeys = config.customFieldKeys ?? defaultCustomFieldKeys
-  const calls: any[] = []
-  function raw(sql: string, params?: any[]) { return { toString: () => sql, sql, params } }
-  function normalizeTable(t: any): { table: string; alias?: string } {
-    if (typeof t === 'string') return { table: t }
-    if (t && typeof t === 'object') {
-      const alias = Object.keys(t)[0]
-      const table = (t as any)[alias]
-      return { table, alias }
-    }
-    return { table: String(t) }
-  }
-  function builderFor(tableArg: any) {
-    const { table, alias } = normalizeTable(tableArg)
-    const ops = { table, alias, wheres: [] as any[], joins: [] as any[], selects: [] as any[], orderBys: [] as any[], limits: 0, offsets: 0, isCountDistinct: false, isCount: false }
-    const b: any = {
-      _ops: ops,
-      select: function (...cols: any[]) { ops.selects.push(cols); return this },
-      where: function (...args: any[]) { ops.wheres.push(args); return this },
-      andWhere: function (...args: any[]) { ops.wheres.push(args); return this },
-      whereIn: function (...args: any[]) { ops.wheres.push(['in', ...args]); return this },
-      whereNotIn: function (...args: any[]) { ops.wheres.push(['notIn', ...args]); return this },
-      whereNull: function (col: any) { ops.wheres.push(['isNull', col]); return this },
-      whereNotNull: function (col: any) { ops.wheres.push(['notNull', col]); return this },
-      leftJoin: function (aliasObj: any, on: any) { ops.joins.push({ aliasObj, on }); return this },
-      orderBy: function (col: any, dir?: any) { ops.orderBys.push([col, dir]); return this },
-      limit: function (n: number) { ops.limits = n; return this },
-      offset: function (n: number) { ops.offsets = n; return this },
-      groupBy: function () { return this },
-      modify: function (fn: (qb: any) => void) { if (typeof fn === 'function') fn(this); return this },
-      clearSelect: function () { ops.selects = []; return this },
-      clearOrder: function () { ops.orderBys = []; return this },
-      clone: function () { return this },
-      as: function (_alias: string) { return table },
-      countDistinct: function () { ops.isCountDistinct = true; return this },
-      count: function () { ops.isCount = true; return this },
-      first: async function () {
-        if (table === 'information_schema.tables') {
-          return { table_name: config.baseTable }
-        }
-        if (table === 'entity_index_coverage') {
-          if (!config.hasIndexAny) return undefined
-          const requiresPositive = ops.wheres.some(
-            (entry) =>
-              Array.isArray(entry) &&
-              entry.length >= 3 &&
-              entry[0] === 'indexed_count' &&
-              entry[1] === '>' &&
-              Number(entry[2]) > 0,
-          )
-          if (requiresPositive && config.indexCount <= 0) return undefined
-          return {
-            base_count: String(config.baseCount),
-            indexed_count: String(config.indexCount),
-            refreshed_at: new Date(),
-          }
-        }
-        if (table === 'entity_indexes' && !ops.isCountDistinct) {
-          return config.hasIndexAny ? { entity_type: 'x' } : undefined
-        }
-        if (ops.isCountDistinct) {
-          if (table === config.baseTable || ops.alias === 'b') return { count: String(config.baseCount) }
-          if (table === 'entity_indexes' || ops.alias === 'ei') return { count: String(config.indexCount) }
-          return { count: '0' }
-        }
-        if (ops.isCount) {
-          return { count: String(config.baseCount) }
-        }
-        return undefined
-      },
-      then: function (resolve: any, reject?: any) {
-        try {
-          let result: any[] = []
-          if (table === 'custom_field_defs') {
-            const entityWhere = ops.wheres.find((entry) => Array.isArray(entry) && entry[0] === 'in' && entry[1] === 'entity_id')
-            const requestedEntities: string[] = Array.isArray(entityWhere?.[2])
-              ? (entityWhere![2] as any[]).map((id) => String(id))
-              : Object.keys(customFieldKeys)
-            result = requestedEntities.flatMap((entityId) => {
-              const keys = customFieldKeys[entityId] ?? []
-              return keys.map((key) => ({ entity_id: entityId, key, is_active: true }))
-            })
-          }
-          return Promise.resolve(resolve(result))
-        } catch (err) {
-          if (reject) return Promise.resolve(reject(err))
-          return Promise.reject(err)
-        }
-      },
-      raw,
-    }
-    calls.push(b)
-    return b
-  }
-  const fn: any = (t: any) => builderFor(t)
-  fn.raw = raw
-  fn.from = (t: any) => builderFor(t)
-  fn._calls = calls
-  return fn
-}
-
-describe('HybridQueryEngine', () => {
-  const originalAutoReindex = process.env.QUERY_INDEX_AUTO_REINDEX
-  const originalForcePartial = process.env.FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES
-
-  beforeEach(() => {
-    delete process.env.QUERY_INDEX_AUTO_REINDEX
-    delete process.env.FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES
-  })
-
-  afterEach(() => {
-    if (originalAutoReindex === undefined) delete process.env.QUERY_INDEX_AUTO_REINDEX
-    else process.env.QUERY_INDEX_AUTO_REINDEX = originalAutoReindex
-    if (originalForcePartial === undefined) delete process.env.FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES
-    else process.env.FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES = originalForcePartial
-    jest.clearAllMocks()
-  })
-
-  test('falls back when wantsCf but no index rows exist', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: false, baseCount: 5, indexCount: 0 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn().mockResolvedValue({ items: [], page: 1, pageSize: 20, total: 0 }) }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-
-    await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-    expect(fallback.query).toHaveBeenCalled()
-    expect(emitEvent).not.toHaveBeenCalled()
-  })
-
-  test('falls back and warns on partial coverage', async () => {
-    process.env.FORCE_QUERY_INDEX_ON_PARTIAL_INDEXES = 'false'
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 10, indexCount: 1 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn().mockResolvedValue({ items: [], page: 1, pageSize: 20, total: 0 }) }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-    expect(fallback.query).toHaveBeenCalled()
-    expect(warnSpy).toHaveBeenCalled()
-    const msg = (warnSpy.mock.calls[0] || [])[0] as string
-    expect(msg).toContain('Partial index coverage')
-    expect(emitEvent).toHaveBeenCalledWith(
-      'query_index.reindex',
-      expect.objectContaining({ entityType: 'example:todo', tenantId: 't1', organizationId: 'org1', force: false }),
-      { persistent: true },
-    )
-    warnSpy.mockRestore()
-  })
-
-  test('skips partial coverage warning when entity has no custom fields', async () => {
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      hasIndexAny: true,
-      baseCount: 8,
-      indexCount: 2,
-      customFieldKeys: {},
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = await engine.query('example:todo', {
-      fields: ['id'],
-      includeCustomFields: true,
-      organizationId: 'org1',
-      tenantId: 't1',
-    })
-
-    expect(fallback.query).not.toHaveBeenCalled()
-    expect(result.meta?.partialIndexWarning).toBeUndefined()
-    expect(warnSpy).not.toHaveBeenCalled()
-
-    warnSpy.mockRestore()
-  })
-
-  test('emits partial coverage metadata when forcing query index usage', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 10, indexCount: 4 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-
-    expect(fallback.query).not.toHaveBeenCalled()
-    expect(result.meta?.partialIndexWarning).toEqual(expect.objectContaining({ entity: 'example:todo' }))
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  test('emits partial coverage metadata when global scope is out of sync', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 5, indexCount: 5 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-
-    const statsSpy = jest
-      .spyOn(engine as any, 'indexCoverageStats')
-      .mockImplementationOnce(async () => ({ baseCount: 5, indexedCount: 5 })) // scoped ok
-      .mockImplementationOnce(async () => ({ baseCount: 10, indexedCount: 7 })) // global mismatch
-
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-
-    expect(fallback.query).not.toHaveBeenCalled()
-    expect(result.meta?.partialIndexWarning).toEqual(expect.objectContaining({ entity: 'example:todo', scope: 'global' }))
-    expect(warnSpy).toHaveBeenCalled()
-
-    statsSpy.mockRestore()
-    warnSpy.mockRestore()
-  })
-
-  test('propagates partial coverage metadata from custom field sources', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'customer_entities', hasIndexAny: true, baseCount: 5, indexCount: 5 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-
-    const originalResolve = (engine as any).resolveCoverageGap.bind(engine)
-    const gapSpy = jest
-      .spyOn(engine as any, 'resolveCoverageGap')
-      .mockImplementationOnce(originalResolve)
-      .mockImplementationOnce(async () => ({ stats: { baseCount: 8, indexedCount: 6 }, scope: 'scoped' }))
-      .mockImplementation(originalResolve)
-
-    const result = await engine.query('customers:customer_entity', {
-      tenantId: 't1',
-      organizationId: 'org1',
-      fields: ['id', 'cf:birthday'],
-      includeCustomFields: ['birthday'],
-      customFieldSources: [
-        {
-          entityId: 'customers:customer_person_profile',
-          table: 'customer_people',
-          alias: 'person_profile',
-          recordIdColumn: 'id',
-          join: { fromField: 'id', toField: 'entity_id' },
-        },
-      ],
-      page: { page: 1, pageSize: 10 },
-    })
-
-    expect(result.meta?.partialIndexWarning).toEqual(expect.objectContaining({ entity: 'customers:customer_person_profile' }))
-    expect(gapSpy).toHaveBeenCalled()
-    gapSpy.mockRestore()
-  })
-
-  test('detects mismatch when index count exceeds base count', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 10, indexCount: 12 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    const result = await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-
-    expect(fallback.query).not.toHaveBeenCalled()
-    expect(result.meta?.partialIndexWarning).toEqual(expect.objectContaining({ entity: 'example:todo' }))
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  test('uses hybrid path when coverage complete', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 10, indexCount: 10 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-
-    await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1', page: { page: 1, pageSize: 5 } })
-    expect(fallback.query).not.toHaveBeenCalled()
-    expect(emitEvent).not.toHaveBeenCalled()
-  })
-
-  test('joins entity index aliases for customFieldSources', async () => {
-    const fakeKnex = createFakeKnex({ baseTable: 'customer_entities', hasIndexAny: true, baseCount: 5, indexCount: 5 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn() }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-
-    await engine.query('customers:customer_entity', {
-      tenantId: 't1',
-      fields: ['id', 'cf:birthday', 'cf:sector'],
-      includeCustomFields: ['birthday', 'sector'],
-      customFieldSources: [
-        {
-          entityId: 'customers:customer_person_profile',
-          table: 'customer_people',
-          alias: 'person_profile',
-          recordIdColumn: 'id',
-          join: { fromField: 'id', toField: 'entity_id' },
-        },
-        {
-          entityId: 'customers:customer_company_profile',
-          table: 'customer_companies',
-          alias: 'company_profile',
-          recordIdColumn: 'id',
-          join: { fromField: 'id', toField: 'entity_id' },
-        },
-      ],
-      page: { page: 1, pageSize: 10 },
-    })
-
-    expect(fallback.query).not.toHaveBeenCalled()
-    const baseCall = fakeKnex._calls.find((call: any) => call._ops.alias === 'b')
-    expect(baseCall).toBeTruthy()
-    const summary = fakeKnex._calls.map((call: any) => ({
-      alias: call._ops.alias,
-      joinAliases: call._ops.joins.map((join: any) => Object.keys(join.aliasObj)[0]),
-    }))
-    expect(summary).toEqual(expect.arrayContaining([
-      expect.objectContaining({
-        alias: 'b',
-        joinAliases: expect.arrayContaining([
-          'ei',
-          'person_profile',
-          'ei_person_profile',
-          'company_profile',
-          'ei_company_profile',
-        ]),
-      }),
-    ]))
-    expect(emitEvent).not.toHaveBeenCalled()
-  })
-
-  test('does not auto reindex when disabled via env', async () => {
-    process.env.QUERY_INDEX_AUTO_REINDEX = 'false'
-    const fakeKnex = createFakeKnex({ baseTable: 'todos', hasIndexAny: true, baseCount: 10, indexCount: 1 })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const fallback = { query: jest.fn().mockResolvedValue({ items: [], page: 1, pageSize: 20, total: 0 }) }
-    const emitEvent = jest.fn().mockResolvedValue(undefined)
-    const engine = new HybridQueryEngine(em, fallback as any, () => ({ emitEvent }))
-    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-
-    await engine.query('example:todo', { fields: ['id', 'cf:priority'], includeCustomFields: true, organizationId: 'org1', tenantId: 't1' })
-    expect(emitEvent).not.toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-})

package/src/modules/query_index/__tests__/indexer.test.ts

@@ -1,175 +0,0 @@
-import { buildIndexDoc, upsertIndexRow, markDeleted } from '../../query_index/lib/indexer'
-import { resolveTenantEncryptionService } from '@open-mercato/shared/lib/encryption/customFieldValues'
-
-jest.mock('@open-mercato/shared/lib/encryption/customFieldValues', () => ({
-  resolveTenantEncryptionService: jest.fn(),
-}))
-
-function createFakeKnex(data: {
-  baseTable: string
-  baseRows: any[]
-  cfValues: any[]
-  indexRows?: any[]
-}) {
-  const calls: any[] = []
-  const inserts: any[] = []
-  const updates: any[] = []
-  const deletes: any[] = []
-  const indexRows = Array.isArray(data.indexRows) ? [...data.indexRows] : []
-
-  function raw(sql: string, params?: any[]) { return { toString: () => sql, sql, params } }
-
-  function builderFor(table: string) {
-    const ops = { table, wheres: [] as any[], selects: [] as any[] }
-    const b: any = {
-      _ops: ops,
-      select: function (...cols: any[]) { ops.selects.push(cols); return this },
-      where: function (...args: any[]) { ops.wheres.push(args[0]); return this },
-      andWhere: function (...args: any[]) { ops.wheres.push(args[0]); return this },
-      andWhereRaw: function (sql: any, params?: any[]) { ops.wheres.push(['andWhereRaw', sql, params]); return this },
-      orWhereNull: function (col: any) { ops.wheres.push(['orWhereNull', col]); return this },
-      modify: function (fn: Function) {
-        const qb: any = {
-          andWhere: (cb: any) => {
-            const inner: any = {
-              where: (obj: any) => ({
-                orWhereNull: (col: any) => { ops.wheres.push(['andWhereFn', obj, ['orWhereNull', col]]); return inner },
-              }),
-            }
-            cb(inner)
-            return qb
-          },
-          whereNull: (col: any) => { ops.wheres.push(['isNull', col]); return qb },
-        }
-        fn(qb)
-        return this
-      },
-      first: async function () {
-        if (table === data.baseTable) return data.baseRows[0]
-        if (table === 'entity_indexes') return indexRows[0]
-        return undefined
-      },
-      then: function (resolve: any) {
-        if (table === 'custom_field_values') return Promise.resolve(resolve(data.cfValues))
-        if (table === data.baseTable) return Promise.resolve(resolve(data.baseRows))
-        return Promise.resolve(resolve([]))
-      },
-      insert: function (payload: any) {
-        inserts.push({ table, payload })
-        return {
-          onConflict: (keys: string[]) => ({
-            merge: (mergePayload: any) => { inserts[inserts.length - 1].conflict = keys; inserts[inserts.length - 1].merge = mergePayload; return Promise.resolve() },
-          }),
-        }
-      },
-      update: function (payload: any) { updates.push({ table, wheres: ops.wheres, payload }); return Promise.resolve(1) },
-      delete: function () { deletes.push({ table, wheres: ops.wheres }); if (table === 'entity_indexes') indexRows.length = 0; return Promise.resolve(1) },
-      del: function () { deletes.push({ table, wheres: ops.wheres }); if (table === 'entity_indexes') indexRows.length = 0; return Promise.resolve(1) },
-      raw,
-    }
-    calls.push(b)
-    return b
-  }
-  const fn: any = (t: any) => builderFor(t)
-  fn._calls = calls
-  fn._inserts = inserts
-  fn._updates = updates
-  fn._deletes = deletes
-  fn.raw = raw
-  fn.fn = { now: () => 'now()' }
-  return fn
-}
-
-const resolveEncryptionMock = resolveTenantEncryptionService as jest.Mock
-
-describe('Indexer', () => {
-  beforeEach(() => {
-    resolveEncryptionMock.mockReset()
-  })
-
-  test('buildIndexDoc composes base row and custom fields (singleton and arrays)', async () => {
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      baseRows: [{ id: '1', title: 'A', organization_id: 'org1', tenant_id: 't1' }],
-      cfValues: [
-        { field_key: 'vip', value_bool: true },
-        { field_key: 'tags', value_text: 'a' },
-        { field_key: 'tags', value_text: 'b' },
-      ],
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const doc = await buildIndexDoc(em, { entityType: 'example:todo', recordId: '1', organizationId: 'org1', tenantId: 't1' })
-    expect(doc).toBeTruthy()
-    expect(doc!.id).toBe('1')
-    expect(doc!['cf:vip']).toBe(true)
-    expect(doc!['cf:tags']).toEqual(['a','b'])
-  })
-
-  test('buildIndexDoc keeps encrypted payload (no decryption on write)', async () => {
-    resolveEncryptionMock.mockReturnValue({
-      isEnabled: () => true,
-      decryptEntityPayload: async (_entityId: string, payload: Record<string, unknown>) => ({
-        ...payload,
-        title: 'Decrypted',
-      }),
-    })
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      baseRows: [{ id: '1', title: 'Encrypted', organization_id: 'org1', tenant_id: 't1' }],
-      cfValues: [{ field_key: 'secret', value_text: 'enc' }],
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    const doc = await buildIndexDoc(em, { entityType: 'example:todo', recordId: '1', organizationId: 'org1', tenantId: 't1' })
-    expect(doc).toBeTruthy()
-    expect(doc!.title).toBe('Encrypted')
-    expect(doc!['cf:secret']).toBe('enc')
-  })
-
-  test('upsertIndexRow inserts or merges index row with built doc', async () => {
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      baseRows: [{ id: '1', title: 'A' }],
-      cfValues: [{ field_key: 'vip', value_bool: false }],
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    await upsertIndexRow(em, { entityType: 'example:todo', recordId: '1', organizationId: 'org1', tenantId: 't1' })
-    const lastInsert = fakeKnex._inserts[fakeKnex._inserts.length - 1]
-    expect(lastInsert.table).toBe('entity_indexes')
-    expect(lastInsert.conflict).toEqual(['entity_type', 'entity_id', 'organization_id_coalesced'])
-    expect(lastInsert.merge.entity_type).toBe('example:todo')
-    expect(lastInsert.merge.entity_id).toBe('1')
-    expect(lastInsert.merge.organization_id).toBe('org1')
-    expect(lastInsert.merge.tenant_id).toBe('t1')
-    expect(lastInsert.merge.doc['cf:vip']).toBe(false)
-  })
-
-  test('upsertIndexRow removes index row when base row missing', async () => {
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      baseRows: [],
-      cfValues: [],
-      indexRows: [{ entity_type: 'example:todo', entity_id: 'x', organization_id: 'org1', deleted_at: null }],
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    await upsertIndexRow(em, { entityType: 'example:todo', recordId: 'x', organizationId: 'org1' })
-    const lastDelete = fakeKnex._deletes[fakeKnex._deletes.length - 1]
-    expect(lastDelete.table).toBe('entity_indexes')
-    // Ensure where contains expected matching keys
-    const whereObj = lastDelete.wheres.find((w: any) => typeof w === 'object')
-    expect(whereObj.entity_type).toBe('example:todo')
-    expect(whereObj.entity_id).toBe('x')
-  })
-
-  test('markDeleted removes index row', async () => {
-    const fakeKnex = createFakeKnex({
-      baseTable: 'todos',
-      baseRows: [],
-      cfValues: [],
-      indexRows: [{ entity_type: 'example:todo', entity_id: '1', organization_id: 'org1', deleted_at: null }],
-    })
-    const em: any = { getConnection: () => ({ getKnex: () => fakeKnex }) }
-    await markDeleted(em, { entityType: 'example:todo', recordId: '1', organizationId: 'org1' })
-    const del = fakeKnex._deletes[fakeKnex._deletes.length - 1]
-    expect(del.table).toBe('entity_indexes')
-  })
-})

package/src/modules/resources/__integration__/TC-INT-007.spec.ts

@@ -1,110 +0,0 @@
-import { expect, test } from "@playwright/test";
-import { login } from "@open-mercato/core/modules/core/__integration__/helpers/auth";
-import { getAuthToken } from "@open-mercato/core/modules/core/__integration__/helpers/api";
-import {
-  createResourceFixture,
-  deleteResourceIfExists,
-} from "./helpers/resourcesFixtures";
-
-export const integrationMeta = {
-  dependsOnModules: ["resources", "audit_logs"],
-};
-
-const versionHistoryTitleRegex = /Version History/i;
-const resourceSubtitleRegex = /Resource profile and activity/i;
-const updateResourceActionRegex =
-  /Update resource|resources\.resources\.update/i;
-
-/**
- * TC-INT-007: Resource Detail Header Pattern
- */
-test.describe("TC-INT-007: Resource Detail Header Pattern", () => {
-  test("should render detail header with title, subtitle and back navigation", async ({
-    page,
-    request,
-  }) => {
-    let token: string | null = null;
-    let resourceId: string | null = null;
-    const stamp = Date.now();
-    const resourceName = `QA TC-INT-007 Resource ${stamp}`;
-
-    try {
-      token = await getAuthToken(request, "admin");
-      resourceId = await createResourceFixture(request, token, resourceName);
-
-      await login(page, "admin");
-      await page.goto(
-        `/backend/resources/resources/${encodeURIComponent(resourceId)}`,
-      );
-
-      await expect(
-        page.getByRole("heading", { name: resourceName }),
-      ).toBeVisible();
-      await expect(page.getByText(resourceSubtitleRegex)).toBeVisible();
-      await expect(
-        page.getByRole("link", { name: /Back to resources/i }),
-      ).toBeVisible();
-      const historyButton = page
-        .getByRole("button", { name: versionHistoryTitleRegex })
-        .first();
-      await expect(historyButton).toBeVisible();
-    } finally {
-      await deleteResourceIfExists(request, token, resourceId);
-    }
-  });
-
-  test("should show resource update in version history after editing details", async ({
-    page,
-    request,
-  }) => {
-    let token: string | null = null;
-    let resourceId: string | null = null;
-    const stamp = Date.now();
-    const resourceName = `QA TC-INT-007 Resource ${stamp}`;
-    const updatedResourceName = `${resourceName} Updated`;
-
-    try {
-      token = await getAuthToken(request, "admin");
-      resourceId = await createResourceFixture(request, token, resourceName);
-
-      await login(page, "admin");
-      await page.goto(
-        `/backend/resources/resources/${encodeURIComponent(resourceId)}`,
-      );
-      await expect(
-        page.getByRole("heading", { name: resourceName }),
-      ).toBeVisible();
-
-      const nameInput = page
-        .getByRole("textbox", { name: /Name|Nazwa|Nombre/i })
-        .first();
-      await expect(nameInput).toBeVisible();
-      await nameInput.fill(updatedResourceName);
-      await page
-        .getByRole("button", { name: /^Save$/i })
-        .first()
-        .click();
-
-      await expect(page).toHaveURL(/\/backend\/resources\/resources$/i);
-      await page.goto(
-        `/backend/resources/resources/${encodeURIComponent(resourceId)}`,
-      );
-
-      const historyButton = page
-        .getByRole("button", { name: versionHistoryTitleRegex })
-        .first();
-      await expect(historyButton).toBeVisible();
-      await historyButton.click();
-
-      const historyDialog = page.getByRole("dialog", {
-        name: versionHistoryTitleRegex,
-      });
-      await expect(historyDialog).toBeVisible();
-      await expect(
-        historyDialog.getByText(updateResourceActionRegex).first(),
-      ).toBeVisible();
-    } finally {
-      await deleteResourceIfExists(request, token, resourceId);
-    }
-  });
-});