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

package/integrations/tests/integration-router-multi-auth.test.js

@@ -1,369 +0,0 @@
-const { AuthenticateUser } = require('../../user/use-cases/authenticate-user');
-const { GetUserFromBearerToken } = require('../../user/use-cases/get-user-from-bearer-token');
-const { GetUserFromXFriggHeaders } = require('../../user/use-cases/get-user-from-x-frigg-headers');
-const { GetUserFromAdopterJwt } = require('../../user/use-cases/get-user-from-adopter-jwt');
-const { User } = require('../../user/user');
-const Boom = require('@hapi/boom');
-
-describe('AuthenticateUser - Multi-Mode Authentication', () => {
-    let authenticateUser;
-    let mockGetUserFromBearerToken;
-    let mockGetUserFromXFriggHeaders;
-    let mockGetUserFromAdopterJwt;
-    let mockUserConfig;
-    let mockUser;
-
-    beforeEach(() => {
-        mockUser = new User(
-            { id: 'user-123', username: 'testuser' },
-            null,
-            false,
-            'individual',
-            true,
-            false
-        );
-
-        mockGetUserFromBearerToken = {
-            execute: jest.fn().mockResolvedValue(mockUser),
-        };
-
-        mockGetUserFromXFriggHeaders = {
-            execute: jest.fn().mockResolvedValue(mockUser),
-        };
-
-        mockGetUserFromAdopterJwt = {
-            execute: jest.fn().mockResolvedValue(mockUser),
-        };
-
-        mockUserConfig = {
-            authModes: {
-                friggToken: true,
-                xFriggHeaders: true,
-                adopterJwt: false,
-            },
-        };
-
-        authenticateUser = new AuthenticateUser({
-            getUserFromBearerToken: mockGetUserFromBearerToken,
-            getUserFromXFriggHeaders: mockGetUserFromXFriggHeaders,
-            getUserFromAdopterJwt: mockGetUserFromAdopterJwt,
-            userConfig: mockUserConfig,
-        });
-    });
-
-    describe('Priority 1: X-Frigg Headers (Backend-to-Backend)', () => {
-        it('should authenticate with x-frigg-appUserId header', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'app-user-123',
-                },
-            };
-
-            const result = await authenticateUser.execute(mockReq);
-
-            expect(result).toBe(mockUser);
-            expect(mockGetUserFromXFriggHeaders.execute).toHaveBeenCalledWith(
-                'app-user-123',
-                undefined
-            );
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-
-        it('should authenticate with x-frigg-appOrgId header', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-apporgid': 'app-org-456',
-                },
-            };
-
-            const result = await authenticateUser.execute(mockReq);
-
-            expect(result).toBe(mockUser);
-            expect(mockGetUserFromXFriggHeaders.execute).toHaveBeenCalledWith(
-                undefined,
-                'app-org-456'
-            );
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-
-        it('should authenticate with both x-frigg headers when they match', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'app-user-123',
-                    'x-frigg-apporgid': 'app-org-456',
-                },
-            };
-
-            const result = await authenticateUser.execute(mockReq);
-
-            expect(result).toBe(mockUser);
-            expect(mockGetUserFromXFriggHeaders.execute).toHaveBeenCalledWith(
-                'app-user-123',
-                'app-org-456'
-            );
-        });
-
-        it('should reject conflicting x-frigg headers (delegated to use case)', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'app-user-123',
-                    'x-frigg-apporgid': 'app-org-999',
-                },
-            };
-
-            const conflictError = Boom.badRequest('User ID mismatch');
-            mockGetUserFromXFriggHeaders.execute.mockRejectedValue(conflictError);
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                conflictError
-            );
-        });
-
-        it('should skip x-frigg headers when authModes.xFriggHeaders is false', async () => {
-            mockUserConfig.authModes.xFriggHeaders = false;
-
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'app-user-123',
-                    authorization: 'Bearer frigg-token-xyz',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromXFriggHeaders.execute).not.toHaveBeenCalled();
-            expect(mockGetUserFromBearerToken.execute).toHaveBeenCalledWith(
-                'Bearer frigg-token-xyz'
-            );
-        });
-    });
-
-    describe('Priority 2: Adopter JWT', () => {
-        beforeEach(() => {
-            mockUserConfig.authModes.adopterJwt = true;
-        });
-
-        it('should try JWT when enabled and Bearer token is 3-part format', async () => {
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer eyJhbGci.eyJzdWIi.signature',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromAdopterJwt.execute).toHaveBeenCalledWith(
-                'eyJhbGci.eyJzdWIi.signature'
-            );
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-
-        it('should fall back to Frigg token when Bearer token is not JWT format', async () => {
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer simple-token',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromAdopterJwt.execute).not.toHaveBeenCalled();
-            expect(mockGetUserFromBearerToken.execute).toHaveBeenCalledWith(
-                'Bearer simple-token'
-            );
-        });
-
-        it('should not try JWT when authModes.adopterJwt is false', async () => {
-            mockUserConfig.authModes.adopterJwt = false;
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer eyJhbGci.eyJzdWIi.signature',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromAdopterJwt.execute).not.toHaveBeenCalled();
-            expect(mockGetUserFromBearerToken.execute).toHaveBeenCalledWith(
-                'Bearer eyJhbGci.eyJzdWIi.signature'
-            );
-        });
-    });
-
-    describe('Priority 3: Frigg Native Token (Fallback)', () => {
-        it('should fall back to Frigg token when no x-frigg headers', async () => {
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer frigg-token-123',
-                },
-            };
-
-            const result = await authenticateUser.execute(mockReq);
-
-            expect(result).toBe(mockUser);
-            expect(mockGetUserFromBearerToken.execute).toHaveBeenCalledWith(
-                'Bearer frigg-token-123'
-            );
-            expect(mockGetUserFromXFriggHeaders.execute).not.toHaveBeenCalled();
-        });
-
-        it('should skip Frigg token when authModes.friggToken is false', async () => {
-            mockUserConfig.authModes.friggToken = false;
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer frigg-token-123',
-                },
-            };
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                Boom.unauthorized().message
-            );
-
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('Priority Ordering', () => {
-        it('should prioritize x-frigg headers over bearer token', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'app-user-123',
-                    authorization: 'Bearer frigg-token-xyz',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromXFriggHeaders.execute).toHaveBeenCalledWith(
-                'app-user-123',
-                undefined
-            );
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-
-        it('should try JWT before Frigg token when JWT enabled', async () => {
-            mockUserConfig.authModes.adopterJwt = true;
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer part1.part2.part3',
-                },
-            };
-
-            await authenticateUser.execute(mockReq);
-
-            expect(mockGetUserFromAdopterJwt.execute).toHaveBeenCalledWith(
-                'part1.part2.part3'
-            );
-            expect(mockGetUserFromBearerToken.execute).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('Auth Mode Configuration', () => {
-        it('should use default friggToken mode when authModes not configured', () => {
-            const authWithDefaults = new AuthenticateUser({
-                getUserFromBearerToken: mockGetUserFromBearerToken,
-                getUserFromXFriggHeaders: mockGetUserFromXFriggHeaders,
-                getUserFromAdopterJwt: mockGetUserFromAdopterJwt,
-                userConfig: {}, // No authModes
-            });
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer token',
-                },
-            };
-
-            authWithDefaults.execute(mockReq);
-
-            expect(mockGetUserFromBearerToken.execute).toHaveBeenCalled();
-        });
-
-        it('should throw unauthorized when no valid authentication provided', async () => {
-            const mockReq = {
-                headers: {},
-            };
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                Boom.unauthorized().message
-            );
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                'No valid authentication provided'
-            );
-        });
-
-        it('should throw unauthorized when all auth modes disabled', async () => {
-            mockUserConfig.authModes = {
-                friggToken: false,
-                xFriggHeaders: false,
-                adopterJwt: false,
-            };
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer token',
-                },
-            };
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                'No valid authentication provided'
-            );
-        });
-    });
-
-    describe('Error Handling', () => {
-        it('should propagate authentication errors from x-frigg headers', async () => {
-            const mockReq = {
-                headers: {
-                    'x-frigg-appuserid': 'invalid-user',
-                },
-            };
-
-            const customError = Boom.badRequest('Invalid user ID');
-            mockGetUserFromXFriggHeaders.execute.mockRejectedValue(customError);
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                customError
-            );
-        });
-
-        it('should propagate authentication errors from bearer token', async () => {
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer invalid-token',
-                },
-            };
-
-            const customError = Boom.unauthorized('Invalid token');
-            mockGetUserFromBearerToken.execute.mockRejectedValue(customError);
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                customError
-            );
-        });
-
-        it('should propagate not implemented error from JWT', async () => {
-            mockUserConfig.authModes.adopterJwt = true;
-
-            const mockReq = {
-                headers: {
-                    authorization: 'Bearer part1.part2.part3',
-                },
-            };
-
-            const notImplementedError = Boom.notImplemented('JWT not implemented');
-            mockGetUserFromAdopterJwt.execute.mockRejectedValue(
-                notImplementedError
-            );
-
-            await expect(authenticateUser.execute(mockReq)).rejects.toThrow(
-                notImplementedError
-            );
-        });
-    });
-});
-
-

