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

package/frigg-cli/domain/entities/AppDefinition.js

@@ -1,227 +0,0 @@
-const {DomainException} = require('../exceptions/DomainException');
-const {SemanticVersion} = require('../value-objects/SemanticVersion');
-
-/**
- * AppDefinition Aggregate Root
- *
- * Represents the entire Frigg application configuration
- * Contains metadata about the app and references to all integrations
- */
-class AppDefinition {
-    constructor(props) {
-        this.name = props.name;
-        this.version = props.version instanceof SemanticVersion ?
-            props.version : new SemanticVersion(props.version);
-        this.description = props.description || '';
-        this.author = props.author || '';
-        this.license = props.license || 'UNLICENSED';
-        this.repository = props.repository || {};
-        this.integrations = props.integrations || [];
-        this.apiModules = props.apiModules || [];
-        this.config = props.config || {};
-        this.createdAt = props.createdAt || new Date();
-        this.updatedAt = props.updatedAt || new Date();
-    }
-
-    /**
-     * Factory method to create a new AppDefinition
-     */
-    static create(props) {
-        return new AppDefinition(props);
-    }
-
-    /**
-     * Register an integration in the app
-     * @param {string} integrationName - Name of the integration to register
-     */
-    registerIntegration(integrationName) {
-        if (this.hasIntegration(integrationName)) {
-            throw new DomainException(`Integration '${integrationName}' is already registered`);
-        }
-
-        this.integrations.push({
-            name: integrationName,
-            enabled: true,
-            registeredAt: new Date()
-        });
-
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Unregister an integration from the app
-     * @param {string} integrationName
-     */
-    unregisterIntegration(integrationName) {
-        const index = this.integrations.findIndex(i => i.name === integrationName);
-
-        if (index === -1) {
-            throw new DomainException(`Integration '${integrationName}' is not registered`);
-        }
-
-        this.integrations.splice(index, 1);
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Check if an integration is registered
-     * @param {string} integrationName
-     * @returns {boolean}
-     */
-    hasIntegration(integrationName) {
-        return this.integrations.some(i => i.name === integrationName);
-    }
-
-    /**
-     * Enable an integration
-     * @param {string} integrationName
-     */
-    enableIntegration(integrationName) {
-        const integration = this.integrations.find(i => i.name === integrationName);
-
-        if (!integration) {
-            throw new DomainException(`Integration '${integrationName}' is not registered`);
-        }
-
-        integration.enabled = true;
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Disable an integration
-     * @param {string} integrationName
-     */
-    disableIntegration(integrationName) {
-        const integration = this.integrations.find(i => i.name === integrationName);
-
-        if (!integration) {
-            throw new DomainException(`Integration '${integrationName}' is not registered`);
-        }
-
-        integration.enabled = false;
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Register an API module
-     * @param {string} moduleName
-     * @param {string} moduleVersion
-     * @param {string} source - npm, local, git
-     */
-    registerApiModule(moduleName, moduleVersion, source = 'npm') {
-        if (this.hasApiModule(moduleName)) {
-            throw new DomainException(`API module '${moduleName}' is already registered`);
-        }
-
-        this.apiModules.push({
-            name: moduleName,
-            version: moduleVersion,
-            source,
-            registeredAt: new Date()
-        });
-
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Check if an API module is registered
-     * @param {string} moduleName
-     * @returns {boolean}
-     */
-    hasApiModule(moduleName) {
-        return this.apiModules.some(m => m.name === moduleName);
-    }
-
-    /**
-     * Get all enabled integrations
-     * @returns {Array}
-     */
-    getEnabledIntegrations() {
-        return this.integrations.filter(i => i.enabled);
-    }
-
-    /**
-     * Validate app definition business rules
-     */
-    validate() {
-        const errors = [];
-
-        // Name validation
-        if (!this.name || this.name.trim().length === 0) {
-            errors.push('App name is required');
-        }
-
-        if (this.name && this.name.length > 100) {
-            errors.push('App name must be 100 characters or less');
-        }
-
-        // Version validation (handled by SemanticVersion value object)
-
-        // Description validation
-        if (this.description && this.description.length > 1000) {
-            errors.push('Description must be 1000 characters or less');
-        }
-
-        // Integrations validation
-        const integrationNames = this.integrations.map(i => i.name);
-        const uniqueNames = new Set(integrationNames);
-        if (integrationNames.length !== uniqueNames.size) {
-            errors.push('Duplicate integration names found');
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Convert to plain object
-     */
-    toObject() {
-        return {
-            name: this.name,
-            version: this.version.value,
-            description: this.description,
-            author: this.author,
-            license: this.license,
-            repository: this.repository,
-            integrations: this.integrations,
-            apiModules: this.apiModules,
-            config: this.config,
-            createdAt: this.createdAt,
-            updatedAt: this.updatedAt
-        };
-    }
-
-    /**
-     * Convert to JSON format (for app-definition.json)
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            version: this.version.value,
-            description: this.description,
-            author: this.author,
-            license: this.license,
-            repository: this.repository,
-            integrations: this.integrations.map(i => ({
-                name: i.name,
-                enabled: i.enabled
-            })),
-            apiModules: this.apiModules.map(m => ({
-                name: m.name,
-                version: m.version,
-                source: m.source
-            })),
-            config: this.config
-        };
-    }
-}
-
-module.exports = {AppDefinition};

package/frigg-cli/domain/entities/Integration.js

@@ -1,198 +0,0 @@
-const {IntegrationId} = require('../value-objects/IntegrationId');
-const {IntegrationName} = require('../value-objects/IntegrationName');
-const {SemanticVersion} = require('../value-objects/SemanticVersion');
-const {DomainException} = require('../exceptions/DomainException');
-
-/**
- * Integration Aggregate Root
- * Represents a Frigg integration with business rules
- */
-class Integration {
-    constructor(props) {
-        // Value objects (immutable, self-validating)
-        this.id = props.id instanceof IntegrationId ? props.id : new IntegrationId(props.id);
-        this.name = props.name instanceof IntegrationName ? props.name : new IntegrationName(props.name);
-        this.version = props.version instanceof SemanticVersion
-            ? props.version
-            : new SemanticVersion(props.version || '1.0.0');
-
-        // Simple properties
-        this.displayName = props.displayName || this._generateDisplayName();
-        this.description = props.description || '';
-        this.type = props.type || 'custom';
-        this.category = props.category;
-        this.tags = props.tags || [];
-
-        // Complex properties
-        this.entities = props.entities || {};
-        this.apiModules = props.apiModules || [];
-        this.capabilities = props.capabilities || {};
-        this.requirements = props.requirements || {};
-        this.options = props.options || {};
-
-        // Metadata
-        this.createdAt = props.createdAt || new Date();
-        this.updatedAt = props.updatedAt || new Date();
-    }
-
-    /**
-     * Factory method for creating new integrations
-     */
-    static create(props) {
-        return new Integration({
-            id: IntegrationId.generate(),
-            ...props,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        });
-    }
-
-    /**
-     * Add an API module to this integration
-     */
-    addApiModule(moduleName, moduleVersion, source = 'npm') {
-        if (this.hasApiModule(moduleName)) {
-            throw new DomainException(`API module '${moduleName}' is already added to this integration`);
-        }
-
-        this.apiModules.push({
-            name: moduleName,
-            version: moduleVersion,
-            source
-        });
-
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Remove an API module from this integration
-     */
-    removeApiModule(moduleName) {
-        const index = this.apiModules.findIndex(m => m.name === moduleName);
-        if (index === -1) {
-            throw new DomainException(`API module '${moduleName}' not found in this integration`);
-        }
-
-        this.apiModules.splice(index, 1);
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Check if API module is already added
-     */
-    hasApiModule(moduleName) {
-        return this.apiModules.some(m => m.name === moduleName);
-    }
-
-    /**
-     * Add an entity to this integration
-     */
-    addEntity(entityKey, entityConfig) {
-        if (this.entities[entityKey]) {
-            throw new DomainException(`Entity '${entityKey}' already exists in this integration`);
-        }
-
-        this.entities[entityKey] = {
-            type: entityConfig.type || entityKey,
-            label: entityConfig.label,
-            global: entityConfig.global || false,
-            autoProvision: entityConfig.autoProvision || false,
-            required: entityConfig.required !== false
-        };
-
-        this.updatedAt = new Date();
-        return this;
-    }
-
-    /**
-     * Validate integration business rules
-     */
-    validate() {
-        const errors = [];
-
-        // Display name validation
-        if (!this.displayName || this.displayName.trim().length === 0) {
-            errors.push('Display name is required');
-        }
-
-        // Description validation
-        if (this.description && this.description.length > 1000) {
-            errors.push('Description must be 1000 characters or less');
-        }
-
-        // Type validation
-        const validTypes = ['api', 'webhook', 'sync', 'transform', 'custom'];
-        if (!validTypes.includes(this.type)) {
-            errors.push(`Invalid integration type: ${this.type}. Must be one of: ${validTypes.join(', ')}`);
-        }
-
-        // Entity validation
-        if (Object.keys(this.entities).length === 0) {
-            // Warning: integration with no entities is unusual but not invalid
-        }
-
-        return {
-            isValid: errors.length === 0,
-            errors
-        };
-    }
-
-    /**
-     * Convert to plain object (for persistence)
-     */
-    toObject() {
-        return {
-            id: this.id.value,
-            name: this.name.value,
-            version: this.version.value,
-            displayName: this.displayName,
-            description: this.description,
-            type: this.type,
-            category: this.category,
-            tags: this.tags,
-            entities: this.entities,
-            apiModules: this.apiModules,
-            capabilities: this.capabilities,
-            requirements: this.requirements,
-            options: this.options,
-            createdAt: this.createdAt,
-            updatedAt: this.updatedAt
-        };
-    }
-
-    /**
-     * Convert to JSON format (for integration-definition.json)
-     * Follows the integration-definition.schema.json structure
-     */
-    toJSON() {
-        return {
-            name: this.name.value,
-            version: this.version.value,
-            options: {
-                type: this.type,
-                display: {
-                    name: this.displayName,
-                    description: this.description || '',
-                    category: this.category,
-                    tags: this.tags
-                },
-                ...this.options
-            },
-            entities: this.entities,
-            capabilities: this.capabilities,
-            requirements: this.requirements
-        };
-    }
-
-    _generateDisplayName() {
-        // Convert kebab-case to Title Case
-        return this.name.value
-            .split('-')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-            .join(' ');
-    }
-}
-
-module.exports = {Integration};

package/frigg-cli/domain/exceptions/DomainException.js

@@ -1,24 +0,0 @@
-/**
- * Base exception for domain-level errors
- */
-class DomainException extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DomainException';
-        Error.captureStackTrace(this, this.constructor);
-    }
-}
-
-class ValidationException extends DomainException {
-    constructor(errors) {
-        const message = Array.isArray(errors) ? errors.join(', ') : errors;
-        super(message);
-        this.name = 'ValidationException';
-        this.errors = Array.isArray(errors) ? errors : [errors];
-    }
-}
-
-module.exports = {
-    DomainException,
-    ValidationException
-};

package/frigg-cli/domain/ports/IApiModuleRepository.js

@@ -1,53 +0,0 @@
-/**
- * IApiModuleRepository Port (Interface)
- *
- * Defines the contract for ApiModule persistence
- * Concrete implementations will be in the infrastructure layer
- */
-class IApiModuleRepository {
-    /**
-     * Save an API module
-     * @param {ApiModule} apiModule
-     * @returns {Promise<ApiModule>}
-     */
-    async save(apiModule) {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Find API module by name
-     * @param {string} name
-     * @returns {Promise<ApiModule|null>}
-     */
-    async findByName(name) {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Check if API module exists
-     * @param {string} name
-     * @returns {Promise<boolean>}
-     */
-    async exists(name) {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * List all API modules
-     * @returns {Promise<Array<ApiModule>>}
-     */
-    async list() {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Delete an API module
-     * @param {string} name
-     * @returns {Promise<boolean>}
-     */
-    async delete(name) {
-        throw new Error('Not implemented');
-    }
-}
-
-module.exports = {IApiModuleRepository};

package/frigg-cli/domain/ports/IAppDefinitionRepository.js

@@ -1,43 +0,0 @@
-/**
- * IAppDefinitionRepository Port (Interface)
- *
- * Defines the contract for AppDefinition persistence
- * Concrete implementations will be in the infrastructure layer
- */
-class IAppDefinitionRepository {
-    /**
-     * Load the app definition from project
-     * @returns {Promise<AppDefinition|null>}
-     */
-    async load() {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Save the app definition to project
-     * @param {AppDefinition} appDefinition
-     * @returns {Promise<AppDefinition>}
-     */
-    async save(appDefinition) {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Check if app definition exists
-     * @returns {Promise<boolean>}
-     */
-    async exists() {
-        throw new Error('Not implemented');
-    }
-
-    /**
-     * Create a new app definition
-     * @param {object} props - Initial properties
-     * @returns {Promise<AppDefinition>}
-     */
-    async create(props) {
-        throw new Error('Not implemented');
-    }
-}
-
-module.exports = {IAppDefinitionRepository};

package/frigg-cli/domain/ports/IIntegrationRepository.js

@@ -1,61 +0,0 @@
-/**
- * Integration Repository Port (Interface)
- * Defines the contract for persisting Integration entities
- * Implementation will be in infrastructure layer
- */
-class IIntegrationRepository {
-    /**
-     * Save an integration (create or update)
-     * @param {Integration} integration - The integration entity to save
-     * @returns {Promise<Integration>} The saved integration
-     */
-    async save(integration) {
-        throw new Error('Not implemented: save must be implemented by concrete repository');
-    }
-
-    /**
-     * Find integration by ID
-     * @param {IntegrationId|string} id - The integration ID
-     * @returns {Promise<Integration|null>} The integration or null if not found
-     */
-    async findById(id) {
-        throw new Error('Not implemented: findById must be implemented by concrete repository');
-    }
-
-    /**
-     * Find integration by name
-     * @param {IntegrationName|string} name - The integration name
-     * @returns {Promise<Integration|null>} The integration or null if not found
-     */
-    async findByName(name) {
-        throw new Error('Not implemented: findByName must be implemented by concrete repository');
-    }
-
-    /**
-     * Check if integration exists by name
-     * @param {IntegrationName|string} name - The integration name
-     * @returns {Promise<boolean>} True if exists, false otherwise
-     */
-    async exists(name) {
-        throw new Error('Not implemented: exists must be implemented by concrete repository');
-    }
-
-    /**
-     * List all integrations
-     * @returns {Promise<Integration[]>} Array of all integrations
-     */
-    async list() {
-        throw new Error('Not implemented: list must be implemented by concrete repository');
-    }
-
-    /**
-     * Delete an integration by ID
-     * @param {IntegrationId|string} id - The integration ID
-     * @returns {Promise<boolean>} True if deleted, false if not found
-     */
-    async delete(id) {
-        throw new Error('Not implemented: delete must be implemented by concrete repository');
-    }
-}
-
-module.exports = {IIntegrationRepository};