@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.dba001a.0

package/handlers/workers/db-migration.js

@@ -49,16 +49,28 @@ const {
 const {
     CheckDatabaseStateUseCase,
 } = require('../../database/use-cases/check-database-state-use-case');
-const {
-    MigrationStatusRepositoryS3,
-} = require('../../database/repositories/migration-status-repository-s3');
-
 // Inject prisma-runner as dependency
 const prismaRunner = require('../../database/utils/prisma-runner');
 
-// Use S3 repository for migration status tracking (no User table dependency)
-const bucketName = process.env.S3_BUCKET_NAME || process.env.MIGRATION_STATUS_BUCKET;
-const migrationStatusRepository = new MigrationStatusRepositoryS3(bucketName);
+// Migration status repository is loaded from the resolved provider.
+const { resolveProvider } = require('../../providers/resolve-provider');
+
+let _migrationStatusRepository = null;
+function getMigrationStatusRepository() {
+    if (!_migrationStatusRepository) {
+        const provider = resolveProvider();
+        const MigrationStatusRepository = provider.MigrationStatusRepositoryS3;
+        if (!MigrationStatusRepository) {
+            throw new Error(
+                `Provider '${provider.name}' does not export a MigrationStatusRepository`
+            );
+        }
+        const bucketName =
+            process.env.S3_BUCKET_NAME || process.env.MIGRATION_STATUS_BUCKET;
+        _migrationStatusRepository = new MigrationStatusRepository(bucketName);
+    }
+    return _migrationStatusRepository;
+}
 
 /**
  * Sanitizes error messages to prevent credential leaks
@@ -68,19 +80,27 @@ const migrationStatusRepository = new MigrationStatusRepositoryS3(bucketName);
 function sanitizeError(errorMessage) {
     if (!errorMessage) return 'Unknown error';
 
-    return String(errorMessage)
-        // Remove PostgreSQL connection strings
-        .replace(/postgresql:\/\/[^@\s]+@[^\s/]+/gi, 'postgresql://***:***@***')
-        // Remove MongoDB connection strings
-        .replace(/mongodb(\+srv)?:\/\/[^@\s]+@[^\s/]+/gi, 'mongodb$1://***:***@***')
-        // Remove password parameters
-        .replace(/password[=:]\s*[^\s,;)]+/gi, 'password=***')
-        // Remove API keys
-        .replace(/apikey[=:]\s*[^\s,;)]+/gi, 'apikey=***')
-        .replace(/api[_-]?key[=:]\s*[^\s,;)]+/gi, 'api_key=***')
-        // Remove tokens
-        .replace(/token[=:]\s*[^\s,;)]+/gi, 'token=***')
-        .replace(/bearer\s+[^\s,;)]+/gi, 'bearer ***');
+    return (
+        String(errorMessage)
+            // Remove PostgreSQL connection strings
+            .replace(
+                /postgresql:\/\/[^@\s]+@[^\s/]+/gi,
+                'postgresql://***:***@***'
+            )
+            // Remove MongoDB connection strings
+            .replace(
+                /mongodb(\+srv)?:\/\/[^@\s]+@[^\s/]+/gi,
+                'mongodb$1://***:***@***'
+            )
+            // Remove password parameters
+            .replace(/password[=:]\s*[^\s,;)]+/gi, 'password=***')
+            // Remove API keys
+            .replace(/apikey[=:]\s*[^\s,;)]+/gi, 'apikey=***')
+            .replace(/api[_-]?key[=:]\s*[^\s,;)]+/gi, 'api_key=***')
+            // Remove tokens
+            .replace(/token[=:]\s*[^\s,;)]+/gi, 'token=***')
+            .replace(/bearer\s+[^\s,;)]+/gi, 'bearer ***')
+    );
 }
 
 /**
@@ -145,11 +165,18 @@ exports.handler = async (event, context) => {
     console.log('Database Migration Lambda Started');
     console.log('========================================');
     console.log('Event:', JSON.stringify(event, null, 2));
-    console.log('Context:', JSON.stringify({
-        requestId: context.requestId,
-        functionName: context.functionName,
-        remainingTimeInMillis: context.getRemainingTimeInMillis(),
-    }, null, 2));
+    console.log(
+        'Context:',
+        JSON.stringify(
+            {
+                requestId: context.requestId,
+                functionName: context.functionName,
+                remainingTimeInMillis: context.getRemainingTimeInMillis(),
+            },
+            null,
+            2
+        )
+    );
 
     // Extract migration parameters from event
     const { migrationId, dbType, stage } = extractMigrationParams(event);
@@ -164,7 +191,9 @@ exports.handler = async (event, context) => {
         console.log(`========================================`);
 
         try {
-            const checkDbStateUseCase = new CheckDatabaseStateUseCase({ prismaRunner });
+            const checkDbStateUseCase = new CheckDatabaseStateUseCase({
+                prismaRunner,
+            });
             const status = await checkDbStateUseCase.execute(dbType, stage);
 
             console.log('✓ Database state check completed');
@@ -217,8 +246,10 @@ exports.handler = async (event, context) => {
 
         // Update migration status to RUNNING (if migrationId provided)
         if (migrationId) {
-            console.log(`\n✓ Updating migration status to RUNNING: ${migrationId}`);
-            await migrationStatusRepository.update({
+            console.log(
+                `\n✓ Updating migration status to RUNNING: ${migrationId}`
+            );
+            await getMigrationStatusRepository().update({
                 migrationId,
                 stage,
                 state: 'RUNNING',
@@ -255,8 +286,10 @@ exports.handler = async (event, context) => {
 
         // Update migration status to COMPLETED (if migrationId provided)
         if (migrationId) {
-            console.log(`\n✓ Updating migration status to COMPLETED: ${migrationId}`);
-            await migrationStatusRepository.update({
+            console.log(
+                `\n✓ Updating migration status to COMPLETED: ${migrationId}`
+            );
+            await getMigrationStatusRepository().update({
                 migrationId,
                 stage,
                 state: 'COMPLETED',
@@ -284,7 +317,6 @@ exports.handler = async (event, context) => {
             statusCode: 200,
             body: JSON.stringify(responseBody),
         };
-
     } catch (error) {
         console.error('\n========================================');
         console.error('Migration Failed');
@@ -317,8 +349,10 @@ exports.handler = async (event, context) => {
         // Update migration status to FAILED (if migrationId provided)
         if (migrationId) {
             try {
-                console.log(`\n✓ Updating migration status to FAILED: ${migrationId}`);
-                await migrationStatusRepository.update({
+                console.log(
+                    `\n✓ Updating migration status to FAILED: ${migrationId}`
+                );
+                await getMigrationStatusRepository().update({
                     migrationId,
                     stage,
                     state: 'FAILED',
@@ -327,7 +361,10 @@ exports.handler = async (event, context) => {
                     failedAt: new Date().toISOString(),
                 });
             } catch (updateError) {
-                console.error('Failed to update migration status:', updateError.message);
+                console.error(
+                    'Failed to update migration status:',
+                    updateError.message
+                );
                 // Continue - don't let status update failure block error response
             }
         }
@@ -337,7 +374,9 @@ exports.handler = async (event, context) => {
             error: sanitizedError,
             errorType: error.name || 'Error',
             // Only include stack traces in development environments
-            ...(stage === 'dev' || stage === 'local' || stage === 'test' ? { stack: error.stack } : {}),
+            ...(stage === 'dev' || stage === 'local' || stage === 'test'
+                ? { stack: error.stack }
+                : {}),
         };
 
         if (migrationId) {

package/index.js

@@ -21,7 +21,6 @@ const {
 } = require('./database/index');
 const {
     createUserRepository,
-    UserRepositoryMongo,
     UserRepositoryPostgres,
 } = require('./user/repositories/user-repository-factory');
 const {
@@ -30,9 +29,7 @@ const {
 const {
     GetUserFromAdopterJwt,
 } = require('./user/use-cases/get-user-from-adopter-jwt');
-const {
-    AuthenticateUser,
-} = require('./user/use-cases/authenticate-user');
+const { AuthenticateUser } = require('./user/use-cases/authenticate-user');
 
 const {
     CredentialRepository,
@@ -43,18 +40,14 @@ const {
 const {
     IntegrationMappingRepository,
 } = require('./integrations/repositories/integration-mapping-repository');
-const {
-    CreateProcess,
-} = require('./integrations/use-cases/create-process');
+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 { GetProcess } = require('./integrations/use-cases/get-process');
 const { Cryptor } = require('./encrypt');
 const {
     BaseError,
@@ -70,12 +63,11 @@ const {
     checkRequiredParams,
     getModulesDefinitionFromIntegrationClasses,
     LoadIntegrationContextUseCase,
+    createProcessRepository,
 } = require('./integrations/index');
 const { TimeoutCatcher } = require('./lambda/index');
 const { debug, initDebugLog, flushDebugLog } = require('./logs/index');
 const {
-    Credential,
-    Entity,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
@@ -86,7 +78,31 @@ const {
 const application = require('./application');
 const utils = require('./utils');
 
-const { QueuerUtil } = require('./queues');
+const {
+    QueuerUtil,
+    QueueProvider,
+    QueueClientInterface,
+    createQueueProvider,
+    QUEUE_PROVIDERS,
+} = require('./queues');
+
+const {
+    EncryptionKeyProviderInterface,
+} = require('./encrypt/encryption-key-provider-interface');
+const {
+    AesEncryptionKeyProvider,
+} = require('./encrypt/aes-encryption-key-provider');
+const {
+    WebSocketMessageSenderInterface,
+    StaleConnectionError,
+} = require('./websocket/websocket-message-sender-interface');
+
+const {
+    resolveProvider,
+    determineProviderName,
+    providerPackageName,
+    KNOWN_PROVIDERS,
+} = require('./providers');
 
 module.exports = {
     // assertions
@@ -110,7 +126,7 @@ module.exports = {
     TokenRepository,
     WebsocketConnectionRepository,
     createUserRepository,
-    UserRepositoryMongo,
+    get UserRepositoryMongo() { return require('./user/repositories/user-repository-factory').UserRepositoryMongo; },
     UserRepositoryPostgres,
     GetUserFromXFriggHeaders,
     GetUserFromAdopterJwt,
@@ -138,6 +154,7 @@ module.exports = {
     UpdateProcessState,
     UpdateProcessMetrics,
     GetProcess,
+    createProcessRepository,
 
     // application - Command factories for integration developers
     application,
@@ -147,6 +164,7 @@ module.exports = {
     createEntityCommands: application.createEntityCommands,
     createCredentialCommands: application.createCredentialCommands,
     createSchedulerCommands: application.createSchedulerCommands,
+    createAdminScriptCommands: application.createAdminScriptCommands,
     findIntegrationContextByExternalEntityId:
         application.findIntegrationContextByExternalEntityId,
     integrationCommands: application.integrationCommands,
@@ -160,8 +178,6 @@ module.exports = {
     flushDebugLog,
 
     // module plugin
-    Credential,
-    Entity,
     ApiKeyRequester,
     BasicAuthRequester,
     OAuth2Requester,
@@ -170,6 +186,24 @@ module.exports = {
     ModuleFactory,
     // queues
     QueuerUtil,
+    QueueProvider,
+    QueueClientInterface,
+    createQueueProvider,
+    QUEUE_PROVIDERS,
+
+    // encryption interfaces
+    EncryptionKeyProviderInterface,
+    AesEncryptionKeyProvider,
+
+    // websocket interfaces
+    WebSocketMessageSenderInterface,
+    StaleConnectionError,
+
+    // providers
+    resolveProvider,
+    determineProviderName,
+    providerPackageName,
+    KNOWN_PROVIDERS,
 
     // utils
     ...utils,

package/infrastructure/scheduler/index.js

@@ -4,30 +4,34 @@
  * 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)
+ * Use createSchedulerService() to get the correct adapter for the
+ * active provider. The factory uses resolveProvider() internally.
+ *
+ * Adapters:
+ * - AWS EventBridge: via @friggframework/provider-aws (SchedulerAdapter)
+ * - Netlify: NetlifySchedulerAdapter (ships with core, no AWS deps)
+ * - Mock: MockSchedulerAdapter (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,
+    // Core adapters (no external SDK dependencies)
+    get MockSchedulerAdapter() {
+        return require('./mock-scheduler-adapter').MockSchedulerAdapter;
+    },
+    get NetlifySchedulerAdapter() {
+        return require('./netlify-scheduler-adapter').NetlifySchedulerAdapter;
+    },
 
-    // Factory
+    // Factory — resolves the correct adapter via provider plugin system
     createSchedulerService,
     SCHEDULER_PROVIDERS,
-    determineProvider,
 };

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

@@ -0,0 +1,185 @@
+/**
+ * Netlify Scheduler Adapter
+ *
+ * Implements SchedulerServiceInterface for Netlify deployments.
+ *
+ * Netlify Scheduled Functions use cron syntax but are defined statically in
+ * netlify.toml or via the @netlify/functions schedule() helper. They cannot
+ * be created dynamically at runtime like EventBridge Scheduler.
+ *
+ * Strategy for one-time scheduled jobs on Netlify:
+ *   1. Store the schedule in the database (same as mock adapter pattern)
+ *   2. A Netlify Scheduled Function runs on a cron interval (e.g., every 5 min)
+ *   3. The cron function queries for due schedules and dispatches them
+ *      to a background function for execution
+ *
+ * This is a "poll-and-dispatch" pattern vs EventBridge's "push" pattern.
+ * Trade-off: slightly less precise timing (up to cron interval delay),
+ * but works on any platform without cloud-specific scheduling APIs.
+ *
+ * For integrations that need the queue provider to dispatch jobs:
+ *   - queueResourceId maps to the background function URL path
+ *   - Payload is stored and forwarded when the cron fires
+ */
+
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
+
+class NetlifySchedulerAdapter extends SchedulerServiceInterface {
+    /**
+     * @param {Object} options
+     * @param {Object} options.repository - Repository for persisting schedules
+     *   Must implement: save(schedule), delete(scheduleName),
+     *   findByName(scheduleName), findDue(now)
+     * @param {Object} [options.queueProvider] - Queue provider for dispatching due jobs
+     */
+    constructor(options = {}) {
+        super();
+        this.repository = options.repository;
+        this.queueProvider = options.queueProvider;
+
+        if (!this.repository) {
+            console.warn(
+                '[NetlifyScheduler] No repository provided. ' +
+                    'Schedules will be stored in memory (lost on function restart). ' +
+                    'Provide a database-backed repository for production use.'
+            );
+            this._inMemorySchedules = new Map();
+        }
+    }
+
+    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: 'PENDING',
+        };
+
+        if (this.repository) {
+            await this.repository.save(scheduleData);
+        } else {
+            this._inMemorySchedules.set(scheduleName, scheduleData);
+        }
+
+        console.log(
+            `[NetlifyScheduler] Scheduled: ${scheduleName} for ${scheduleAt.toISOString()}`
+        );
+
+        return {
+            scheduledJobId: `netlify-schedule-${scheduleName}`,
+            scheduledAt: scheduleAt.toISOString(),
+        };
+    }
+
+    async deleteSchedule(scheduleName) {
+        if (!scheduleName) throw new Error('scheduleName is required');
+
+        if (this.repository) {
+            await this.repository.delete(scheduleName);
+        } else {
+            this._inMemorySchedules.delete(scheduleName);
+        }
+
+        console.log(`[NetlifyScheduler] Deleted schedule: ${scheduleName}`);
+    }
+
+    async getScheduleStatus(scheduleName) {
+        if (!scheduleName) throw new Error('scheduleName is required');
+
+        let schedule;
+        if (this.repository) {
+            schedule = await this.repository.findByName(scheduleName);
+        } else {
+            schedule = this._inMemorySchedules.get(scheduleName);
+        }
+
+        if (!schedule) {
+            return { exists: false };
+        }
+
+        return {
+            exists: true,
+            scheduledAt: schedule.scheduledAt,
+            state: schedule.state,
+        };
+    }
+
+    /**
+     * Process due schedules. Called by the Netlify cron function.
+     *
+     * Finds all schedules where scheduledAt <= now, dispatches them
+     * to the queue provider, and marks them as completed.
+     *
+     * @returns {Promise<{ processed: number, errors: number }>}
+     */
+    async processDueSchedules() {
+        if (!this.repository) {
+            console.warn(
+                '[NetlifyScheduler] Cannot process due schedules without a repository'
+            );
+            return { processed: 0, errors: 0 };
+        }
+
+        const now = new Date();
+        const dueSchedules = await this.repository.findDue(now);
+
+        let processed = 0;
+        let errors = 0;
+
+        for (const schedule of dueSchedules) {
+            try {
+                // Mark as PROCESSING before dispatch so the next cron tick
+                // won't re-pick this schedule (findDue only returns PENDING).
+                await this.repository.save({
+                    ...schedule,
+                    state: 'PROCESSING',
+                });
+
+                if (this.queueProvider) {
+                    await this.queueProvider.send(
+                        schedule.payload,
+                        schedule.queueResourceId
+                    );
+                } else {
+                    console.log(
+                        `[NetlifyScheduler] No queue provider — logging payload for: ${schedule.scheduleName}`,
+                        JSON.stringify(schedule.payload)
+                    );
+                }
+
+                await this.repository.delete(schedule.scheduleName);
+                processed++;
+            } catch (error) {
+                console.error(
+                    `[NetlifyScheduler] Error processing schedule ${schedule.scheduleName}:`,
+                    error
+                );
+                // Mark as FAILED so it won't be re-dispatched automatically.
+                // Operators can inspect FAILED schedules and retry manually.
+                await this.repository
+                    .save({ ...schedule, state: 'FAILED' })
+                    .catch(() => {});
+                errors++;
+            }
+        }
+
+        console.log(
+            `[NetlifyScheduler] Processed ${processed} due schedules, ${errors} errors`
+        );
+        return { processed, errors };
+    }
+}
+
+module.exports = { NetlifySchedulerAdapter };

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

