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

package/frigg-cli/domain/services/IntegrationValidator.js

@@ -1,185 +0,0 @@
-const {DomainException, ValidationException} = require('../exceptions/DomainException');
-
-/**
- * IntegrationValidator Domain Service
- *
- * Centralizes validation logic that involves multiple entities or external checks
- * Complements the entity's self-validation by handling cross-cutting concerns
- */
-class IntegrationValidator {
-    constructor(integrationRepository) {
-        this.integrationRepository = integrationRepository;
-    }
-
-    /**
-     * Validate that integration name is unique
-     * @param {IntegrationName} name - Integration name to check
-     * @returns {Promise<{isValid: boolean, errors: string[]}>}
-     */
-    async validateUniqueness(name) {
-        const exists = await this.integrationRepository.exists(name);
-
-        if (exists) {
-            return {
-                isValid: false,
-                errors: [`Integration with name '${name.value}' already exists`]
-            };
-        }
-
-        return {
-            isValid: true,
-            errors: []
-        };
-    }
-
-    /**
-     * Validate integration against business rules
-     * Combines entity validation with domain-level rules
-     *
-     * @param {Integration} integration - Integration entity to validate
-     * @returns {Promise<{isValid: boolean, errors: string[]}>}
-     */
-    async validate(integration) {
-        const errors = [];
-
-        // 1. Entity self-validation
-        const entityValidation = integration.validate();
-        if (!entityValidation.isValid) {
-            errors.push(...entityValidation.errors);
-        }
-
-        // 2. Uniqueness check
-        const uniquenessValidation = await this.validateUniqueness(integration.name);
-        if (!uniquenessValidation.isValid) {
-            errors.push(...uniquenessValidation.errors);
-        }
-
-        // 3. Additional domain rules
-        const domainRules = this.validateDomainRules(integration);
-        if (!domainRules.isValid) {
-            errors.push(...domainRules.errors);
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Validate domain-specific business rules
-     * These are rules that apply across the domain, not just to one entity
-     *
-     * @param {Integration} integration
-     * @returns {{isValid: boolean, errors: string[]}}
-     */
-    validateDomainRules(integration) {
-        const errors = [];
-
-        // Rule: Webhook integrations must have webhook capability
-        if (integration.type === 'webhook' && !integration.capabilities.webhooks) {
-            errors.push('Webhook integrations must have webhooks capability enabled');
-        }
-
-        // Rule: Sync integrations should have bidirectional capability
-        if (integration.type === 'sync' && integration.capabilities.sync && !integration.capabilities.sync.bidirectional) {
-            // This is a warning, not an error - sync can be unidirectional
-            // But we'll log it for the developer's awareness
-        }
-
-        // Rule: OAuth2 integrations must have auth capability
-        if (integration.capabilities.auth && integration.capabilities.auth.includes('oauth2')) {
-            // This is good - OAuth2 should be in auth array
-        }
-
-        // Rule: Integrations with realtime capability should have websocket requirements
-        if (integration.capabilities.realtime) {
-            if (!integration.requirements || !integration.requirements.websocket) {
-                // Warn but don't fail - they might add it later
-            }
-        }
-
-        // Rule: Integration should have at least one entity or be marked as entityless
-        if (Object.keys(integration.entities).length === 0) {
-            // This is unusual but not invalid - might be a transform-only integration
-            // We don't add an error, just note it
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Validate integration configuration before update
-     * Ensures updates don't violate domain rules
-     *
-     * @param {Integration} existingIntegration
-     * @param {Integration} updatedIntegration
-     * @returns {{isValid: boolean, errors: string[]}}
-     */
-    validateUpdate(existingIntegration, updatedIntegration) {
-        const errors = [];
-
-        // Rule: Cannot change integration name
-        if (!existingIntegration.name.equals(updatedIntegration.name)) {
-            errors.push('Integration name cannot be changed after creation');
-        }
-
-        // Rule: Version must be incremented, not decremented
-        if (existingIntegration.version.isGreaterThan(updatedIntegration.version)) {
-            errors.push('Cannot downgrade integration version');
-        }
-
-        // Rule: Cannot remove entities that have existing data
-        // (This would require checking with a data repository in real implementation)
-        const removedEntities = Object.keys(existingIntegration.entities)
-            .filter(key => !updatedIntegration.entities[key]);
-
-        if (removedEntities.length > 0) {
-            errors.push(`Cannot remove entities with potential existing data: ${removedEntities.join(', ')}`);
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Validate API module addition
-     * Ensures API module can be safely added to integration
-     *
-     * @param {Integration} integration
-     * @param {string} moduleName
-     * @param {string} moduleVersion
-     * @returns {{isValid: boolean, errors: string[]}}
-     */
-    validateApiModuleAddition(integration, moduleName, moduleVersion) {
-        const errors = [];
-
-        // Check if module already exists
-        if (integration.hasApiModule(moduleName)) {
-            errors.push(`API module '${moduleName}' is already added to this integration`);
-        }
-
-        // Validate module name format
-        if (!moduleName || moduleName.trim().length === 0) {
-            errors.push('API module name is required');
-        }
-
-        // Validate version format (should be semantic version)
-        const versionPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
-        if (!versionPattern.test(moduleVersion)) {
-            errors.push(`Invalid API module version format: ${moduleVersion}. Must be semantic version (e.g., 1.0.0)`);
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-}
-
-module.exports = {IntegrationValidator};

package/frigg-cli/domain/value-objects/IntegrationId.js

@@ -1,42 +0,0 @@
-const {DomainException} = require('../exceptions/DomainException');
-const crypto = require('crypto');
-
-/**
- * IntegrationId Value Object
- * Unique identifier for integrations
- */
-class IntegrationId {
-    constructor(value) {
-        if (value) {
-            // Use provided ID
-            if (typeof value !== 'string' || value.length === 0) {
-                throw new DomainException('Integration ID must be a non-empty string');
-            }
-            this._value = value;
-        } else {
-            // Generate new ID
-            this._value = crypto.randomUUID();
-        }
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    equals(other) {
-        if (!(other instanceof IntegrationId)) {
-            return false;
-        }
-        return this._value === other._value;
-    }
-
-    toString() {
-        return this._value;
-    }
-
-    static generate() {
-        return new IntegrationId();
-    }
-}
-
-module.exports = {IntegrationId};

package/frigg-cli/domain/value-objects/IntegrationName.js

@@ -1,60 +0,0 @@
-const {DomainException} = require('../exceptions/DomainException');
-
-/**
- * IntegrationName Value Object
- * Ensures integration names follow kebab-case format
- */
-class IntegrationName {
-    constructor(value) {
-        if (!value || typeof value !== 'string') {
-            throw new DomainException('Integration name must be a non-empty string');
-        }
-
-        this._value = value;
-        this._validate();
-    }
-
-    _validate() {
-        const rules = [
-            {
-                test: () => /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(this._value),
-                message: 'Name must be kebab-case (lowercase letters, numbers, and hyphens only)'
-            },
-            {
-                test: () => this._value.length >= 2 && this._value.length <= 100,
-                message: 'Name must be between 2 and 100 characters'
-            },
-            {
-                test: () => !this._value.startsWith('-') && !this._value.endsWith('-'),
-                message: 'Name cannot start or end with a hyphen'
-            },
-            {
-                test: () => !this._value.includes('--'),
-                message: 'Name cannot contain consecutive hyphens'
-            }
-        ];
-
-        for (const rule of rules) {
-            if (!rule.test()) {
-                throw new DomainException(rule.message);
-            }
-        }
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    equals(other) {
-        if (!(other instanceof IntegrationName)) {
-            return false;
-        }
-        return this._value === other._value;
-    }
-
-    toString() {
-        return this._value;
-    }
-}
-
-module.exports = {IntegrationName};

package/frigg-cli/domain/value-objects/SemanticVersion.js

@@ -1,70 +0,0 @@
-const {DomainException} = require('../exceptions/DomainException');
-const semver = require('semver');
-
-/**
- * SemanticVersion Value Object
- * Ensures versions follow semantic versioning
- */
-class SemanticVersion {
-    constructor(value) {
-        if (!value || typeof value !== 'string') {
-            throw new DomainException('Version must be a non-empty string');
-        }
-
-        if (!semver.valid(value)) {
-            throw new DomainException(
-                `Invalid semantic version: ${value}. Must follow format X.Y.Z (e.g., 1.0.0)`
-            );
-        }
-
-        this._value = value;
-        this._parsed = semver.parse(value);
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    get major() {
-        return this._parsed.major;
-    }
-
-    get minor() {
-        return this._parsed.minor;
-    }
-
-    get patch() {
-        return this._parsed.patch;
-    }
-
-    get prerelease() {
-        return this._parsed.prerelease;
-    }
-
-    equals(other) {
-        if (!(other instanceof SemanticVersion)) {
-            return false;
-        }
-        return this._value === other._value;
-    }
-
-    isGreaterThan(other) {
-        if (!(other instanceof SemanticVersion)) {
-            throw new DomainException('Can only compare with another SemanticVersion');
-        }
-        return semver.gt(this._value, other._value);
-    }
-
-    isLessThan(other) {
-        if (!(other instanceof SemanticVersion)) {
-            throw new DomainException('Can only compare with another SemanticVersion');
-        }
-        return semver.lt(this._value, other._value);
-    }
-
-    toString() {
-        return this._value;
-    }
-}
-
-module.exports = {SemanticVersion};

package/frigg-cli/infrastructure/UnitOfWork.js

@@ -1,46 +0,0 @@
-/**
- * UnitOfWork
- * Coordinates transactions across repositories
- */
-class UnitOfWork {
-    constructor(fileSystemAdapter) {
-        this.fileSystemAdapter = fileSystemAdapter;
-        this.repositories = new Map();
-    }
-
-    /**
-     * Register a repository
-     */
-    registerRepository(name, repository) {
-        this.repositories.set(name, repository);
-        return this;
-    }
-
-    /**
-     * Commit all tracked operations
-     */
-    async commit() {
-        try {
-            await this.fileSystemAdapter.commit();
-            return {success: true};
-        } catch (error) {
-            throw new Error(`Failed to commit transaction: ${error.message}`);
-        }
-    }
-
-    /**
-     * Rollback all tracked operations
-     */
-    async rollback() {
-        return await this.fileSystemAdapter.rollback();
-    }
-
-    /**
-     * Clear tracked operations without commit/rollback
-     */
-    clear() {
-        this.fileSystemAdapter.clear();
-    }
-}
-
-module.exports = {UnitOfWork};

package/frigg-cli/infrastructure/adapters/BackendJsUpdater.js

@@ -1,197 +0,0 @@
-const path = require('path');
-const fs = require('fs-extra');
-
-/**
- * BackendJsUpdater
- *
- * Infrastructure service for updating backend.js file with new integrations
- * Uses AST manipulation to safely add integration imports and registrations
- */
-class BackendJsUpdater {
-    constructor(fileSystemAdapter, backendPath) {
-        this.fileSystemAdapter = fileSystemAdapter;
-        this.backendPath = backendPath;
-        this.indexJsPath = path.join(backendPath, 'index.js');
-    }
-
-    /**
-     * Register an integration in backend/index.js
-     * @param {string} integrationName - kebab-case integration name
-     * @returns {Promise<void>}
-     */
-    async registerIntegration(integrationName) {
-        if (!await this.fileSystemAdapter.exists(this.indexJsPath)) {
-            throw new Error('backend/index.js not found');
-        }
-
-        const className = this._toClassName(integrationName);
-        const importPath = `./src/integrations/${className}Integration`;
-
-        await this.fileSystemAdapter.updateFile(this.indexJsPath, (content) => {
-            return this._addIntegration(content, className, integrationName, importPath);
-        });
-    }
-
-    /**
-     * Remove an integration from backend/index.js
-     * @param {string} integrationName
-     * @returns {Promise<void>}
-     */
-    async unregisterIntegration(integrationName) {
-        if (!await this.fileSystemAdapter.exists(this.indexJsPath)) {
-            throw new Error('backend/index.js not found');
-        }
-
-        const className = this._toClassName(integrationName);
-
-        await this.fileSystemAdapter.updateFile(this.indexJsPath, (content) => {
-            return this._removeIntegration(content, className, integrationName);
-        });
-    }
-
-    /**
-     * Add integration to backend.js content
-     * Simple string manipulation approach (can be replaced with AST parsing if needed)
-     *
-     * @param {string} content - Current backend.js content
-     * @param {string} className - Integration class name
-     * @param {string} integrationName - kebab-case name
-     * @param {string} importPath - relative import path
-     * @returns {string} - Updated content
-     */
-    _addIntegration(content, className, integrationName, importPath) {
-        // Check if integration is already registered
-        if (content.includes(`const ${className}Integration`)) {
-            console.warn(`Integration ${integrationName} is already registered in backend.js`);
-            return content;
-        }
-
-        let updated = content;
-
-        // 1. Add import statement after other integration imports
-        const importRegex = /(const \w+Integration = require\('\.\/src\/integrations\/[^']+'\);)/g;
-        const importMatches = [...content.matchAll(importRegex)];
-
-        if (importMatches.length > 0) {
-            // Add after last integration import
-            const lastImport = importMatches[importMatches.length - 1];
-            const insertIndex = lastImport.index + lastImport[0].length;
-            const importStatement = `\nconst ${className}Integration = require('${importPath}');`;
-            updated = updated.slice(0, insertIndex) + importStatement + updated.slice(insertIndex);
-        } else {
-            // No existing imports - add at the top after requires
-            const requiresRegex = /const .+ = require\([^)]+\);/g;
-            const requireMatches = [...content.matchAll(requiresRegex)];
-            if (requireMatches.length > 0) {
-                const lastRequire = requireMatches[requireMatches.length - 1];
-                const insertIndex = lastRequire.index + lastRequire[0].length;
-                const importStatement = `\n\n// Integrations\nconst ${className}Integration = require('${importPath}');`;
-                updated = updated.slice(0, insertIndex) + importStatement + updated.slice(insertIndex);
-            }
-        }
-
-        // 2. Add to integrations array
-        // Look for patterns:
-        // - const integrations = [...]
-        // - integrations: [...] (inside appDefinition object)
-
-        // Try standalone array first
-        const standaloneArrayRegex = /const integrations = \[([\s\S]*?)\];/;
-        let match = updated.match(standaloneArrayRegex);
-
-        if (match) {
-            const currentArray = match[1];
-            const newEntry = `\n    ${className}Integration,`;
-
-            // Check if it's an empty array
-            if (currentArray.trim() === '') {
-                updated = updated.replace(standaloneArrayRegex, `const integrations = [${newEntry}\n];`);
-            } else {
-                // Add to existing array
-                const insertAt = match.index + match[0].length - 2; // Before ];
-                updated = updated.slice(0, insertAt) + ',' + newEntry + updated.slice(insertAt);
-            }
-        } else {
-            // Try appDefinition pattern
-            const appDefArrayRegex = /integrations:\s*\[([\s\S]*?)\]/;
-            match = updated.match(appDefArrayRegex);
-
-            if (match) {
-                const currentArray = match[1];
-                const newEntry = `\n        ${className}Integration,`;
-
-                // Check if array is empty or has only comments
-                const hasOnlyComments = currentArray.trim() === '' ||
-                    currentArray.trim().split('\n').every(line => line.trim().startsWith('//'));
-
-                if (hasOnlyComments) {
-                    // Replace entire array content
-                    updated = updated.replace(appDefArrayRegex, `integrations: [${newEntry}\n    ]`);
-                } else {
-                    // Add to existing array - find the last entry and add comma if needed
-                    const lines = currentArray.split('\n');
-                    const lastNonEmptyLine = lines.reverse().find(line => line.trim() && !line.trim().startsWith('//'));
-                    const needsComma = lastNonEmptyLine && !lastNonEmptyLine.trim().endsWith(',');
-                    const comma = needsComma ? ',' : '';
-
-                    const insertAt = match.index + match[0].length - 1; // Before ]
-                    updated = updated.slice(0, insertAt) + comma + newEntry + '\n    ' + updated.slice(insertAt);
-                }
-            } else {
-                // No integrations array found - this is a problem
-                console.warn('Could not find integrations array in backend/index.js');
-            }
-        }
-
-        return updated;
-    }
-
-    /**
-     * Remove integration from backend.js content
-     *
-     * @param {string} content
-     * @param {string} className
-     * @param {string} integrationName
-     * @returns {string}
-     */
-    _removeIntegration(content, className, integrationName) {
-        let updated = content;
-
-        // 1. Remove import statement
-        const importRegex = new RegExp(`\\nconst ${className}Integration = require\\([^)]+\\);`, 'g');
-        updated = updated.replace(importRegex, '');
-
-        // 2. Remove from integrations array
-        const arrayEntryRegex = new RegExp(`,?\\s*${className}Integration,?`, 'g');
-        updated = updated.replace(arrayEntryRegex, '');
-
-        // Clean up extra commas
-        updated = updated.replace(/,\s*,/g, ',');
-        updated = updated.replace(/\[\s*,/g, '[');
-        updated = updated.replace(/,\s*\]/g, ']');
-
-        return updated;
-    }
-
-    /**
-     * Convert kebab-case to ClassName
-     * @param {string} kebabCase
-     * @returns {string}
-     */
-    _toClassName(kebabCase) {
-        return kebabCase
-            .split('-')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-    }
-
-    /**
-     * Check if backend/index.js exists
-     * @returns {Promise<boolean>}
-     */
-    async exists() {
-        return await this.fileSystemAdapter.exists(this.indexJsPath);
-    }
-}
-
-module.exports = {BackendJsUpdater};