@friggframework/core 2.0.0-next.12 → 2.0.0-next.120

package/index.js

@@ -1,5 +1,4 @@
 const {
-    expectShallowEqualDbObject,
     get,
     getAll,
     verifyType,
@@ -12,61 +11,103 @@ const {
     Worker,
     loadInstalledModules,
     createHandler,
+    runInvocationScope,
 } = require('./core/index');
 const {
-    mongoose,
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-    IndividualUser,
-    OrganizationUser,
-    State,
-    Token,
-    UserModel,
-    WebsocketConnection,
+    prisma,
+    connectPrisma,
+    disconnectPrisma,
+    TokenRepository,
+    WebsocketConnectionRepository,
 } = require('./database/index');
-const { Encrypt, Cryptor } = require('./encrypt/encrypt');
+const {
+    createUserRepository,
+    UserRepositoryMongo,
+    UserRepositoryPostgres,
+} = require('./user/repositories/user-repository-factory');
+const {
+    GetUserFromXFriggHeaders,
+} = require('./user/use-cases/get-user-from-x-frigg-headers');
+const {
+    GetUserFromAdopterJwt,
+} = require('./user/use-cases/get-user-from-adopter-jwt');
+const { AuthenticateUser } = require('./user/use-cases/authenticate-user');
+
+const {
+    CredentialRepository,
+} = require('./credential/repositories/credential-repository');
+const {
+    ModuleRepository,
+} = require('./modules/repositories/module-repository');
+const {
+    IntegrationMappingRepository,
+} = require('./integrations/repositories/integration-mapping-repository');
+const { CreateProcess } = require('./integrations/use-cases/create-process');
+const {
+    UpdateProcessState,
+} = require('./integrations/use-cases/update-process-state');
+const {
+    UpdateProcessMetrics,
+} = require('./integrations/use-cases/update-process-metrics');
+const { GetProcess } = require('./integrations/use-cases/get-process');
+const { Cryptor } = require('./encrypt');
 const {
     BaseError,
     FetchError,
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
+    MappingAlreadyExistsError,
 } = require('./errors/index');
 const {
     IntegrationBase,
-    IntegrationModel,
     Options,
-    IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     createIntegrationRouter,
     checkRequiredParams,
-    createFriggBackend,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
 } = require('./integrations/index');
+const {
+    ReportBase,
+    IntegrationsReport,
+    BUILTIN_REPORTS,
+    createReportCommands,
+} = require('./reporting/index');
+const {
+    createTelemetry,
+    getTelemetry,
+    CANONICAL_COUNTERS,
+} = require('./telemetry/index');
+const { createUsageRepository } = require('./usage/index');
 const { TimeoutCatcher } = require('./lambda/index');
-const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
+const {
+    getLogger,
+    createMemorySink,
+    resetLoggerForTests,
+    serializeError,
+    redactValue,
+    toSanitizedSurrogate,
+    debug,
+    initDebugLog,
+    flushDebugLog,
+} = require('./logs/index');
 const {
     Credential,
-    EntityManager,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
-} = require('./module-plugin/index');
-
-// const {Sync } = require('./syncs/model');
+} = require('./modules/index');
+const application = require('./application');
+const utils = require('./utils');
 
 const { QueuerUtil } = require('./queues');
 
 module.exports = {
     // assertions
-    expectShallowEqualDbObject,
     get,
     getAll,
     verifyType,
@@ -79,21 +120,23 @@ module.exports = {
     Worker,
     loadInstalledModules,
     createHandler,
+    runInvocationScope,
 
     // database
-    mongoose,
-    connectToDatabase,
-    disconnectFromDatabase,
-    createObjectId,
-    IndividualUser,
-    OrganizationUser,
-    State,
-    Token,
-    UserModel,
-    WebsocketConnection,
-
-    // encrypt
-    Encrypt,
+    prisma,
+    connectPrisma,
+    disconnectPrisma,
+    TokenRepository,
+    WebsocketConnectionRepository,
+    createUserRepository,
+    UserRepositoryMongo,
+    UserRepositoryPostgres,
+    GetUserFromXFriggHeaders,
+    GetUserFromAdopterJwt,
+    AuthenticateUser,
+    CredentialRepository,
+    ModuleRepository,
+    IntegrationMappingRepository,
     Cryptor,
 
     // errors
@@ -102,39 +145,72 @@ module.exports = {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
+    MappingAlreadyExistsError,
 
     // integrations
     IntegrationBase,
-    IntegrationModel,
     Options,
-    IntegrationMapping,
-    IntegrationFactory,
-    IntegrationHelper,
     checkRequiredParams,
     createIntegrationRouter,
-    createFriggBackend,
+    getModulesDefinitionFromIntegrationClasses,
+    LoadIntegrationContextUseCase,
+    CreateProcess,
+    UpdateProcessState,
+    UpdateProcessMetrics,
+    GetProcess,
+
+    // reporting
+    ReportBase,
+    IntegrationsReport,
+    BUILTIN_REPORTS,
+    createReportCommands,
+
+    // telemetry
+    createTelemetry,
+    getTelemetry,
+    CANONICAL_COUNTERS,
+    createUsageRepository,
+
+    // application - Command factories for integration developers
+    application,
+    createFriggCommands: application.createFriggCommands,
+    createIntegrationCommands: application.createIntegrationCommands,
+    createUserCommands: application.createUserCommands,
+    createEntityCommands: application.createEntityCommands,
+    createCredentialCommands: application.createCredentialCommands,
+    createProcessCommands: application.createProcessCommands,
+    createSchedulerCommands: application.createSchedulerCommands,
+    createUsageCommands: application.createUsageCommands,
+    findIntegrationContextByExternalEntityId:
+        application.findIntegrationContextByExternalEntityId,
+    integrationCommands: application.integrationCommands,
 
     // lambda
     TimeoutCatcher,
 
     // logs
+    getLogger,
+    createMemorySink,
+    resetLoggerForTests,
+    serializeError,
+    redactValue,
+    toSanitizedSurrogate,
     debug,
     initDebugLog,
     flushDebugLog,
 
     // module plugin
     Credential,
-    EntityManager,
     Entity,
-    ModuleManager,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
     Requester,
     ModuleConstants,
     ModuleFactory,
-    Auther,
-
     // queues
     QueuerUtil,
+
+    // utils
+    ...utils,
 };

package/infrastructure/scheduler/eventbridge-scheduler-adapter.js

@@ -0,0 +1,184 @@
+/**
+ * EventBridge Scheduler Adapter
+ *
+ * Infrastructure Layer - Hexagonal Architecture
+ *
+ * Responsible for:
+ * - Creating one-time EventBridge Scheduler schedules
+ * - Deleting schedules when no longer needed
+ * - Checking schedule status
+ *
+ * This adapter implements SchedulerServiceInterface for AWS EventBridge Scheduler.
+ */
+
+const {
+    SchedulerClient,
+    CreateScheduleCommand,
+    DeleteScheduleCommand,
+    GetScheduleCommand,
+    ResourceNotFoundException,
+} = require('@aws-sdk/client-scheduler');
+
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+
+class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
+    constructor({ region } = {}) {
+        super();
+        this.client = new SchedulerClient({
+            region: region || process.env.AWS_REGION || 'us-east-1',
+        });
+        this.scheduleGroupName =
+            process.env.SCHEDULE_GROUP_NAME || 'frigg-integration-schedules';
+        this.roleArn = process.env.SCHEDULER_ROLE_ARN;
+    }
+
+    /**
+     * Create a one-time schedule that sends a message to SQS
+     *
+     * @param {Object} params
+     * @param {string} params.scheduleName - Unique name for the schedule
+     * @param {Date} params.scheduleAt - When to trigger the schedule
+     * @param {string} params.queueResourceId - Queue resource identifier (ARN) to send message to
+     * @param {Object} params.payload - Message payload
+     * @returns {Promise<{scheduledJobId: string, scheduledAt: string}>}
+     */
+    async scheduleOneTime({ scheduleName, scheduleAt, queueResourceId, payload }) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+        if (!scheduleAt || !(scheduleAt instanceof Date)) {
+            throw new Error('scheduleAt must be a valid Date object');
+        }
+        if (!queueResourceId) {
+            throw new Error('queueResourceId is required');
+        }
+        if (!this.roleArn) {
+            throw new Error(
+                'SCHEDULER_ROLE_ARN environment variable is not set'
+            );
+        }
+
+        // Format date to AWS schedule expression (at(yyyy-mm-ddThh:mm:ss))
+        const scheduleExpression = `at(${scheduleAt.toISOString().replace(/\.\d{3}Z$/, '')})`;
+
+        const command = new CreateScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+            ScheduleExpression: scheduleExpression,
+            ScheduleExpressionTimezone: 'UTC',
+            FlexibleTimeWindow: {
+                Mode: 'OFF',
+            },
+            Target: {
+                Arn: queueResourceId,
+                RoleArn: this.roleArn,
+                Input: JSON.stringify(payload),
+            },
+            ActionAfterCompletion: 'DELETE', // Auto-cleanup after execution
+        });
+
+        try {
+            const response = await this.client.send(command);
+            console.log(
+                `[Scheduler] Created schedule ${scheduleName} for ${scheduleAt.toISOString()}`
+            );
+
+            return {
+                scheduledJobId: response.ScheduleArn,
+                scheduledAt: scheduleAt.toISOString(),
+            };
+        } catch (error) {
+            console.error(
+                `[Scheduler] Failed to create schedule ${scheduleName}:`,
+                error.message
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Delete a schedule
+     *
+     * @param {string} scheduleName - Name of the schedule to delete
+     * @returns {Promise<void>}
+     */
+    async deleteSchedule(scheduleName) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+
+        const command = new DeleteScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+        });
+
+        try {
+            await this.client.send(command);
+            console.log(`[Scheduler] Deleted schedule ${scheduleName}`);
+        } catch (error) {
+            if (error instanceof ResourceNotFoundException) {
+                console.log(
+                    `[Scheduler] Schedule ${scheduleName} not found (already deleted or executed)`
+                );
+                return; // Graceful handling - schedule doesn't exist
+            }
+            console.error(
+                `[Scheduler] Failed to delete schedule ${scheduleName}:`,
+                error.message
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Get schedule status
+     *
+     * @param {string} scheduleName - Name of the schedule
+     * @returns {Promise<{exists: boolean, scheduledAt?: string, state?: string}>}
+     */
+    async getScheduleStatus(scheduleName) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+
+        const command = new GetScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+        });
+
+        try {
+            const response = await this.client.send(command);
+
+            // Parse the schedule expression to get the scheduled time
+            // Format: at(yyyy-mm-ddThh:mm:ss)
+            let scheduledAt = null;
+            if (response.ScheduleExpression) {
+                const match = response.ScheduleExpression.match(
+                    /^at\((.+)\)$/
+                );
+                if (match) {
+                    scheduledAt = new Date(match[1] + 'Z').toISOString();
+                }
+            }
+
+            return {
+                exists: true,
+                scheduledAt,
+                state: response.State,
+            };
+        } catch (error) {
+            if (error instanceof ResourceNotFoundException) {
+                return {
+                    exists: false,
+                };
+            }
+            console.error(
+                `[Scheduler] Failed to get schedule ${scheduleName}:`,
+                error.message
+            );
+            throw error;
+        }
+    }
+}
+
+module.exports = { EventBridgeSchedulerAdapter };

