@friggframework/devtools 2.0.0--canary.545.e256e95.0 → 2.0.0--canary.553.dc5f898.0

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

@@ -1,332 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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);
-        });
-    });
-});

package/frigg-cli/validate-command/__tests__/infrastructure/integration-class-validator.test.js

@@ -1,146 +0,0 @@
-const { IntegrationClassValidator } = require('../../infrastructure/validators/integration-class-validator');
-
-describe('IntegrationClassValidator', () => {
-    let validator;
-
-    beforeEach(() => {
-        validator = new IntegrationClassValidator();
-    });
-
-    describe('valid integration classes', () => {
-        it('validates class with Definition static property', () => {
-            class ValidIntegration {
-                static Definition = {
-                    name: 'test-integration',
-                    version: '1.0.0',
-                    modules: {}
-                };
-            }
-            const result = validator.validate(ValidIntegration, 0);
-            expect(result.isValid()).toBe(true);
-        });
-
-        it('validates class with modules configuration', () => {
-            class ValidIntegration {
-                static Definition = {
-                    name: 'oauth-integration',
-                    version: '1.0.0',
-                    modules: {
-                        hubspot: {
-                            definition: { moduleName: 'hubspot' },
-                            options: {}
-                        }
-                    }
-                };
-            }
-            const result = validator.validate(ValidIntegration, 0);
-            expect(result.isValid()).toBe(true);
-        });
-    });
-
-    describe('invalid integration classes', () => {
-        it('errors when not a function/class', () => {
-            const notAClass = { Definition: { name: 'test' } };
-            const result = validator.validate(notAClass, 0);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()[0].message).toContain('class');
-        });
-
-        it('errors when Definition is missing', () => {
-            class NoDefinition {}
-            const result = validator.validate(NoDefinition, 0);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()[0].path).toBe('integrations[0].Definition');
-        });
-
-        it('errors when Definition.name is missing', () => {
-            class MissingName {
-                static Definition = { version: '1.0.0' };
-            }
-            const result = validator.validate(MissingName, 0);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()[0].path).toBe('integrations[0].Definition');
-            expect(result.getErrors()[0].message).toContain('name');
-        });
-
-        it('errors when Definition.name is not a string', () => {
-            class BadName {
-                static Definition = { name: 123, version: '1.0.0' };
-            }
-            const result = validator.validate(BadName, 0);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors()[0].path).toBe('integrations[0].Definition.name');
-        });
-    });
-
-    describe('modules validation', () => {
-        it('errors when module lacks definition', () => {
-            class BadModule {
-                static Definition = {
-                    name: 'test',
-                    version: '1.0.0',
-                    modules: {
-                        hubspot: { options: {} }
-                    }
-                };
-            }
-            const result = validator.validate(BadModule, 0);
-            expect(result.isValid()).toBe(false);
-            expect(result.getErrors().some(e => e.path.includes('modules.hubspot') && e.message.includes('definition'))).toBe(true);
-        });
-
-        it('warns when module definition lacks moduleName', () => {
-            class ModuleNoModuleName {
-                static Definition = {
-                    name: 'test',
-                    version: '1.0.0',
-                    modules: {
-                        hubspot: {
-                            definition: {},
-                            options: {}
-                        }
-                    }
-                };
-            }
-            const result = validator.validate(ModuleNoModuleName, 0);
-            expect(result.getWarnings().some(w =>
-                w.code === 'MISSING_MODULE_NAME' && w.message.includes('moduleName')
-            )).toBe(true);
-        });
-    });
-
-    describe('lifecycle methods', () => {
-        it('warns when onCreate is not implemented', () => {
-            class NoOnCreate {
-                static Definition = { name: 'test-integration', version: '1.0.0' };
-            }
-            const result = validator.validate(NoOnCreate, 0);
-            expect(result.getWarnings().some(w => w.message.includes('onCreate'))).toBe(true);
-        });
-
-        it('passes when onCreate is implemented', () => {
-            class WithOnCreate {
-                static Definition = { name: 'test-integration', version: '1.0.0' };
-                async onCreate() {}
-            }
-            const result = validator.validate(WithOnCreate, 0);
-            expect(result.getWarnings().filter(w => w.message.includes('onCreate'))).toHaveLength(0);
-        });
-
-        it('warns when getConfigOptions is not implemented', () => {
-            class NoConfigOptions {
-                static Definition = { name: 'test-integration', version: '1.0.0' };
-            }
-            const result = validator.validate(NoConfigOptions, 0);
-            expect(result.getWarnings().some(w => w.message.includes('getConfigOptions'))).toBe(true);
-        });
-    });
-
-    describe('index parameter', () => {
-        it('includes correct index in error paths', () => {
-            class Invalid {}
-            const result = validator.validate(Invalid, 5);
-            expect(result.getErrors()[0].path).toContain('integrations[5]');
-        });
-    });
-});