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

package/src/modules/entities/__tests__/cli-rotate-encryption.test.ts

@@ -1,123 +0,0 @@
-/** @jest-environment node */
-import { EncryptionMap } from '@open-mercato/core/modules/entities/data/entities'
-import { Organization } from '@open-mercato/core/modules/directory/data/entities'
-import { decryptWithAesGcm } from '@open-mercato/shared/lib/encryption/aes'
-import { registerEntityIds } from '@open-mercato/shared/lib/encryption/entityIds'
-
-// Register mock entity IDs for the test
-registerEntityIds({
-  audit_logs: {
-    access_log: 'audit_logs:access_log',
-  },
-} as any)
-
-const execute = jest.fn()
-const find = jest.fn()
-
-jest.mock('@open-mercato/core/modules/entities/lib/install-from-ce', () => ({
-  installCustomEntitiesFromModules: jest.fn(async () => ({ processed: 0, synchronized: 0, fieldChanges: 0, skipped: 0 })),
-  getAggregatedCustomEntityConfigs: jest.fn(() => []),
-}))
-
-jest.mock('@open-mercato/shared/lib/encryption/aes', () => ({
-  decryptWithAesGcm: jest.fn(),
-}))
-
-jest.mock('@open-mercato/shared/lib/encryption/tenantDataEncryptionService', () => ({
-  TenantDataEncryptionService: jest.fn().mockImplementation(() => ({
-    isEnabled: () => true,
-    getDek: jest.fn(async (tenantId: string) => ({ tenantId, key: 'new-key', fetchedAt: 0 })),
-    encryptEntityPayload: jest.fn(async (_entityId: string, payload: Record<string, unknown>) => {
-      const next: Record<string, unknown> = { ...payload }
-      Object.entries(payload).forEach(([key, value]) => {
-        if (typeof value === 'string') {
-          next[key] = `enc:${value}`
-        } else {
-          next[key] = `enc:${JSON.stringify(value)}`
-        }
-      })
-      return next
-    }),
-  })),
-}))
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({
-    resolve: () => ({
-      getConnection: () => ({ execute }),
-      getMetadata: () => ({
-        getAll: () => ([{
-          className: 'AccessLog',
-          name: 'AccessLog',
-          tableName: 'access_logs',
-          primaryKeys: ['id'],
-          properties: {
-            resourceId: {
-              name: 'resourceId',
-              fieldNames: ['resource_id'],
-              columnTypes: ['text'],
-              type: 'text',
-            },
-            contextJson: {
-              name: 'contextJson',
-              fieldNames: ['context_json'],
-              columnTypes: ['jsonb'],
-              type: 'jsonb',
-            },
-          },
-        }]),
-      }),
-      find: (...args: any[]) => find(...args),
-    }),
-  }),
-}))
-
-describe('entities rotate-encryption-key CLI', () => {
-  let cli: Array<{ command: string; run: (args: string[]) => Promise<void> }>
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    process.env.TENANT_DATA_ENCRYPTION = 'yes'
-    cli = require('@open-mercato/core/modules/entities/cli').default
-  })
-
-  it('rotates mapped fields with old key and updates rows', async () => {
-    const rotate = cli.find((c: any) => c.command === 'rotate-encryption-key')!
-    const encryptedValue = 'iv:cipher:tag:v1'
-
-    find.mockImplementation(async (entity: any) => {
-      if (entity === EncryptionMap) {
-        return [{
-          entityId: 'audit_logs:access_log',
-          tenantId: 'tenant-1',
-          organizationId: 'org-1',
-          fieldsJson: [{ field: 'resource_id' }, { field: 'context_json' }],
-          deletedAt: null,
-        }]
-      }
-      if (entity === Organization) {
-        return [{ id: 'org-1', tenantId: 'tenant-1' }]
-      }
-      return []
-    })
-
-    execute.mockResolvedValueOnce([
-      { id: 'row-1', resource_id: encryptedValue, context_json: encryptedValue },
-    ])
-    ;(decryptWithAesGcm as jest.Mock)
-      .mockReturnValueOnce('resource-value')
-      .mockReturnValueOnce('{"note":"hello"}')
-
-    await rotate.run(['--old-key', 'old-secret', '--tenant', 'tenant-1', '--org', 'org-1'])
-
-    expect(decryptWithAesGcm).toHaveBeenCalledTimes(2)
-    expect(execute).toHaveBeenCalledTimes(2)
-    const updateCall = execute.mock.calls[1]
-    expect(updateCall[0]).toMatch(/update\s+"access_logs"/)
-    expect(updateCall[1]).toEqual(expect.arrayContaining([
-      'enc:resource-value',
-      '"enc:{\\"note\\":\\"hello\\"}"',
-      'row-1',
-    ]))
-  })
-})

