@friggframework/core 2.0.0-next.69 → 2.0.0-next.70

package/application/commands/scheduler-commands.js

@@ -0,0 +1,263 @@
+/**
+ * Scheduler Commands
+ *
+ * Application Layer - Command pattern for scheduling operations.
+ *
+ * Follows hexagonal architecture:
+ * - Receives SchedulerServiceInterface via dependency injection
+ * - Contains business logic (validation, logging, error mapping)
+ * - Protocol-agnostic (doesn't know about HTTP/Lambda)
+ *
+ * @example
+ * const schedulerCommands = createSchedulerCommands({ integrationName: 'zoho' });
+ * await schedulerCommands.scheduleJob({
+ *     jobId: 'zoho-notif-renewal-abc123',
+ *     scheduledAt: new Date(Date.now() + 6 * 24 * 60 * 60 * 1000), // 6 days
+ *     event: 'REFRESH_WEBHOOK',
+ *     payload: { integrationId: 'abc123' },
+ *     queueUrl: process.env.ZOHO_QUEUE_URL,
+ * });
+ */
+
+const { createSchedulerService } = require('../../infrastructure/scheduler');
+
+/**
+ * Derive SQS ARN from SQS URL
+ *
+ * SQS URL format: https://sqs.{region}.amazonaws.com/{account-id}/{queue-name}
+ * SQS ARN format: arn:aws:sqs:{region}:{account-id}:{queue-name}
+ *
+ * @param {string} queueUrl - SQS queue URL
+ * @returns {string} SQS queue ARN
+ */
+function deriveArnFromQueueUrl(queueUrl) {
+    try {
+        const url = new URL(queueUrl);
+        const region = url.hostname.split('.')[1];
+        const pathParts = url.pathname.split('/').filter(Boolean);
+        const accountId = pathParts[0];
+        const queueName = pathParts[1];
+        return `arn:aws:sqs:${region}:${accountId}:${queueName}`;
+    } catch (error) {
+        throw new Error(`Invalid SQS queue URL: ${queueUrl}`);
+    }
+}
+
+const ERROR_CODE_MAP = {
+    SCHEDULER_NOT_CONFIGURED: 503,
+    INVALID_JOB_DATA: 400,
+    SCHEDULE_NOT_FOUND: 404,
+};
+
+function mapErrorToResponse(error) {
+    const status = ERROR_CODE_MAP[error?.code] || 500;
+    return {
+        error: status,
+        reason: error?.message,
+        code: error?.code,
+    };
+}
+
+/**
+ * Create scheduler commands for an integration
+ *
+ * @param {Object} params
+ * @param {string} params.integrationName - Name of the integration (used for logging)
+ * @param {SchedulerServiceInterface} [params.schedulerService] - Optional injected scheduler service
+ * @returns {Object} Scheduler commands object
+ */
+function createSchedulerCommands({ integrationName, schedulerService }) {
+    if (!integrationName) {
+        throw new Error('integrationName is required');
+    }
+
+    // Support both dependency injection and lazy creation
+    // DI is preferred for testability, lazy creation for convenience
+    let _schedulerService = schedulerService || null;
+
+    function getSchedulerService() {
+        if (!_schedulerService) {
+            try {
+                _schedulerService = createSchedulerService();
+            } catch (error) {
+                console.warn(
+                    `[${integrationName}] Scheduler service not available: ${error.message}`
+                );
+                return null;
+            }
+        }
+        return _schedulerService;
+    }
+
+    return {
+        /**
+         * Schedule a one-time job to be executed at a specific time
+         *
+         * @param {Object} params
+         * @param {string} params.jobId - Unique identifier for the job
+         * @param {Date} params.scheduledAt - When to execute the job
+         * @param {string} params.event - Event name to trigger
+         * @param {Object} params.payload - Additional payload data
+         * @param {string} params.queueUrl - Target SQS queue URL (ARN is derived internally)
+         * @returns {Promise<{jobArn: string, scheduledAt: string} | {error: number, reason: string}>}
+         */
+        async scheduleJob({ jobId, scheduledAt, event, payload, queueUrl }) {
+            try {
+                if (!jobId) {
+                    const error = new Error('jobId is required');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                if (!scheduledAt || !(scheduledAt instanceof Date)) {
+                    const error = new Error('scheduledAt must be a valid Date');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                if (!event) {
+                    const error = new Error('event is required');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                if (!queueUrl) {
+                    const error = new Error('queueUrl is required');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                // Derive ARN from URL (business logic - transformation)
+                const queueArn = deriveArnFromQueueUrl(queueUrl);
+
+                // Get scheduler service (via DI or factory)
+                const service = getSchedulerService();
+                if (!service) {
+                    console.warn(
+                        `[${integrationName}] Scheduler not configured, skipping job schedule`
+                    );
+                    return {
+                        jobId,
+                        jobArn: null,
+                        scheduledAt: null,
+                        warning: 'Scheduler not configured',
+                    };
+                }
+
+                // Build the SQS message payload (business logic - assembly)
+                const sqsPayload = {
+                    event,
+                    integrationName,
+                    data: payload || {},
+                    scheduledAt: scheduledAt.toISOString(),
+                    createdAt: new Date().toISOString(),
+                };
+
+                // Delegate to service (Port interface)
+                const result = await service.scheduleOneTime({
+                    scheduleName: jobId,
+                    scheduleAt: scheduledAt,
+                    queueResourceId: queueArn,
+                    payload: sqsPayload,
+                });
+
+                console.log(
+                    `[${integrationName}] Scheduled job ${jobId} for ${result.scheduledAt}`
+                );
+
+                return {
+                    jobId,
+                    jobArn: result.scheduledJobId,
+                    scheduledAt: result.scheduledAt,
+                };
+            } catch (error) {
+                console.error(
+                    `[${integrationName}] Failed to schedule job ${jobId}:`,
+                    error.message
+                );
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Delete a scheduled job
+         *
+         * @param {string} jobId - Job ID to delete
+         * @returns {Promise<{success: boolean, jobId: string} | {error: number, reason: string}>}
+         */
+        async deleteJob(jobId) {
+            try {
+                if (!jobId) {
+                    const error = new Error('jobId is required');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                const service = getSchedulerService();
+                if (!service) {
+                    console.warn(
+                        `[${integrationName}] Scheduler not configured, skipping job deletion`
+                    );
+                    return {
+                        success: true,
+                        jobId,
+                        warning: 'Scheduler not configured',
+                    };
+                }
+
+                await service.deleteSchedule(jobId);
+
+                console.log(`[${integrationName}] Deleted scheduled job ${jobId}`);
+
+                return {
+                    success: true,
+                    jobId,
+                };
+            } catch (error) {
+                console.error(
+                    `[${integrationName}] Failed to delete job ${jobId}:`,
+                    error.message
+                );
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Get the status of a scheduled job
+         *
+         * @param {string} jobId - Job ID to check
+         * @returns {Promise<{exists: boolean, scheduledAt?: string, state?: string} | {error: number, reason: string}>}
+         */
+        async getJobStatus(jobId) {
+            try {
+                if (!jobId) {
+                    const error = new Error('jobId is required');
+                    error.code = 'INVALID_JOB_DATA';
+                    throw error;
+                }
+
+                const service = getSchedulerService();
+                if (!service) {
+                    return {
+                        exists: false,
+                        warning: 'Scheduler not configured',
+                    };
+                }
+
+                const status = await service.getScheduleStatus(jobId);
+
+                return status;
+            } catch (error) {
+                console.error(
+                    `[${integrationName}] Failed to get job status ${jobId}:`,
+                    error.message
+                );
+                return mapErrorToResponse(error);
+            }
+        },
+    };
+}
+
+module.exports = {
+    createSchedulerCommands,
+};

package/application/index.js

@@ -7,6 +7,9 @@ const { createEntityCommands } = require('./commands/entity-commands');
 const {
     createCredentialCommands,
 } = require('./commands/credential-commands');
+const {
+    createSchedulerCommands,
+} = require('./commands/scheduler-commands');
 
 /**
  * Create a unified command factory with all CRUD operations
@@ -57,6 +60,7 @@ module.exports = {
     createUserCommands,
     createEntityCommands,
     createCredentialCommands,
+    createSchedulerCommands,
 
     // Legacy standalone function
     findIntegrationContextByExternalEntityId,

package/index.js

@@ -166,6 +166,7 @@ module.exports = {
     createUserCommands: application.createUserCommands,
     createEntityCommands: application.createEntityCommands,
     createCredentialCommands: application.createCredentialCommands,
+    createSchedulerCommands: application.createSchedulerCommands,
     findIntegrationContextByExternalEntityId:
         application.findIntegrationContextByExternalEntityId,
     integrationCommands: application.integrationCommands,

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,
+};

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

@@ -0,0 +1,47 @@
+/**
+ * Scheduler Service Interface (Port)
+ *
+ * Defines the contract for scheduling one-time jobs.
+ * All scheduler adapters must extend this interface.
+ *
+ * Following Frigg's hexagonal architecture pattern:
+ * - Port defines WHAT the service does (contract)
+ * - Adapters implement HOW (AWS EventBridge, Mock, etc.)
+ */
+class SchedulerServiceInterface {
+    /**
+     * 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 }) {
+        throw new Error('Method scheduleOneTime must be implemented by subclass');
+    }
+
+    /**
+     * Delete a scheduled job
+     *
+     * @param {string} scheduleName - Name of the schedule to delete
+     * @returns {Promise<void>}
+     */
+    async deleteSchedule(scheduleName) {
+        throw new Error('Method deleteSchedule must be implemented by subclass');
+    }
+
+    /**
+     * 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) {
+        throw new Error('Method getScheduleStatus must be implemented by subclass');
+    }
+}
+
+module.exports = { SchedulerServiceInterface };

package/modules/requester/oauth-2.js

@@ -115,7 +115,10 @@ class OAuth2Requester extends Requester {
      */
     async setTokens(params) {
         this.access_token = get(params, 'access_token');
-        this.refresh_token = get(params, 'refresh_token', null);
+        const newRefreshToken = get(params, 'refresh_token', null);
+        if (newRefreshToken !== null) {
+            this.refresh_token = newRefreshToken;
+        }
         const accessExpiresIn = get(params, 'expires_in', null);
         const refreshExpiresIn = get(
             params,
@@ -124,7 +127,9 @@ class OAuth2Requester extends Requester {
         );
 
         this.accessTokenExpire = new Date(Date.now() + accessExpiresIn * 1000);
-        this.refreshTokenExpire = new Date(Date.now() + refreshExpiresIn * 1000);
+        if (refreshExpiresIn !== null) {
+            this.refreshTokenExpire = new Date(Date.now() + refreshExpiresIn * 1000);
+        }
 
         await this.notify(this.DLGT_TOKEN_UPDATE);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.69",
+    "version": "2.0.0-next.70",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0-next.69",
-        "@friggframework/prettier-config": "2.0.0-next.69",
-        "@friggframework/test": "2.0.0-next.69",
+        "@friggframework/eslint-config": "2.0.0-next.70",
+        "@friggframework/prettier-config": "2.0.0-next.70",
+        "@friggframework/test": "2.0.0-next.70",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "018c93f98b5f14786d016a4f621adef10ad27597"
+    "gitHead": "dee1112300e01813e68b2598c3a722d1a31e1677"
 }