@friggframework/devtools 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.21b69ac.0

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

@@ -1,181 +0,0 @@
-const { validateApiModuleDefinition } = require('@friggframework/schemas');
-const { ValidationResult } = require('../../domain/entities/validation-result');
-const { ValidationError } = require('../../domain/value-objects/validation-error');
-
-const REQUIRED_MODULE_METHODS = ['getToken', 'getEntityDetails', 'getCredentialDetails'];
-
-class ApiModuleValidator {
-    /**
-     * Validate API module definitions within an integration
-     * @param {object} integrationDefinition - The integration's Definition object
-     * @param {number} integrationIndex - Index of the integration in the app
-     * @returns {ValidationResult}
-     */
-    validate(integrationDefinition, integrationIndex) {
-        const result = ValidationResult.create();
-        const prefix = `integrations[${integrationIndex}].Definition.modules`;
-
-        if (!integrationDefinition.modules || typeof integrationDefinition.modules !== 'object') {
-            return result;
-        }
-
-        Object.entries(integrationDefinition.modules).forEach(([moduleName, moduleConfig]) => {
-            const modulePath = `${prefix}.${moduleName}`;
-
-            if (!moduleConfig.definition) {
-                result.addError(ValidationError.create({
-                    path: `${modulePath}.definition`,
-                    message: `Module '${moduleName}' must have a definition property`,
-                    severity: 'error',
-                    code: 'MISSING_DEFINITION'
-                }));
-                return;
-            }
-
-            this._validateModuleDefinitionWithSchema(moduleConfig.definition, modulePath, moduleName, result);
-            this._validateRequiredMethods(moduleConfig.definition, modulePath, moduleName, result);
-            this._validateApiPropertiesToPersist(moduleConfig.definition, modulePath, moduleName, result);
-        });
-
-        return result;
-    }
-
-    _validateModuleDefinitionWithSchema(definition, modulePath, moduleName, result) {
-        // Sanitize the definition before JSON Schema validation
-        // API module definitions contain functions and classes that JSON Schema can't validate
-        const sanitizedDefinition = this._sanitizeForSchemaValidation(definition);
-        const schemaResult = validateApiModuleDefinition(sanitizedDefinition);
-
-        if (!schemaResult.valid && schemaResult.errors) {
-            schemaResult.errors.forEach(error => {
-                const path = error.instancePath
-                    ? `${modulePath}.definition${error.instancePath.replace(/\//g, '.')}`
-                    : `${modulePath}.definition`;
-
-                result.addError(ValidationError.create({
-                    path,
-                    message: this._formatSchemaErrorMessage(error),
-                    severity: 'error',
-                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
-                }));
-            });
-        }
-    }
-
-    /**
-     * Create a copy of the module definition safe for JSON Schema validation.
-     * Converts functions to descriptors but preserves all properties so that
-     * unknown properties can be properly rejected by the schema.
-     */
-    _sanitizeForSchemaValidation(definition) {
-        if (!definition) return definition;
-
-        const sanitized = {};
-
-        // Copy ALL properties, converting functions/classes to descriptors
-        // This allows JSON Schema to properly reject unknown properties
-        for (const key of Object.keys(definition)) {
-            sanitized[key] = this._sanitizeValue(definition[key]);
-        }
-
-        return sanitized;
-    }
-
-    /**
-     * Recursively sanitize a value for JSON Schema validation.
-     * Functions become {type: "function"} descriptors.
-     * Classes become {type: "object"} descriptors.
-     */
-    _sanitizeValue(value) {
-        if (value === null || value === undefined) {
-            return value;
-        }
-
-        // Convert functions to descriptors
-        if (typeof value === 'function') {
-            return { type: 'function', name: value.name || 'anonymous' };
-        }
-
-        // Handle arrays
-        if (Array.isArray(value)) {
-            return value.map(item => this._sanitizeValue(item));
-        }
-
-        // Handle objects (but not class instances with constructors other than Object)
-        if (typeof value === 'object') {
-            // Check if it's a class instance (not a plain object)
-            if (value.constructor && value.constructor.name !== 'Object') {
-                return { type: 'object', className: value.constructor.name };
-            }
-
-            // Recursively sanitize plain objects
-            const sanitizedObj = {};
-            for (const [key, val] of Object.entries(value)) {
-                sanitizedObj[key] = this._sanitizeValue(val);
-            }
-            return sanitizedObj;
-        }
-
-        // Primitives pass through unchanged
-        return value;
-    }
-
-    _formatSchemaErrorMessage(error) {
-        let message = error.message;
-        if (error.params?.allowedValues) {
-            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
-        }
-        if (error.params?.additionalProperty) {
-            message += `: ${error.params.additionalProperty}`;
-        }
-        if (error.params?.missingProperty) {
-            message = `must have required property '${error.params.missingProperty}'`;
-        }
-        return message;
-    }
-
-    _validateRequiredMethods(definition, modulePath, moduleName, result) {
-        if (!definition.requiredAuthMethods) {
-            return;
-        }
-
-        REQUIRED_MODULE_METHODS.forEach(method => {
-            if (!definition.requiredAuthMethods[method]) {
-                result.addError(ValidationError.create({
-                    path: `${modulePath}.definition.requiredAuthMethods.${method}`,
-                    message: `Module '${moduleName}' should implement ${method} method`,
-                    severity: 'warning',
-                    code: 'MISSING_METHOD'
-                }));
-            }
-        });
-    }
-
-    _validateApiPropertiesToPersist(definition, modulePath, moduleName, result) {
-        const props = definition.requiredAuthMethods?.apiPropertiesToPersist;
-
-        if (!props) {
-            return;
-        }
-
-        if (!props.credential || !Array.isArray(props.credential) || props.credential.length === 0) {
-            result.addError(ValidationError.create({
-                path: `${modulePath}.definition.requiredAuthMethods.apiPropertiesToPersist.credential`,
-                message: `Module '${moduleName}' should specify credential properties to persist`,
-                severity: 'warning',
-                code: 'MISSING_CREDENTIAL_PROPS'
-            }));
-        }
-
-        if (!props.entity || !Array.isArray(props.entity) || props.entity.length === 0) {
-            result.addError(ValidationError.create({
-                path: `${modulePath}.definition.requiredAuthMethods.apiPropertiesToPersist.entity`,
-                message: `Module '${moduleName}' should specify entity properties to persist`,
-                severity: 'warning',
-                code: 'MISSING_ENTITY_PROPS'
-            }));
-        }
-    }
-}
-
-module.exports = { ApiModuleValidator };

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

