@friggframework/devtools 2.0.0--canary.546.c17a357.0 → 2.0.0--canary.545.e7becd9.0

package/frigg-cli/__tests__/domain/entities/ApiModule.test.js

@@ -0,0 +1,373 @@
+const {ApiModule} = require('../../../domain/entities/ApiModule');
+const {DomainException} = require('../../../domain/exceptions/DomainException');
+
+describe('ApiModule Entity', () => {
+    describe('create()', () => {
+        test('successfully creates a new API module with required fields', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                displayName: 'Salesforce',
+                apiConfig: {
+                    baseUrl: 'https://api.salesforce.com',
+                    authType: 'oauth2',
+                    version: 'v1'
+                }
+            });
+
+            expect(apiModule.name).toBe('salesforce');
+            expect(apiModule.displayName).toBe('Salesforce');
+            expect(apiModule.apiConfig.baseUrl).toBe('https://api.salesforce.com');
+            expect(apiModule.apiConfig.authType).toBe('oauth2');
+            expect(apiModule.apiConfig.version).toBe('v1');
+            expect(apiModule.version.value).toBe('1.0.0');
+            expect(apiModule.entities).toEqual({});
+            expect(apiModule.scopes).toEqual([]);
+            expect(apiModule.credentials).toEqual([]);
+        });
+
+        test('generates displayName from name if not provided', () => {
+            const apiModule = ApiModule.create({
+                name: 'stripe-payment-api',
+                apiConfig: {authType: 'api-key'}
+            });
+
+            expect(apiModule.displayName).toBe('Stripe Payment Api');
+        });
+
+        test('accepts semantic version', () => {
+            const apiModule = ApiModule.create({
+                name: 'hubspot',
+                version: '2.5.0',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            expect(apiModule.version.value).toBe('2.5.0');
+        });
+
+        test('throws error when name is missing', () => {
+            expect(() => {
+                ApiModule.create({
+                    apiConfig: {authType: 'oauth2'}
+                });
+            }).toThrow(DomainException);
+        });
+
+        test('throws error when name is invalid', () => {
+            expect(() => {
+                ApiModule.create({
+                    name: 'Invalid Name!',
+                    apiConfig: {authType: 'oauth2'}
+                });
+            }).toThrow();
+        });
+
+        test('throws error when authType is missing', () => {
+            expect(() => {
+                ApiModule.create({
+                    name: 'salesforce',
+                    apiConfig: {}
+                });
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('addEntity()', () => {
+        test('successfully adds an entity', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEntity('account', {
+                label: 'Salesforce Account',
+                required: true,
+                fields: ['id', 'name', 'email']
+            });
+
+            expect(apiModule.hasEntity('account')).toBe(true);
+            expect(apiModule.entities.account.label).toBe('Salesforce Account');
+            expect(apiModule.entities.account.required).toBe(true);
+            expect(apiModule.entities.account.fields).toEqual(['id', 'name', 'email']);
+        });
+
+        test('generates label from entity name if not provided', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEntity('contact', {});
+
+            expect(apiModule.entities.contact.label).toBe('contact');
+        });
+
+        test('sets required to true by default', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEntity('lead', {});
+
+            expect(apiModule.entities.lead.required).toBe(true);
+        });
+
+        test('throws error when entity already exists', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEntity('account', {});
+
+            expect(() => {
+                apiModule.addEntity('account', {});
+            }).toThrow(DomainException);
+            expect(() => {
+                apiModule.addEntity('account', {});
+            }).toThrow("Entity 'account' already exists");
+        });
+    });
+
+    describe('addEndpoint()', () => {
+        test('successfully adds an endpoint', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEndpoint('getAccount', {
+                method: 'GET',
+                path: '/services/data/v1/accounts/:id',
+                description: 'Get account by ID'
+            });
+
+            expect(apiModule.hasEndpoint('getAccount')).toBe(true);
+            expect(apiModule.endpoints.getAccount.method).toBe('GET');
+            expect(apiModule.endpoints.getAccount.path).toBe('/services/data/v1/accounts/:id');
+        });
+
+        test('throws error when endpoint already exists', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addEndpoint('getAccount', {method: 'GET', path: '/accounts'});
+
+            expect(() => {
+                apiModule.addEndpoint('getAccount', {method: 'POST', path: '/accounts'});
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('addScope()', () => {
+        test('successfully adds a scope', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addScope('read:accounts');
+
+            expect(apiModule.scopes).toContain('read:accounts');
+        });
+
+        test('prevents duplicate scopes', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addScope('read:accounts');
+
+            expect(() => {
+                apiModule.addScope('read:accounts');
+            }).toThrow(DomainException);
+            expect(() => {
+                apiModule.addScope('read:accounts');
+            }).toThrow("Scope 'read:accounts' already exists");
+        });
+    });
+
+    describe('addCredential()', () => {
+        test('successfully adds a credential', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addCredential('clientId', {
+                type: 'string',
+                description: 'OAuth client ID',
+                required: true,
+                envVar: 'SALESFORCE_CLIENT_ID'
+            });
+
+            expect(apiModule.hasCredential('clientId')).toBe(true);
+            expect(apiModule.credentials[0].name).toBe('clientId');
+            expect(apiModule.credentials[0].type).toBe('string');
+            expect(apiModule.credentials[0].required).toBe(true);
+        });
+
+        test('sets required to true by default', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addCredential('apiKey', {type: 'string'});
+
+            expect(apiModule.credentials[0].required).toBe(true);
+        });
+
+        test('throws error when credential already exists', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            apiModule.addCredential('clientId', {type: 'string'});
+
+            expect(() => {
+                apiModule.addCredential('clientId', {type: 'string'});
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('validate()', () => {
+        test('validates successfully with required fields', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                displayName: 'Salesforce',
+                apiConfig: {
+                    authType: 'oauth2',
+                    baseUrl: 'https://api.salesforce.com'
+                }
+            });
+
+            const result = apiModule.validate();
+
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toEqual([]);
+        });
+
+        test('fails when displayName is empty', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+            apiModule.displayName = '';
+
+            const result = apiModule.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Display name is required');
+        });
+
+        test('fails when authType is missing', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+            apiModule.apiConfig.authType = '';
+
+            const result = apiModule.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('Authentication type is required');
+        });
+
+        test('fails when authType is invalid', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                apiConfig: {authType: 'oauth2'}
+            });
+            apiModule.apiConfig.authType = 'invalid-type';
+
+            const result = apiModule.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors[0]).toContain('Invalid auth type');
+        });
+    });
+
+    describe('toObject()', () => {
+        test('converts to plain object with all properties', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                displayName: 'Salesforce',
+                description: 'Salesforce CRM API',
+                version: '1.2.0',
+                apiConfig: {
+                    baseUrl: 'https://api.salesforce.com',
+                    authType: 'oauth2',
+                    version: 'v1'
+                }
+            });
+
+            apiModule.addEntity('account', {label: 'Account'});
+            apiModule.addScope('read:accounts');
+            apiModule.addCredential('clientId', {type: 'string'});
+
+            const obj = apiModule.toObject();
+
+            expect(obj.name).toBe('salesforce');
+            expect(obj.displayName).toBe('Salesforce');
+            expect(obj.description).toBe('Salesforce CRM API');
+            expect(obj.version).toBe('1.2.0');
+            expect(obj.apiConfig.authType).toBe('oauth2');
+            expect(obj.entities).toHaveProperty('account');
+            expect(obj.scopes).toContain('read:accounts');
+            expect(obj.credentials).toHaveLength(1);
+            expect(obj.createdAt).toBeInstanceOf(Date);
+            expect(obj.updatedAt).toBeInstanceOf(Date);
+        });
+    });
+
+    describe('toJSON()', () => {
+        test('converts to JSON format for api-module-definition.json', () => {
+            const apiModule = ApiModule.create({
+                name: 'salesforce',
+                displayName: 'Salesforce',
+                description: 'Salesforce CRM API',
+                version: '1.2.0',
+                apiConfig: {
+                    baseUrl: 'https://api.salesforce.com',
+                    authType: 'oauth2',
+                    version: 'v1'
+                }
+            });
+
+            const json = apiModule.toJSON();
+
+            expect(json.name).toBe('salesforce');
+            expect(json.version).toBe('1.2.0');
+            expect(json.display.name).toBe('Salesforce');
+            expect(json.display.description).toBe('Salesforce CRM API');
+            expect(json.api.authType).toBe('oauth2');
+        });
+    });
+
+    describe('fromObject()', () => {
+        test('reconstructs ApiModule from plain object', () => {
+            const originalModule = ApiModule.create({
+                name: 'salesforce',
+                displayName: 'Salesforce',
+                version: '1.0.0',
+                apiConfig: {authType: 'oauth2'}
+            });
+
+            originalModule.addEntity('account', {label: 'Account'});
+            originalModule.addScope('read:accounts');
+
+            const obj = originalModule.toObject();
+            const reconstructed = ApiModule.fromObject(obj);
+
+            expect(reconstructed.name).toBe('salesforce');
+            expect(reconstructed.displayName).toBe('Salesforce');
+            expect(reconstructed.hasEntity('account')).toBe(true);
+            expect(reconstructed.scopes).toContain('read:accounts');
+        });
+    });
+});

