@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

package/application/commands/admin-script-commands.js

@@ -1,12 +1,6 @@
-const bcrypt = require('bcryptjs');
-const { v4: uuid } = require('uuid');
-
 const ERROR_CODE_MAP = {
-    INVALID_API_KEY: 401,
-    EXPIRED_API_KEY: 401,
     SCRIPT_NOT_FOUND: 404,
     EXECUTION_NOT_FOUND: 404,
-    UNAUTHORIZED_SCOPE: 403,
 };
 
 function mapErrorToResponse(error) {
@@ -23,166 +17,50 @@ function mapErrorToResponse(error) {
  * - Maps errors to HTTP-friendly responses
  * - Returns data or error objects (never throws)
  *
+ * WHY SEPARATE FROM integration-commands.js:
+ * These commands are intentionally separate because they serve different domains:
+ * - integration-commands: User-context operations on integrations
+ *   - Requires integrationClass constructor parameter
+ *   - Works with userId, entityIds, integration contexts
+ *   - Uses IntegrationRepository, ModuleRepository
+ * - admin-script-commands: System/admin operations without user context
+ *   - No user context required
+ *   - Works with AdminProcess, ScriptSchedule
+ *   - Uses AdminProcessRepository, ScriptScheduleRepository
+ *
+ * Merging them would violate SRP and create coupling between
+ * user-facing integration code and admin/system code.
+ *
+ * Authentication:
+ * - Uses ENV-based ADMIN_API_KEY (see handlers/middleware/admin-auth.js)
+ * - No database-backed API keys (simplified from original design)
+ *
  * @returns {Object} Command methods for admin scripts
  */
 function createAdminScriptCommands() {
     // Lazy-load repository factories to avoid circular dependencies
-    const {
-        createAdminApiKeyRepository,
-    } = require('../../admin-scripts/repositories/admin-api-key-repository-factory');
-    const {
-        createScriptExecutionRepository,
-    } = require('../../admin-scripts/repositories/script-execution-repository-factory');
-    const {
-        createScriptScheduleRepository,
-    } = require('../../admin-scripts/repositories/script-schedule-repository-factory');
+    const { createAdminProcessRepository } = require('../../admin-scripts/repositories/admin-process-repository-factory');
+    const { createScriptScheduleRepository } = require('../../admin-scripts/repositories/script-schedule-repository-factory');
 
-    const apiKeyRepository = createAdminApiKeyRepository();
-    const executionRepository = createScriptExecutionRepository();
+    const adminProcessRepository = createAdminProcessRepository();
     const scheduleRepository = createScriptScheduleRepository();
 
     return {
-        // ==================== API Key Management Commands ====================
-
-        /**
-         * Create a new admin API key
-         * Generates a UUID, hashes it with bcrypt, stores in database
-         *
-         * @param {Object} params - Key creation parameters
-         * @param {string} params.name - Human-readable name for the key
-         * @param {string[]} params.scopes - Permission scopes (e.g., ['scripts:execute'])
-         * @param {Date} [params.expiresAt] - Optional expiration date
-         * @param {string} [params.createdBy] - Optional creator identifier
-         * @returns {Promise<Object>} Created key with rawKey (only returned once!)
-         */
-        async createAdminApiKey({ name, scopes, expiresAt, createdBy }) {
-            try {
-                // Generate raw key (UUID format)
-                const rawKey = uuid();
-
-                // Hash with bcrypt (cost factor 10)
-                const keyHash = await bcrypt.hash(rawKey, 10);
-
-                // Store last 4 characters for display
-                const keyLast4 = rawKey.slice(-4);
-
-                // Create via repository
-                const record = await apiKeyRepository.createApiKey({
-                    name,
-                    keyHash,
-                    keyLast4,
-                    scopes,
-                    expiresAt,
-                    createdBy,
-                });
-
-                // Return record with rawKey (ONLY TIME IT'S RETURNED!)
-                return {
-                    id: record.id,
-                    rawKey, // User must save this - we never show it again
-                    name: record.name,
-                    keyLast4: record.keyLast4,
-                    scopes: record.scopes,
-                    expiresAt: record.expiresAt,
-                };
-            } catch (error) {
-                return mapErrorToResponse(error);
-            }
-        },
+        // ==================== Admin Process Management Commands ====================
 
         /**
-         * Validate an admin API key
-         * Compares bcrypt hash, checks expiration, updates lastUsedAt
+         * Create a new admin process record
          *
-         * @param {string} rawKey - The raw API key to validate
-         * @returns {Promise<Object>} { valid: true, apiKey } or error response
-         */
-        async validateAdminApiKey(rawKey) {
-            try {
-                // Find all active keys
-                const activeKeys = await apiKeyRepository.findActiveApiKeys();
-
-                // Compare bcrypt hash for each key
-                for (const key of activeKeys) {
-                    const isMatch = await bcrypt.compare(rawKey, key.keyHash);
-                    if (isMatch) {
-                        // Check expiration
-                        if (
-                            key.expiresAt &&
-                            new Date(key.expiresAt) < new Date()
-                        ) {
-                            const error = new Error('API key has expired');
-                            error.code = 'EXPIRED_API_KEY';
-                            return mapErrorToResponse(error);
-                        }
-
-                        // Update lastUsedAt on success
-                        await apiKeyRepository.updateApiKeyLastUsed(key.id);
-
-                        return { valid: true, apiKey: key };
-                    }
-                }
-
-                // No match found
-                const error = new Error('Invalid API key');
-                error.code = 'INVALID_API_KEY';
-                return mapErrorToResponse(error);
-            } catch (error) {
-                return mapErrorToResponse(error);
-            }
-        },
-
-        /**
-         * List all active admin API keys
-         * Returns keys without keyHash (security)
-         *
-         * @returns {Promise<Array>} Array of API key records (without keyHash)
-         */
-        async listAdminApiKeys() {
-            try {
-                const keys = await apiKeyRepository.findActiveApiKeys();
-
-                // Remove keyHash from response (security)
-                return keys.map((key) => {
-                    const { keyHash, ...safeKey } = key;
-                    return safeKey;
-                });
-            } catch (error) {
-                return mapErrorToResponse(error);
-            }
-        },
-
-        /**
-         * Deactivate an admin API key
-         * Soft delete - sets isActive to false
-         *
-         * @param {string|number} id - The API key ID
-         * @returns {Promise<Object>} Updated record or error
-         */
-        async deactivateAdminApiKey(id) {
-            try {
-                const result = await apiKeyRepository.deactivateApiKey(id);
-                return result;
-            } catch (error) {
-                return mapErrorToResponse(error);
-            }
-        },
-
-        // ==================== Execution Management Commands ====================
-
-        /**
-         * Create a new script execution record
-         *
-         * @param {Object} params - Execution creation parameters
+         * @param {Object} params - Process creation parameters
          * @param {string} params.scriptName - Name of script being executed
          * @param {string} [params.scriptVersion] - Script version
          * @param {string} params.trigger - Trigger type ('MANUAL', 'SCHEDULED', 'QUEUE', 'WEBHOOK')
          * @param {string} [params.mode] - Execution mode ('sync' or 'async', default 'async')
          * @param {Object} [params.input] - Input parameters
          * @param {Object} [params.audit] - Audit information (apiKeyName, apiKeyLast4, ipAddress)
-         * @returns {Promise<Object>} Created execution record
+         * @returns {Promise<Object>} Created admin process record
          */
-        async createScriptExecution({
+        async createAdminProcess({
             scriptName,
             scriptVersion,
             trigger,
@@ -191,7 +69,7 @@ function createAdminScriptCommands() {
             audit,
         }) {
             try {
-                const execution = await executionRepository.createExecution({
+                const process = await adminProcessRepository.createAdminProcess({
                     scriptName,
                     scriptVersion,
                     trigger,
@@ -199,51 +77,46 @@ function createAdminScriptCommands() {
                     input,
                     audit,
                 });
-                return execution;
+                return process;
             } catch (error) {
                 return mapErrorToResponse(error);
             }
         },
 
         /**
-         * Find a script execution by ID
+         * Find an admin process by ID
          *
-         * @param {string|number} executionId - The execution ID
-         * @returns {Promise<Object>} Execution record or error
+         * @param {string|number} processId - The admin process ID
+         * @returns {Promise<Object>} Admin process record or error
          */
-        async findScriptExecutionById(executionId) {
+        async findAdminProcessById(processId) {
             try {
-                const execution = await executionRepository.findExecutionById(
-                    executionId
-                );
-                if (!execution) {
-                    const error = new Error(
-                        `Execution ${executionId} not found`
-                    );
+                const process = await adminProcessRepository.findAdminProcessById(processId);
+                if (!process) {
+                    const error = new Error(`Execution ${processId} not found`);
                     error.code = 'EXECUTION_NOT_FOUND';
                     return mapErrorToResponse(error);
                 }
-                return execution;
+                return process;
             } catch (error) {
                 return mapErrorToResponse(error);
             }
         },
 
         /**
-         * Find all executions for a specific script
+         * Find all admin processes for a specific script
          *
          * @param {string} scriptName - Script name to filter by
          * @param {Object} [options] - Query options (limit, offset, sortBy, sortOrder)
-         * @returns {Promise<Array>} Array of execution records
+         * @returns {Promise<Array>} Array of admin process records
          */
-        async findScriptExecutionsByName(scriptName, options = {}) {
+        async findAdminProcessesByName(scriptName, options = {}) {
             try {
-                const executions =
-                    await executionRepository.findExecutionsByScriptName(
-                        scriptName,
-                        options
-                    );
-                return executions;
+                const processes = await adminProcessRepository.findAdminProcessesByName(
+                    scriptName,
+                    options
+                );
+                return processes;
             } catch (error) {
                 // Return empty array on error (non-critical)
                 return [];
@@ -251,17 +124,17 @@ function createAdminScriptCommands() {
         },
 
         /**
-         * Update execution status
+         * Update admin process state
          *
-         * @param {string|number} executionId - The execution ID
-         * @param {string} status - New status ('PENDING', 'RUNNING', 'COMPLETED', 'FAILED', 'TIMEOUT', 'CANCELLED')
-         * @returns {Promise<Object>} Updated execution record
+         * @param {string|number} processId - The admin process ID
+         * @param {string} state - New state ('PENDING', 'RUNNING', 'COMPLETED', 'FAILED')
+         * @returns {Promise<Object>} Updated admin process record
          */
-        async updateScriptExecutionStatus(executionId, status) {
+        async updateAdminProcessState(processId, state) {
             try {
-                const updated = await executionRepository.updateExecutionStatus(
-                    executionId,
-                    status
+                const updated = await adminProcessRepository.updateAdminProcessState(
+                    processId,
+                    state
                 );
                 return updated;
             } catch (error) {
@@ -270,16 +143,16 @@ function createAdminScriptCommands() {
         },
 
         /**
-         * Append a log entry to an execution's log array
+         * Append a log entry to an admin process's results.logs array
          *
-         * @param {string|number} executionId - The execution ID
+         * @param {string|number} processId - The admin process ID
          * @param {Object} logEntry - Log entry { level, message, data, timestamp }
-         * @returns {Promise<Object>} Updated execution record
+         * @returns {Promise<Object>} Updated admin process record
          */
-        async appendScriptExecutionLog(executionId, logEntry) {
+        async appendAdminProcessLog(processId, logEntry) {
             try {
-                const updated = await executionRepository.appendExecutionLog(
-                    executionId,
+                const updated = await adminProcessRepository.appendAdminProcessLog(
+                    processId,
                     logEntry
                 );
                 return updated;
@@ -289,46 +162,31 @@ function createAdminScriptCommands() {
         },
 
         /**
-         * Complete a script execution
-         * Updates status, output, error, and metrics
+         * Complete an admin process
+         * Updates state, output, error, and metrics
          *
-         * @param {string|number} executionId - The execution ID
+         * @param {string|number} processId - The admin process ID
          * @param {Object} params - Completion parameters
-         * @param {string} [params.status] - Final status ('COMPLETED', 'FAILED', 'TIMEOUT')
-         * @param {Object} [params.output] - Script output/result
-         * @param {Object} [params.error] - Error details { name, message, stack }
-         * @param {Object} [params.metrics] - Performance metrics { startTime, endTime, durationMs }
+         * @param {string} [params.state] - Final state ('COMPLETED', 'FAILED')
+         * @param {Object} [params.output] - Script output/result (stored in results.output)
+         * @param {Object} [params.error] - Error details { name, message, stack } (stored in results.error)
+         * @param {Object} [params.metrics] - Performance metrics { startTime, endTime, durationMs } (stored in results.metrics)
          * @returns {Promise<Object>} { success: true } or error
          */
-        async completeScriptExecution(
-            executionId,
-            { status, output, error, metrics }
-        ) {
+        async completeAdminProcess(processId, { state, output, error, metrics }) {
             try {
                 // Update each field independently (partial updates allowed)
-                if (status) {
-                    await executionRepository.updateExecutionStatus(
-                        executionId,
-                        status
-                    );
+                if (state) {
+                    await adminProcessRepository.updateAdminProcessState(processId, state);
                 }
                 if (output !== undefined) {
-                    await executionRepository.updateExecutionOutput(
-                        executionId,
-                        output
-                    );
+                    await adminProcessRepository.updateAdminProcessOutput(processId, output);
                 }
                 if (error) {
-                    await executionRepository.updateExecutionError(
-                        executionId,
-                        error
-                    );
+                    await adminProcessRepository.updateAdminProcessError(processId, error);
                 }
                 if (metrics) {
-                    await executionRepository.updateExecutionMetrics(
-                        executionId,
-                        metrics
-                    );
+                    await adminProcessRepository.updateAdminProcessMetrics(processId, metrics);
                 }
 
                 return { success: true };
@@ -338,32 +196,29 @@ function createAdminScriptCommands() {
         },
 
         /**
-         * Find recent executions across all scripts
+         * Find recent admin processes across all scripts
          *
          * @param {Object} [options] - Query options
          * @param {number} [options.limit] - Maximum results (default 20)
-         * @param {string} [options.status] - Filter by status
+         * @param {string} [options.state] - Filter by state
          * @param {Date} [options.since] - Filter by created date
-         * @returns {Promise<Array>} Array of recent executions
+         * @returns {Promise<Array>} Array of recent admin processes
          */
-        async findRecentExecutions(options = {}) {
+        async findRecentAdminProcesses(options = {}) {
             try {
-                const { limit = 20, status, since } = options;
-
-                // If status filter provided, use status query
-                if (status) {
-                    return await executionRepository.findExecutionsByStatus(
-                        status,
-                        {
-                            limit,
-                            sortBy: 'createdAt',
-                            sortOrder: 'desc',
-                        }
-                    );
+                const { limit = 20, state, since } = options;
+
+                // If state filter provided, use state query
+                if (state) {
+                    return await adminProcessRepository.findAdminProcessesByState(state, {
+                        limit,
+                        sortBy: 'createdAt',
+                        sortOrder: 'desc',
+                    });
                 }
 
                 // Otherwise, use generic recent query (would need to be added to interface)
-                // For now, fall back to empty array if no status filter
+                // For now, fall back to empty array if no state filter
                 return [];
             } catch (error) {
                 return [];
@@ -381,10 +236,7 @@ function createAdminScriptCommands() {
          */
         async getScheduleByScriptName(scriptName) {
             try {
-                const schedule =
-                    await scheduleRepository.findScheduleByScriptName(
-                        scriptName
-                    );
+                const schedule = await scheduleRepository.findScheduleByScriptName(scriptName);
                 return schedule;
             } catch (error) {
                 return mapErrorToResponse(error);
@@ -401,12 +253,7 @@ function createAdminScriptCommands() {
          * @param {string} [params.timezone] - Timezone (default 'UTC')
          * @returns {Promise<Object>} Created or updated schedule
          */
-        async upsertSchedule({
-            scriptName,
-            enabled,
-            cronExpression,
-            timezone,
-        }) {
+        async upsertSchedule({ scriptName, enabled, cronExpression, timezone }) {
             try {
                 const schedule = await scheduleRepository.upsertSchedule({
                     scriptName,
@@ -428,9 +275,7 @@ function createAdminScriptCommands() {
          */
         async deleteSchedule(scriptName) {
             try {
-                const result = await scheduleRepository.deleteSchedule(
-                    scriptName
-                );
+                const result = await scheduleRepository.deleteSchedule(scriptName);
                 return result;
             } catch (error) {
                 return mapErrorToResponse(error);
@@ -438,26 +283,20 @@ function createAdminScriptCommands() {
         },
 
         /**
-         * Update AWS EventBridge Scheduler information
+         * Update external scheduler information
          *
          * @param {string} scriptName - The script name
-         * @param {Object} awsInfo - AWS schedule information
-         * @param {string} [awsInfo.awsScheduleArn] - AWS EventBridge Scheduler ARN
-         * @param {string} [awsInfo.awsScheduleName] - AWS EventBridge Scheduler name
+         * @param {Object} externalInfo - External schedule information
+         * @param {string} [externalInfo.externalScheduleId] - External scheduler ID (e.g., AWS ARN)
+         * @param {string} [externalInfo.externalScheduleName] - External scheduler name
          * @returns {Promise<Object>} Updated schedule
          */
-        async updateScheduleAwsInfo(
-            scriptName,
-            { awsScheduleArn, awsScheduleName }
-        ) {
+        async updateScheduleExternalInfo(scriptName, { externalScheduleId, externalScheduleName }) {
             try {
-                const schedule = await scheduleRepository.updateScheduleAwsInfo(
-                    scriptName,
-                    {
-                        awsScheduleArn,
-                        awsScheduleName,
-                    }
-                );
+                const schedule = await scheduleRepository.updateScheduleExternalInfo(scriptName, {
+                    externalScheduleId,
+                    externalScheduleName,
+                });
                 return schedule;
             } catch (error) {
                 return mapErrorToResponse(error);
@@ -474,11 +313,10 @@ function createAdminScriptCommands() {
          */
         async updateScheduleLastTriggered(scriptName, timestamp) {
             try {
-                const schedule =
-                    await scheduleRepository.updateScheduleLastTriggered(
-                        scriptName,
-                        timestamp
-                    );
+                const schedule = await scheduleRepository.updateScheduleLastTriggered(
+                    scriptName,
+                    timestamp
+                );
                 return schedule;
             } catch (error) {
                 return mapErrorToResponse(error);
@@ -494,9 +332,7 @@ function createAdminScriptCommands() {
          */
         async listSchedules(options = {}) {
             try {
-                const schedules = await scheduleRepository.listSchedules(
-                    options
-                );
+                const schedules = await scheduleRepository.listSchedules(options);
                 return schedules;
             } catch (error) {
                 return [];

package/application/commands/integration-commands.js

@@ -152,11 +152,10 @@ function createIntegrationCommands({ integrationClass }) {
          */
         async updateIntegrationConfig({ integrationId, config }) {
             try {
-                const integration =
-                    await integrationRepository.updateIntegrationConfig(
-                        integrationId,
-                        config
-                    );
+                const integration = await integrationRepository.updateIntegrationConfig(
+                    integrationId,
+                    config
+                );
                 return integration;
             } catch (error) {
                 return mapErrorToResponse(error);
@@ -176,15 +175,10 @@ function createIntegrationCommands({ integrationClass }) {
                     throw error;
                 }
 
-                const deleted =
-                    await integrationRepository.deleteIntegrationById(
-                        integrationId
-                    );
+                const deleted = await integrationRepository.deleteIntegrationById(integrationId);
 
                 if (!deleted) {
-                    const error = new Error(
-                        `Integration ${integrationId} not found`
-                    );
+                    const error = new Error(`Integration ${integrationId} not found`);
                     error.code = 'INTEGRATION_NOT_FOUND';
                     return mapErrorToResponse(error);
                 }

package/application/index.js

@@ -4,7 +4,9 @@ const {
 } = require('./commands/integration-commands');
 const { createUserCommands } = require('./commands/user-commands');
 const { createEntityCommands } = require('./commands/entity-commands');
-const { createCredentialCommands } = require('./commands/credential-commands');
+const {
+    createCredentialCommands,
+} = require('./commands/credential-commands');
 
 /**
  * Create a unified command factory with all CRUD operations

package/assertions/get.js

@@ -1,5 +1,8 @@
 const lodashGet = require('lodash.get');
-const { RequiredPropertyError, ParameterTypeError } = require('../errors');
+const {
+    RequiredPropertyError,
+    ParameterTypeError,
+} = require('../errors');
 
 const get = (o, key, defaultValue) => {
     const value = lodashGet(o, key, defaultValue);