@friggframework/core 2.0.0--canary.549.a579cca.0 → 2.0.0--canary.549.70ef06a.0

package/src/application/commands/integration-commands.test.ts

@@ -0,0 +1,158 @@
+jest.mock('../../database/config', () => {
+    const mockConfig = {
+        DB_TYPE: 'mongodb',
+        getDatabaseType: jest.fn(() => 'mongodb'),
+        PRISMA_LOG_LEVEL: 'error,warn',
+        PRISMA_QUERY_LOGGING: false,
+    };
+    return { __esModule: true, default: mockConfig, ...mockConfig };
+});
+
+jest.mock('../../integrations/repositories/integration-repository-factory', () => ({
+    createIntegrationRepository: jest.fn(() => ({
+        findIntegrationById: jest.fn(),
+        findIntegrationByUserId: jest.fn(),
+        findIntegrationsByUserId: jest.fn(),
+        createIntegration: jest.fn(),
+        updateIntegrationById: jest.fn(),
+        deleteIntegrationById: jest.fn(),
+    })),
+}));
+
+jest.mock('../../modules/repositories/module-repository-factory', () => ({
+    createModuleRepository: jest.fn(() => ({})),
+}));
+
+const mockFindExecute: any = jest.fn();
+
+jest.mock('../../integrations/use-cases/find-integration-context-by-external-entity-id', () => {
+    return {
+        FindIntegrationContextByExternalEntityIdUseCase: jest
+            .fn()
+            .mockImplementation(() => ({
+                execute: mockFindExecute,
+            })),
+    };
+});
+
+import {
+    createIntegrationCommands,
+    findIntegrationContextByExternalEntityId,
+} from './integration-commands';
+import {
+    FindIntegrationContextByExternalEntityIdUseCase,
+} from '../../integrations/use-cases/find-integration-context-by-external-entity-id';
+import { DummyIntegration } from '../../integrations/tests/doubles/dummy-integration-class';
+
+describe('integration commands', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFindExecute.mockReset();
+    });
+
+    it('requires an integrationClass when creating commands', () => {
+        expect(() => createIntegrationCommands({} as any)).toThrow(
+            'integrationClass is required',
+        );
+    });
+
+    it('creates use cases with default repositories', () => {
+        createIntegrationCommands({
+            integrationClass: DummyIntegration,
+        });
+
+        // Verify that the use case is created with default repositories instantiated internally
+        expect(
+            FindIntegrationContextByExternalEntityIdUseCase,
+        ).toHaveBeenCalledWith({
+            integrationRepository: expect.any(Object),
+            moduleRepository: expect.any(Object),
+            loadIntegrationContextUseCase: expect.any(Object),
+        });
+    });
+
+    it('returns context when findIntegrationContextByExternalEntityId succeeds', async () => {
+        const expectedContext = { record: { id: 'integration-1' } };
+        mockFindExecute.mockResolvedValue({ context: expectedContext });
+        const commands = createIntegrationCommands({
+            integrationClass: DummyIntegration,
+        });
+
+        const result = await commands.findIntegrationContextByExternalEntityId(
+            'ext-1',
+        );
+
+        expect(mockFindExecute).toHaveBeenCalledWith({
+            externalEntityId: 'ext-1',
+        });
+        expect(result).toEqual({ context: expectedContext });
+    });
+
+    it('maps known errors to status codes', async () => {
+        const error = Object.assign(new Error('Entity missing'), {
+            code: 'ENTITY_NOT_FOUND',
+        });
+        mockFindExecute.mockRejectedValue(error);
+        const commands = createIntegrationCommands({
+            integrationClass: DummyIntegration,
+        });
+
+        const result = await commands.findIntegrationContextByExternalEntityId(
+            'ext-1',
+        );
+
+        expect(result).toEqual({
+            error: 401,
+            reason: 'Entity missing',
+            code: 'ENTITY_NOT_FOUND',
+        });
+    });
+
+    it('delegates loadIntegrationContextById to the loader use case', async () => {
+        const commands = createIntegrationCommands({
+            integrationClass: DummyIntegration,
+        });
+
+        const result = await commands.loadIntegrationContextById('integration-1');
+
+        expect(result).toHaveProperty('error');
+    });
+
+    it('exposes a one-off helper for finding integration context by external entity id', async () => {
+        const expectedContext = { record: { id: 'integration-1' } };
+        mockFindExecute.mockResolvedValue({ context: expectedContext });
+
+        const result = await findIntegrationContextByExternalEntityId({
+            integrationClass: DummyIntegration,
+            externalEntityId: 'ext-2',
+        });
+
+        expect(mockFindExecute).toHaveBeenCalledWith({
+            externalEntityId: 'ext-2',
+        });
+        expect(result).toEqual({ context: expectedContext });
+    });
+
+    describe('deleteIntegrationById', () => {
+        it('returns error if integrationId is missing', async () => {
+            const commands = createIntegrationCommands({
+                integrationClass: DummyIntegration,
+            });
+
+            const result = await commands.deleteIntegrationById(null as any);
+
+            expect(result).toHaveProperty('error');
+            expect(result.reason).toContain('integrationId is required');
+        });
+
+        it('calls repository deleteIntegrationById', async () => {
+            const commands = createIntegrationCommands({
+                integrationClass: DummyIntegration,
+            });
+
+            const result = await commands.deleteIntegrationById('integration-123');
+
+            expect(result).toHaveProperty('error');
+        });
+    });
+});