package/src/modules/entities/api/__tests__/encryption.api.test.ts

@@ -1,57 +0,0 @@
-/** @jest-environment node */
-import { GET, POST } from '@open-mercato/core/modules/entities/api/encryption'
-
-const mockMapRepo = {
-  findOne: jest.fn(),
-  create: jest.fn((data) => data),
-}
-const mockEm = {
-  getRepository: () => mockMapRepo,
-  persistAndFlush: jest.fn(),
-}
-
-const mockEncSvc = {
-  invalidateMap: jest.fn(async () => {}),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({
-    resolve: (k: string) => {
-      if (k === 'em') return mockEm
-      if (k === 'tenantEncryptionService') return mockEncSvc
-      return null
-    },
-  }),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromRequest: () => ({ tenantId: 't-1', orgId: 'o-1', roles: ['admin'] }),
-}))
-
-describe('entities/encryption API', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('returns empty map when none exists', async () => {
-    mockMapRepo.findOne.mockResolvedValueOnce(null).mockResolvedValueOnce(null).mockResolvedValueOnce(null)
-    const res = await GET(new Request('http://x/api/entities/encryption?entityId=auth:user'))
-    expect(res.status).toBe(200)
-    const json = await res.json()
-    expect(json).toMatchObject({ entityId: 'auth:user', fields: [] })
-  })
-
-  it('creates map on POST and invalidates cache', async () => {
-    mockMapRepo.findOne.mockResolvedValue(null)
-    const payload = { entityId: 'auth:user', fields: [{ field: 'email', hashField: 'email_hash' }] }
-    const res = await POST(new Request('http://x/api/entities/encryption', {
-      method: 'POST',
-      body: JSON.stringify(payload),
-      headers: { 'content-type': 'application/json' },
-    }))
-    expect(res.status).toBe(200)
-    expect(mockMapRepo.create).toHaveBeenCalled()
-    expect(mockEm.persistAndFlush).toHaveBeenCalled()
-    expect(mockEncSvc.invalidateMap).toHaveBeenCalledWith('auth:user', 't-1', 'o-1')
-  })
-})

package/src/modules/entities/api/__tests__/records.get.custom-entity.test.ts

@@ -1,43 +0,0 @@
-/** @jest-environment node */
-import { GET } from '@open-mercato/core/modules/entities/api/records'
-
-const mockQE = {
-  query: jest.fn(async (_entityId: string, _options: { filters?: Record<string, unknown> }) => ({
-    items: [
-      { id: 'rec-1', cf_date: '1', cf_how_long: 2, created_at: '2024-10-03T00:00:00Z' },
-    ],
-    total: 1,
-    page: 1,
-    pageSize: 50,
-  })),
-}
-
-const mockEm = {
-  findOne: jest.fn(async () => ({ id: 'ce-1', entityId: 'example:custom' })),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({ resolve: (k: string) => (k === 'queryEngine' ? mockQE : mockEm) }),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({ getAuthFromRequest: () => ({ orgId: 'org', tenantId: 't1', roles: ['admin'] }) }))
-
-describe('GET /api/entities/records for custom entities', () => {
-  beforeEach(() => { jest.clearAllMocks() })
-
-  it('returns items with bare keys (no cf_ prefix) and passes bare-key filters to QE', async () => {
-    const url = 'http://x/api/entities/records?entityId=example:custom&page=1&pageSize=50&sortField=id&sortDir=asc&date=1&how_long=2'
-    const req = new Request(url)
-    const res = await GET(req)
-    expect(res.status).toBe(200)
-    const json = await res.json()
-    expect(Array.isArray(json.items)).toBe(true)
-    expect(json.items[0]).toMatchObject({ id: 'rec-1', date: true, how_long: 2 })
-
-    // QE called with filters containing bare keys when custom entity
-    expect(mockQE.query).toHaveBeenCalled()
-    const firstCall = mockQE.query.mock.calls[0] as [string, { filters?: Record<string, unknown> }]
-    const [, opts] = firstCall
-    expect(opts?.filters).toMatchObject({ date: true, how_long: '2' })
-  })
-})

