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

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

@@ -0,0 +1,272 @@
+const {DomainException} = require('../exceptions/DomainException');
+const {SemanticVersion} = require('../value-objects/SemanticVersion');
+
+/**
+ * ApiModule Entity
+ *
+ * Represents an API module that can be used by integrations
+ * API modules are reusable API clients for external services
+ */
+class ApiModule {
+    constructor(props) {
+        this.name = props.name; // kebab-case name
+        this.version = props.version instanceof SemanticVersion ?
+            props.version : new SemanticVersion(props.version || '1.0.0');
+        this.displayName = props.displayName || this._generateDisplayName();
+        this.description = props.description || '';
+        this.author = props.author || '';
+        this.license = props.license || 'UNLICENSED';
+        this.apiConfig = props.apiConfig || {
+            baseUrl: '',
+            authType: 'oauth2',
+            version: 'v1'
+        };
+        this.entities = props.entities || {}; // Database entities this module needs
+        this.scopes = props.scopes || []; // OAuth scopes required
+        this.credentials = props.credentials || []; // Required credentials
+        this.endpoints = props.endpoints || {}; // API endpoints
+        this.createdAt = props.createdAt || new Date();
+        this.updatedAt = props.updatedAt || new Date();
+    }
+
+    /**
+     * Factory method to create a new ApiModule
+     */
+    static create(props) {
+        if (!props.name) {
+            throw new DomainException('API module name is required');
+        }
+
+        // Validate name format
+        const namePattern = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+        if (!namePattern.test(props.name)) {
+            throw new DomainException('API module name must be kebab-case');
+        }
+
+        // Validate authType is provided
+        if (!props.apiConfig || !props.apiConfig.authType) {
+            throw new DomainException('Authentication type is required');
+        }
+
+        return new ApiModule(props);
+    }
+
+    /**
+     * Reconstruct ApiModule from plain object
+     */
+    static fromObject(obj) {
+        return new ApiModule({
+            ...obj,
+            version: obj.version,
+            createdAt: new Date(obj.createdAt),
+            updatedAt: new Date(obj.updatedAt)
+        });
+    }
+
+    /**
+     * Add an entity configuration
+     * Entities are database records that store API credentials and state
+     *
+     * @param {string} entityName - Entity name (e.g., 'credential', 'user')
+     * @param {object} config - Entity configuration
+     */
+    addEntity(entityName, config = {}) {
+        if (this.hasEntity(entityName)) {
+            throw new DomainException(`Entity '${entityName}' already exists`);
+        }
+
+        this.entities[entityName] = {
+            type: entityName,
+            label: config.label || entityName,
+            required: config.required !== false,
+            fields: config.fields || [],
+            ...config
+        };
+
+        this.updatedAt = new Date();
+        return this;
+    }
+
+    /**
+     * Check if entity exists
+     */
+    hasEntity(entityName) {
+        return entityName in this.entities;
+    }
+
+    /**
+     * Add an endpoint definition
+     */
+    addEndpoint(name, config) {
+        if (this.hasEndpoint(name)) {
+            throw new DomainException(`Endpoint '${name}' already exists`);
+        }
+
+        this.endpoints[name] = {
+            method: config.method || 'GET',
+            path: config.path,
+            description: config.description || '',
+            parameters: config.parameters || [],
+            response: config.response || {},
+            ...config
+        };
+
+        this.updatedAt = new Date();
+        return this;
+    }
+
+    /**
+     * Check if endpoint exists
+     */
+    hasEndpoint(name) {
+        return name in this.endpoints;
+    }
+
+    /**
+     * Add required OAuth scope
+     */
+    addScope(scope) {
+        if (this.scopes.includes(scope)) {
+            throw new DomainException(`Scope '${scope}' already exists`);
+        }
+        this.scopes.push(scope);
+        this.updatedAt = new Date();
+        return this;
+    }
+
+    /**
+     * Add required credential
+     */
+    addCredential(name, config = {}) {
+        const existing = this.credentials.find(c => c.name === name);
+        if (existing) {
+            throw new DomainException(`Credential '${name}' already exists`);
+        }
+
+        this.credentials.push({
+            name,
+            type: config.type || 'string',
+            required: config.required !== false,
+            description: config.description || '',
+            example: config.example || '',
+            envVar: config.envVar || '',
+            ...config
+        });
+
+        this.updatedAt = new Date();
+        return this;
+    }
+
+    /**
+     * Check if credential exists
+     */
+    hasCredential(name) {
+        return this.credentials.some(c => c.name === name);
+    }
+
+    /**
+     * Validate API module business rules
+     */
+    validate() {
+        const errors = [];
+
+        // Name validation (kebab-case)
+        if (!this.name || this.name.trim().length === 0) {
+            errors.push('API module name is required');
+        }
+
+        const namePattern = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+        if (this.name && !namePattern.test(this.name)) {
+            errors.push('API module name must be kebab-case');
+        }
+
+        // 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');
+        }
+
+        // API config validation
+        if (!this.apiConfig.baseUrl) {
+            // Warning: base URL should be provided, but not required at creation
+        }
+
+        // Auth type validation
+        if (!this.apiConfig.authType || this.apiConfig.authType.trim().length === 0) {
+            errors.push('Authentication type is required');
+        } else {
+            const validAuthTypes = ['oauth2', 'api-key', 'basic', 'token', 'custom'];
+            if (!validAuthTypes.includes(this.apiConfig.authType)) {
+                errors.push(`Invalid auth type. Must be one of: ${validAuthTypes.join(', ')}`);
+            }
+        }
+
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Convert to plain object
+     */
+    toObject() {
+        return {
+            name: this.name,
+            version: this.version.value,
+            displayName: this.displayName,
+            description: this.description,
+            author: this.author,
+            license: this.license,
+            apiConfig: this.apiConfig,
+            entities: this.entities,
+            scopes: this.scopes,
+            credentials: this.credentials,
+            endpoints: this.endpoints,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt
+        };
+    }
+
+    /**
+     * Convert to JSON format (for api-module definition files)
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            version: this.version.value,
+            display: {
+                name: this.displayName,
+                description: this.description
+            },
+            api: {
+                baseUrl: this.apiConfig.baseUrl,
+                authType: this.apiConfig.authType,
+                version: this.apiConfig.version
+            },
+            entities: this.entities,
+            auth: {
+                type: this.apiConfig.authType,
+                scopes: this.scopes,
+                credentials: this.credentials
+            },
+            endpoints: this.endpoints
+        };
+    }
+
+    /**
+     * Generate display name from kebab-case name
+     */
+    _generateDisplayName() {
+        return this.name
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+}
+
+module.exports = {ApiModule};

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

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

@@ -0,0 +1,198 @@
+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};