@friggframework/core 2.0.0--canary.517.f04156f.0 → 2.0.0--canary.517.a37d697.0

package/admin-scripts/index.js

@@ -16,16 +16,16 @@
  */
 
 // Repository Interfaces
-const { ScriptExecutionRepositoryInterface } = require('./repositories/script-execution-repository-interface');
+const { AdminProcessRepositoryInterface } = require('./repositories/admin-process-repository-interface');
 const { ScriptScheduleRepositoryInterface } = require('./repositories/script-schedule-repository-interface');
 
 // Repository Factories
 const {
-    createScriptExecutionRepository,
-    ScriptExecutionRepositoryMongo,
-    ScriptExecutionRepositoryPostgres,
-    ScriptExecutionRepositoryDocumentDB,
-} = require('./repositories/script-execution-repository-factory');
+    createAdminProcessRepository,
+    AdminProcessRepositoryMongo,
+    AdminProcessRepositoryPostgres,
+    AdminProcessRepositoryDocumentDB,
+} = require('./repositories/admin-process-repository-factory');
 const {
     createScriptScheduleRepository,
     ScriptScheduleRepositoryMongo,
@@ -35,17 +35,17 @@ const {
 
 module.exports = {
     // Repository Interfaces
-    ScriptExecutionRepositoryInterface,
+    AdminProcessRepositoryInterface,
     ScriptScheduleRepositoryInterface,
 
     // Repository Factories (primary exports for use cases)
-    createScriptExecutionRepository,
+    createAdminProcessRepository,
     createScriptScheduleRepository,
 
     // Concrete Implementations (for testing)
-    ScriptExecutionRepositoryMongo,
-    ScriptExecutionRepositoryPostgres,
-    ScriptExecutionRepositoryDocumentDB,
+    AdminProcessRepositoryMongo,
+    AdminProcessRepositoryPostgres,
+    AdminProcessRepositoryDocumentDB,
     ScriptScheduleRepositoryMongo,
     ScriptScheduleRepositoryPostgres,
     ScriptScheduleRepositoryDocumentDB,

package/admin-scripts/repositories/{script-execution-repository-documentdb.js → admin-process-repository-documentdb.js}

@@ -1,9 +1,9 @@
 const {
-    ScriptExecutionRepositoryMongo,
-} = require('./script-execution-repository-mongo');
+    AdminProcessRepositoryMongo,
+} = require('./admin-process-repository-mongo');
 
 /**
- * DocumentDB Script Execution Repository Adapter
+ * DocumentDB Admin Process Repository Adapter
  * Extends MongoDB implementation since DocumentDB uses the same Prisma client
  *
  * DocumentDB-specific characteristics:
@@ -12,10 +12,10 @@ const {
  * - IDs are strings with ObjectId format
  * - All operations identical to MongoDB implementation
  */
-class ScriptExecutionRepositoryDocumentDB extends ScriptExecutionRepositoryMongo {
+class AdminProcessRepositoryDocumentDB extends AdminProcessRepositoryMongo {
     constructor() {
         super();
     }
 }
 
-module.exports = { ScriptExecutionRepositoryDocumentDB };
+module.exports = { AdminProcessRepositoryDocumentDB };

package/admin-scripts/repositories/{script-execution-repository-factory.js → admin-process-repository-factory.js}

@@ -1,12 +1,12 @@
-const { ScriptExecutionRepositoryMongo } = require('./script-execution-repository-mongo');
-const { ScriptExecutionRepositoryPostgres } = require('./script-execution-repository-postgres');
+const { AdminProcessRepositoryMongo } = require('./admin-process-repository-mongo');
+const { AdminProcessRepositoryPostgres } = require('./admin-process-repository-postgres');
 const {
-    ScriptExecutionRepositoryDocumentDB,
-} = require('./script-execution-repository-documentdb');
+    AdminProcessRepositoryDocumentDB,
+} = require('./admin-process-repository-documentdb');
 const config = require('../../database/config');
 
 /**
- * Script Execution Repository Factory
+ * Admin Process Repository Factory
  * Creates the appropriate repository adapter based on database type
  *
  * This implements the Factory pattern for Hexagonal Architecture:
@@ -16,24 +16,24 @@ const config = require('../../database/config');
  *
  * Usage:
  * ```javascript
- * const repository = createScriptExecutionRepository();
+ * const repository = createAdminProcessRepository();
  * ```
  *
- * @returns {ScriptExecutionRepositoryInterface} Configured repository adapter
+ * @returns {AdminProcessRepositoryInterface} Configured repository adapter
  * @throws {Error} If database type is not supported
  */
-function createScriptExecutionRepository() {
+function createAdminProcessRepository() {
     const dbType = config.DB_TYPE;
 
     switch (dbType) {
         case 'mongodb':
-            return new ScriptExecutionRepositoryMongo();
+            return new AdminProcessRepositoryMongo();
 
         case 'postgresql':
-            return new ScriptExecutionRepositoryPostgres();
+            return new AdminProcessRepositoryPostgres();
 
         case 'documentdb':
-            return new ScriptExecutionRepositoryDocumentDB();
+            return new AdminProcessRepositoryDocumentDB();
 
         default:
             throw new Error(
@@ -43,9 +43,9 @@ function createScriptExecutionRepository() {
 }
 
 module.exports = {
-    createScriptExecutionRepository,
+    createAdminProcessRepository,
     // Export adapters for direct testing
-    ScriptExecutionRepositoryMongo,
-    ScriptExecutionRepositoryPostgres,
-    ScriptExecutionRepositoryDocumentDB,
+    AdminProcessRepositoryMongo,
+    AdminProcessRepositoryPostgres,
+    AdminProcessRepositoryDocumentDB,
 };

package/admin-scripts/repositories/admin-process-repository-interface.js

@@ -0,0 +1,150 @@
+/**
+ * Admin Process Repository Interface
+ * Abstract base class defining the contract for admin process persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Admin processes track administrative operations including:
+ * - Admin script executions
+ * - Database migrations
+ * - Scheduled maintenance tasks
+ *
+ * The AdminProcess model uses a flexible JSON storage pattern:
+ * - context: Input parameters, trigger info, audit data, script version
+ * - results: Output data, logs, metrics, error details
+ *
+ * @abstract
+ */
+class AdminProcessRepositoryInterface {
+    /**
+     * Create a new admin process record
+     *
+     * @param {Object} params - Process creation parameters
+     * @param {string} params.name - Name of the process (e.g., script name, migration name)
+     * @param {string} params.type - Type of process (e.g., 'ADMIN_SCRIPT', 'DB_MIGRATION')
+     * @param {Object} [params.context] - Context data (input, trigger, audit, script version)
+     * @param {string} [params.context.scriptVersion] - Version of the script
+     * @param {string} [params.context.trigger] - Trigger type ('MANUAL', 'SCHEDULED', 'QUEUE', 'WEBHOOK')
+     * @param {string} [params.context.mode] - Execution mode ('sync' or 'async')
+     * @param {Object} [params.context.input] - Input parameters
+     * @param {Object} [params.context.audit] - Audit information
+     * @param {string} [params.context.audit.apiKeyName] - Name of API key used
+     * @param {string} [params.context.audit.apiKeyLast4] - Last 4 chars of API key
+     * @param {string} [params.context.audit.ipAddress] - IP address of requester
+     * @returns {Promise<Object>} The created process record
+     * @abstract
+     */
+    async createProcess({ name, type, context }) {
+        throw new Error('Method createProcess must be implemented by subclass');
+    }
+
+    /**
+     * Find a process by its ID
+     *
+     * @param {string|number} id - The process ID
+     * @returns {Promise<Object|null>} The process record or null if not found
+     * @abstract
+     */
+    async findProcessById(id) {
+        throw new Error('Method findProcessById must be implemented by subclass');
+    }
+
+    /**
+     * Find all processes with a specific name
+     *
+     * @param {string} name - The process name to filter by
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.offset] - Number of results to skip
+     * @param {string} [options.sortBy] - Field to sort by
+     * @param {string} [options.sortOrder] - Sort order ('asc' or 'desc')
+     * @returns {Promise<Array>} Array of process records
+     * @abstract
+     */
+    async findProcessesByName(name, options = {}) {
+        throw new Error('Method findProcessesByName must be implemented by subclass');
+    }
+
+    /**
+     * Find all processes with a specific state
+     *
+     * @param {string} state - State to filter by ('PENDING', 'RUNNING', 'COMPLETED', 'FAILED')
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.offset] - Number of results to skip
+     * @param {string} [options.sortBy] - Field to sort by
+     * @param {string} [options.sortOrder] - Sort order ('asc' or 'desc')
+     * @returns {Promise<Array>} Array of process records
+     * @abstract
+     */
+    async findProcessesByState(state, options = {}) {
+        throw new Error('Method findProcessesByState must be implemented by subclass');
+    }
+
+    /**
+     * Update the state of a process
+     *
+     * @param {string|number} id - The process ID
+     * @param {string} state - New state value ('PENDING', 'RUNNING', 'COMPLETED', 'FAILED')
+     * @returns {Promise<Object>} Updated process record
+     * @abstract
+     */
+    async updateProcessState(id, state) {
+        throw new Error('Method updateProcessState must be implemented by subclass');
+    }
+
+    /**
+     * Update the results of a process
+     * Merges new results with existing results in the results JSON field
+     *
+     * @param {string|number} id - The process ID
+     * @param {Object} results - Results data to merge
+     * @param {Object} [results.output] - Output data from the process
+     * @param {Object} [results.error] - Error information
+     * @param {string} [results.error.name] - Error name/type
+     * @param {string} [results.error.message] - Error message
+     * @param {string} [results.error.stack] - Error stack trace
+     * @param {Object} [results.metrics] - Performance metrics
+     * @param {Date} [results.metrics.startTime] - Process start time
+     * @param {Date} [results.metrics.endTime] - Process end time
+     * @param {number} [results.metrics.durationMs] - Duration in milliseconds
+     * @returns {Promise<Object>} Updated process record
+     * @abstract
+     */
+    async updateProcessResults(id, results) {
+        throw new Error('Method updateProcessResults must be implemented by subclass');
+    }
+
+    /**
+     * Append a log entry to a process's log array in results
+     *
+     * @param {string|number} id - The process ID
+     * @param {Object} logEntry - Log entry to append
+     * @param {string} logEntry.level - Log level ('debug', 'info', 'warn', 'error')
+     * @param {string} logEntry.message - Log message
+     * @param {Object} [logEntry.data] - Additional log data
+     * @param {string} logEntry.timestamp - ISO timestamp
+     * @returns {Promise<Object>} Updated process record
+     * @abstract
+     */
+    async appendProcessLog(id, logEntry) {
+        throw new Error('Method appendProcessLog must be implemented by subclass');
+    }
+
+    /**
+     * Delete all processes older than a specific date
+     * Used for cleanup and retention policies
+     *
+     * @param {Date} date - Delete processes older than this date
+     * @returns {Promise<Object>} Deletion result with count
+     * @abstract
+     */
+    async deleteProcessesOlderThan(date) {
+        throw new Error('Method deleteProcessesOlderThan must be implemented by subclass');
+    }
+}
+
+module.exports = { AdminProcessRepositoryInterface };

package/admin-scripts/repositories/admin-process-repository-mongo.js

@@ -0,0 +1,213 @@
+const { prisma } = require('../../database/prisma');
+const {
+    AdminProcessRepositoryInterface,
+} = require('./admin-process-repository-interface');
+
+/**
+ * MongoDB Admin Process Repository Adapter
+ * Handles admin process persistence using Prisma with MongoDB
+ *
+ * MongoDB-specific characteristics:
+ * - IDs are strings with @db.ObjectId
+ * - context and results are Json objects
+ * - Stores logs in results.logs array
+ */
+class AdminProcessRepositoryMongo extends AdminProcessRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Create a new admin process record
+     *
+     * @param {Object} params - Process creation parameters
+     * @param {string} params.name - Name of the process
+     * @param {string} params.type - Type of process (e.g., 'ADMIN_SCRIPT', 'DB_MIGRATION')
+     * @param {Object} [params.context] - Context data
+     * @returns {Promise<Object>} The created process record
+     */
+    async createProcess({ name, type, context = {} }) {
+        const data = {
+            name,
+            type,
+            context,
+            results: { logs: [] },
+        };
+
+        const process = await this.prisma.adminProcess.create({
+            data,
+        });
+
+        return process;
+    }
+
+    /**
+     * Find a process by its ID
+     *
+     * @param {string} id - The process ID
+     * @returns {Promise<Object|null>} The process record or null if not found
+     */
+    async findProcessById(id) {
+        const process = await this.prisma.adminProcess.findUnique({
+            where: { id },
+        });
+
+        return process;
+    }
+
+    /**
+     * Find all processes with a specific name
+     *
+     * @param {string} name - The process name to filter by
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.offset] - Number of results to skip
+     * @param {string} [options.sortBy] - Field to sort by
+     * @param {string} [options.sortOrder] - Sort order ('asc' or 'desc')
+     * @returns {Promise<Array>} Array of process records
+     */
+    async findProcessesByName(name, options = {}) {
+        const { limit, offset, sortBy = 'createdAt', sortOrder = 'desc' } = options;
+
+        const processes = await this.prisma.adminProcess.findMany({
+            where: { name },
+            orderBy: { [sortBy]: sortOrder },
+            take: limit,
+            skip: offset,
+        });
+
+        return processes;
+    }
+
+    /**
+     * Find all processes with a specific state
+     *
+     * @param {string} state - State to filter by
+     * @param {Object} [options] - Query options
+     * @param {number} [options.limit] - Maximum number of results
+     * @param {number} [options.offset] - Number of results to skip
+     * @param {string} [options.sortBy] - Field to sort by
+     * @param {string} [options.sortOrder] - Sort order ('asc' or 'desc')
+     * @returns {Promise<Array>} Array of process records
+     */
+    async findProcessesByState(state, options = {}) {
+        const { limit, offset, sortBy = 'createdAt', sortOrder = 'desc' } = options;
+
+        const processes = await this.prisma.adminProcess.findMany({
+            where: { state },
+            orderBy: { [sortBy]: sortOrder },
+            take: limit,
+            skip: offset,
+        });
+
+        return processes;
+    }
+
+    /**
+     * Update the state of a process
+     *
+     * @param {string} id - The process ID
+     * @param {string} state - New state value
+     * @returns {Promise<Object>} Updated process record
+     */
+    async updateProcessState(id, state) {
+        const process = await this.prisma.adminProcess.update({
+            where: { id },
+            data: { state },
+        });
+
+        return process;
+    }
+
+    /**
+     * Update the results of a process
+     * Merges new results with existing results
+     *
+     * @param {string} id - The process ID
+     * @param {Object} results - Results data to merge
+     * @returns {Promise<Object>} Updated process record
+     */
+    async updateProcessResults(id, results) {
+        // Get current process to merge results
+        const currentProcess = await this.prisma.adminProcess.findUnique({
+            where: { id },
+        });
+
+        if (!currentProcess) {
+            throw new Error(`AdminProcess ${id} not found`);
+        }
+
+        // Merge new results with existing results
+        const mergedResults = {
+            ...(currentProcess.results || {}),
+            ...results,
+        };
+
+        const process = await this.prisma.adminProcess.update({
+            where: { id },
+            data: { results: mergedResults },
+        });
+
+        return process;
+    }
+
+    /**
+     * Append a log entry to a process's log array in results
+     *
+     * @param {string} id - The process ID
+     * @param {Object} logEntry - Log entry to append
+     * @param {string} logEntry.level - Log level ('debug', 'info', 'warn', 'error')
+     * @param {string} logEntry.message - Log message
+     * @param {Object} [logEntry.data] - Additional log data
+     * @param {string} logEntry.timestamp - ISO timestamp
+     * @returns {Promise<Object>} Updated process record
+     */
+    async appendProcessLog(id, logEntry) {
+        // Get current process
+        const process = await this.prisma.adminProcess.findUnique({
+            where: { id },
+        });
+
+        if (!process) {
+            throw new Error(`AdminProcess ${id} not found`);
+        }
+
+        // Get current results and logs
+        const results = process.results || {};
+        const logs = Array.isArray(results.logs) ? [...results.logs] : [];
+        logs.push(logEntry);
+
+        // Update with new logs array in results
+        const updated = await this.prisma.adminProcess.update({
+            where: { id },
+            data: { results: { ...results, logs } },
+        });
+
+        return updated;
+    }
+
+    /**
+     * Delete all processes older than a specific date
+     * Used for cleanup and retention policies
+     *
+     * @param {Date} date - Delete processes older than this date
+     * @returns {Promise<Object>} Deletion result with count
+     */
+    async deleteProcessesOlderThan(date) {
+        const result = await this.prisma.adminProcess.deleteMany({
+            where: {
+                createdAt: {
+                    lt: date,
+                },
+            },
+        });
+
+        return {
+            acknowledged: true,
+            deletedCount: result.count,
+        };
+    }
+}
+
+module.exports = { AdminProcessRepositoryMongo };