@@ -4,70 +4,77 @@
  * Creates scheduler service instances based on configuration.
  * Returns implementations of SchedulerServiceInterface.
  *
+ * Uses the provider plugin system (resolveProvider) to load the correct
+ * scheduler adapter for the active platform (AWS, Netlify, etc.).
+ *
  * 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
+ * - Otherwise -> Resolved provider's SchedulerAdapter
  */
 
-const { EventBridgeSchedulerAdapter } = require('./eventbridge-scheduler-adapter');
-const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+const { resolveProvider } = require('../../providers/resolve-provider');
 
 const SCHEDULER_PROVIDERS = {
-    EVENTBRIDGE: 'eventbridge',
     MOCK: 'mock',
 };
 
 const LOCAL_STAGES = ['dev', 'test', 'local'];
 
 /**
- * Determine the scheduler provider based on environment
+ * Determine if mock scheduler should be used
  *
- * @returns {string} Provider name
+ * @param {string} [explicit] - Explicit provider override
+ * @returns {boolean}
  */
-function determineProvider() {
-    const explicitProvider = process.env.SCHEDULER_PROVIDER;
-    if (explicitProvider) {
-        return explicitProvider;
+function shouldUseMock(explicit) {
+    if (explicit === SCHEDULER_PROVIDERS.MOCK) {
+        return true;
     }
-
-    const stage = process.env.STAGE || 'dev';
-    if (LOCAL_STAGES.includes(stage)) {
-        return SCHEDULER_PROVIDERS.MOCK;
+    if (!explicit) {
+        const stage = process.env.STAGE || 'dev';
+        return LOCAL_STAGES.includes(stage);
     }
-
-    return SCHEDULER_PROVIDERS.EVENTBRIDGE;
+    return false;
 }
 
 /**
  * Create a scheduler service instance
  *
  * @param {Object} options
- * @param {string} options.provider - Scheduler provider ('eventbridge' or 'mock')
+ * @param {string} options.provider - Scheduler provider ('mock', or omit for auto-detect)
  * @param {string} options.region - AWS region (for EventBridge)
  * @param {boolean} options.verbose - Verbose logging (for Mock)
+ * @param {Object} options.repository - Schedule repository (for Netlify - persists schedules)
+ * @param {Object} options.queueProvider - Queue provider (for Netlify - dispatches due jobs)
  * @returns {SchedulerServiceInterface} Implementation of scheduler interface
  */
 function createSchedulerService(options = {}) {
-    const provider = options.provider || determineProvider();
+    const explicit = options.provider || process.env.SCHEDULER_PROVIDER;
+
+    if (shouldUseMock(explicit)) {
+        const { MockSchedulerAdapter } = require('./mock-scheduler-adapter');
+        return new MockSchedulerAdapter({ verbose: options.verbose });
+    }
+
+    // Use the resolved provider's scheduler adapter.
+    // Legacy SCHEDULER_PROVIDER values (eventbridge, netlify) are mapped
+    // to provider names for backward compatibility.
+    const LEGACY_MAP = { eventbridge: 'aws', netlify: 'netlify' };
+    const providerName = LEGACY_MAP[explicit] || explicit;
+    const providerOverride = providerName ? { provider: providerName } : {};
+    const provider = resolveProvider(null, providerOverride);
 
-    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}`);
+    const Adapter = provider.SchedulerAdapter;
+    if (!Adapter) {
+        throw new Error(
+            `Provider '${provider.name}' does not export a SchedulerAdapter`
+        );
     }
+    return new Adapter(options);
 }
 
 module.exports = {
     createSchedulerService,
     SCHEDULER_PROVIDERS,
-    determineProvider,
 };