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

package/src/modules/feature_toggles/lib/__tests__/feature-flag-check.test.ts

@@ -1,365 +0,0 @@
-import { FeatureTogglesService } from '../feature-flag-check';
-import { FeatureToggle, FeatureToggleOverride } from '../../data/entities';
-import { CacheService } from '@open-mercato/cache';
-import { EntityManager } from '@mikro-orm/core';
-
-jest.mock('@open-mercato/cache');
-jest.mock('../../data/entities');
-
-describe('FeatureTogglesService', () => {
-    let service: FeatureTogglesService;
-    let mockCache: jest.Mocked<CacheService>;
-    let mockEm: jest.Mocked<EntityManager>;
-
-    const mockIdentifier = 'test-feature';
-    const mockTenantId = 'tenant-123';
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            delete: jest.fn(),
-            deleteByTags: jest.fn(),
-        } as unknown as jest.Mocked<CacheService>;
-
-        mockEm = {
-            findOne: jest.fn(),
-        } as unknown as jest.Mocked<EntityManager>;
-
-        service = new FeatureTogglesService(mockCache, mockEm);
-    });
-
-    describe('getBoolConfig (via isFeatureEnabled logic)', () => {
-        it('should return cached value if present', async () => {
-            const cachedValue = {
-                valueType: 'boolean',
-                value: true,
-                source: 'default',
-                toggleId: 'toggle-1',
-                identifier: mockIdentifier,
-                tenantId: mockTenantId,
-            };
-            mockCache.get.mockResolvedValue(cachedValue);
-
-            const result = await service.getBoolConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(true);
-            }
-            expect(mockCache.get).toHaveBeenCalledTimes(1);
-            expect(mockEm.findOne).not.toHaveBeenCalled();
-        });
-
-        it('should throw when checking toggle fails (DB Error)', async () => {
-            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
-
-            mockCache.get.mockResolvedValue(null);
-            mockEm.findOne.mockRejectedValue(new Error('DB Error'));
-
-            await expect(service.getBoolConfig(mockIdentifier, mockTenantId)).rejects.toThrow('DB Error');
-
-            warnSpy.mockRestore();
-        });
-
-        it('should return missing default when toggle not found', async () => {
-            mockCache.get.mockResolvedValue(null);
-            mockEm.findOne.mockResolvedValue(null);
-
-            const result = await service.getBoolConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe('MISSING_TOGGLE');
-            }
-        });
-
-        it('should return default state if no override exists', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-1',
-                identifier: mockIdentifier,
-                defaultState: true,
-
-                type: 'boolean',
-                defaultValue: true
-            };
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getBoolConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(true);
-                expect(result.resolution.source).toBe('default');
-            }
-            expect(mockCache.set).toHaveBeenCalled();
-        });
-
-        it('should return override state if override exists', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-1',
-                identifier: mockIdentifier,
-                defaultState: true,
-                type: 'boolean'
-            };
-            const mockOverride = {
-                value: false,
-                source: 'override'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(mockOverride as any);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getBoolConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(false);
-                expect(result.resolution.source).toBe('override');
-            }
-            expect(mockCache.set).toHaveBeenCalled();
-        });
-
-        it('should throw error when checking override fails', async () => {
-
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-1',
-                identifier: mockIdentifier,
-                defaultState: false,
-
-                type: 'boolean'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.reject(new Error('DB Error'));
-                return Promise.resolve(null);
-            });
-
-            await expect(service.getBoolConfig(mockIdentifier, mockTenantId)).rejects.toThrow('DB Error');
-        });
-
-        it('should return INVALID_VALUE error if value is not boolean', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-invalid-val',
-                identifier: mockIdentifier,
-                defaultValue: "not-a-bool", // Invalid value for boolean type
-                type: 'boolean'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            // Suppress console.error for this test
-            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-            const result = await service.getBoolConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe('INVALID_VALUE');
-                expect(result.error.expectedType).toBe('boolean');
-            }
-
-            errorSpy.mockRestore();
-        });
-    });
-
-    describe('getStringConfig', () => {
-        it('should return string value', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-str',
-                identifier: mockIdentifier,
-                defaultValue: "default string",
-                type: 'string'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getStringConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe("default string");
-                expect(result.resolution.valueType).toBe('string');
-            }
-        });
-
-        it('should return type mismatch error if toggle is boolean', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-bool',
-                identifier: mockIdentifier,
-                defaultState: true,
-                type: 'boolean'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            // Suppress console.error for this test
-            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-            const result = await service.getStringConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe('TYPE_MISMATCH');
-                expect(result.error.expectedType).toBe('string');
-                expect(result.error.actualType).toBe('boolean');
-            }
-
-            errorSpy.mockRestore();
-        });
-    });
-
-    describe('getNumberConfig', () => {
-        it('should return number value', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-num',
-                identifier: mockIdentifier,
-                defaultValue: 42,
-                type: 'number'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getNumberConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(42);
-                expect(result.resolution.valueType).toBe('number');
-            }
-        });
-
-        it('should return type mismatch error if toggle is string', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const mockToggle = {
-                id: 'toggle-str',
-                identifier: mockIdentifier,
-                defaultValue: "not a number",
-                type: 'string'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            // Suppress console.error for this test
-            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-            const result = await service.getNumberConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe('TYPE_MISMATCH');
-                expect(result.error.expectedType).toBe('number');
-                expect(result.error.actualType).toBe('string');
-            }
-
-            errorSpy.mockRestore();
-        });
-    });
-
-    describe('getJsonConfig', () => {
-        it('should return json value', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const defaultJson = { foo: "bar" };
-
-            const mockToggle = {
-                id: 'toggle-json',
-                identifier: mockIdentifier,
-                defaultValue: defaultJson,
-                type: 'json'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(null);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getJsonConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toEqual(defaultJson);
-                expect(result.resolution.valueType).toBe('json');
-            }
-        });
-
-        it('should successfully retrieve JSON override', async () => {
-            mockCache.get.mockResolvedValue(null);
-
-            const defaultJson = { foo: "default" };
-            const overrideJson = { foo: "override" };
-
-            const mockToggle = {
-                id: 'toggle-json',
-                identifier: mockIdentifier,
-                defaultValue: defaultJson,
-                type: 'json'
-            };
-
-            const mockOverride = {
-                value: overrideJson,
-                source: 'override'
-            };
-
-            mockEm.findOne.mockImplementation((entity) => {
-                if (entity === FeatureToggle) return Promise.resolve(mockToggle as any);
-                if (entity === FeatureToggleOverride) return Promise.resolve(mockOverride as any);
-                return Promise.resolve(null);
-            });
-
-            const result = await service.getJsonConfig(mockIdentifier, mockTenantId);
-
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toEqual(overrideJson);
-                expect(result.resolution.source).toBe('override');
-            }
-        });
-    });
-});