package/src/application/commands/integration-commands.ts

@@ -1,26 +1,11 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
-const {
-    createIntegrationRepository,
-} = require('../../../integrations/repositories/integration-repository-factory');
-const {
-    createModuleRepository,
-} = require('../../../modules/repositories/module-repository-factory');
-const { ModuleFactory } = require('../../../modules/module-factory');
-const {
-    LoadIntegrationContextUseCase,
-} = require('../../../integrations/use-cases/load-integration-context');
-const {
-    FindIntegrationContextByExternalEntityIdUseCase,
-} = require('../../../integrations/use-cases/find-integration-context-by-external-entity-id');
-const {
-    GetIntegrationsForUser,
-} = require('../../../integrations/use-cases/get-integrations-for-user');
-const {
-    CreateIntegration,
-} = require('../../../integrations/use-cases/create-integration');
-const {
-    getModulesDefinitionFromIntegrationClasses,
-} = require('../../../integrations/utils/map-integration-dto');
+import { createIntegrationRepository } from '../../integrations/repositories/integration-repository-factory';
+import { createModuleRepository } from '../../modules/repositories/module-repository-factory';
+import { ModuleFactory } from '../../modules/module-factory';
+import { LoadIntegrationContextUseCase } from '../../integrations/use-cases/load-integration-context';
+import { FindIntegrationContextByExternalEntityIdUseCase } from '../../integrations/use-cases/find-integration-context-by-external-entity-id';
+import { GetIntegrationsForUser } from '../../integrations/use-cases/get-integrations-for-user';
+import { CreateIntegration } from '../../integrations/use-cases/create-integration';
+import { getModulesDefinitionFromIntegrationClasses } from '../../integrations/utils/map-integration-dto';
 
 export interface IntegrationClass {
     name?: string;
@@ -84,7 +69,7 @@ function mapErrorToResponse(error: Error & { code?: string }): ErrorResponse {
     };
 }
 