package/integrations/tests/use-cases/create-integration.test.js

@@ -1,131 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { CreateIntegration } = require('../../use-cases/create-integration');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('CreateIntegration Use-Case', () => {
-    let integrationRepository;
-    let moduleFactory;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        moduleFactory = new TestModuleFactory();
-        useCase = new CreateIntegration({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-            moduleFactory,
-        });
-    });
-
-    describe('happy path', () => {
-        it('creates an integration and returns DTO', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy', foo: 'bar' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.id).toBeDefined();
-            expect(dto.config).toEqual(config);
-            expect(dto.userId).toBe(userId);
-            expect(dto.entities).toEqual(entities);
-            expect(dto.status).toBe('NEW');
-        });
-
-        it('triggers ON_CREATE event with correct payload', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy', foo: 'bar' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            const record = await integrationRepository.findIntegrationById(dto.id);
-            expect(record).toBeTruthy();
-
-            const history = integrationRepository.getOperationHistory();
-            const createOperation = history.find(op => op.operation === 'create');
-            expect(createOperation).toEqual({
-                operation: 'create',
-                id: dto.id,
-                userId,
-                config
-            });
-        });
-
-        it('loads modules for each entity', async () => {
-            const entities = ['entity-1', 'entity-2'];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.entities).toEqual(entities);
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration class is not found', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'unknown-type' };
-
-            await expect(useCase.execute(entities, userId, config))
-                .rejects
-                .toThrow('No integration class found for type: unknown-type');
-        });
-
-        it('throws error when no integration classes provided', async () => {
-            const useCaseWithoutClasses = new CreateIntegration({
-                integrationRepository,
-                integrationClasses: [],
-                moduleFactory,
-            });
-
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            await expect(useCaseWithoutClasses.execute(entities, userId, config))
-                .rejects
-                .toThrow('No integration class found for type: dummy');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles empty entities array', async () => {
-            const entities = [];
-            const userId = 'user-1';
-            const config = { type: 'dummy' };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.entities).toEqual([]);
-            expect(dto.id).toBeDefined();
-        });
-
-        it('handles complex config objects', async () => {
-            const entities = ['entity-1'];
-            const userId = 'user-1';
-            const config = {
-                type: 'dummy',
-                nested: {
-                    value: 123,
-                    array: [1, 2, 3],
-                    bool: true
-                }
-            };
-
-            const dto = await useCase.execute(entities, userId, config);
-
-            expect(dto.config).toEqual(config);
-        });
-    });
-}); 

