@friggframework/admin-scripts 2.0.0--canary.517.41839c5.0

package/src/adapters/aws-scheduler-adapter.js

@@ -0,0 +1,138 @@
+const { SchedulerAdapter } = require('./scheduler-adapter');
+
+// Lazy-loaded AWS SDK clients (following AWSProviderAdapter pattern)
+let SchedulerClient, CreateScheduleCommand, DeleteScheduleCommand,
+    GetScheduleCommand, UpdateScheduleCommand, ListSchedulesCommand;
+
+function loadSchedulerSDK() {
+    if (!SchedulerClient) {
+        const schedulerModule = require('@aws-sdk/client-scheduler');
+        SchedulerClient = schedulerModule.SchedulerClient;
+        CreateScheduleCommand = schedulerModule.CreateScheduleCommand;
+        DeleteScheduleCommand = schedulerModule.DeleteScheduleCommand;
+        GetScheduleCommand = schedulerModule.GetScheduleCommand;
+        UpdateScheduleCommand = schedulerModule.UpdateScheduleCommand;
+        ListSchedulesCommand = schedulerModule.ListSchedulesCommand;
+    }
+}
+
+/**
+ * AWS EventBridge Scheduler Adapter
+ *
+ * Infrastructure Adapter - Hexagonal Architecture
+ *
+ * Implements scheduling using AWS EventBridge Scheduler.
+ * Supports cron expressions, timezone configuration, and Lambda invocation.
+ */
+class AWSSchedulerAdapter extends SchedulerAdapter {
+    constructor({ region, credentials, targetLambdaArn, scheduleGroupName } = {}) {
+        super();
+        this.region = region || process.env.AWS_REGION || 'us-east-1';
+        this.credentials = credentials;
+        this.targetLambdaArn = targetLambdaArn || process.env.ADMIN_SCRIPT_LAMBDA_ARN;
+        this.scheduleGroupName = scheduleGroupName || process.env.SCHEDULE_GROUP_NAME || 'frigg-admin-scripts';
+        this.scheduler = null;
+    }
+
+    getSchedulerClient() {
+        if (!this.scheduler) {
+            loadSchedulerSDK();
+            this.scheduler = new SchedulerClient({
+                region: this.region,
+                credentials: this.credentials,
+            });
+        }
+        return this.scheduler;
+    }
+
+    getName() {
+        return 'aws-eventbridge-scheduler';
+    }
+
+    async createSchedule({ scriptName, cronExpression, timezone, input }) {
+        const client = this.getSchedulerClient();
+        const scheduleName = `frigg-script-${scriptName}`;
+
+        const command = new CreateScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+            ScheduleExpression: cronExpression,
+            ScheduleExpressionTimezone: timezone || 'UTC',
+            FlexibleTimeWindow: { Mode: 'OFF' },
+            Target: {
+                Arn: this.targetLambdaArn,
+                RoleArn: process.env.SCHEDULER_ROLE_ARN,
+                Input: JSON.stringify({
+                    scriptName,
+                    trigger: 'SCHEDULED',
+                    params: input || {},
+                }),
+            },
+            State: 'ENABLED',
+        });
+
+        const response = await client.send(command);
+        return {
+            scheduleArn: response.ScheduleArn,
+            scheduleName: scheduleName,
+        };
+    }
+
+    async deleteSchedule(scriptName) {
+        const client = this.getSchedulerClient();
+        const scheduleName = `frigg-script-${scriptName}`;
+
+        await client.send(new DeleteScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+        }));
+    }
+
+    async setScheduleEnabled(scriptName, enabled) {
+        const client = this.getSchedulerClient();
+        const scheduleName = `frigg-script-${scriptName}`;
+
+        // Get the current schedule first to preserve all settings
+        const getCommand = new GetScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+        });
+
+        const currentSchedule = await client.send(getCommand);
+
+        // Update with the new state
+        await client.send(new UpdateScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+            ScheduleExpression: currentSchedule.ScheduleExpression,
+            ScheduleExpressionTimezone: currentSchedule.ScheduleExpressionTimezone,
+            FlexibleTimeWindow: currentSchedule.FlexibleTimeWindow,
+            Target: currentSchedule.Target,
+            State: enabled ? 'ENABLED' : 'DISABLED',
+        }));
+    }
+
+    async listSchedules() {
+        const client = this.getSchedulerClient();
+
+        const response = await client.send(new ListSchedulesCommand({
+            GroupName: this.scheduleGroupName,
+        }));
+
+        return response.Schedules || [];
+    }
+
+    async getSchedule(scriptName) {
+        const client = this.getSchedulerClient();
+        const scheduleName = `frigg-script-${scriptName}`;
+
+        const response = await client.send(new GetScheduleCommand({
+            Name: scheduleName,
+            GroupName: this.scheduleGroupName,
+        }));
+
+        return response;
+    }
+}
+
+module.exports = { AWSSchedulerAdapter };

