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

package/database/encryption/prisma-encryption-extension.test.js

@@ -1,439 +0,0 @@
-const { createEncryptionExtension } = require('./prisma-encryption-extension');
-
-describe('Prisma Encryption Extension', () => {
-    let mockCryptor;
-    let mockQuery;
-
-    beforeEach(() => {
-        // Mock Cryptor
-        mockCryptor = {
-            encrypt: jest
-                .fn()
-                .mockImplementation(
-                    (value) => `encrypted:${value}:iv:enckey`
-                ),
-            decrypt: jest
-                .fn()
-                .mockImplementation((value) => {
-                    const parts = value.split(':');
-                    return parts[1]; // Extract original value
-                }),
-        };
-
-        // Mock Prisma query function
-        mockQuery = jest.fn().mockImplementation((args) => args.mockResult);
-    });
-
-    describe('createEncryptionExtension', () => {
-        it('should create extension with valid config', () => {
-            const extension = createEncryptionExtension({
-                cryptor: mockCryptor,
-                enabled: true,
-            });
-
-            expect(extension).toBeDefined();
-            expect(extension.name).toBe('frigg-field-encryption');
-            expect(extension.query).toBeDefined();
-            expect(extension.query.$allModels).toBeDefined();
-        });
-
-        it('should return no-op extension when disabled', () => {
-            const extension = createEncryptionExtension({
-                cryptor: mockCryptor,
-                enabled: false,
-            });
-
-            // No-op extension is a function that returns its input
-            const mockClient = { $extends: jest.fn() };
-            const result = extension(mockClient);
-
-            expect(result).toBe(mockClient);
-        });
-
-        it('should throw if cryptor not provided when enabled', () => {
-            expect(() => {
-                createEncryptionExtension({ enabled: true });
-            }).toThrow('Cryptor instance required');
-        });
-
-        it('should not throw if cryptor not provided when disabled', () => {
-            expect(() => {
-                createEncryptionExtension({ enabled: false });
-            }).not.toThrow();
-        });
-    });
-
-    describe('Query Interceptors', () => {
-        let extension;
-        let handlers;
-
-        beforeEach(() => {
-            extension = createEncryptionExtension({
-                cryptor: mockCryptor,
-                enabled: true,
-            });
-            handlers = extension.query.$allModels;
-        });
-
-        describe('create', () => {
-            it('should encrypt data before create', async () => {
-                const args = {
-                    data: {
-                        data: { access_token: 'secret123' },
-                    },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:secret123:iv:enckey' },
-                    },
-                };
-
-                await handlers.create({
-                    model: 'Credential',
-                    operation: 'create',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('secret123');
-                expect(args.data.data.access_token).toBe(
-                    'encrypted:secret123:iv:enckey'
-                );
-            });
-
-            it('should decrypt result after create', async () => {
-                const args = {
-                    data: { data: { access_token: 'secret123' } },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:secret123:iv:enckey' },
-                    },
-                };
-
-                const result = await handlers.create({
-                    model: 'Credential',
-                    operation: 'create',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.decrypt).toHaveBeenCalledWith(
-                    'encrypted:secret123:iv:enckey'
-                );
-                expect(result.data.access_token).toBe('secret123');
-            });
-
-            it('should handle null result', async () => {
-                const args = {
-                    data: { data: { access_token: 'secret123' } },
-                    mockResult: null,
-                };
-
-                const result = await handlers.create({
-                    model: 'Credential',
-                    operation: 'create',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result).toBeNull();
-            });
-        });
-
-        describe('createMany', () => {
-            it('should encrypt array of data', async () => {
-                const args = {
-                    data: [
-                        { data: { access_token: 'secret1' } },
-                        { data: { access_token: 'secret2' } },
-                    ],
-                    mockResult: { count: 2 },
-                };
-
-                await handlers.createMany({
-                    model: 'Credential',
-                    operation: 'createMany',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('secret1');
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('secret2');
-                expect(args.data[0].data.access_token).toBe(
-                    'encrypted:secret1:iv:enckey'
-                );
-                expect(args.data[1].data.access_token).toBe(
-                    'encrypted:secret2:iv:enckey'
-                );
-            });
-
-            it('should handle single object in createMany', async () => {
-                const args = {
-                    data: { data: { access_token: 'secret' } },
-                    mockResult: { count: 1 },
-                };
-
-                await handlers.createMany({
-                    model: 'Credential',
-                    operation: 'createMany',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('secret');
-            });
-        });
-
-        describe('update', () => {
-            it('should encrypt update data', async () => {
-                const args = {
-                    data: { data: { access_token: 'newsecret' } },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:newsecret:iv:enckey' },
-                    },
-                };
-
-                await handlers.update({
-                    model: 'Credential',
-                    operation: 'update',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('newsecret');
-            });
-
-            it('should decrypt result after update', async () => {
-                const args = {
-                    data: { data: { access_token: 'newsecret' } },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:newsecret:iv:enckey' },
-                    },
-                };
-
-                const result = await handlers.update({
-                    model: 'Credential',
-                    operation: 'update',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result.data.access_token).toBe('newsecret');
-            });
-        });
-
-        describe('upsert', () => {
-            it('should encrypt both create and update data', async () => {
-                const args = {
-                    create: { data: { access_token: 'createsecret' } },
-                    update: { data: { access_token: 'updatesecret' } },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:createsecret:iv:enckey' },
-                    },
-                };
-
-                await handlers.upsert({
-                    model: 'Credential',
-                    operation: 'upsert',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('createsecret');
-                expect(mockCryptor.encrypt).toHaveBeenCalledWith('updatesecret');
-            });
-        });
-
-        describe('findUnique', () => {
-            it('should decrypt result', async () => {
-                const args = {
-                    where: { id: '1' },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:secret:iv:enckey' },
-                    },
-                };
-
-                const result = await handlers.findUnique({
-                    model: 'Credential',
-                    operation: 'findUnique',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(mockCryptor.decrypt).toHaveBeenCalledWith(
-                    'encrypted:secret:iv:enckey'
-                );
-                expect(result.data.access_token).toBe('secret');
-            });
-
-            it('should handle null result', async () => {
-                const args = {
-                    where: { id: '999' },
-                    mockResult: null,
-                };
-
-                const result = await handlers.findUnique({
-                    model: 'Credential',
-                    operation: 'findUnique',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result).toBeNull();
-                expect(mockCryptor.decrypt).not.toHaveBeenCalled();
-            });
-        });
-
-        describe('findMany', () => {
-            it('should decrypt array of results', async () => {
-                const args = {
-                    mockResult: [
-                        {
-                            id: '1',
-                            data: { access_token: 'encrypted:secret1:iv:enckey' },
-                        },
-                        {
-                            id: '2',
-                            data: { access_token: 'encrypted:secret2:iv:enckey' },
-                        },
-                    ],
-                };
-
-                const results = await handlers.findMany({
-                    model: 'Credential',
-                    operation: 'findMany',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(results).toHaveLength(2);
-                expect(results[0].data.access_token).toBe('secret1');
-                expect(results[1].data.access_token).toBe('secret2');
-            });
-
-            it('should handle empty array', async () => {
-                const args = {
-                    mockResult: [],
-                };
-
-                const results = await handlers.findMany({
-                    model: 'Credential',
-                    operation: 'findMany',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(results).toEqual([]);
-            });
-        });
-
-        describe('delete', () => {
-            it('should decrypt deleted record', async () => {
-                const args = {
-                    where: { id: '1' },
-                    mockResult: {
-                        id: '1',
-                        data: { access_token: 'encrypted:secret:iv:enckey' },
-                    },
-                };
-
-                const result = await handlers.delete({
-                    model: 'Credential',
-                    operation: 'delete',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result.data.access_token).toBe('secret');
-            });
-        });
-
-        describe('count', () => {
-            it('should pass through without encryption', async () => {
-                const args = {
-                    mockResult: { count: 5 },
-                };
-
-                const result = await handlers.count({
-                    model: 'Credential',
-                    operation: 'count',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result).toEqual({ count: 5 });
-                expect(mockCryptor.encrypt).not.toHaveBeenCalled();
-                expect(mockCryptor.decrypt).not.toHaveBeenCalled();
-            });
-        });
-
-        describe('Model without encrypted fields', () => {
-            it('should pass through State model without encryption', async () => {
-                const args = {
-                    data: { state: { some: 'data' } },
-                    mockResult: { id: '1', state: { some: 'data' } },
-                };
-
-                const result = await handlers.create({
-                    model: 'State',
-                    operation: 'create',
-                    args,
-                    query: mockQuery,
-                });
-
-                expect(result.state).toEqual({ some: 'data' });
-                expect(mockCryptor.encrypt).not.toHaveBeenCalled();
-                expect(mockCryptor.decrypt).not.toHaveBeenCalled();
-            });
-        });
-    });
-
-    describe('Integration with FieldEncryptionService', () => {
-        it('should handle nested JSON paths correctly', async () => {
-            const extension = createEncryptionExtension({
-                cryptor: mockCryptor,
-                enabled: true,
-            });
-            const handlers = extension.query.$allModels;
-
-            const args = {
-                data: {
-                    id: '123',
-                    data: {
-                        access_token: 'secret',
-                        refresh_token: 'refresh',
-                        other: 'public',
-                    },
-                },
-                mockResult: {
-                    id: '123',
-                    data: {
-                        access_token: 'encrypted:secret:iv:enckey',
-                        refresh_token: 'encrypted:refresh:iv:enckey',
-                        other: 'public',
-                    },
-                },
-            };
-
-            const result = await handlers.create({
-                model: 'Credential',
-                operation: 'create',
-                args,
-                query: mockQuery,
-            });
-
-            // Verify encryption was called for encrypted fields
-            expect(mockCryptor.encrypt).toHaveBeenCalledWith('secret');
-            expect(mockCryptor.encrypt).toHaveBeenCalledWith('refresh');
-            // 'other' should not be encrypted
-
-            // Verify decryption in result
-            expect(result.data.access_token).toBe('secret');
-            expect(result.data.refresh_token).toBe('refresh');
-            expect(result.data.other).toBe('public');
-        });
-    });
-});

package/errors/base-error.test.js

@@ -1,32 +0,0 @@
-const { BaseError } = require('./base-error');
-
-describe('BaseError', () => {
-    it('can be inherited and instantiated', () => {
-        class XyzError extends BaseError {}
-        const error = new XyzError();
-        expect(error).toHaveProperty('message', '');
-        expect(error).toHaveProperty('stack');
-        expect(error.stack).toContain('XyzError');
-        expect(error.stack).toContain('at new XyzError');
-        expect(error.stack).toContain('base-error.test.js:');
-    });
-
-    it('can set the error message', () => {
-        class TestError extends BaseError {}
-        const error = new TestError('Goblins!');
-        expect(error).toHaveProperty('message', 'Goblins!');
-    });
-
-    it('sets the error name correctly', () => {
-        class TestError extends BaseError {}
-        const error = new TestError();
-        expect(error).toHaveProperty('name', 'TestError');
-    });
-
-    it('can set the parent cause', () => {
-        class TestError extends BaseError {}
-        const rootError = new Error('Davros!');
-        const error = new TestError('Daleks!', { cause: rootError });
-        expect(error).toHaveProperty('cause', rootError);
-    });
-});

package/errors/fetch-error.test.js

@@ -1,79 +0,0 @@
-const fetch = require('node-fetch');
-const { stripIndent } = require('common-tags');
-const { FetchError } = require('./fetch-error');
-const FormData = require('form-data');
-
-describe('FetchError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new FetchError();
-        expect(error).toHaveProperty('message');
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('can be created asynchronously with default values', async () => {
-        const error = await FetchError.create();
-        expect(error).toHaveProperty('message');
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('can be created asynchronously', async () => {
-        const resource = 'http://example.com';
-        const init = {};
-        const response = {
-            status: 500,
-            statusText: 'Space aliens!',
-            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
-            text: async () => '<!doctype html>',
-        };
-
-        const error = await FetchError.create({
-            resource,
-            init,
-            response,
-        });
-
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('GET http://example.com');
-        expect(error.message).toContain('500 Space aliens!');
-        expect(error.message).toContain('"cache-control": "123"');
-        expect(error.message).toContain('<!doctype html>');
-    });
-
-    it('can be passed an object for the body', async () => {
-        const error = new FetchError({ responseBody: { test: true } });
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('"test": true');
-    });
-
-    it('ignores response body if already streamed', async () => {
-        const response = { bodyUsed: true };
-        const error = await FetchError.create({ response });
-
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('<response body is unavailable>');
-    });
-
-    it.only('prints a formData body legibly', async () => {
-        const response = {
-            status: 500,
-            statusText: 'Space aliens!',
-            headers: Object.entries({ 'cache-control': '123' }), // needs to be an Iterable
-            text: async () => '<!doctype html>',
-        };
-
-        const params = new URLSearchParams();
-        params.append('test', 'test');
-        const init = {
-            method: 'POST',
-            credentials: 'include',
-            headers: {},
-            query: {},
-            body: params,
-            returnFullRes: false,
-        };
-        const error = await FetchError.create({ response, init });
-
-        expect(error).toHaveProperty('message');
-        expect(error.message).toContain('test=test');
-    });
-});

package/errors/halt-error.test.js

@@ -1,11 +0,0 @@
-const { HaltError } = require('./halt-error');
-
-describe('HaltError', () => {
-    it('can be instantiated', () => {
-        const rootError = new Error('Gremlinoids!!');
-        const error = new HaltError('STOP', { cause: rootError });
-        expect(error).toHaveProperty('message', 'STOP');
-        expect(error).toHaveProperty('cause', rootError);
-        expect(error).toHaveProperty('isHaltError', true);
-    });
-});

package/errors/validation-errors.test.js

@@ -1,120 +0,0 @@
-const {
-    RequiredPropertyError,
-    ParameterTypeError,
-} = require('./validation-errors');
-
-describe('RequiredPropertyError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new RequiredPropertyError();
-        expect(error).toHaveProperty(
-            'message',
-            'Key "" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the key name of the error', () => {
-        const error = new RequiredPropertyError({ key: 'abc' });
-        expect(error).toHaveProperty(
-            'message',
-            'Key "abc" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the parent of the error', () => {
-        const error = new RequiredPropertyError({ parent: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            '(Xyz) Key "" is a required parameter.'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('passes cause through to the Error parent class', () => {
-        const error = new RequiredPropertyError(
-            {
-                parent: class Qrs {},
-                key: 'def',
-            },
-            { cause: new Error('Gremlins!!') }
-        );
-        const expectedMessage = '(Qrs) Key "def" is a required parameter.';
-        expect(error).toHaveProperty('message', expectedMessage);
-        expect(error).toHaveProperty('cause');
-        expect(error.cause).toHaveProperty('message', 'Gremlins!!');
-    });
-});
-
-describe('ParameterTypeError', () => {
-    it('can be instantiated with default arguments', () => {
-        const error = new ParameterTypeError();
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the key name of the error', () => {
-        const error = new ParameterTypeError({ key: 'abc' });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected key "abc" with value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the parent of the error', () => {
-        const error = new ParameterTypeError({ parent: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            '(Xyz) Expected value "" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the value of the error', () => {
-        const error = new ParameterTypeError({ value: 1 });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "1" to be of type ""'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the expected type of the error', () => {
-        const error = new ParameterTypeError({ expectedType: class Xyz {} });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type "Xyz"'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('allows setting the expected type of the error to Array', () => {
-        const error = new ParameterTypeError({ expectedType: Array });
-        expect(error).toHaveProperty(
-            'message',
-            'Expected value "" to be of type "Array"'
-        );
-        expect(error).not.toHaveProperty('cause');
-    });
-
-    it('passes cause through to the Error parent class', () => {
-        const rootError = new Error('Gremlins!!');
-        const error = new ParameterTypeError(
-            {
-                parent: class Parent {},
-                key: 'clé',
-                expectedType: class Expected {},
-                value: 'schmalue',
-            },
-            { cause: rootError }
-        );
-        const expectedMessage =
-            '(Parent) Expected key "clé" with value "schmalue" to be of type "Expected"';
-        expect(error).toHaveProperty('message', expectedMessage);
-        expect(error).toHaveProperty('cause', rootError);
-    });
-});