@friggframework/devtools 2.0.0--canary.546.74db90f.0 → 2.0.0--canary.545.e7becd9.0

package/frigg-cli/validate-command/__tests__/domain/validation-result.test.js

@@ -0,0 +1,152 @@
+const { ValidationResult } = require('../../domain/entities/validation-result');
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
+
+describe('ValidationResult', () => {
+    describe('creation', () => {
+        it('creates empty result with no errors', () => {
+            const result = ValidationResult.create();
+            expect(result.isValid()).toBe(true);
+            expect(result.getErrors()).toHaveLength(0);
+            expect(result.getWarnings()).toHaveLength(0);
+        });
+
+        it('creates result with errors', () => {
+            const error = ValidationError.create({
+                path: 'integrations[0].name',
+                message: 'Integration name is required',
+                severity: 'error'
+            });
+            const result = ValidationResult.create({ errors: [error] });
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()).toHaveLength(1);
+        });
+
+        it('creates result with warnings', () => {
+            const warning = ValidationError.create({
+                path: 'config.timeout',
+                message: 'Timeout value is unusually high',
+                severity: 'warning'
+            });
+            const result = ValidationResult.create({ errors: [warning] });
+            expect(result.isValid()).toBe(true);
+            expect(result.getWarnings()).toHaveLength(1);
+        });
+    });
+
+    describe('addError', () => {
+        it('adds error to result', () => {
+            const result = ValidationResult.create();
+            const error = ValidationError.create({
+                path: 'name',
+                message: 'Name is required',
+                severity: 'error'
+            });
+            result.addError(error);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()).toContain(error);
+        });
+
+        it('adds warning without affecting validity', () => {
+            const result = ValidationResult.create();
+            const warning = ValidationError.create({
+                path: 'description',
+                message: 'Description is recommended',
+                severity: 'warning'
+            });
+            result.addError(warning);
+            expect(result.isValid()).toBe(true);
+            expect(result.getWarnings()).toContain(warning);
+        });
+    });
+
+    describe('merge', () => {
+        it('merges two valid results', () => {
+            const result1 = ValidationResult.create();
+            const result2 = ValidationResult.create();
+            const merged = result1.merge(result2);
+            expect(merged.isValid()).toBe(true);
+        });
+
+        it('merges results with errors', () => {
+            const error1 = ValidationError.create({
+                path: 'name',
+                message: 'Name required',
+                severity: 'error'
+            });
+            const error2 = ValidationError.create({
+                path: 'version',
+                message: 'Version required',
+                severity: 'error'
+            });
+            const result1 = ValidationResult.create({ errors: [error1] });
+            const result2 = ValidationResult.create({ errors: [error2] });
+            const merged = result1.merge(result2);
+            expect(merged.isValid()).toBe(false);
+            expect(merged.getErrors()).toHaveLength(2);
+        });
+
+        it('preserves context from both results', () => {
+            const result1 = ValidationResult.create({ context: { file: 'index.js' } });
+            const result2 = ValidationResult.create({ context: { integration: 'oauth' } });
+            const merged = result1.merge(result2);
+            expect(merged.getContext()).toMatchObject({ file: 'index.js', integration: 'oauth' });
+        });
+    });
+
+    describe('filtering', () => {
+        it('filters errors by path prefix', () => {
+            const errors = [
+                ValidationError.create({ path: 'integrations[0].name', message: 'a', severity: 'error' }),
+                ValidationError.create({ path: 'integrations[1].config', message: 'b', severity: 'error' }),
+                ValidationError.create({ path: 'database.uri', message: 'c', severity: 'error' })
+            ];
+            const result = ValidationResult.create({ errors });
+            const filtered = result.filterByPath('integrations');
+            expect(filtered.getErrors()).toHaveLength(2);
+        });
+
+        it('filters by severity', () => {
+            const errors = [
+                ValidationError.create({ path: 'a', message: 'error1', severity: 'error' }),
+                ValidationError.create({ path: 'b', message: 'warning1', severity: 'warning' }),
+                ValidationError.create({ path: 'c', message: 'info1', severity: 'info' })
+            ];
+            const result = ValidationResult.create({ errors });
+            expect(result.getBySeverity('error')).toHaveLength(1);
+            expect(result.getBySeverity('warning')).toHaveLength(1);
+            expect(result.getBySeverity('info')).toHaveLength(1);
+        });
+    });
+
+    describe('summary', () => {
+        it('generates summary statistics', () => {
+            const errors = [
+                ValidationError.create({ path: 'a', message: 'm1', severity: 'error' }),
+                ValidationError.create({ path: 'b', message: 'm2', severity: 'error' }),
+                ValidationError.create({ path: 'c', message: 'm3', severity: 'warning' })
+            ];
+            const result = ValidationResult.create({ errors });
+            const summary = result.getSummary();
+            expect(summary.errorCount).toBe(2);
+            expect(summary.warningCount).toBe(1);
+            expect(summary.isValid).toBe(false);
+        });
+    });
+
+    describe('serialization', () => {
+        it('converts to JSON', () => {
+            const error = ValidationError.create({
+                path: 'name',
+                message: 'Required',
+                severity: 'error',
+                fix: FixSuggestion.create({ action: 'add', description: 'Add name field' })
+            });
+            const result = ValidationResult.create({ errors: [error] });
+            const json = result.toJSON();
+            expect(json).toHaveProperty('valid', false);
+            expect(json).toHaveProperty('errors');
+            expect(json.errors[0]).toHaveProperty('path', 'name');
+        });
+    });
+});