package/src/adapters/local-scheduler-adapter.js

@@ -0,0 +1,103 @@
+const { SchedulerAdapter } = require('./scheduler-adapter');
+
+/**
+ * Local Scheduler Adapter
+ *
+ * Infrastructure Adapter - Hexagonal Architecture
+ *
+ * In-memory implementation for local development and testing.
+ * Stores schedule configurations but does not execute them.
+ * For actual cron execution, use a library like node-cron.
+ */
+class LocalSchedulerAdapter extends SchedulerAdapter {
+    constructor() {
+        super();
+        this.schedules = new Map();
+        this.intervals = new Map();
+    }
+
+    getName() {
+        return 'local-cron';
+    }
+
+    async createSchedule({ scriptName, cronExpression, timezone, input }) {
+        // Store schedule (actual cron execution would use node-cron)
+        this.schedules.set(scriptName, {
+            scriptName,
+            cronExpression,
+            timezone: timezone || 'UTC',
+            input,
+            enabled: true,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+
+        return {
+            scheduleName: scriptName,
+            scheduleArn: `local:schedule:${scriptName}`,
+        };
+    }
+
+    async deleteSchedule(scriptName) {
+        this.schedules.delete(scriptName);
+        if (this.intervals.has(scriptName)) {
+            clearInterval(this.intervals.get(scriptName));
+            this.intervals.delete(scriptName);
+        }
+    }
+
+    async setScheduleEnabled(scriptName, enabled) {
+        const schedule = this.schedules.get(scriptName);
+        if (!schedule) {
+            throw new Error(`Schedule for script "${scriptName}" not found`);
+        }
+
+        schedule.enabled = enabled;
+        schedule.updatedAt = new Date().toISOString();
+    }
+
+    async listSchedules() {
+        return Array.from(this.schedules.values());
+    }
+
+    async getSchedule(scriptName) {
+        const schedule = this.schedules.get(scriptName);
+        if (!schedule) {
+            throw new Error(`Schedule for script "${scriptName}" not found`);
+        }
+
+        return {
+            Name: scriptName,
+            State: schedule.enabled ? 'ENABLED' : 'DISABLED',
+            ScheduleExpression: schedule.cronExpression,
+            ScheduleExpressionTimezone: schedule.timezone,
+            Target: {
+                Input: JSON.stringify({
+                    scriptName,
+                    trigger: 'SCHEDULED',
+                    params: schedule.input || {},
+                }),
+            },
+            CreationDate: new Date(schedule.createdAt),
+            LastModificationDate: new Date(schedule.updatedAt),
+        };
+    }
+
+    /**
+     * Clear all schedules (useful for testing)
+     */
+    clear() {
+        this.schedules.clear();
+        this.intervals.forEach((interval) => clearInterval(interval));
+        this.intervals.clear();
+    }
+
+    /**
+     * Get number of schedules (useful for testing)
+     */
+    get size() {
+        return this.schedules.size;
+    }
+}
+
+module.exports = { LocalSchedulerAdapter };

package/src/adapters/scheduler-adapter-factory.js

@@ -0,0 +1,69 @@
+const { AWSSchedulerAdapter } = require('./aws-scheduler-adapter');
+const { LocalSchedulerAdapter } = require('./local-scheduler-adapter');
+
+/**
+ * Scheduler Adapter Factory
+ *
+ * Application Layer - Hexagonal Architecture
+ *
+ * Creates the appropriate scheduler adapter based on configuration.
+ * Supports environment-based auto-detection and explicit configuration.
+ */
+
+/**
+ * Create a scheduler adapter instance
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.type] - Adapter type ('aws', 'eventbridge', 'local')
+ * @param {string} [options.region] - AWS region (for AWS adapter)
+ * @param {Object} [options.credentials] - AWS credentials (for AWS adapter)
+ * @param {string} [options.targetLambdaArn] - Lambda ARN to invoke (for AWS adapter)
+ * @param {string} [options.scheduleGroupName] - EventBridge schedule group name (for AWS adapter)
+ * @returns {SchedulerAdapter} Configured scheduler adapter
+ */
+function createSchedulerAdapter(options = {}) {
+    const adapterType = options.type || detectSchedulerAdapterType();
+
+    switch (adapterType.toLowerCase()) {
+        case 'aws':
+        case 'eventbridge':
+            return new AWSSchedulerAdapter({
+                region: options.region,
+                credentials: options.credentials,
+                targetLambdaArn: options.targetLambdaArn,
+                scheduleGroupName: options.scheduleGroupName,
+            });
+
+        case 'local':
+        default:
+            return new LocalSchedulerAdapter();
+    }
+}
+
+/**
+ * Determine the appropriate scheduler adapter type based on environment
+ *
+ * @returns {string} Adapter type ('aws' or 'local')
+ */
+function detectSchedulerAdapterType() {
+    // If explicitly set, use that
+    if (process.env.SCHEDULER_ADAPTER) {
+        return process.env.SCHEDULER_ADAPTER;
+    }
+
+    // Auto-detect based on environment
+    const stage = process.env.STAGE || process.env.NODE_ENV || 'local';
+
+    // Use AWS adapter in production/staging environments
+    if (['production', 'prod', 'staging', 'stage'].includes(stage.toLowerCase())) {
+        return 'aws';
+    }
+
+    // Use local adapter for dev/test/local
+    return 'local';
+}
+
+module.exports = {
+    createSchedulerAdapter,
+    detectSchedulerAdapterType,
+};

package/src/adapters/scheduler-adapter.js

@@ -0,0 +1,64 @@
+/**
+ * Scheduler Adapter (Abstract Base Class)
+ *
+ * Port - Hexagonal Architecture
+ *
+ * Defines the contract for scheduler implementations.
+ * Supports AWS EventBridge, local cron, or other providers.
+ */
+class SchedulerAdapter {
+    getName() {
+        throw new Error('SchedulerAdapter.getName() must be implemented');
+    }
+
+    /**
+     * Create or update a schedule for a script
+     * @param {Object} config
+     * @param {string} config.scriptName - Script identifier
+     * @param {string} config.cronExpression - Cron expression
+     * @param {string} [config.timezone] - Timezone (default UTC)
+     * @param {Object} [config.input] - Optional input params
+     * @returns {Promise<Object>} Created schedule { scheduleArn, scheduleName }
+     */
+    async createSchedule(config) {
+        throw new Error('SchedulerAdapter.createSchedule() must be implemented');
+    }
+
+    /**
+     * Delete a schedule
+     * @param {string} scriptName - Script identifier
+     * @returns {Promise<void>}
+     */
+    async deleteSchedule(scriptName) {
+        throw new Error('SchedulerAdapter.deleteSchedule() must be implemented');
+    }
+
+    /**
+     * Enable or disable a schedule
+     * @param {string} scriptName - Script identifier
+     * @param {boolean} enabled - Whether to enable
+     * @returns {Promise<void>}
+     */
+    async setScheduleEnabled(scriptName, enabled) {
+        throw new Error('SchedulerAdapter.setScheduleEnabled() must be implemented');
+    }
+
+    /**
+     * List all schedules
+     * @returns {Promise<Array>} List of schedules
+     */
+    async listSchedules() {
+        throw new Error('SchedulerAdapter.listSchedules() must be implemented');
+    }
+
+    /**
+     * Get a specific schedule
+     * @param {string} scriptName - Script identifier
+     * @returns {Promise<Object>} Schedule details
+     */
+    async getSchedule(scriptName) {
+        throw new Error('SchedulerAdapter.getSchedule() must be implemented');
+    }
+}
+
+module.exports = { SchedulerAdapter };