package/frigg-cli/__tests__/domain/entities/AppDefinition.test.js

@@ -0,0 +1,313 @@
+const {AppDefinition} = require('../../../domain/entities/AppDefinition');
+const {DomainException} = require('../../../domain/exceptions/DomainException');
+
+describe('AppDefinition', () => {
+    describe('create', () => {
+        test('creates app definition with minimal props', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            expect(appDef.name).toBe('my-app');
+            expect(appDef.version.value).toBe('1.0.0');
+            expect(appDef.integrations).toEqual([]);
+            expect(appDef.apiModules).toEqual([]);
+        });
+
+        test('creates app definition with full props', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0',
+                description: 'My application',
+                author: 'John Doe',
+                license: 'MIT',
+                repository: {url: 'https://github.com/user/repo'},
+                config: {feature1: true}
+            });
+
+            expect(appDef.description).toBe('My application');
+            expect(appDef.author).toBe('John Doe');
+            expect(appDef.license).toBe('MIT');
+            expect(appDef.repository.url).toBe('https://github.com/user/repo');
+            expect(appDef.config.feature1).toBe(true);
+        });
+    });
+
+    describe('registerIntegration', () => {
+        test('successfully registers new integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('salesforce-sync');
+
+            expect(appDef.hasIntegration('salesforce-sync')).toBe(true);
+            expect(appDef.integrations).toHaveLength(1);
+            expect(appDef.integrations[0].name).toBe('salesforce-sync');
+            expect(appDef.integrations[0].enabled).toBe(true);
+        });
+
+        test('throws error when registering duplicate integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('salesforce-sync');
+
+            expect(() => {
+                appDef.registerIntegration('salesforce-sync');
+            }).toThrow(DomainException);
+            expect(() => {
+                appDef.registerIntegration('salesforce-sync');
+            }).toThrow("already registered");
+        });
+
+        test('updates updatedAt timestamp', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            const beforeTime = appDef.updatedAt.getTime();
+            appDef.registerIntegration('test-integration');
+            const afterTime = appDef.updatedAt.getTime();
+
+            expect(afterTime).toBeGreaterThanOrEqual(beforeTime);
+        });
+    });
+
+    describe('unregisterIntegration', () => {
+        test('successfully unregisters integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('salesforce-sync');
+            appDef.unregisterIntegration('salesforce-sync');
+
+            expect(appDef.hasIntegration('salesforce-sync')).toBe(false);
+            expect(appDef.integrations).toHaveLength(0);
+        });
+
+        test('throws error when unregistering non-existent integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            expect(() => {
+                appDef.unregisterIntegration('non-existent');
+            }).toThrow(DomainException);
+            expect(() => {
+                appDef.unregisterIntegration('non-existent');
+            }).toThrow("not registered");
+        });
+    });
+
+    describe('hasIntegration', () => {
+        test('returns true for registered integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('test-integration');
+
+            expect(appDef.hasIntegration('test-integration')).toBe(true);
+        });
+
+        test('returns false for unregistered integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            expect(appDef.hasIntegration('non-existent')).toBe(false);
+        });
+    });
+
+    describe('enableIntegration', () => {
+        test('enables integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('test-integration');
+            appDef.disableIntegration('test-integration');
+            appDef.enableIntegration('test-integration');
+
+            const integration = appDef.integrations.find(i => i.name === 'test-integration');
+            expect(integration.enabled).toBe(true);
+        });
+
+        test('throws error for non-existent integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            expect(() => {
+                appDef.enableIntegration('non-existent');
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('disableIntegration', () => {
+        test('disables integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('test-integration');
+            appDef.disableIntegration('test-integration');
+
+            const integration = appDef.integrations.find(i => i.name === 'test-integration');
+            expect(integration.enabled).toBe(false);
+        });
+
+        test('throws error for non-existent integration', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            expect(() => {
+                appDef.disableIntegration('non-existent');
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('registerApiModule', () => {
+        test('registers new API module', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerApiModule('salesforce', '2.0.0', 'npm');
+
+            expect(appDef.hasApiModule('salesforce')).toBe(true);
+            expect(appDef.apiModules).toHaveLength(1);
+            expect(appDef.apiModules[0].name).toBe('salesforce');
+            expect(appDef.apiModules[0].version).toBe('2.0.0');
+            expect(appDef.apiModules[0].source).toBe('npm');
+        });
+
+        test('throws error for duplicate API module', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerApiModule('salesforce', '2.0.0');
+
+            expect(() => {
+                appDef.registerApiModule('salesforce', '3.0.0');
+            }).toThrow(DomainException);
+        });
+    });
+
+    describe('getEnabledIntegrations', () => {
+        test('returns only enabled integrations', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0'
+            });
+
+            appDef.registerIntegration('integration1');
+            appDef.registerIntegration('integration2');
+            appDef.registerIntegration('integration3');
+            appDef.disableIntegration('integration2');
+
+            const enabled = appDef.getEnabledIntegrations();
+
+            expect(enabled).toHaveLength(2);
+            expect(enabled.map(i => i.name)).toContain('integration1');
+            expect(enabled.map(i => i.name)).toContain('integration3');
+            expect(enabled.map(i => i.name)).not.toContain('integration2');
+        });
+    });
+
+    describe('validate', () => {
+        test('passes for valid app definition', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0',
+                description: 'A valid app'
+            });
+
+            const result = appDef.validate();
+
+            expect(result.isValid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+
+        test('fails when name is missing', () => {
+            const appDef = AppDefinition.create({
+                name: '',
+                version: '1.0.0'
+            });
+
+            const result = appDef.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors).toContain('App name is required');
+        });
+
+        test('fails when name is too long', () => {
+            const appDef = AppDefinition.create({
+                name: 'a'.repeat(101),
+                version: '1.0.0'
+            });
+
+            const result = appDef.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors.some(e => e.includes('100 characters or less'))).toBe(true);
+        });
+
+        test('fails when description is too long', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0',
+                description: 'a'.repeat(1001)
+            });
+
+            const result = appDef.validate();
+
+            expect(result.isValid).toBe(false);
+            expect(result.errors.some(e => e.includes('1000 characters or less'))).toBe(true);
+        });
+    });
+
+    describe('toJSON', () => {
+        test('converts to JSON format', () => {
+            const appDef = AppDefinition.create({
+                name: 'my-app',
+                version: '1.0.0',
+                description: 'Test app',
+                author: 'John Doe'
+            });
+
+            appDef.registerIntegration('test-integration');
+            appDef.registerApiModule('salesforce', '2.0.0', 'npm');
+
+            const json = appDef.toJSON();
+
+            expect(json.name).toBe('my-app');
+            expect(json.version).toBe('1.0.0');
+            expect(json.description).toBe('Test app');
+            expect(json.author).toBe('John Doe');
+            expect(json.integrations).toHaveLength(1);
+            expect(json.integrations[0].name).toBe('test-integration');
+            expect(json.apiModules).toHaveLength(1);
+            expect(json.apiModules[0].name).toBe('salesforce');
+        });
+    });
+});