package/frigg-cli/validate-command/__tests__/infrastructure/api-module-validator.test.js

@@ -0,0 +1,332 @@
+const { ApiModuleValidator } = require('../../infrastructure/validators/api-module-validator');
+
+describe('ApiModuleValidator', () => {
+    let validator;
+
+    beforeEach(() => {
+        validator = new ApiModuleValidator();
+    });
+
+    describe('valid modules', () => {
+        it('validates integration with no modules', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0'
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(true);
+            expect(result.getErrors()).toHaveLength(0);
+        });
+
+        it('validates integration with valid module definition', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    hubspot: {
+                        definition: {
+                            moduleName: 'hubspot',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function', async: true },
+                                getCredentialDetails: { type: 'function', async: true },
+                                getEntityDetails: { type: 'function', async: true },
+                                apiPropertiesToPersist: {
+                                    credential: ['access_token', 'refresh_token'],
+                                    entity: ['external_id', 'name']
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('validates module with actual functions (not descriptors)', () => {
+            // Real-world API modules have actual functions, not {type: "function"} descriptors
+            // The validator should sanitize these before JSON Schema validation
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    xero: {
+                        definition: {
+                            moduleName: 'xero',
+                            getName: function() { return 'Xero'; },
+                            API: class XeroApi {},
+                            requiredAuthMethods: {
+                                getToken: async function() { return {}; },
+                                getCredentialDetails: async function() { return {}; },
+                                getEntityDetails: async function() { return {}; },
+                                apiPropertiesToPersist: {
+                                    credential: ['access_token', 'refresh_token'],
+                                    entity: ['tenant_id', 'name']
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            // Should not have errors about "must be object" for functions
+            const typeErrors = result.getErrors().filter(e =>
+                e.message.includes('must be object') ||
+                e.message.includes('must be Object')
+            );
+            expect(typeErrors).toHaveLength(0);
+        });
+
+
+        it('validates multiple modules', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    source: {
+                        definition: {
+                            moduleName: 'source-api',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function', async: true },
+                                getCredentialDetails: { type: 'function', async: true },
+                                getEntityDetails: { type: 'function', async: true },
+                                apiPropertiesToPersist: {
+                                    credential: ['token'],
+                                    entity: ['id']
+                                }
+                            }
+                        }
+                    },
+                    target: {
+                        definition: {
+                            moduleName: 'target-api',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function', async: true },
+                                getCredentialDetails: { type: 'function', async: true },
+                                getEntityDetails: { type: 'function', async: true },
+                                apiPropertiesToPersist: {
+                                    credential: ['api_key'],
+                                    entity: ['external_id']
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(true);
+        });
+    });
+
+    describe('missing definition', () => {
+        it('errors when module lacks definition property', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    hubspot: {
+                        // missing definition
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e => e.code === 'MISSING_DEFINITION')).toBe(true);
+        });
+    });
+
+    describe('schema validation', () => {
+        it('errors when moduleName is missing', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    hubspot: {
+                        definition: {
+                            // missing moduleName
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {}
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e =>
+                e.path.includes('definition') && e.message.includes('moduleName')
+            )).toBe(true);
+        });
+
+        it('errors when moduleName has invalid pattern', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    test: {
+                        definition: {
+                            moduleName: '123-invalid', // must start with letter
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {}
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.isValid()).toBe(false);
+        });
+    });
+
+    describe('method validation', () => {
+        it('warns when getToken is missing', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    test: {
+                        definition: {
+                            moduleName: 'test-module',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getCredentialDetails: { type: 'function' },
+                                getEntityDetails: { type: 'function' }
+                                // missing getToken
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            const warnings = result.getWarnings();
+            expect(warnings.some(w =>
+                w.code === 'MISSING_METHOD' && w.message.includes('getToken')
+            )).toBe(true);
+        });
+
+        it('warns when getEntityDetails is missing', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    test: {
+                        definition: {
+                            moduleName: 'test-module',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function' },
+                                getCredentialDetails: { type: 'function' }
+                                // missing getEntityDetails
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            const warnings = result.getWarnings();
+            expect(warnings.some(w =>
+                w.code === 'MISSING_METHOD' && w.message.includes('getEntityDetails')
+            )).toBe(true);
+        });
+    });
+
+    describe('apiPropertiesToPersist validation', () => {
+        it('warns when credential properties are missing', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    test: {
+                        definition: {
+                            moduleName: 'test-module',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function' },
+                                getCredentialDetails: { type: 'function' },
+                                getEntityDetails: { type: 'function' },
+                                apiPropertiesToPersist: {
+                                    credential: [], // empty
+                                    entity: ['external_id']
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            const warnings = result.getWarnings();
+            expect(warnings.some(w => w.code === 'MISSING_CREDENTIAL_PROPS')).toBe(true);
+        });
+
+        it('warns when entity properties are missing', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    test: {
+                        definition: {
+                            moduleName: 'test-module',
+                            getName: { type: 'function' },
+                            requiredAuthMethods: {
+                                getToken: { type: 'function' },
+                                getCredentialDetails: { type: 'function' },
+                                getEntityDetails: { type: 'function' },
+                                apiPropertiesToPersist: {
+                                    credential: ['access_token'],
+                                    entity: [] // empty
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 0);
+            const warnings = result.getWarnings();
+            expect(warnings.some(w => w.code === 'MISSING_ENTITY_PROPS')).toBe(true);
+        });
+    });
+
+    describe('path formatting', () => {
+        it('includes correct path prefix for errors', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0',
+                modules: {
+                    myModule: {
+                        definition: {
+                            // missing required fields
+                        }
+                    }
+                }
+            };
+
+            const result = validator.validate(definition, 2);
+            const errors = result.getErrors();
+            expect(errors[0].path).toContain('integrations[2].Definition.modules.myModule');
+        });
+    });
+
+    describe('result type', () => {
+        it('returns ValidationResult instance', () => {
+            const definition = {
+                name: 'test-integration',
+                version: '1.0.0'
+            };
+
+            const result = validator.validate(definition, 0);
+            expect(result.constructor.name).toBe('ValidationResult');
+        });
+    });
+});

package/frigg-cli/validate-command/__tests__/infrastructure/app-definition-validator.test.js

@@ -0,0 +1,191 @@
+const { AppDefinitionValidator } = require('../../infrastructure/validators/app-definition-validator');
+const { ValidationResult } = require('../../domain/entities/validation-result');
+
+describe('AppDefinitionValidator', () => {
+    let validator;
+
+    beforeEach(() => {
+        validator = new AppDefinitionValidator();
+    });
+
+    describe('valid definitions', () => {
+        it('validates minimal valid definition', () => {
+            const definition = {
+                integrations: []
+            };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('validates definition with database config', () => {
+            const definition = {
+                integrations: [],
+                database: { mongoDB: { enable: true } }
+            };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('validates definition with integration objects', () => {
+            const definition = {
+                integrations: [{ Definition: { name: 'test-integration' } }]
+            };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(true);
+        });
+
+        it('validates definition with integration classes (functions)', () => {
+            // This tests that integration classes are properly sanitized
+            // before JSON Schema validation (classes become stub objects)
+            class MyIntegration {
+                static Definition = {
+                    name: 'my-integration',
+                    version: '1.0.0'
+                };
+            }
+            const definition = {
+                integrations: [MyIntegration]
+            };
+            const result = validator.validate(definition);
+            // Should not have schema errors about "must be object"
+            const schemaErrors = result.getErrors().filter(e =>
+                e.message.includes('must be object') ||
+                e.message.includes('must be Object')
+            );
+            expect(schemaErrors).toHaveLength(0);
+        });
+
+        it('validates definition with multiple integration classes', () => {
+            class IntegrationA {
+                static Definition = { name: 'integration-a', version: '1.0.0' };
+            }
+            class IntegrationB {
+                static Definition = { name: 'integration-b', version: '1.0.0' };
+            }
+            const definition = {
+                integrations: [IntegrationA, IntegrationB]
+            };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(true);
+        });
+    });
+
+    describe('integrations validation', () => {
+        it('errors when integrations is not an array', () => {
+            const definition = { integrations: 'not-an-array' };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors()[0].path).toBe('integrations');
+        });
+
+        it('errors when integrations is missing', () => {
+            const definition = {};
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e => e.message.includes('integrations'))).toBe(true);
+        });
+
+        it('errors when integration lacks Definition property', () => {
+            const BadIntegration = class {};
+            const definition = { integrations: [BadIntegration] };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e => e.path === 'integrations[0]' && e.message.includes('Definition'))).toBe(true);
+        });
+
+        it('errors when integration Definition lacks name', () => {
+            const BadIntegration = class {
+                static Definition = {};
+            };
+            const definition = { integrations: [BadIntegration] };
+            const result = validator.validate(definition);
+            expect(result.isValid()).toBe(false);
+            expect(result.getErrors().some(e => e.path.includes('integrations[0]') && e.message.includes('name'))).toBe(true);
+        });
+
+        it('warns on duplicate integration names', () => {
+            const Int1 = class { static Definition = { name: 'same-name', version: '1.0.0' }; };
+            const Int2 = class { static Definition = { name: 'same-name', version: '1.0.0' }; };
+            const definition = { integrations: [Int1, Int2] };
+            const result = validator.validate(definition);
+            expect(result.getWarnings().some(w => w.message.includes('duplicate'))).toBe(true);
+        });
+    });
+
+    describe('database validation', () => {
+        it('validates mongoDB configuration', () => {
+            const definition = {
+                integrations: [],
+                database: { mongoDB: { enable: true } }
+            };
+            const result = validator.validate(definition);
+            const dbErrors = result.getErrors().filter(e => e.path.startsWith('database'));
+            expect(dbErrors).toHaveLength(0);
+        });
+
+        it('validates postgres configuration', () => {
+            const definition = {
+                integrations: [],
+                database: { postgres: { enable: true } }
+            };
+            const result = validator.validate(definition);
+            const dbErrors = result.getErrors().filter(e => e.path.startsWith('database'));
+            expect(dbErrors).toHaveLength(0);
+        });
+
+        it('validates documentDB configuration', () => {
+            const definition = {
+                integrations: [],
+                database: { documentDB: { enable: true } }
+            };
+            const result = validator.validate(definition);
+            const dbErrors = result.getErrors().filter(e => e.path.startsWith('database'));
+            expect(dbErrors).toHaveLength(0);
+        });
+    });
+
+    describe('user configuration', () => {
+        it('validates user with password enabled', () => {
+            const definition = {
+                integrations: [],
+                user: { usePassword: true }
+            };
+            const result = validator.validate(definition);
+            const userErrors = result.getErrors().filter(e => e.path.startsWith('user'));
+            expect(userErrors).toHaveLength(0);
+        });
+
+        it('validates user with custom model object', () => {
+            const definition = {
+                integrations: [],
+                user: { model: { name: 'CustomUserModel' } }
+            };
+            const result = validator.validate(definition);
+            const userErrors = result.getErrors().filter(e => e.path.startsWith('user'));
+            expect(userErrors).toHaveLength(0);
+        });
+
+        it('validates user authModes configuration', () => {
+            const definition = {
+                integrations: [],
+                user: {
+                    authModes: {
+                        friggToken: true,
+                        sharedSecret: true
+                    }
+                }
+            };
+            const result = validator.validate(definition);
+            const userErrors = result.getErrors().filter(e => e.path.startsWith('user'));
+            expect(userErrors).toHaveLength(0);
+        });
+    });
+
+    describe('result type', () => {
+        it('returns ValidationResult instance', () => {
+            const definition = { integrations: [] };
+            const result = validator.validate(definition);
+            expect(result).toBeInstanceOf(ValidationResult);
+        });
+    });
+});