@friggframework/devtools 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/frigg-cli/validate-command/domain/value-objects/validation-error.js

@@ -0,0 +1,68 @@
+const VALID_SEVERITIES = ['error', 'warning', 'info'];
+
+class ValidationError {
+    constructor({ path, message, severity, code, fix }) {
+        if (!path) {
+            throw new Error('path is required');
+        }
+        if (!message) {
+            throw new Error('message is required');
+        }
+        if (severity && !VALID_SEVERITIES.includes(severity)) {
+            throw new Error(`Invalid severity: ${severity}. Must be one of: ${VALID_SEVERITIES.join(', ')}`);
+        }
+
+        this.path = path;
+        this.message = message;
+        this.severity = severity || 'error';
+        this.code = code || null;
+        this.fix = fix || null;
+    }
+
+    static create(props) {
+        return new ValidationError(props);
+    }
+
+    getPathSegments() {
+        return this.path
+            .replace(/\[(\d+)\]/g, '.$1')
+            .split('.')
+            .filter(Boolean);
+    }
+
+    getRootPath() {
+        return this.getPathSegments()[0];
+    }
+
+    isError() {
+        return this.severity === 'error';
+    }
+
+    isWarning() {
+        return this.severity === 'warning';
+    }
+
+    isInfo() {
+        return this.severity === 'info';
+    }
+
+    hasFix() {
+        return this.fix !== null;
+    }
+
+    equals(other) {
+        return this.path === other.path && this.message === other.message;
+    }
+
+    toJSON() {
+        return {
+            path: this.path,
+            message: this.message,
+            severity: this.severity,
+            code: this.code,
+            fix: this.fix ? this.fix.toJSON() : null
+        };
+    }
+}
+
+module.exports = { ValidationError };

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

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

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

@@ -0,0 +1,113 @@
+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/create-frigg-infrastructure.js

@@ -23,6 +23,92 @@ function isProcessRunning(pid) {
     }
 }
 
+/**
+ * Build for a non-AWS provider.
+ *
+ * When infrastructure.js is invoked (e.g. `node infrastructure.js package`),
+ * but the appDefinition specifies a non-AWS provider, we skip the entire
+ * serverless/CloudFormation pipeline and instead:
+ *   1. Validate the appDefinition against the provider
+ *   2. Generate the provider-specific config (e.g. netlify.toml)
+ *   3. Generate function entry points
+ *
+ * This mirrors what the CLI's buildCommand does for non-AWS providers,
+ * but works when invoked directly via `node infrastructure.js package`.
+ */
+async function buildWithProvider(appDefinition, providerName, backendDir) {
+    const { resolveProvider } = require('@friggframework/core/providers/resolve-provider');
+    const provider = resolveProvider(appDefinition);
+
+    console.log(`Building for ${providerName} provider (skipping AWS infrastructure)...`);
+
+    // 1. Validate
+    if (typeof provider.validate === 'function') {
+        const validation = provider.validate(appDefinition);
+        if (validation.errors?.length > 0) {
+            console.error(`\nValidation errors for ${providerName}:`);
+            for (const error of validation.errors) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+        if (validation.warnings?.length > 0) {
+            for (const warning of validation.warnings) {
+                console.warn(`  Warning: ${warning}`);
+            }
+        }
+    }
+
+    // 2. Generate platform config (e.g. netlify.toml)
+    // Written to the project root (one level up from backend/)
+    const projectDir = path.dirname(backendDir);
+    if (typeof provider.generateConfig === 'function') {
+        const config = provider.generateConfig(appDefinition);
+        const configFileNames = { netlify: 'netlify.toml' };
+        const configFileName = configFileNames[providerName] || `${providerName}.config`;
+        const configPath = path.join(projectDir, configFileName);
+
+        fs.writeFileSync(configPath, config, 'utf-8');
+        console.log(`  Written ${configFileName}`);
+    }
+
+    // 3. Generate function entry points
+    if (typeof provider.getFunctionEntryPoints === 'function') {
+        const entryPoints = provider.getFunctionEntryPoints(appDefinition);
+        const functionsDir = path.join(projectDir, 'netlify', 'functions');
+
+        fs.mkdirSync(functionsDir, { recursive: true });
+
+        for (const [filename, content] of Object.entries(entryPoints)) {
+            const filePath = path.join(functionsDir, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+        }
+
+        console.log(`  Generated ${Object.keys(entryPoints).length} function entry points`);
+    }
+
+    // 4. Generate lib entry points (re-export shims for runtime dependencies)
+    if (typeof provider.getLibEntryPoints === 'function') {
+        const libEntryPoints = provider.getLibEntryPoints(appDefinition);
+        const libDir = path.join(projectDir, 'netlify', 'lib');
+
+        fs.mkdirSync(libDir, { recursive: true });
+
+        for (const [filename, content] of Object.entries(libEntryPoints)) {
+            const filePath = path.join(libDir, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+        }
+
+        console.log(`  Generated ${Object.keys(libEntryPoints).length} lib entry points`);
+    }
+
+    console.log(`\nBuild complete for ${providerName}.`);
+
+    // Return an empty serverless definition — osls will see no functions
+    // and effectively no-op. The real deployment is handled by the provider.
+    return {};
+}
+
 async function createFriggInfrastructure() {
     const backendPath = findNearestBackendPackageJson();
     if (!backendPath) {
@@ -104,6 +190,13 @@ async function createFriggInfrastructure() {
         const backend = require(backendFilePath);
         const appDefinition = backend.Definition;
 
+        // Check if a non-AWS provider is configured.
+        // If so, run the provider's build pipeline instead of AWS CloudFormation.
+        const providerName = appDefinition.provider || 'aws';
+        if (providerName !== 'aws') {
+            return buildWithProvider(appDefinition, providerName, backendDir);
+        }
+
         const definition = await composeServerlessDefinition(
             appDefinition,
         );

package/infrastructure/docs/iam-policy-templates.md

@@ -160,7 +160,7 @@ Consider separate policies for different environments:
 ### Validation
 Test your policy by deploying a simple Frigg app:
 ```bash
-npx create-frigg-app test-deployment
+frigg init test-deployment
 cd test-deployment
 frigg deploy
 ```