-export function createIntegrationCommands({ integrationClass }: { integrationClass: IntegrationClass }): IntegrationCommands {
+export function createIntegrationCommands({ integrationClass }: { integrationClass: IntegrationClass }): any {
     if (!integrationClass) {
         throw new Error('integrationClass is required');
     }
@@ -94,41 +79,41 @@ export function createIntegrationCommands({ integrationClass }: { integrationCla
 
     const moduleDefinitions = getModulesDefinitionFromIntegrationClasses([
         integrationClass,
-    ]);
+    ] as any);
 
     const moduleFactory = new ModuleFactory({
-        moduleRepository,
-        moduleDefinitions,
+        moduleRepository: moduleRepository as any,
+        moduleDefinitions: moduleDefinitions as any,
     });
 
     const loadIntegrationContextUseCase = new LoadIntegrationContextUseCase({
         integrationRepository,
-        moduleRepository,
+        moduleRepository: moduleRepository as any,
         moduleFactory,
     });
 
     const findByExternalEntityIdUseCase =
         new FindIntegrationContextByExternalEntityIdUseCase({
             integrationRepository,
-            moduleRepository,
+            moduleRepository: moduleRepository as any,
             loadIntegrationContextUseCase: loadIntegrationContextUseCase,
         });
 
     const getIntegrationsForUserUseCase = new GetIntegrationsForUser({
         integrationRepository,
-        integrationClasses: [integrationClass],
+        integrationClasses: [integrationClass] as any,
         moduleFactory,
-        moduleRepository,
+        moduleRepository: moduleRepository as any,
     });
 
     const createIntegrationUseCase = new CreateIntegration({
         integrationRepository,
-        integrationClasses: [integrationClass],
+        integrationClasses: [integrationClass] as any,
         moduleFactory,
     });
 
     return {
-        async findIntegrationContextByExternalEntityId(externalEntityId: string) {
+        async findIntegrationContextByExternalEntityId(externalEntityId: string): Promise<any> {
             try {
                 const { context } = await findByExternalEntityIdUseCase.execute(
                     {
@@ -167,7 +152,7 @@ export function createIntegrationCommands({ integrationClass }: { integrationCla
                 const integration = await createIntegrationUseCase.execute(
                     entityIds,
                     userId,
-                    config
+                    config as any
                 );
                 return integration;
             } catch (error) {
@@ -177,7 +162,7 @@ export function createIntegrationCommands({ integrationClass }: { integrationCla
 
         async updateIntegrationConfig({ integrationId, config }: UpdateIntegrationConfigParams) {
             try {
-                const integration = await integrationRepository.updateIntegrationConfig(
+                const integration = await (integrationRepository as any).updateIntegrationConfig(
                     integrationId,
                     config
                 );

package/src/core/Worker.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for Worker - AWS SDK v3 Migration
+ *
+ * Tests SQS Worker operations using aws-sdk-client-mock
+ */
+
+import { mockClient } from 'aws-sdk-client-mock';
+import { SQSClient, GetQueueUrlCommand, SendMessageCommand } from '@aws-sdk/client-sqs';
+import { Worker } from './Worker';
+
+describe('Worker - AWS SDK v3', () => {
+    let sqsMock: ReturnType<typeof mockClient>;
+    let worker: Worker;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        sqsMock = mockClient(SQSClient);
+        worker = new Worker();
+        jest.clearAllMocks();
+        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
+    });
+
+    afterEach(() => {
+        sqsMock.reset();
+        process.env = originalEnv;
+    });
+
+    describe('getQueueURL()', () => {
+        it('should get queue URL from SQS', async () => {
+            sqsMock.on(GetQueueUrlCommand).resolves({
+                QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+            });
+
+            const result = await worker.getQueueURL({ QueueName: 'test-queue' });
+
+            expect(result).toBe('https://sqs.us-east-1.amazonaws.com/123456789/test-queue');
+            expect(sqsMock.calls()).toHaveLength(1);
+
+            const call = sqsMock.call(0);
+            expect(call.args[0].input).toMatchObject({
+                QueueName: 'test-queue',
+            });
+        });
+
+        it('should handle queue not found error', async () => {
+            sqsMock.on(GetQueueUrlCommand).rejects(new Error('Queue does not exist'));
+
+            await expect(worker.getQueueURL({ QueueName: 'nonexistent-queue' }))
+                .rejects.toThrow('Queue does not exist');
+        });
+    });
+
+    describe('sendAsyncSQSMessage()', () => {
+        it('should send message and return MessageId', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'message-123',
+            });
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                MessageBody: JSON.stringify({ test: 'data' }),
+            };
+
+            const result = await worker.sendAsyncSQSMessage(params);
+
+            expect(result).toBe('message-123');
+            expect(sqsMock.calls()).toHaveLength(1);
+        });
+
+        it('should handle send errors', async () => {
+            sqsMock.on(SendMessageCommand).rejects(new Error('Send failed'));
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                MessageBody: 'test',
+            };
+
+            await expect(worker.sendAsyncSQSMessage(params)).rejects.toThrow('Send failed');
+        });
+    });
+
+    describe('send()', () => {
+        it('should validate params and send message with delay', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'delayed-message-id',
+            });
+
+            worker._validateParams = jest.fn();  // Mock validation
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                data: 'test',
+            };
+
+            const result = await worker.send(params, 5);
+
+            expect(worker._validateParams).toHaveBeenCalledWith(params);
+            expect(result).toBe('delayed-message-id');
+
+            const call = sqsMock.call(0);
+            expect((call.args[0].input as any).DelaySeconds).toBe(5);
+        });
+
+        it('should send message with zero delay by default', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'message-id',
+            });
+
+            worker._validateParams = jest.fn();
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                data: 'test',
+            };
+
+            await worker.send(params);
+
+            const call = sqsMock.call(0);
+            expect((call.args[0].input as any).DelaySeconds).toBe(0);
+        });
+    });
+
+    describe('run()', () => {
+        it('should process SQS records', async () => {
+            worker._validateParams = jest.fn();
+            worker._run = jest.fn().mockResolvedValue(undefined);
+
+            const params = {
+                Records: [
+                    { body: JSON.stringify({ task: 'test-1' }) },
+                    { body: JSON.stringify({ task: 'test-2' }) },
+                ],
+            };
+
+            await worker.run(params);
+
+            expect(worker._run).toHaveBeenCalledTimes(2);
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test-1' }, {});
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test-2' }, {});
+        });
+
+        it('should pass context to _run method', async () => {
+            worker._validateParams = jest.fn();
+            worker._run = jest.fn().mockResolvedValue(undefined);
+
+            const params = {
+                Records: [
+                    { body: JSON.stringify({ task: 'test' }) },
+                ],
+            };
+            const context = { userId: '123' };
+
+            await worker.run(params, context);
+
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test' }, context);
+        });
+    });
+});