@@ -1,128 +0,0 @@
-const { validateAppDefinition } = require('@friggframework/schemas');
-const { ValidationResult } = require('../../domain/entities/validation-result');
-const { ValidationError } = require('../../domain/value-objects/validation-error');
-
-class AppDefinitionValidator {
-    validate(definition) {
-        const result = ValidationResult.create();
-
-        // Create a sanitized copy for JSON Schema validation
-        // Integrations contain classes/functions which JSON Schema can't validate
-        // IntegrationClassValidator handles those separately
-        const sanitizedDefinition = this._sanitizeForSchemaValidation(definition);
-        const schemaResult = validateAppDefinition(sanitizedDefinition);
-
-        if (!schemaResult.valid && schemaResult.errors) {
-            schemaResult.errors.forEach(error => {
-                result.addError(ValidationError.create({
-                    path: this._convertPath(error.instancePath) || 'root',
-                    message: this._formatErrorMessage(error),
-                    severity: 'error',
-                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
-                }));
-            });
-        }
-
-        this._validateIntegrationDuplicates(definition, result);
-        this._validateIntegrationDefinitions(definition, result);
-
-        return result;
-    }
-
-    /**
-     * Create a copy of the definition safe for JSON Schema validation.
-     * Replaces integration classes with stub objects since JSON Schema
-     * cannot validate JavaScript classes/functions.
-     */
-    _sanitizeForSchemaValidation(definition) {
-        if (!definition) return definition;
-
-        const sanitized = { ...definition };
-
-        // Replace integration classes with stub objects
-        // The actual class validation is handled by IntegrationClassValidator
-        if (Array.isArray(definition.integrations)) {
-            sanitized.integrations = definition.integrations.map(integration => {
-                if (typeof integration === 'function') {
-                    // Return a stub object representing the class
-                    return { _isClass: true, name: integration.name };
-                }
-                return integration;
-            });
-        }
-
-        return sanitized;
-    }
-
-    _convertPath(jsonPointerPath) {
-        if (!jsonPointerPath) return '';
-        return jsonPointerPath
-            .replace(/^\//, '')
-            .replace(/\/(\d+)/g, '[$1]')
-            .replace(/\//g, '.');
-    }
-
-    _formatErrorMessage(error) {
-        let message = error.message;
-        if (error.params?.allowedValues) {
-            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
-        }
-        if (error.params?.additionalProperty) {
-            message += `: ${error.params.additionalProperty}`;
-        }
-        if (error.params?.missingProperty) {
-            message = `must have required property '${error.params.missingProperty}'`;
-        }
-        return message;
-    }
-
-    _validateIntegrationDefinitions(definition, result) {
-        if (!definition.integrations || !Array.isArray(definition.integrations)) {
-            return;
-        }
-
-        definition.integrations.forEach((integration, index) => {
-            if (typeof integration === 'function') {
-                if (!integration.Definition) {
-                    result.addError(ValidationError.create({
-                        path: `integrations[${index}]`,
-                        message: 'Integration class must have a static Definition property',
-                        severity: 'error',
-                        code: 'MISSING_DEFINITION'
-                    }));
-                } else if (!integration.Definition.name) {
-                    result.addError(ValidationError.create({
-                        path: `integrations[${index}].Definition.name`,
-                        message: 'Integration Definition must have a name property',
-                        severity: 'error',
-                        code: 'REQUIRED_FIELD'
-                    }));
-                }
-            }
-        });
-    }
-
-    _validateIntegrationDuplicates(definition, result) {
-        if (!definition.integrations || !Array.isArray(definition.integrations)) {
-            return;
-        }
-
-        const names = [];
-        definition.integrations.forEach((integration, index) => {
-            const name = integration.Definition?.name;
-            if (name) {
-                if (names.includes(name)) {
-                    result.addError(ValidationError.create({
-                        path: `integrations[${index}].Definition.name`,
-                        message: `duplicate integration name: ${name}`,
-                        severity: 'warning',
-                        code: 'DUPLICATE_NAME'
-                    }));
-                }
-                names.push(name);
-            }
-        });
-    }
-}
-
-module.exports = { AppDefinitionValidator };

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

@@ -1,113 +0,0 @@
-const { validateIntegrationDefinition } = require('@friggframework/schemas');
-const { ValidationResult } = require('../../domain/entities/validation-result');
-const { ValidationError } = require('../../domain/value-objects/validation-error');
-const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
-
-const LIFECYCLE_METHODS = ['onCreate', 'getConfigOptions', 'testAuth'];
-
-class IntegrationClassValidator {
-    validate(integrationClass, index) {
-        const result = ValidationResult.create();
-        const prefix = `integrations[${index}]`;
-
-        if (typeof integrationClass !== 'function') {
-            result.addError(ValidationError.create({
-                path: prefix,
-                message: 'Integration must be a class (function)',
-                severity: 'error',
-                code: 'INVALID_TYPE'
-            }));
-            return result;
-        }
-
-        if (!integrationClass.Definition) {
-            result.addError(ValidationError.create({
-                path: `${prefix}.Definition`,
-                message: 'Integration class must have a static Definition property',
-                severity: 'error',
-                code: 'MISSING_DEFINITION',
-                fix: FixSuggestion.create({
-                    action: 'add',
-                    description: 'Add static Definition property to integration class',
-                    codeSnippet: `static Definition = {\n    name: 'my-integration',\n    version: '1.0.0',\n    modules: {}\n};`
-                })
-            }));
-            return result;
-        }
-
-        this._validateDefinitionWithSchema(integrationClass.Definition, prefix, result);
-        this._validateModuleNames(integrationClass.Definition, prefix, result);
-        this._validateLifecycleMethods(integrationClass, prefix, result);
-
-        return result;
-    }
-
-    _validateDefinitionWithSchema(definition, prefix, result) {
-        const schemaResult = validateIntegrationDefinition(definition);
-
-        if (!schemaResult.valid && schemaResult.errors) {
-            schemaResult.errors.forEach(error => {
-                const path = error.instancePath
-                    ? `${prefix}.Definition${error.instancePath.replace(/\//g, '.')}`
-                    : `${prefix}.Definition`;
-
-                result.addError(ValidationError.create({
-                    path,
-                    message: this._formatSchemaErrorMessage(error),
-                    severity: 'error',
-                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
-                }));
-            });
-        }
-    }
-
-    _formatSchemaErrorMessage(error) {
-        let message = error.message;
-        if (error.params?.allowedValues) {
-            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
-        }
-        if (error.params?.additionalProperty) {
-            message += `: ${error.params.additionalProperty}`;
-        }
-        if (error.params?.missingProperty) {
-            message = `must have required property '${error.params.missingProperty}'`;
-        }
-        return message;
-    }
-
-    _validateModuleNames(definition, prefix, result) {
-        if (!definition.modules) {
-            return;
-        }
-
-        Object.entries(definition.modules).forEach(([moduleName, moduleConfig]) => {
-            // Check for moduleName (the correct property per API module schema and core Module class)
-            // Note: getName() method returns definition.moduleName, not definition.name
-            if (moduleConfig.definition && !moduleConfig.definition.moduleName) {
-                result.addError(ValidationError.create({
-                    path: `${prefix}.Definition.modules.${moduleName}.definition.moduleName`,
-                    message: `Module ${moduleName} definition should have a moduleName property`,
-                    severity: 'warning',
-                    code: 'MISSING_MODULE_NAME'
-                }));
-            }
-        });
-    }
-
-    _validateLifecycleMethods(integrationClass, prefix, result) {
-        const proto = integrationClass.prototype;
-
-        LIFECYCLE_METHODS.forEach(method => {
-            if (typeof proto[method] !== 'function') {
-                result.addError(ValidationError.create({
-                    path: `${prefix}.${method}`,
-                    message: `Integration should implement ${method}() method`,
-                    severity: 'warning',
-                    code: 'MISSING_METHOD'
-                }));
-            }
-        });
-    }
-}
-
-module.exports = { IntegrationClassValidator };