@friggframework/devtools 2.0.0--canary.545.e256e95.0 → 2.0.0--canary.553.dc5f898.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,145 +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;
-            });
-        }
-
-        // Sanitize extensions — strip functions (bootstrap, routes.handler)
-        // that JSON Schema cannot validate
-        if (Array.isArray(definition.extensions)) {
-            sanitized.extensions = definition.extensions.map(ext => {
-                const sanitizedExt = { ...ext };
-                // Remove function properties
-                if (typeof sanitizedExt.bootstrap === 'function') {
-                    delete sanitizedExt.bootstrap;
-                }
-                if (sanitizedExt.routes && typeof sanitizedExt.routes.handler === 'function') {
-                    sanitizedExt.routes = { ...sanitizedExt.routes };
-                    delete sanitizedExt.routes.handler;
-                }
-                return sanitizedExt;
-            });
-        }
-
-        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 };

package/infrastructure/domains/admin-scripts/admin-script-builder.js

@@ -1,200 +0,0 @@
-/**
- * Admin Script Builder
- *
- * Domain Layer - Hexagonal Architecture
- *
- * Responsible for:
- * - Creating SQS queue for admin script execution
- * - Creating Lambda function for script execution (worker)
- * - Creating Lambda function for admin API routes (router)
- * - Creating EventBridge Scheduler resources (Phase 2)
- * - Creating IAM roles for scheduler to invoke Lambda
- */
-
-const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
-
-class AdminScriptBuilder extends InfrastructureBuilder {
-    constructor() {
-        super();
-        this.name = 'AdminScriptBuilder';
-    }
-
-    shouldExecute(appDefinition) {
-        return Array.isArray(appDefinition.adminScripts) && appDefinition.adminScripts.length > 0;
-    }
-
-    getDependencies() {
-        return []; // Can run independently
-    }
-
-    validate(appDefinition) {
-        const result = new ValidationResult();
-
-        if (!appDefinition.adminScripts) {
-            return result; // Not an error, just no scripts
-        }
-
-        if (!Array.isArray(appDefinition.adminScripts)) {
-            result.addError('adminScripts must be an array');
-            return result;
-        }
-
-        // Validate each script
-        appDefinition.adminScripts.forEach((script, index) => {
-            if (!script?.Definition?.name) {
-                result.addError(`Admin script at index ${index} is missing Definition or name`);
-            }
-        });
-
-        return result;
-    }
-
-    async build(appDefinition, discoveredResources) {
-        console.log(`\n[${this.name}] Configuring admin scripts...`);
-        console.log(`  Processing ${appDefinition.adminScripts.length} scripts...`);
-
-        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
-        const adminConfig = appDefinition.admin || {};
-
-        const result = {
-            functions: {},
-            resources: {},
-            environment: {},
-            custom: {},
-            iamStatements: [],
-        };
-
-        // Create admin script queue
-        this.createAdminScriptQueue(result);
-
-        // Create Lambda function for script execution
-        this.createScriptExecutorFunction(result, usePrismaLayer);
-
-        // Create API routes for script management
-        this.createAdminScriptRoutes(result, usePrismaLayer);
-
-        // Phase 2: Create EventBridge Scheduler resources
-        if (adminConfig.enableScheduling) {
-            this.createSchedulerResources(appDefinition, result);
-        }
-
-        // Log registered scripts
-        appDefinition.adminScripts.forEach(script => {
-            const name = script.Definition?.name || 'unknown';
-            const schedule = script.Definition?.schedule;
-            console.log(`    ✓ Registered: ${name}${schedule?.enabled ? ' (scheduled)' : ''}`);
-        });
-
-        console.log(`[${this.name}] ✅ Admin script configuration completed`);
-        return result;
-    }
-
-    createAdminScriptQueue(result) {
-        result.resources.AdminScriptQueue = {
-            Type: 'AWS::SQS::Queue',
-            Properties: {
-                QueueName: '${self:service}-${self:provider.stage}-AdminScriptQueue',
-                MessageRetentionPeriod: 86400, // 1 day
-                VisibilityTimeout: 900, // 15 minutes (Lambda max)
-                RedrivePolicy: {
-                    maxReceiveCount: 3,
-                    deadLetterTargetArn: {
-                        'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                    },
-                },
-            },
-        };
-
-        result.environment.ADMIN_SCRIPT_QUEUE_URL = { Ref: 'AdminScriptQueue' };
-        console.log('  ✓ Created AdminScriptQueue');
-    }
-
-    createScriptExecutorFunction(result, usePrismaLayer) {
-        result.functions.adminScriptExecutor = {
-            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/script-executor-handler.handler',
-            skipEsbuild: true,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
-            timeout: 900, // 15 minutes max
-            memorySize: 1024,
-            events: [
-                {
-                    sqs: {
-                        arn: { 'Fn::GetAtt': ['AdminScriptQueue', 'Arn'] },
-                        batchSize: 1,
-                    },
-                },
-            ],
-        };
-        console.log('  ✓ Created adminScriptExecutor function');
-    }
-
-    createAdminScriptRoutes(result, usePrismaLayer) {
-        result.functions.adminScriptRouter = {
-            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/admin-script-router.handler',
-            skipEsbuild: true,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
-            timeout: 30,
-            events: [
-                // List scripts
-                { httpApi: { path: '/admin/scripts', method: 'GET' } },
-                // Get script details
-                { httpApi: { path: '/admin/scripts/{scriptName}', method: 'GET' } },
-                // Execute script (sync or async)
-                { httpApi: { path: '/admin/scripts/{scriptName}/execute', method: 'POST' } },
-                // Get execution status
-                { httpApi: { path: '/admin/executions/{executionId}', method: 'GET' } },
-                // List executions
-                { httpApi: { path: '/admin/executions', method: 'GET' } },
-                // Schedule management (Phase 2)
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'GET' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'PUT' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'DELETE' } },
-            ],
-        };
-        console.log('  ✓ Created adminScriptRouter function');
-    }
-
-    createSchedulerResources(appDefinition, result) {
-        // Create IAM role for EventBridge Scheduler
-        result.resources.AdminScriptSchedulerRole = {
-            Type: 'AWS::IAM::Role',
-            Properties: {
-                RoleName: '${self:service}-${self:provider.stage}-admin-script-scheduler',
-                AssumeRolePolicyDocument: {
-                    Version: '2012-10-17',
-                    Statement: [{
-                        Effect: 'Allow',
-                        Principal: { Service: 'scheduler.amazonaws.com' },
-                        Action: 'sts:AssumeRole',
-                    }],
-                },
-                Policies: [{
-                    PolicyName: 'InvokeLambda',
-                    PolicyDocument: {
-                        Version: '2012-10-17',
-                        Statement: [{
-                            Effect: 'Allow',
-                            Action: 'lambda:InvokeFunction',
-                            Resource: { 'Fn::GetAtt': ['AdminScriptExecutorLambdaFunction', 'Arn'] },
-                        }],
-                    },
-                }],
-            },
-        };
-
-        // Create schedule group
-        result.resources.AdminScriptScheduleGroup = {
-            Type: 'AWS::Scheduler::ScheduleGroup',
-            Properties: {
-                Name: '${self:service}-${self:provider.stage}-admin-scripts',
-            },
-        };
-
-        result.environment.SCHEDULER_ROLE_ARN = { 'Fn::GetAtt': ['AdminScriptSchedulerRole', 'Arn'] };
-        result.environment.SCHEDULE_GROUP_NAME = { Ref: 'AdminScriptScheduleGroup' };
-
-        console.log('  ✓ Created EventBridge Scheduler resources');
-    }
-}
-
-module.exports = { AdminScriptBuilder };