package/src/database/adapters/lambda-invoker.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Tests for LambdaInvoker
+ * Infrastructure layer - AWS Lambda invocation adapter
+ */
+
+import { LambdaInvoker, LambdaInvocationError } from './lambda-invoker';
+
+describe('LambdaInvoker', () => {
+    let invoker: LambdaInvoker;
+    let mockLambdaClient: { send: jest.Mock };
+
+    beforeEach(() => {
+        mockLambdaClient = {
+            send: jest.fn(),
+        };
+        invoker = new LambdaInvoker(mockLambdaClient as any);
+    });
+
+    describe('invoke()', () => {
+        it('should invoke Lambda and return parsed result on success', async () => {
+            mockLambdaClient.send.mockResolvedValue({
+                Payload: Buffer.from(JSON.stringify({
+                    statusCode: 200,
+                    body: { upToDate: true, pendingMigrations: 0 },
+                })),
+            });
+
+            const result = await invoker.invoke('test-function', { action: 'checkStatus' });
+
+            expect(result).toEqual({ upToDate: true, pendingMigrations: 0 });
+            expect(mockLambdaClient.send).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    input: expect.objectContaining({
+                        FunctionName: 'test-function',
+                        InvocationType: 'RequestResponse',
+                        Payload: JSON.stringify({ action: 'checkStatus' }),
+                    }),
+                })
+            );
+        });
+
+        it('should throw LambdaInvocationError on Lambda error status', async () => {
+            mockLambdaClient.send.mockResolvedValue({
+                Payload: Buffer.from(JSON.stringify({
+                    statusCode: 500,
+                    body: { error: 'Database connection failed' },
+                })),
+            });
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow(LambdaInvocationError);
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow(/test-function/);
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow(/Database connection failed/);
+        });
+
+        it('should throw LambdaInvocationError on malformed response', async () => {
+            mockLambdaClient.send.mockResolvedValue({
+                Payload: Buffer.from('not json'),
+            });
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow(LambdaInvocationError);
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow(/Failed to parse/);
+        });
+
+        it('should handle AWS SDK errors', async () => {
+            mockLambdaClient.send.mockRejectedValue(new Error('AccessDenied: User not authorized'));
+
+            await expect(invoker.invoke('test-function', {}))
+                .rejects
+                .toThrow('Failed to invoke Lambda test-function: AccessDenied: User not authorized');
+        });
+
+        it('should include function name in LambdaInvocationError', async () => {
+            mockLambdaClient.send.mockResolvedValue({
+                Payload: Buffer.from(JSON.stringify({
+                    statusCode: 500,
+                    body: { error: 'Test error' },
+                })),
+            });
+
+            try {
+                await invoker.invoke('my-function-name', {});
+                fail('Should have thrown');
+            } catch (error: any) {
+                expect(error).toBeInstanceOf(LambdaInvocationError);
+                expect(error.functionName).toBe('my-function-name');
+                expect(error.statusCode).toBe(500);
+                expect(error.message).toContain('my-function-name');
+            }
+        });
+    });
+});