package/src/modules/feature_toggles/lib/__tests__/queries.test.ts

@@ -1,130 +0,0 @@
-import { EntityManager } from '@mikro-orm/postgresql'
-import { getOverrides } from '../../lib/queries'
-import { GetOverridesQuery } from '../../data/validators'
-import { FeatureToggle, FeatureToggleOverride } from '../../data/entities'
-import { Tenant } from '@open-mercato/core/modules/directory/data/entities'
-
-describe('getOverrides', () => {
-    let em: EntityManager
-
-    const mockTenant1 = { id: 'tenant-1', name: 'Tenant 1' } as Tenant
-
-    const mockToggle1 = {
-        id: 'toggle-1',
-        identifier: 'toggle.one',
-        name: 'Toggle One',
-        category: 'cat1',
-        defaultValue: false,
-        type: 'boolean',
-        failMode: 'fail_closed',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    } as unknown as FeatureToggle
-
-    const mockToggle2 = {
-        id: 'toggle-2',
-        identifier: 'toggle.two',
-        name: 'Toggle Two',
-        category: 'cat2',
-        defaultValue: false,
-        type: 'boolean',
-        failMode: 'fail_closed',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    } as unknown as FeatureToggle
-
-    const mockOverride1 = {
-        id: 'override-1',
-        toggle: { id: 'toggle-1' },
-        tenantId: 'tenant-1',
-        value: undefined,
-    } as unknown as FeatureToggleOverride
-
-    beforeEach(() => {
-        em = {
-            find: jest.fn(),
-        } as unknown as EntityManager
-    })
-
-    it('should return combined toggles and overrides with inheritance', async () => {
-        (em.find as jest.Mock).mockResolvedValueOnce([mockToggle1, mockToggle2]);
-        (em.find as jest.Mock).mockResolvedValueOnce([mockOverride1]);
-
-        const result = await getOverrides(em, mockTenant1, { page: 1, pageSize: 25 })
-
-        expect(result.items).toHaveLength(2)
-
-        const item1 = result.items.find((i) => i.toggleId === 'toggle-1')
-        expect(item1).toMatchObject({
-            toggleId: 'toggle-1',
-            tenantId: 'tenant-1',
-        })
-
-        const item2 = result.items.find((i) => i.toggleId === 'toggle-2')
-        expect(item2).toMatchObject({
-            toggleId: 'toggle-2',
-            tenantId: 'tenant-1',
-        })
-
-        expect(result.total).toBe(2)
-    })
-
-    it('should apply filters to global toggles query', async () => {
-        (em.find as jest.Mock).mockResolvedValueOnce([]);
-        (em.find as jest.Mock).mockResolvedValueOnce([]);
-
-        const query: GetOverridesQuery = {
-            category: 'cat1',
-            name: 'One',
-            page: 1,
-            pageSize: 25,
-        }
-
-        await getOverrides(em, mockTenant1, query)
-
-        const findCalls = (em.find as jest.Mock).mock.calls
-        const toggleFilter = findCalls[0][1] as any[]
-
-        expect(toggleFilter).toHaveLength(2)
-        expect(toggleFilter).toContainEqual({ category: { $ilike: '%cat1%' } })
-        expect(toggleFilter).toContainEqual({ name: { $ilike: '%One%' } })
-    })
-
-    it('should paginate results', async () => {
-        const manyToggles = Array.from({ length: 30 }).map((_, i) => ({
-            id: `t-${i}`,
-            identifier: `t.${i}`,
-            defaultValue: false,
-            type: 'boolean',
-            failMode: 'fail_closed',
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        } as unknown as FeatureToggle));
-
-        (em.find as jest.Mock).mockResolvedValueOnce(manyToggles);
-        (em.find as jest.Mock).mockResolvedValueOnce([]);
-
-        const result = await getOverrides(em, mockTenant1, { page: 2, pageSize: 10 })
-
-        expect(result.total).toBe(30)
-        expect(result.items).toHaveLength(10)
-        expect(result.page).toBe(2)
-        expect(result.items[0].toggleId).toBe('t-10')
-    })
-
-
-    it('should sort results locally', async () => {
-        (em.find as jest.Mock).mockResolvedValueOnce([mockToggle1, mockToggle2]);
-        (em.find as jest.Mock).mockResolvedValueOnce([]);
-        (em.find as jest.Mock).mockResolvedValueOnce([mockToggle1, mockToggle2]);
-        (em.find as jest.Mock).mockResolvedValueOnce([]);
-
-        const resultAsc = await getOverrides(em, mockTenant1, { sortField: 'name', sortDir: 'asc', page: 1, pageSize: 25 })
-        expect(resultAsc.items[0].name).toBe('Toggle One')
-        expect(resultAsc.items[1].name).toBe('Toggle Two')
-
-        const resultDesc = await getOverrides(em, mockTenant1, { sortField: 'name', sortDir: 'desc', page: 1, pageSize: 25 })
-        expect(resultDesc.items[0].name).toBe('Toggle Two')
-        expect(resultDesc.items[1].name).toBe('Toggle One')
-    })
-})

