@friggframework/core 2.0.0-next.45 → 2.0.0-next.46

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/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}`);
-    });
-}); 

package/user/tests/use-cases/get-user-from-bearer-token.test.js

@@ -1,64 +0,0 @@
-const {
-    GetUserFromBearerToken,
-} = require('../../use-cases/get-user-from-bearer-token');
-const { TestUserRepository } = require('../doubles/test-user-repository');
-
-describe('GetUserFromBearerToken Use Case', () => {
-    let userRepository;
-    let getUserFromBearerToken;
-    let userConfig;
-
-    beforeEach(() => {
-        userConfig = {
-            usePassword: true,
-            primary: 'individual',
-            individualUserRequired: true,
-            organizationUserRequired: false,
-        };
-        userRepository = new TestUserRepository({ userConfig });
-        getUserFromBearerToken = new GetUserFromBearerToken({
-            userRepository,
-            userConfig
-        });
-    });
-
-    it('should retrieve a user for a valid bearer token', async () => {
-        const userId = 'user-123';
-        const token = await userRepository.createToken(userId);
-        const createdUserData = await userRepository.createIndividualUser({
-            id: userId,
-        });
-
-        const user = await getUserFromBearerToken.execute(`Bearer ${token}`);
-
-        expect(user).toBeDefined();
-        expect(user.getId()).toBe(createdUserData.id);
-    });
-
-    it('should throw an unauthorized error if the bearer token is missing', async () => {
-        await expect(getUserFromBearerToken.execute(null)).rejects.toThrow(
-            'Missing Authorization Header'
-        );
-    });
-
-    it('should throw an unauthorized error for an invalid token format', async () => {
-        await expect(
-            getUserFromBearerToken.execute('InvalidToken')
-        ).rejects.toThrow('Invalid Token Format');
-    });
-
-    it('should throw an unauthorized error if the Session Token is not found', async () => {
-        userRepository.getSessionToken = jest.fn().mockResolvedValue(null);
-        await expect(
-            getUserFromBearerToken.execute('Bearer invalid-token')
-        ).rejects.toThrow('Session Token Not Found');
-    });
-
-    it('should throw an unauthorized error if the token is valid but finds no user', async () => {
-        userRepository.getSessionToken = jest.fn().mockResolvedValue(null);
-        const token = await userRepository.createToken('user-dne');
-        await expect(
-            getUserFromBearerToken.execute(`Bearer ${token}`)
-        ).rejects.toThrow('Session Token Not Found');
-    });
-}); 

package/user/tests/use-cases/login-user.test.js

@@ -1,220 +0,0 @@
-const bcrypt = require('bcryptjs');
-const { LoginUser } = require('../../use-cases/login-user');
-const { TestUserRepository } = require('../doubles/test-user-repository');
-
-jest.mock('bcryptjs', () => ({
-    compare: jest.fn(),
-}));
-
-describe('LoginUser Use Case', () => {
-    let userRepository;
-    let loginUser;
-    let userConfig;
-
-    beforeEach(() => {
-        userConfig = { usePassword: true, individualUserRequired: true, organizationUserRequired: false };
-        userRepository = new TestUserRepository({ userConfig });
-        loginUser = new LoginUser({ userRepository, userConfig });
-
-        bcrypt.compare.mockClear();
-    });
-
-    describe('With Password Authentication', () => {
-        it('should successfully log in a user with correct credentials', async () => {
-            const username = 'test-user';
-            const password = 'password123';
-            await userRepository.createIndividualUser({
-                username,
-                hashword: 'hashed-password',
-            });
-
-            bcrypt.compare.mockResolvedValue(true);
-
-            const user = await loginUser.execute({ username, password });
-
-            expect(bcrypt.compare).toHaveBeenCalledWith(
-                password,
-                'hashed-password'
-            );
-            expect(user).toBeDefined();
-            expect(user.getIndividualUser().username).toBe(username);
-        });
-
-        it('should throw an unauthorized error for an incorrect password', async () => {
-            const username = 'test-user';
-            const password = 'wrong-password';
-            await userRepository.createIndividualUser({
-                username,
-                hashword: 'hashed-password',
-            });
-
-            bcrypt.compare.mockResolvedValue(false);
-
-            await expect(
-                loginUser.execute({ username, password })
-            ).rejects.toThrow('Incorrect username or password');
-        });
-
-        it('should throw an unauthorized error for a non-existent user', async () => {
-            const username = 'non-existent-user';
-            const password = 'password123';
-
-            await expect(
-                loginUser.execute({ username, password })
-            ).rejects.toThrow('user not found');
-        });
-    });
-
-    describe('Without Password (appUserId)', () => {
-        beforeEach(() => {
-            userConfig = { usePassword: false, individualUserRequired: true, organizationUserRequired: false };
-            userRepository = new TestUserRepository({ userConfig });
-            loginUser = new LoginUser({
-                userRepository,
-                userConfig,
-            });
-        });
-
-        it('should successfully retrieve a user by appUserId', async () => {
-            const appUserId = 'app-user-123';
-            const createdUserData = await userRepository.createIndividualUser({
-                appUserId,
-            });
-
-            const result = await loginUser.execute({ appUserId });
-            expect(result.getId()).toBe(createdUserData.id);
-        });
-    });
-
-    describe('With Organization User', () => {
-        beforeEach(() => {
-            userConfig = {
-                primary: 'organization',
-                individualUserRequired: false,
-                organizationUserRequired: true,
-            };
-            userRepository = new TestUserRepository({ userConfig });
-            loginUser = new LoginUser({
-                userRepository,
-                userConfig,
-            });
-        });
-
-        it('should successfully retrieve an organization user by appOrgId', async () => {
-            const appOrgId = 'app-org-123';
-            const createdUserData = await userRepository.createOrganizationUser({
-                name: 'Test Org',
-                appOrgId,
-            });
-
-            const result = await loginUser.execute({ appOrgId });
-            expect(result.getId()).toBe(createdUserData.id);
-        });
-
-        it('should throw an unauthorized error for a non-existent organization user', async () => {
-            const appOrgId = 'non-existent-org';
-
-            await expect(loginUser.execute({ appOrgId })).rejects.toThrow(
-                'org user non-existent-org not found'
-            );
-        });
-    });
-
-    describe('Required User Checks', () => {
-        it('should throw an error if a required individual user is not found', async () => {
-            userConfig = {
-                individualUserRequired: true,
-                usePassword: false,
-            };
-            userRepository = new TestUserRepository({ userConfig });
-            loginUser = new LoginUser({
-                userRepository,
-                userConfig,
-            });
-
-            await expect(
-                loginUser.execute({ appUserId: 'a-non-existent-user-id' })
-            ).rejects.toThrow('user not found');
-        });
-    });
-
-    describe('Bcrypt Hash Verification', () => {
-        beforeEach(() => {
-            userConfig = { usePassword: true, individualUserRequired: true, organizationUserRequired: false };
-            userRepository = new TestUserRepository({ userConfig });
-            loginUser = new LoginUser({ userRepository, userConfig });
-        });
-
-        it('should verify bcrypt.compare is called with plain password and hash', async () => {
-            const username = 'bcrypt-test-user';
-            const plainPassword = 'MyPlainPassword123';
-            const bcryptHash = '$2b$10$abcdefghijklmnopqrstuv';
-
-            await userRepository.createIndividualUser({
-                username,
-                hashword: bcryptHash,
-            });
-
-            bcrypt.compare.mockResolvedValue(true);
-
-            await loginUser.execute({ username, password: plainPassword });
-
-            expect(bcrypt.compare).toHaveBeenCalledTimes(1);
-            expect(bcrypt.compare).toHaveBeenCalledWith(plainPassword, bcryptHash);
-
-            const [firstArg, secondArg] = bcrypt.compare.mock.calls[0];
-            expect(firstArg).toBe(plainPassword);
-            expect(secondArg).toBe(bcryptHash);
-        });
-
-        it('should verify stored password has bcrypt hash format', async () => {
-            const username = 'format-test-user';
-            const bcryptHash = '$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy';
-
-            await userRepository.createIndividualUser({
-                username,
-                hashword: bcryptHash,
-            });
-
-            const user = await userRepository.findIndividualUserByUsername(username);
-
-            expect(user.hashword).toMatch(/^\$2[ab]\$/);
-            expect(user.hashword.length).toBeGreaterThan(50);
-            expect(user.hashword).not.toContain(':');
-        });
-
-        it('should reject passwords that look encrypted (have colon separators)', async () => {
-            const username = 'encrypted-format-user';
-            const encryptedLookingValue = 'kms:us-east-1:key:ciphertext';
-
-            await userRepository.createIndividualUser({
-                username,
-                hashword: encryptedLookingValue,
-            });
-
-            bcrypt.compare.mockResolvedValue(false);
-
-            await expect(
-                loginUser.execute({ username, password: 'any-password' })
-            ).rejects.toThrow('Incorrect username or password');
-        });
-
-        it('should verify bcrypt.compare returns false for mismatched passwords', async () => {
-            const username = 'mismatch-test-user';
-            const correctHash = '$2b$10$correcthash';
-
-            await userRepository.createIndividualUser({
-                username,
-                hashword: correctHash,
-            });
-
-            bcrypt.compare.mockResolvedValue(false);
-
-            await expect(
-                loginUser.execute({ username, password: 'wrong-password' })
-            ).rejects.toThrow('Incorrect username or password');
-
-            expect(bcrypt.compare).toHaveBeenCalledWith('wrong-password', correctHash);
-        });
-    });
-});