package/infrastructure/scheduler/index.js

@@ -0,0 +1,33 @@
+/**
+ * Scheduler Infrastructure
+ *
+ * Provides scheduling capabilities for one-time jobs.
+ * Follows hexagonal architecture with interface + adapters pattern.
+ *
+ * Providers:
+ * - eventbridge: AWS EventBridge Scheduler (production)
+ * - mock: In-memory mock scheduler (local development)
+ */
+
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
+const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+const {
+    createSchedulerService,
+    SCHEDULER_PROVIDERS,
+    determineProvider,
+} = require('./scheduler-service-factory');
+
+module.exports = {
+    // Interface (Port)
+    SchedulerServiceInterface,
+
+    // Adapters
+    EventBridgeSchedulerAdapter,
+    MockSchedulerAdapter,
+
+    // Factory
+    createSchedulerService,
+    SCHEDULER_PROVIDERS,
+    determineProvider,
+};

package/infrastructure/scheduler/mock-scheduler-adapter.js

@@ -0,0 +1,143 @@
+/**
+ * Mock Scheduler Adapter for Local Development
+ *
+ * Stores schedules in memory and logs instead of creating real EventBridge schedules.
+ * Used when SCHEDULER_PROVIDER=mock or in local/dev/test environments.
+ *
+ * This adapter implements SchedulerServiceInterface for local development and testing.
+ */
+
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+
+class MockSchedulerAdapter extends SchedulerServiceInterface {
+    constructor(options = {}) {
+        super();
+        this.verbose = options.verbose || false;
+        this.schedules = new Map();
+    }
+
+    /**
+     * Schedule a one-time job to be executed at a specific time
+     *
+     * @param {Object} params
+     * @param {string} params.scheduleName - Unique name for the schedule
+     * @param {Date} params.scheduleAt - When to trigger the schedule
+     * @param {string} params.queueResourceId - Queue resource identifier to send message to
+     * @param {Object} params.payload - JSON payload to send
+     * @returns {Promise<{scheduledJobId: string, scheduledAt: string}>}
+     */
+    async scheduleOneTime({ scheduleName, scheduleAt, queueResourceId, payload }) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+        if (!scheduleAt || !(scheduleAt instanceof Date)) {
+            throw new Error('scheduleAt must be a valid Date object');
+        }
+        if (!queueResourceId) {
+            throw new Error('queueResourceId is required');
+        }
+
+        const scheduleData = {
+            scheduleName,
+            scheduledAt: scheduleAt.toISOString(),
+            queueResourceId,
+            payload,
+            createdAt: new Date().toISOString(),
+            state: 'ENABLED',
+        };
+
+        this.schedules.set(scheduleName, scheduleData);
+
+        console.log(`[MockScheduler] Created schedule: ${scheduleName}`);
+        console.log(`[MockScheduler]   Scheduled for: ${scheduleAt.toISOString()}`);
+        console.log(`[MockScheduler]   Target: ${queueResourceId}`);
+        if (this.verbose) {
+            console.log(`[MockScheduler]   Payload:`, JSON.stringify(payload, null, 2));
+        }
+
+        return {
+            scheduledJobId: `mock-job-${scheduleName}`,
+            scheduledAt: scheduleAt.toISOString(),
+        };
+    }
+
+    /**
+     * Delete a scheduled job
+     *
+     * @param {string} scheduleName - Name of the schedule to delete
+     * @returns {Promise<void>}
+     */
+    async deleteSchedule(scheduleName) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+
+        const existed = this.schedules.has(scheduleName);
+        this.schedules.delete(scheduleName);
+
+        console.log(`[MockScheduler] Deleted schedule: ${scheduleName} (existed: ${existed})`);
+    }
+
+    /**
+     * Get the status of a scheduled job
+     *
+     * @param {string} scheduleName - Name of the schedule
+     * @returns {Promise<{exists: boolean, scheduledAt?: string, state?: string}>}
+     */
+    async getScheduleStatus(scheduleName) {
+        if (!scheduleName) {
+            throw new Error('scheduleName is required');
+        }
+
+        const schedule = this.schedules.get(scheduleName);
+
+        if (!schedule) {
+            return { exists: false };
+        }
+
+        return {
+            exists: true,
+            scheduledAt: schedule.scheduledAt,
+            state: schedule.state,
+        };
+    }
+
+    /**
+     * Get all scheduled jobs (helper for testing)
+     *
+     * @returns {Object} Map of all schedules as plain object
+     */
+    _getSchedules() {
+        return Object.fromEntries(this.schedules);
+    }
+
+    /**
+     * Clear all schedules (helper for testing)
+     */
+    _clearSchedules() {
+        const count = this.schedules.size;
+        this.schedules.clear();
+        console.log(`[MockScheduler] Cleared ${count} schedules`);
+    }
+
+    /**
+     * Simulate triggering a schedule (helper for testing)
+     *
+     * @param {string} scheduleName - Name of the schedule to trigger
+     * @returns {Object|null} The payload that would be sent, or null if not found
+     */
+    _simulateTrigger(scheduleName) {
+        const schedule = this.schedules.get(scheduleName);
+        if (!schedule) {
+            console.log(`[MockScheduler] Cannot trigger - schedule not found: ${scheduleName}`);
+            return null;
+        }
+
+        console.log(`[MockScheduler] Simulating trigger for: ${scheduleName}`);
+        console.log(`[MockScheduler]   Payload:`, JSON.stringify(schedule.payload, null, 2));
+
+        return schedule.payload;
+    }
+}
+
+module.exports = { MockSchedulerAdapter };