package/src/modules/inbox_ops/api/emails/[id]/reprocess/__tests__/route.test.ts

@@ -1,194 +0,0 @@
-/** @jest-environment node */
-
-import { POST } from '@open-mercato/core/modules/inbox_ops/api/emails/[id]/reprocess/route'
-import { InboxDiscrepancy, InboxEmail, InboxProposal, InboxProposalAction } from '@open-mercato/core/modules/inbox_ops/data/entities'
-
-const mockFindOneWithDecryption = jest.fn()
-const mockFindWithDecryption = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
-  findOneWithDecryption: (...args: unknown[]) => mockFindOneWithDecryption(...args),
-  findWithDecryption: (...args: unknown[]) => mockFindWithDecryption(...args),
-}))
-
-const mockGetAuth = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromRequest: (...args: unknown[]) => mockGetAuth(...args),
-}))
-
-const mockEm = {
-  fork: jest.fn(),
-  flush: jest.fn(),
-}
-
-const mockContainer = {
-  resolve: jest.fn((token: string) => {
-    if (token === 'em') return mockEm
-    return null
-  }),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: jest.fn(async () => mockContainer),
-}))
-
-jest.mock('@open-mercato/core/modules/inbox_ops/lib/eventBus', () => ({
-  resolveOptionalEventBus: jest.fn(() => null),
-}))
-
-const mockEmitInboxOpsEvent = jest.fn()
-jest.mock('@open-mercato/core/modules/inbox_ops/events', () => ({
-  emitInboxOpsEvent: (...args: unknown[]) => mockEmitInboxOpsEvent(...args),
-}))
-
-function makeRequest() {
-  return new Request('http://localhost/api/inbox_ops/emails/email-1/reprocess', {
-    method: 'POST',
-  })
-}
-
-describe('POST /api/inbox_ops/emails/[id]/reprocess', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockEm.fork.mockReturnValue(mockEm)
-    mockEm.flush.mockResolvedValue(undefined)
-    mockEmitInboxOpsEvent.mockResolvedValue(undefined)
-    mockGetAuth.mockResolvedValue({
-      sub: 'user-1',
-      tenantId: 'tenant-1',
-      orgId: 'org-1',
-    })
-    mockContainer.resolve.mockImplementation((token: string) => {
-      if (token === 'em') return mockEm
-      return null
-    })
-  })
-
-  it('returns 409 when an active proposal already has execution started', async () => {
-    const email = {
-      id: 'email-1',
-      status: 'failed',
-      processingError: 'previous error',
-      tenantId: 'tenant-1',
-      organizationId: 'org-1',
-      forwardedByAddress: 'ops@example.com',
-      subject: 'Order request',
-    } as unknown as InboxEmail
-
-    const proposal = {
-      id: 'proposal-1',
-      inboxEmailId: 'email-1',
-      status: 'pending',
-      isActive: true,
-      metadata: null,
-    } as unknown as InboxProposal
-
-    const startedAction = {
-      id: 'action-1',
-      proposalId: 'proposal-1',
-      status: 'executed',
-    } as unknown as InboxProposalAction
-
-    mockFindOneWithDecryption.mockResolvedValueOnce(email)
-    mockFindWithDecryption
-      .mockResolvedValueOnce([proposal])
-      .mockResolvedValueOnce([startedAction])
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(409)
-    expect(payload.error).toContain('Cannot reprocess')
-    expect(email.status).toBe('failed')
-    expect(email.processingError).toBe('previous error')
-    expect(mockEmitInboxOpsEvent).not.toHaveBeenCalled()
-  })
-
-  it('supersedes active proposals and requeues email for processing', async () => {
-    const email = {
-      id: 'email-1',
-      status: 'failed',
-      processingError: 'previous error',
-      tenantId: 'tenant-1',
-      organizationId: 'org-1',
-      forwardedByAddress: 'ops@example.com',
-      subject: 'Order request',
-    } as unknown as InboxEmail
-
-    const proposal = {
-      id: 'proposal-1',
-      inboxEmailId: 'email-1',
-      status: 'pending',
-      isActive: true,
-      metadata: {},
-      reviewedAt: null,
-      reviewedByUserId: null,
-    } as unknown as InboxProposal
-
-    const pendingAction = {
-      id: 'action-1',
-      proposalId: 'proposal-1',
-      status: 'pending',
-      executionError: null,
-      executedAt: null,
-      executedByUserId: null,
-    } as unknown as InboxProposalAction
-
-    const failedAction = {
-      id: 'action-2',
-      proposalId: 'proposal-1',
-      status: 'failed',
-      executionError: 'Failed in previous attempt',
-      executedAt: null,
-      executedByUserId: null,
-    } as unknown as InboxProposalAction
-
-    const discrepancy = {
-      id: 'disc-1',
-      proposalId: 'proposal-1',
-      resolved: false,
-    } as unknown as InboxDiscrepancy
-
-    mockFindOneWithDecryption.mockResolvedValueOnce(email)
-    mockFindWithDecryption
-      .mockResolvedValueOnce([proposal])
-      .mockResolvedValueOnce([pendingAction, failedAction])
-      .mockResolvedValueOnce([discrepancy])
-
-    const response = await POST(makeRequest())
-    const payload = await response.json()
-
-    expect(response.status).toBe(200)
-    expect(payload).toMatchObject({
-      ok: true,
-      retiredProposalCount: 1,
-      retiredActionCount: 2,
-    })
-
-    expect(proposal.isActive).toBe(false)
-    expect(proposal.status).toBe('rejected')
-    expect(proposal.reviewedByUserId).toBe('user-1')
-    expect(proposal.reviewedAt).toBeInstanceOf(Date)
-    expect((proposal.metadata as Record<string, unknown>).supersededReason).toBe('email_reprocessed')
-
-    expect(pendingAction.status).toBe('rejected')
-    expect(failedAction.status).toBe('rejected')
-    expect(failedAction.executionError).toBe('Failed in previous attempt')
-    expect(discrepancy.resolved).toBe(true)
-
-    expect(email.status).toBe('received')
-    expect(email.processingError).toBeNull()
-
-    expect(mockEmitInboxOpsEvent).toHaveBeenNthCalledWith(
-      1,
-      'inbox_ops.email.reprocessed',
-      expect.objectContaining({ emailId: 'email-1' }),
-    )
-    expect(mockEmitInboxOpsEvent).toHaveBeenNthCalledWith(
-      2,
-      'inbox_ops.email.received',
-      expect.objectContaining({ emailId: 'email-1' }),
-    )
-  })
-})