@friggframework/core 2.0.0--canary.461.61382d8.0 → 2.0.0--canary.461.3d6d8ad.0

package/lambda/TimeoutCatcher.test.js

@@ -1,68 +0,0 @@
-const { TimeoutCatcher } = require("./TimeoutCatcher");
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-describe("Time Sentinel", () => {
-  it("requires a positive wait time", () => {
-    try {
-      new TimeoutCatcher({
-        timeout: 1_000,
-      });
-      throw new Error("Expected error was not thrown");
-    } catch (error) {
-      expect(error).toHaveProperty(
-        "message",
-        "Wait time was not a positive number of milliseconds"
-      );
-    }
-  });
-
-  it("exits normally if the work is completed", async () => {
-    let cleanUpCalled = false;
-    const sentinel = new TimeoutCatcher({
-      cleanUp: () => (cleanUpCalled = true),
-      timeout: 3_000,
-      work: async () => {
-        await sleep(500);
-      },
-    });
-
-    const didFinish = await sentinel.watch();
-    expect(didFinish).toEqual(true);
-    expect(cleanUpCalled).toEqual(false);
-  });
-
-  it("terminates before time out if work runs long", async () => {
-    let cleanUpCalled = false;
-    const sentinel = new TimeoutCatcher({
-      cleanUp: () => (cleanUpCalled = true),
-      timeout: 3_000,
-      work: async () => {
-        await sleep(1_500);
-      },
-    });
-
-    const didFinish = await sentinel.watch();
-    expect(didFinish).toEqual(false);
-    expect(cleanUpCalled).toEqual(true);
-  });
-
-  it("rethrows unexpected errors", async () => {
-    let cleanUpCalled = false;
-    const sentinel = new TimeoutCatcher({
-      cleanUp: () => (cleanUpCalled = true),
-      timeout: 3_000,
-      work: async () => {
-        throw new Error("Spam spam spam spam");
-      },
-    });
-
-    try {
-      await sentinel.watch();
-      throw new Error("Expected error did not occur");
-    } catch (error) {
-      expect(error).toHaveProperty("message", "Spam spam spam spam");
-      expect(cleanUpCalled).toEqual(false);
-    }
-  });
-});

package/logs/logger.test.js

@@ -1,76 +0,0 @@
-const { debug, initDebugLog, flushDebugLog } = require('./logger');
-const sinon = require('sinon');
-const {
-    overrideEnvironment,
-    restoreEnvironment,
-} = require('@friggframework/test');
-
-/* eslint-disable no-console */
-
-describe('Logger', () => {
-    beforeEach(() => {
-        sinon.stub(console, 'debug');
-        sinon.stub(console, 'error');
-    });
-
-    afterEach(() => {
-        console.debug.restore();
-        console.error.restore();
-        restoreEnvironment();
-    });
-
-    it('runs', () => {
-        initDebugLog('Test Event', { test: true });
-        debug('Add a message', 'or two', { or: 3 });
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 2);
-        expect(console.error).toHaveProperty('callCount', 1);
-    });
-
-    it('logs immediately when environment variable set', () => {
-        overrideEnvironment({ DEBUG_VERBOSE: '1' });
-
-        debug('Add a message', 'or two', { or: 3 });
-        debug('And another');
-
-        expect(console.debug).toHaveProperty('callCount', 2);
-        expect(console.error).toHaveProperty('callCount', 0);
-    });
-
-    it('is resilient to missing parameters', () => {
-        initDebugLog();
-        debug();
-        flushDebugLog();
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 1);
-    });
-
-    it('outputs parent errors', () => {
-        initDebugLog();
-
-        const error = new Error();
-        error.cause = new Error();
-        error.cause.cause = new Error();
-        error.cause.cause.cause = new Error();
-
-        flushDebugLog(error);
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 7); // 1 + 2 for each cause
-    });
-
-    it('adds a debug message if more than 1 error encountered', () => {
-        initDebugLog();
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 0);
-        expect(console.error).toHaveProperty('callCount', 1);
-
-        flushDebugLog(new Error());
-
-        expect(console.debug).toHaveProperty('callCount', 1);
-        expect(console.error).toHaveProperty('callCount', 2);
-    });
-});

package/modules/module-hydration.test.js