package/src/modules/entities/api/__tests__/records.validation.test.ts

@@ -1,53 +0,0 @@
-/** @jest-environment node */
-import { POST, PUT } from '@open-mercato/core/modules/entities/api/records'
-
-const mockEm = {
-  find: jest.fn(async () => [] as Array<Record<string, unknown>>),
-  findOne: jest.fn(async () => null),
-}
-
-const mockDataEngine = {
-  createCustomEntityRecord: jest.fn(async () => ({ id: 'rec-1' })),
-  updateCustomEntityRecord: jest.fn(async () => undefined),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({ resolve: (k: string) => (k === 'em' ? mockEm : mockDataEngine) }),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({ getAuthFromRequest: () => ({ orgId: 'org', tenantId: 't1', roles: ['admin'] }) }))
-
-describe('Records API validation (custom fields)', () => {
-  beforeEach(() => { jest.clearAllMocks() })
-
-  it('POST rejects invalid custom fields with 400 and fields map', async () => {
-    // Emulate definition with required + integer
-    mockEm.find.mockResolvedValueOnce([
-      { key: 'priority', kind: 'integer', configJson: { validation: [ { rule: 'required', message: 'priority required' }, { rule: 'integer', message: 'priority int' } ] }, organizationId: 'org', tenantId: 't1' }
-    ])
-    const req = new Request('http://x/api/entities/records', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ entityId: 'example:todo', values: { cf_priority: '' } }),
-    })
-    const res = await POST(req)
-    expect(res.status).toBe(400)
-    const json = await res.json()
-    expect(json?.error).toBe('Validation failed')
-    expect(json?.fields?.cf_priority).toBe('priority required')
-  })
-
-  it('PUT accepts valid input', async () => {
-    mockEm.find.mockResolvedValueOnce([
-      { key: 'priority', kind: 'integer', configJson: { validation: [ { rule: 'integer', message: 'priority int' } ] }, organizationId: null, tenantId: null }
-    ])
-    const req = new Request('http://x/api/entities/records', {
-      method: 'PUT',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ entityId: 'example:todo', recordId: '123e4567-e89b-12d3-a456-426614174000', values: { cf_priority: 3 } }),
-    })
-    const res = await PUT(req)
-    expect(res.status).toBe(200)
-    expect(mockDataEngine.updateCustomEntityRecord).toHaveBeenCalled()
-  })
-})

package/src/modules/entities/backend/entities/user/__tests__/create-entity-submit.test.ts

@@ -1,47 +0,0 @@
-jest.mock('@open-mercato/ui/backend/CrudForm', () => ({
-  CrudForm: () => null,
-}))
-
-import { submitCreateEntity } from '../create/page'
-
-describe('submitCreateEntity', () => {
-  it('throws a CrudFormError when entity id is missing', async () => {
-    const error = await submitCreateEntity({ values: { entityId: '   ' }, fetchEntities: async () => [] }).catch(
-      (err) => err as Error,
-    )
-    expect(error).toBeInstanceOf(Error)
-    expect(error).toMatchObject({
-      message: 'Entity ID is required',
-      fieldErrors: { entityId: 'Entity ID is required' },
-    })
-  })
-
-  it('throws a CrudFormError when entity id already exists', async () => {
-    const error = await submitCreateEntity({
-      values: { entityId: 'custom:example' },
-      fetchEntities: async () => [{ entityId: 'custom:example', source: 'custom' }],
-    }).catch((err) => err as Error)
-
-    expect(error).toBeInstanceOf(Error)
-    expect(error).toMatchObject({
-      message: 'Entity ID already exists',
-      fieldErrors: { entityId: 'Entity ID already exists' },
-    })
-  })
-
-  it('invokes createEntity with normalized payload and returns entity id', async () => {
-    const createEntity = jest.fn(async () => {})
-    const entityId = await submitCreateEntity({
-      values: { entityId: 'custom:example', defaultEditor: '', description: 'Test' },
-      fetchEntities: async () => [],
-      createEntity,
-    })
-    expect(entityId).toBe('custom:example')
-    expect(createEntity).toHaveBeenCalledWith({
-      entityId: 'custom:example',
-      defaultEditor: undefined,
-      description: 'Test',
-      labelField: 'name',
-    })
-  })
-})

