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

package/admin-scripts/repositories/admin-api-key-repository-postgres.js

@@ -1,189 +0,0 @@
-const { prisma } = require('../../database/prisma');
-const {
-    AdminApiKeyRepositoryInterface,
-} = require('./admin-api-key-repository-interface');
-
-/**
- * PostgreSQL Admin API Key Repository Adapter
- * Handles admin API key persistence using Prisma with PostgreSQL
- *
- * PostgreSQL-specific characteristics:
- * - Uses Int IDs with autoincrement
- * - Requires ID conversion: String (app layer) ↔ Int (database)
- * - All returned IDs are converted to strings for application layer consistency
- */
-class AdminApiKeyRepositoryPostgres extends AdminApiKeyRepositoryInterface {
-    constructor() {
-        super();
-        this.prisma = prisma;
-    }
-
-    /**
-     * Convert string ID to integer for PostgreSQL queries
-     * @private
-     * @param {string|number|null|undefined} id - ID to convert
-     * @returns {number|null|undefined} Integer ID or null/undefined
-     * @throws {Error} If ID cannot be converted to integer
-     */
-    _convertId(id) {
-        if (id === null || id === undefined) return id;
-        const parsed = Number.parseInt(id, 10);
-        if (Number.isNaN(parsed)) {
-            throw new Error(`Invalid ID: ${id} cannot be converted to integer`);
-        }
-        return parsed;
-    }
-
-    /**
-     * Convert API key object IDs to strings
-     * @private
-     * @param {Object|null} apiKey - API key object from database
-     * @returns {Object|null} API key with string IDs
-     */
-    _convertApiKeyIds(apiKey) {
-        if (!apiKey) return apiKey;
-        return {
-            ...apiKey,
-            id: apiKey.id?.toString(),
-        };
-    }
-
-    /**
-     * Create a new admin API key
-     *
-     * @param {Object} params - API key creation parameters
-     * @param {string} params.name - Human-readable name for the key
-     * @param {string} params.keyHash - bcrypt hash of the raw key
-     * @param {string} params.keyLast4 - Last 4 characters of key (for display)
-     * @param {string[]} params.scopes - Array of permission scopes
-     * @param {Date} [params.expiresAt] - Optional expiration date
-     * @param {string} [params.createdBy] - Optional identifier of creator
-     * @returns {Promise<Object>} The created API key record with string ID
-     */
-    async createApiKey({
-        name,
-        keyHash,
-        keyLast4,
-        scopes,
-        expiresAt,
-        createdBy,
-    }) {
-        const apiKey = await this.prisma.adminApiKey.create({
-            data: {
-                name,
-                keyHash,
-                keyLast4,
-                scopes,
-                expiresAt,
-                createdBy,
-            },
-        });
-
-        return this._convertApiKeyIds(apiKey);
-    }
-
-    /**
-     * Find an API key by its bcrypt hash
-     * Used during authentication to validate incoming keys
-     *
-     * @param {string} keyHash - The bcrypt hash to search for
-     * @returns {Promise<Object|null>} The API key record with string ID or null if not found
-     */
-    async findApiKeyByHash(keyHash) {
-        const apiKey = await this.prisma.adminApiKey.findUnique({
-            where: { keyHash },
-        });
-
-        return this._convertApiKeyIds(apiKey);
-    }
-
-    /**
-     * Find an API key by its ID
-     *
-     * @param {string|number} id - The API key ID
-     * @returns {Promise<Object|null>} The API key record with string ID or null if not found
-     */
-    async findApiKeyById(id) {
-        const intId = this._convertId(id);
-        const apiKey = await this.prisma.adminApiKey.findUnique({
-            where: { id: intId },
-        });
-
-        return this._convertApiKeyIds(apiKey);
-    }
-
-    /**
-     * Find all active (non-expired, non-deactivated) API keys
-     * Used during authentication to check all valid keys
-     *
-     * @returns {Promise<Array>} Array of active API key records with string IDs
-     */
-    async findActiveApiKeys() {
-        const now = new Date();
-        const apiKeys = await this.prisma.adminApiKey.findMany({
-            where: {
-                isActive: true,
-                OR: [{ expiresAt: null }, { expiresAt: { gt: now } }],
-            },
-        });
-
-        return apiKeys.map((apiKey) => this._convertApiKeyIds(apiKey));
-    }
-
-    /**
-     * Update the lastUsedAt timestamp for an API key
-     * Called after successful authentication
-     *
-     * @param {string|number} id - The API key ID
-     * @returns {Promise<Object>} Updated API key record with string ID
-     */
-    async updateApiKeyLastUsed(id) {
-        const intId = this._convertId(id);
-        const apiKey = await this.prisma.adminApiKey.update({
-            where: { id: intId },
-            data: {
-                lastUsedAt: new Date(),
-            },
-        });
-
-        return this._convertApiKeyIds(apiKey);
-    }
-
-    /**
-     * Deactivate an API key (soft delete)
-     * Sets isActive to false, preventing further use
-     *
-     * @param {string|number} id - The API key ID
-     * @returns {Promise<Object>} Updated API key record with string ID
-     */
-    async deactivateApiKey(id) {
-        const intId = this._convertId(id);
-        const apiKey = await this.prisma.adminApiKey.update({
-            where: { id: intId },
-            data: {
-                isActive: false,
-            },
-        });
-
-        return this._convertApiKeyIds(apiKey);
-    }
-
-    /**
-     * Delete an API key (hard delete)
-     * Permanently removes the key from the database
-     *
-     * @param {string|number} id - The API key ID
-     * @returns {Promise<Object>} Deletion result
-     */
-    async deleteApiKey(id) {
-        const intId = this._convertId(id);
-        await this.prisma.adminApiKey.delete({
-            where: { id: intId },
-        });
-
-        // Return Mongoose-compatible result
-        return { acknowledged: true, deletedCount: 1 };
-    }
-}
-
-module.exports = { AdminApiKeyRepositoryPostgres };