@@ -1,205 +0,0 @@
-jest.mock('../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { Module } = require('./module');
-const { ModuleFactory } = require('./module-factory');
-
-// Mock OAuth2Requester base class
-class MockOAuth2Api {
-    constructor(params) {
-        // Capture all params passed to API constructor
-        this.client_id = params.client_id;
-        this.client_secret = params.client_secret;
-        this.redirect_uri = params.redirect_uri;
-        this.scope = params.scope;
-        this.access_token = params.access_token;
-        this.refresh_token = params.refresh_token;
-        this.domain = params.domain;
-        this.delegate = params.delegate;
-    }
-
-    // Mock API methods
-    async listProjects() {
-        if (!this.access_token) {
-            throw new Error('No access token provided');
-        }
-        return { projects: ['project1', 'project2'] };
-    }
-
-    async getFolders() {
-        if (!this.access_token) {
-            throw new Error('No access token provided');
-        }
-        return { folders: ['folder1', 'folder2'] };
-    }
-
-    getAuthorizationRequirements() {
-        return { type: 'oauth2', url: 'https://example.com/oauth' };
-    }
-}
-
-MockOAuth2Api.requesterType = 'oauth2';
-
-// Mock module definition
-const mockModuleDefinition = {
-    moduleName: 'testmodule',
-    modelName: 'TestModule',
-    API: MockOAuth2Api,
-    requiredAuthMethods: {
-        getToken: async () => {},
-        getEntityDetails: async () => {},
-        getCredentialDetails: async () => {},
-        apiPropertiesToPersist: {
-            credential: ['access_token', 'refresh_token'],
-            entity: ['domain'],
-        },
-        testAuthRequest: async () => true,
-    },
-    env: {
-        client_id: 'test_client_id',
-        client_secret: 'test_client_secret',
-        redirect_uri: 'https://test.com/redirect',
-        scope: 'read write',
-    },
-};
-
-describe('Module Hydration', () => {
-    describe('Module API instantiation', () => {
-        it('should create API instance with merged env and credential params', () => {
-            const entity = {
-                id: 'entity-1',
-                moduleName: 'testmodule',
-                domain: 'test.domain.com',
-                credential: {
-                    data: {
-                        access_token: 'test_access_token',
-                        refresh_token: 'test_refresh_token',
-                    },
-                },
-            };
-
-            const module = new Module({
-                definition: mockModuleDefinition,
-                userId: 'user-1',
-                entity,
-            });
-
-            // Verify module properties
-            expect(module.name).toBe('testmodule');
-            expect(module.api).toBeDefined();
-
-            // Verify API was instantiated with correct params
-            expect(module.api.client_id).toBe('test_client_id');
-            expect(module.api.client_secret).toBe('test_client_secret');
-            expect(module.api.redirect_uri).toBe('https://test.com/redirect');
-            expect(module.api.scope).toBe('read write');
-            expect(module.api.access_token).toBe('test_access_token');
-            expect(module.api.refresh_token).toBe('test_refresh_token');
-            expect(module.api.domain).toBe('test.domain.com');
-        });
-
-        it('should allow API methods to be called with credentials', async () => {
-            const entity = {
-                id: 'entity-1',
-                moduleName: 'testmodule',
-                credential: {
-                    data: {
-                        access_token: 'valid_token',
-                        refresh_token: 'valid_refresh_token',
-                    },
-                },
-            };
-
-            const module = new Module({
-                definition: mockModuleDefinition,
-                userId: 'user-1',
-                entity,
-            });
-
-            // Test that API methods work with credentials
-            const projects = await module.api.listProjects();
-            expect(projects).toEqual({ projects: ['project1', 'project2'] });
-
-            const folders = await module.api.getFolders();
-            expect(folders).toEqual({ folders: ['folder1', 'folder2'] });
-        });
-
-        it('should handle missing credentials gracefully', () => {
-            const entity = {
-                id: 'entity-1',
-                moduleName: 'testmodule',
-                credential: {
-                    data: {
-                        // Empty credential data - no access_token
-                    },
-                },
-            };
-
-            const module = new Module({
-                definition: mockModuleDefinition,
-                userId: 'user-1',
-                entity,
-            });
-
-            // API should still be created with env params only
-            expect(module.api).toBeDefined();
-            expect(module.api.client_id).toBe('test_client_id');
-            expect(module.api.access_token).toBeUndefined();
-        });
-    });
-
-    describe('ModuleFactory', () => {
-        it('should create module instance from entity and definition', async () => {
-            const entity = {
-                id: 'entity-1',
-                moduleName: 'testmodule',
-                userId: 'user-1',
-                credential: {
-                    data: {
-                        access_token: 'factory_token',
-                    },
-                },
-            };
-
-            const moduleRepository = {
-                findEntityById: jest.fn().mockResolvedValue(entity),
-            };
-
-            const factory = new ModuleFactory({
-                moduleRepository,
-                moduleDefinitions: [mockModuleDefinition],
-            });
-
-            const module = await factory.getModuleInstance('entity-1', 'user-1');
-
-            expect(module).toBeDefined();
-            expect(module.api).toBeDefined();
-            expect(module.api.access_token).toBe('factory_token');
-        });
-
-        it('should throw error if module definition not found', async () => {
-            const entity = {
-                id: 'entity-1',
-                moduleName: 'unknownmodule',
-                userId: 'user-1',
-            };
-
-            const moduleRepository = {
-                findEntityById: jest.fn().mockResolvedValue(entity),
-            };
-
-            const factory = new ModuleFactory({
-                moduleRepository,
-                moduleDefinitions: [mockModuleDefinition],
-            });
-
-            await expect(
-                factory.getModuleInstance('entity-1', 'user-1')
-            ).rejects.toThrow('Module definition not found for module: unknownmodule');
-        });
-    });
-});

package/modules/requester/requester.test.js

@@ -1,28 +0,0 @@
-const { Requester } = require('./requester');
-
-describe('429 and 5xx testing', () => {
-    let backOffArray = [1, 1, 1];
-    let requester = new Requester({ backOff: backOffArray });
-    let sum = backOffArray.reduce((a, b) => {
-        return a + b;
-    }, 0);
-    it.skip("should retry with 'exponential' back off due to 429", async () => {
-        let startTime = await Date.now();
-        let res = await requester._get({
-            url: 'https://70e18ff0-1967-4fb5-8f96-10477ab6bb9e.mock.pstmn.io//429',
-        });
-        let endTime = await Date.now();
-        let difference = endTime - startTime;
-        expect(difference).toBeGreaterThan(sum * 1000);
-    });
-
-    it.skip("should retry with 'exponential' back off due to 500", async () => {
-        let startTime = await Date.now();
-        let res = await requester._get({
-            url: 'https://70e18ff0-1967-4fb5-8f96-10477ab6bb9e.mock.pstmn.io//5xx',
-        });
-        let endTime = await Date.now();
-        let difference = endTime - startTime;
-        expect(difference).toBeGreaterThan(sum * 1000);
-    });
-});

package/queues/queuer-util.test.js

@@ -1,132 +0,0 @@
-/**
- * Tests for QueuerUtil - AWS SDK v3 Migration
- * 
- * Tests SQS operations using aws-sdk-client-mock
- */
-
-const { mockClient } = require('aws-sdk-client-mock');
-const { SQSClient, SendMessageCommand, SendMessageBatchCommand } = require('@aws-sdk/client-sqs');
-const { QueuerUtil } = require('./queuer-util');
-
-describe('QueuerUtil - AWS SDK v3', () => {
-    let sqsMock;
-
-    beforeEach(() => {
-        sqsMock = mockClient(SQSClient);
-        jest.clearAllMocks();
-    });
-
-    afterEach(() => {
-        sqsMock.reset();
-    });
-
-    describe('send()', () => {
-        it('should send single message to SQS', async () => {
-            sqsMock.on(SendMessageCommand).resolves({ 
-                MessageId: 'test-message-id-123' 
-            });
-
-            const message = { test: 'data', id: 1 };
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            const result = await QueuerUtil.send(message, queueUrl);
-
-            expect(result.MessageId).toBe('test-message-id-123');
-            expect(sqsMock.calls()).toHaveLength(1);
-            
-            const call = sqsMock.call(0);
-            expect(call.args[0].input).toMatchObject({
-                MessageBody: JSON.stringify(message),
-                QueueUrl: queueUrl,
-            });
-        });
-
-        it('should handle SQS errors', async () => {
-            sqsMock.on(SendMessageCommand).rejects(new Error('SQS Error'));
-
-            const message = { test: 'data' };
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            await expect(QueuerUtil.send(message, queueUrl)).rejects.toThrow('SQS Error');
-        });
-    });
-
-    describe('batchSend()', () => {
-        it('should send batch of messages to SQS', async () => {
-            sqsMock.on(SendMessageBatchCommand).resolves({ 
-                Successful: [{ MessageId: 'msg-1' }],
-                Failed: []
-            });
-
-            const entries = Array(5).fill().map((_, i) => ({ data: `test-${i}` }));
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            const result = await QueuerUtil.batchSend(entries, queueUrl);
-
-            expect(sqsMock.calls()).toHaveLength(1);
-            
-            const call = sqsMock.call(0);
-            expect(call.args[0].input.Entries).toHaveLength(5);
-            expect(call.args[0].input.QueueUrl).toBe(queueUrl);
-        });
-
-        it('should send multiple batches for large entry sets (10 per batch)', async () => {
-            sqsMock.on(SendMessageBatchCommand).resolves({ 
-                Successful: [],
-                Failed: []
-            });
-
-            const entries = Array(25).fill().map((_, i) => ({ data: `test-${i}` }));
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            await QueuerUtil.batchSend(entries, queueUrl);
-
-            // Should send 3 batches (10 + 10 + 5)
-            expect(sqsMock.calls()).toHaveLength(3);
-            
-            expect(sqsMock.call(0).args[0].input.Entries).toHaveLength(10);
-            expect(sqsMock.call(1).args[0].input.Entries).toHaveLength(10);
-            expect(sqsMock.call(2).args[0].input.Entries).toHaveLength(5);
-        });
-
-        it('should handle empty entries array', async () => {
-            const result = await QueuerUtil.batchSend([], 'https://queue-url');
-
-            expect(result).toEqual({});
-            expect(sqsMock.calls()).toHaveLength(0);
-        });
-
-        it('should send exact batch of 10 without remainder', async () => {
-            sqsMock.on(SendMessageBatchCommand).resolves({ 
-                Successful: [],
-                Failed: []
-            });
-
-            const entries = Array(10).fill().map((_, i) => ({ data: `test-${i}` }));
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            const result = await QueuerUtil.batchSend(entries, queueUrl);
-
-            expect(sqsMock.calls()).toHaveLength(1);
-            expect(result).toEqual({});  // Returns empty object when exact batch
-        });
-
-        it('should generate unique IDs for each entry', async () => {
-            sqsMock.on(SendMessageBatchCommand).resolves({ 
-                Successful: [],
-                Failed: []
-            });
-
-            const entries = [{ data: 'test-1' }, { data: 'test-2' }];
-            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
-
-            await QueuerUtil.batchSend(entries, queueUrl);
-
-            const sentEntries = sqsMock.call(0).args[0].input.Entries;
-            expect(sentEntries[0].Id).toBeDefined();
-            expect(sentEntries[1].Id).toBeDefined();
-            expect(sentEntries[0].Id).not.toBe(sentEntries[1].Id);
-        });
-    });
-});
-

package/user/tests/use-cases/create-individual-user.test.js

@@ -1,24 +0,0 @@
-const {
-    CreateIndividualUser,
-} = require('../../use-cases/create-individual-user');
-const { TestUserRepository } = require('../doubles/test-user-repository');
-
-describe('CreateIndividualUser Use Case', () => {
-    it('should create and return an individual user via the repository', async () => {
-        const userConfig = { usePassword: true };
-        const userRepository = new TestUserRepository({ userConfig });
-        const createIndividualUser = new CreateIndividualUser({
-            userRepository,
-            userConfig,
-        });
-
-        const params = {
-            username: 'test-user',
-            password: 'password123',
-        };
-        const user = await createIndividualUser.execute(params);
-
-        expect(user).toBeDefined();
-        expect(user.getIndividualUser().username).toBe(params.username);
-    });
-});

package/user/tests/use-cases/create-organization-user.test.js

@@ -1,28 +0,0 @@
-const {
-    CreateOrganizationUser,
-} = require('../../use-cases/create-organization-user');
-const { TestUserRepository } = require('../doubles/test-user-repository');
-
-describe('CreateOrganizationUser Use Case', () => {
-    it('should create and return an organization user via the repository', async () => {
-        const userConfig = {
-            primary: 'organization',
-            organizationUserRequired: true,
-            individualUserRequired: false,
-        };
-        const userRepository = new TestUserRepository({ userConfig });
-        const createOrganizationUser = new CreateOrganizationUser({
-            userRepository,
-            userConfig,
-        });
-
-        const params = {
-            name: 'Test Org',
-            appOrgId: 'org-123',
-        };
-        const user = await createOrganizationUser.execute(params);
-
-        expect(user).toBeDefined();
-        expect(user.getOrganizationUser().name).toBe(params.name);
-    });
-}); 

package/user/tests/use-cases/create-token-for-user-id.test.js

@@ -1,19 +0,0 @@
-const {
-    CreateTokenForUserId,
-} = require('../../use-cases/create-token-for-user-id');
-const { TestUserRepository } = require('../doubles/test-user-repository');
-
-describe('CreateTokenForUserId Use Case', () => {
-    it('should create and return a token via the repository', async () => {
-        const userConfig = {}; // Not used by this use case, but required by the test repo
-        const userRepository = new TestUserRepository({ userConfig });
-        const createTokenForUserId = new CreateTokenForUserId({ userRepository });
-
-        const userId = 'user-123';
-        const token = await createTokenForUserId.execute(userId);
-
-        expect(token).toBeDefined();
-        // The mock token is deterministic, so we can check it
-        expect(token).toContain(`token-for-${userId}`);
-    });
-});