package/integrations/tests/use-cases/delete-integration-for-user.test.js

@@ -1,150 +0,0 @@
-jest.mock('../../../database/config', () => ({
-    DB_TYPE: 'mongodb',
-    getDatabaseType: jest.fn(() => 'mongodb'),
-    PRISMA_LOG_LEVEL: 'error,warn',
-    PRISMA_QUERY_LOGGING: false,
-}));
-
-const { DeleteIntegrationForUser } = require('../../use-cases/delete-integration-for-user');
-const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
-const { DummyIntegration } = require('../doubles/dummy-integration-class');
-
-describe('DeleteIntegrationForUser Use-Case', () => {
-    let integrationRepository;
-    let useCase;
-
-    beforeEach(() => {
-        integrationRepository = new TestIntegrationRepository();
-        useCase = new DeleteIntegrationForUser({
-            integrationRepository,
-            integrationClasses: [DummyIntegration],
-        });
-    });
-
-    describe('happy path', () => {
-        it('deletes integration successfully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-
-        it('tracks delete operation', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-            integrationRepository.clearHistory();
-
-            await useCase.execute(record.id, 'user-1');
-
-            const history = integrationRepository.getOperationHistory();
-            const deleteOperation = history.find(op => op.operation === 'delete');
-            expect(deleteOperation).toEqual({
-                operation: 'delete',
-                id: record.id,
-                existed: true,
-                success: true
-            });
-        });
-
-        it('deletes integration with multiple entities', async () => {
-            const record = await integrationRepository.createIntegration(['e1', 'e2', 'e3'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-    });
-
-    describe('error cases', () => {
-        it('throws error when integration not found', async () => {
-            const nonExistentId = 'non-existent-id';
-
-            await expect(useCase.execute(nonExistentId, 'user-1'))
-                .rejects
-                .toThrow(`Integration with id of ${nonExistentId} does not exist`);
-        });
-
-        it('throws error when user does not own integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, 'different-user'))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User different-user`);
-        });
-
-        it('throws error when integration class not found', async () => {
-            const useCaseWithoutClasses = new DeleteIntegrationForUser({
-                integrationRepository,
-                integrationClasses: [],
-            });
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCaseWithoutClasses.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow();
-        });
-
-        it('tracks failed delete operation for non-existent integration', async () => {
-            const nonExistentId = 'non-existent-id';
-            integrationRepository.clearHistory();
-
-            try {
-                await useCase.execute(nonExistentId, 'user-1');
-            } catch (error) {
-                const history = integrationRepository.getOperationHistory();
-                const findOperation = history.find(op => op.operation === 'findById');
-                expect(findOperation).toEqual({
-                    operation: 'findById',
-                    id: nonExistentId,
-                    found: false
-                });
-            }
-        });
-    });
-
-    describe('edge cases', () => {
-        it('handles deletion of already deleted integration', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await useCase.execute(record.id, 'user-1');
-
-            await expect(useCase.execute(record.id, 'user-1'))
-                .rejects
-                .toThrow(`Integration with id of ${record.id} does not exist`);
-        });
-
-        it('handles integration with complex config during deletion', async () => {
-            const complexConfig = {
-                type: 'dummy',
-                settings: { nested: { deep: 'value' } },
-                credentials: { encrypted: true }
-            };
-
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', complexConfig);
-
-            await useCase.execute(record.id, 'user-1');
-
-            const found = await integrationRepository.findIntegrationById(record.id);
-            expect(found).toBeNull();
-        });
-
-        it('handles null userId gracefully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, null))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User null`);
-        });
-
-        it('handles undefined userId gracefully', async () => {
-            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
-
-            await expect(useCase.execute(record.id, undefined))
-                .rejects
-                .toThrow(`Integration ${record.id} does not belong to User undefined`);
-        });
-    });
-});