package/admin-scripts/repositories/script-execution-repository-documentdb.js

@@ -1,21 +0,0 @@
-const {
-    ScriptExecutionRepositoryMongo,
-} = require('./script-execution-repository-mongo');
-
-/**
- * DocumentDB Script Execution Repository Adapter
- * Extends MongoDB implementation since DocumentDB uses the same Prisma client
- *
- * DocumentDB-specific characteristics:
- * - Uses MongoDB-compatible API
- * - Prisma client handles the connection
- * - IDs are strings with ObjectId format
- * - All operations identical to MongoDB implementation
- */
-class ScriptExecutionRepositoryDocumentDB extends ScriptExecutionRepositoryMongo {
-    constructor() {
-        super();
-    }
-}
-
-module.exports = { ScriptExecutionRepositoryDocumentDB };

package/admin-scripts/repositories/script-execution-repository-factory.js

@@ -1,55 +0,0 @@
-const {
-    ScriptExecutionRepositoryMongo,
-} = require('./script-execution-repository-mongo');
-const {
-    ScriptExecutionRepositoryPostgres,
-} = require('./script-execution-repository-postgres');
-const {
-    ScriptExecutionRepositoryDocumentDB,
-} = require('./script-execution-repository-documentdb');
-const config = require('../../database/config');
-
-/**
- * Script Execution Repository Factory
- * Creates the appropriate repository adapter based on database type
- *
- * This implements the Factory pattern for Hexagonal Architecture:
- * - Reads database type from app definition (backend/index.js)
- * - Returns correct adapter (MongoDB, DocumentDB, or PostgreSQL)
- * - Provides clear error for unsupported databases
- *
- * Usage:
- * ```javascript
- * const repository = createScriptExecutionRepository();
- * ```
- *
- * @returns {ScriptExecutionRepositoryInterface} Configured repository adapter
- * @throws {Error} If database type is not supported
- */
-function createScriptExecutionRepository() {
-    const dbType = config.DB_TYPE;
-
-    switch (dbType) {
-        case 'mongodb':
-            return new ScriptExecutionRepositoryMongo();
-
-        case 'postgresql':
-            return new ScriptExecutionRepositoryPostgres();
-
-        case 'documentdb':
-            return new ScriptExecutionRepositoryDocumentDB();
-
-        default:
-            throw new Error(
-                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'documentdb', 'postgresql'`
-            );
-    }
-}
-
-module.exports = {
-    createScriptExecutionRepository,
-    // Export adapters for direct testing
-    ScriptExecutionRepositoryMongo,
-    ScriptExecutionRepositoryPostgres,
-    ScriptExecutionRepositoryDocumentDB,
-};

package/admin-scripts/repositories/script-execution-repository-interface.js

@@ -1,193 +0,0 @@
-/**
- * Script Execution Repository Interface
- * Abstract base class defining the contract for script execution 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
- *
- * Script executions track the lifecycle of admin script runs, including:
- * - Input parameters and output results
- * - Execution status and error details
- * - Performance metrics
- * - Audit trail (who triggered, when, from where)
- * - Real-time logs
- *
- * @abstract
- */
-class ScriptExecutionRepositoryInterface {
-    /**
-     * Create a new script execution record
-     *
-     * @param {Object} params - Execution creation parameters
-     * @param {string} params.scriptName - Name of the script being executed
-     * @param {string} [params.scriptVersion] - Version of the script
-     * @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 for the script
-     * @param {Object} [params.audit] - Audit information
-     * @param {string} [params.audit.apiKeyName] - Name of API key used
-     * @param {string} [params.audit.apiKeyLast4] - Last 4 chars of API key
-     * @param {string} [params.audit.ipAddress] - IP address of requester
-     * @returns {Promise<Object>} The created execution record
-     * @abstract
-     */
-    async createExecution({
-        scriptName,
-        scriptVersion,
-        trigger,
-        mode,
-        input,
-        audit,
-    }) {
-        throw new Error(
-            'Method createExecution must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Find an execution by its ID
-     *
-     * @param {string|number} id - The execution ID
-     * @returns {Promise<Object|null>} The execution record or null if not found
-     * @abstract
-     */
-    async findExecutionById(id) {
-        throw new Error(
-            'Method findExecutionById must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Find all executions for a specific script
-     *
-     * @param {string} scriptName - The script 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 execution records
-     * @abstract
-     */
-    async findExecutionsByScriptName(scriptName, options = {}) {
-        throw new Error(
-            'Method findExecutionsByScriptName must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Find all executions with a specific status
-     *
-     * @param {string} status - Status to filter by ('PENDING', 'RUNNING', 'COMPLETED', 'FAILED', 'TIMEOUT', 'CANCELLED')
-     * @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 execution records
-     * @abstract
-     */
-    async findExecutionsByStatus(status, options = {}) {
-        throw new Error(
-            'Method findExecutionsByStatus must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Update the status of an execution
-     *
-     * @param {string|number} id - The execution ID
-     * @param {string} status - New status value
-     * @returns {Promise<Object>} Updated execution record
-     * @abstract
-     */
-    async updateExecutionStatus(id, status) {
-        throw new Error(
-            'Method updateExecutionStatus must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Update the output result of an execution
-     *
-     * @param {string|number} id - The execution ID
-     * @param {Object} output - Output data from the script
-     * @returns {Promise<Object>} Updated execution record
-     * @abstract
-     */
-    async updateExecutionOutput(id, output) {
-        throw new Error(
-            'Method updateExecutionOutput must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Update the error details of a failed execution
-     *
-     * @param {string|number} id - The execution ID
-     * @param {Object} error - Error information
-     * @param {string} error.name - Error name/type
-     * @param {string} error.message - Error message
-     * @param {string} [error.stack] - Error stack trace
-     * @returns {Promise<Object>} Updated execution record
-     * @abstract
-     */
-    async updateExecutionError(id, error) {
-        throw new Error(
-            'Method updateExecutionError must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Update the performance metrics of an execution
-     *
-     * @param {string|number} id - The execution ID
-     * @param {Object} metrics - Performance metrics
-     * @param {Date} [metrics.startTime] - Execution start time
-     * @param {Date} [metrics.endTime] - Execution end time
-     * @param {number} [metrics.durationMs] - Duration in milliseconds
-     * @returns {Promise<Object>} Updated execution record
-     * @abstract
-     */
-    async updateExecutionMetrics(id, metrics) {
-        throw new Error(
-            'Method updateExecutionMetrics must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Append a log entry to an execution's log array
-     *
-     * @param {string|number} id - The execution 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 execution record
-     * @abstract
-     */
-    async appendExecutionLog(id, logEntry) {
-        throw new Error(
-            'Method appendExecutionLog must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Delete all executions older than a specific date
-     * Used for cleanup and retention policies
-     *
-     * @param {Date} date - Delete executions older than this date
-     * @returns {Promise<Object>} Deletion result with count
-     * @abstract
-     */
-    async deleteExecutionsOlderThan(date) {
-        throw new Error(
-            'Method deleteExecutionsOlderThan must be implemented by subclass'
-        );
-    }
-}
-
-module.exports = { ScriptExecutionRepositoryInterface };