package/src/modules/entities/backend/entities/user/__tests__/records-submit.test.ts

@@ -1,104 +0,0 @@
-jest.mock('@open-mercato/ui/backend/CrudForm', () => ({
-  CrudForm: () => null,
-}))
-
-import { submitCustomEntityRecord } from '../[entityId]/records/create/page'
-import { submitCustomEntityRecordUpdate } from '../[entityId]/records/[recordId]/page'
-
-describe('submitCustomEntityRecord', () => {
-  it('throws a CrudFormError when entity id is missing', async () => {
-    const error = await submitCustomEntityRecord({
-      entityId: '',
-      values: {},
-      createRecord: async () => {},
-  }).catch((err) => err as Error)
-  expect(error).toBeInstanceOf(Error)
-  expect(error).toMatchObject({
-    message: 'Entity identifier is required',
-    fieldErrors: { entityId: 'Entity identifier is required' },
-  })
-})
-
-  it('calls provided createRecord implementation with normalized payload', async () => {
-    const createRecord = jest.fn(async () => {})
-    await submitCustomEntityRecord({
-      entityId: 'example:custom',
-      values: { foo: 'bar' },
-      createRecord,
-    })
-    expect(createRecord).toHaveBeenCalledWith({
-      entityId: 'example:custom',
-      values: { foo: 'bar' },
-    })
-  })
-
-  it('rethrows errors from createRecord', async () => {
-    const error = new Error('boom')
-    const createRecord = jest.fn(async () => {
-      throw error
-    })
-    await expect(
-      submitCustomEntityRecord({
-        entityId: 'example:custom',
-        values: {},
-        createRecord,
-      }),
-    ).rejects.toBe(error)
-  })
-})
-
-describe('submitCustomEntityRecordUpdate', () => {
-  it('throws a CrudFormError when entity or record id is missing', async () => {
-    const entityError = await submitCustomEntityRecordUpdate({
-      entityId: '',
-      recordId: '1',
-      values: {},
-      updateRecord: async () => {},
-    }).catch((err) => err as Error)
-    expect(entityError).toMatchObject({
-      message: 'Entity identifier is required',
-      fieldErrors: { entityId: 'Entity identifier is required' },
-    })
-
-    const recordError = await submitCustomEntityRecordUpdate({
-      entityId: 'example:custom',
-      recordId: '',
-      values: {},
-      updateRecord: async () => {},
-    }).catch((err) => err as Error)
-    expect(recordError).toMatchObject({
-      message: 'Record identifier is required',
-      fieldErrors: { recordId: 'Record identifier is required' },
-    })
-  })
-
-  it('calls provided updateRecord implementation with normalized payload', async () => {
-    const updateRecord = jest.fn(async () => {})
-    await submitCustomEntityRecordUpdate({
-      entityId: 'example:custom',
-      recordId: '123',
-      values: { foo: 'bar' },
-      updateRecord,
-    })
-    expect(updateRecord).toHaveBeenCalledWith({
-      entityId: 'example:custom',
-      recordId: '123',
-      values: { foo: 'bar' },
-    })
-  })
-
-  it('rethrows errors from updateRecord', async () => {
-    const error = new Error('boom')
-    const updateRecord = jest.fn(async () => {
-      throw error
-    })
-    await expect(
-      submitCustomEntityRecordUpdate({
-        entityId: 'example:custom',
-        recordId: '1',
-        values: {},
-        updateRecord,
-      }),
-    ).rejects.toBe(error)
-  })
-})