package/infrastructure/scheduler/scheduler-service-factory.js

@@ -0,0 +1,73 @@
+/**
+ * Scheduler Service Factory
+ *
+ * Creates scheduler service instances based on configuration.
+ * Returns implementations of SchedulerServiceInterface.
+ *
+ * Environment Detection:
+ * - SCHEDULER_PROVIDER=eventbridge -> Use AWS EventBridge Scheduler
+ * - SCHEDULER_PROVIDER=mock -> Use in-memory mock scheduler
+ * - Default in dev/test/local stages -> Mock scheduler
+ * - Default in other stages -> EventBridge scheduler
+ */
+
+const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
+const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+
+const SCHEDULER_PROVIDERS = {
+    EVENTBRIDGE: 'eventbridge',
+    MOCK: 'mock',
+};
+
+const LOCAL_STAGES = ['dev', 'test', 'local'];
+
+/**
+ * Determine the scheduler provider based on environment
+ *
+ * @returns {string} Provider name
+ */
+function determineProvider() {
+    const explicitProvider = process.env.SCHEDULER_PROVIDER;
+    if (explicitProvider) {
+        return explicitProvider;
+    }
+
+    const stage = process.env.STAGE || 'dev';
+    if (LOCAL_STAGES.includes(stage)) {
+        return SCHEDULER_PROVIDERS.MOCK;
+    }
+
+    return SCHEDULER_PROVIDERS.EVENTBRIDGE;
+}
+
+/**
+ * Create a scheduler service instance
+ *
+ * @param {Object} options
+ * @param {string} options.provider - Scheduler provider ('eventbridge' or 'mock')
+ * @param {string} options.region - AWS region (for EventBridge)
+ * @param {boolean} options.verbose - Verbose logging (for Mock)
+ * @returns {SchedulerServiceInterface} Implementation of scheduler interface
+ */
+function createSchedulerService(options = {}) {
+    const provider = options.provider || determineProvider();
+
+    switch (provider) {
+        case SCHEDULER_PROVIDERS.EVENTBRIDGE:
+            return new EventBridgeSchedulerAdapter({
+                region: options.region,
+            });
+        case SCHEDULER_PROVIDERS.MOCK:
+            return new MockSchedulerAdapter({
+                verbose: options.verbose,
+            });
+        default:
+            throw new Error(`Unknown scheduler provider: ${provider}`);
+    }
+}
+
+module.exports = {
+    createSchedulerService,
+    SCHEDULER_PROVIDERS,
+    determineProvider,
+};