@friggframework/admin-scripts 2.0.0--canary.517.9066dd6.0 → 2.0.0--canary.522.923dfae.0

package/index.js

@@ -8,17 +8,11 @@
 // Application Services
 const { ScriptFactory, getScriptFactory, createScriptFactory } = require('./src/application/script-factory');
 const { AdminScriptBase } = require('./src/application/admin-script-base');
-const {
-    AdminScriptContext,
-    createAdminScriptContext,
-    // Legacy aliases (deprecated)
-    AdminFriggCommands,
-    createAdminFriggCommands,
-} = require('./src/application/admin-frigg-commands');
+const { AdminFriggCommands, createAdminFriggCommands } = require('./src/application/admin-frigg-commands');
 const { ScriptRunner, createScriptRunner } = require('./src/application/script-runner');
 
 // Infrastructure
-const { validateAdminApiKey } = require('./src/infrastructure/admin-auth-middleware');
+const { adminAuthMiddleware } = require('./src/infrastructure/admin-auth-middleware');
 const { router, app, handler: routerHandler } = require('./src/infrastructure/admin-script-router');
 const { handler: executorHandler } = require('./src/infrastructure/script-executor-handler');
 
@@ -36,6 +30,7 @@ const { AWSSchedulerAdapter } = require('./src/adapters/aws-scheduler-adapter');
 const { LocalSchedulerAdapter } = require('./src/adapters/local-scheduler-adapter');
 const {
     createSchedulerAdapter,
+    detectSchedulerAdapterType,
 } = require('./src/adapters/scheduler-adapter-factory');
 
 module.exports = {
@@ -44,16 +39,13 @@ module.exports = {
     ScriptFactory,
     getScriptFactory,
     createScriptFactory,
-    AdminScriptContext,
-    createAdminScriptContext,
-    // Legacy aliases (deprecated)
     AdminFriggCommands,
     createAdminFriggCommands,
     ScriptRunner,
     createScriptRunner,
 
     // Infrastructure layer
-    validateAdminApiKey,
+    adminAuthMiddleware,
     router,
     app,
     routerHandler,
@@ -70,4 +62,5 @@ module.exports = {
     AWSSchedulerAdapter,
     LocalSchedulerAdapter,
     createSchedulerAdapter,
+    detectSchedulerAdapterType,
 };

package/package.json

@@ -1,24 +1,27 @@
 {
     "name": "@friggframework/admin-scripts",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.517.9066dd6.0",
+    "version": "2.0.0--canary.522.923dfae.0",
     "description": "Admin Script Runner for Frigg - Execute maintenance and operational scripts in hosted environments",
     "dependencies": {
         "@aws-sdk/client-scheduler": "^3.588.0",
-        "@friggframework/core": "2.0.0--canary.517.9066dd6.0",
+        "@friggframework/core": "2.0.0--canary.522.923dfae.0",
         "bcryptjs": "^2.4.3",
         "express": "^4.18.2",
         "lodash": "4.17.21",
+        "mongoose": "6.11.6",
         "serverless-http": "^3.2.0",
         "uuid": "^9.0.1"
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.517.9066dd6.0",
-        "@friggframework/prettier-config": "2.0.0--canary.517.9066dd6.0",
-        "@friggframework/test": "2.0.0--canary.517.9066dd6.0",
+        "@friggframework/eslint-config": "2.0.0--canary.522.923dfae.0",
+        "@friggframework/prettier-config": "2.0.0--canary.522.923dfae.0",
+        "@friggframework/test": "2.0.0--canary.522.923dfae.0",
+        "chai": "^4.3.6",
         "eslint": "^8.22.0",
         "jest": "^29.7.0",
         "prettier": "^2.7.1",
+        "sinon": "^16.1.1",
         "supertest": "^7.1.4"
     },
     "scripts": {
@@ -46,5 +49,5 @@
         "maintenance",
         "operations"
     ],
-    "gitHead": "9066dd6181d4fb9a1ec3d046c3f0de4ebba651a8"
+    "gitHead": "923dfaebed139e79450165c5e2ecf11ef7cbcd40"
 }

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

@@ -18,28 +18,34 @@ jest.mock('@aws-sdk/client-scheduler', () => {
     };
 });
 
-const defaultParams = {
-    targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:admin-script-executor',
-    scheduleGroupName: 'frigg-admin-scripts',
-    roleArn: 'arn:aws:iam::123456789012:role/test-role',
-};
-
 describe('AWSSchedulerAdapter', () => {
     let adapter;
     let mockSend;
-    const originalEnv = process.env;
+    let originalEnv;
+
+    beforeAll(() => {
+        originalEnv = { ...process.env };
+    });
 
     beforeEach(() => {
         jest.clearAllMocks();
-        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
+
+        // Reset environment variables
+        process.env.AWS_REGION = 'us-east-1';
+        process.env.SCHEDULE_GROUP_NAME = 'test-schedule-group';
+        process.env.SCHEDULER_ROLE_ARN = 'arn:aws:iam::123456789012:role/test-role';
+        process.env.ADMIN_SCRIPT_LAMBDA_ARN = 'arn:aws:lambda:us-east-1:123456789012:function:test-executor';
 
         const sdk = require('@aws-sdk/client-scheduler');
         mockSend = sdk._mockSend;
 
-        adapter = new AWSSchedulerAdapter({ ...defaultParams });
+        adapter = new AWSSchedulerAdapter({
+            targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:admin-script-executor',
+            scheduleGroupName: 'frigg-admin-scripts',
+        });
     });
 
-    afterEach(() => {
+    afterAll(() => {
         process.env = originalEnv;
     });
 
@@ -54,46 +60,35 @@ describe('AWSSchedulerAdapter', () => {
     });
 
     describe('Constructor', () => {
-        it('should use provided configuration and AWS_REGION from env', () => {
-            process.env.AWS_REGION = 'eu-west-1';
+        it('should use provided configuration', () => {
             const customAdapter = new AWSSchedulerAdapter({
+                region: 'eu-west-1',
                 targetLambdaArn: 'arn:aws:lambda:eu-west-1:123456789012:function:custom',
                 scheduleGroupName: 'custom-group',
-                roleArn: 'arn:aws:iam::123456789012:role/custom-role',
             });
 
             expect(customAdapter.region).toBe('eu-west-1');
             expect(customAdapter.targetLambdaArn).toBe('arn:aws:lambda:eu-west-1:123456789012:function:custom');
             expect(customAdapter.scheduleGroupName).toBe('custom-group');
-            expect(customAdapter.roleArn).toBe('arn:aws:iam::123456789012:role/custom-role');
         });
 
-        it('should throw if AWS_REGION is not set', () => {
-            delete process.env.AWS_REGION;
-            expect(() => new AWSSchedulerAdapter({
-                ...defaultParams,
-            })).toThrow('AWSSchedulerAdapter requires AWS_REGION environment variable');
-        });
+        it('should use environment variables as fallback', () => {
+            const envAdapter = new AWSSchedulerAdapter();
 
-        it('should throw if targetLambdaArn is missing', () => {
-            expect(() => new AWSSchedulerAdapter({
-                scheduleGroupName: defaultParams.scheduleGroupName,
-                roleArn: defaultParams.roleArn,
-            })).toThrow('AWSSchedulerAdapter requires targetLambdaArn');
+            expect(envAdapter.region).toBe('us-east-1');
+            expect(envAdapter.targetLambdaArn).toBe('arn:aws:lambda:us-east-1:123456789012:function:test-executor');
+            expect(envAdapter.scheduleGroupName).toBe('test-schedule-group');
         });
 
-        it('should throw if scheduleGroupName is missing', () => {
-            expect(() => new AWSSchedulerAdapter({
-                targetLambdaArn: defaultParams.targetLambdaArn,
-                roleArn: defaultParams.roleArn,
-            })).toThrow('AWSSchedulerAdapter requires scheduleGroupName');
-        });
+        it('should use defaults when no config or env vars', () => {
+            delete process.env.AWS_REGION;
+            delete process.env.SCHEDULE_GROUP_NAME;
+            delete process.env.ADMIN_SCRIPT_LAMBDA_ARN;
+
+            const defaultAdapter = new AWSSchedulerAdapter();
 
-        it('should throw if roleArn is missing', () => {
-            expect(() => new AWSSchedulerAdapter({
-                targetLambdaArn: defaultParams.targetLambdaArn,
-                scheduleGroupName: defaultParams.scheduleGroupName,
-            })).toThrow('AWSSchedulerAdapter requires roleArn');
+            expect(defaultAdapter.region).toBe('us-east-1');
+            expect(defaultAdapter.scheduleGroupName).toBe('frigg-admin-scripts');
         });
     });
 
@@ -144,7 +139,7 @@ describe('AWSSchedulerAdapter', () => {
             });
         });
 
-        it('should configure target with Lambda ARN and constructor roleArn', async () => {
+        it('should configure target with Lambda ARN and role', async () => {
             mockSend.mockResolvedValue({
                 ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
             });
@@ -159,26 +154,6 @@ describe('AWSSchedulerAdapter', () => {
             expect(command.params.Target.RoleArn).toBe('arn:aws:iam::123456789012:role/test-role');
         });
 
-        it('should use roleArn from constructor, not process.env', async () => {
-            const customRoleArn = 'arn:aws:iam::999999999999:role/custom-scheduler-role';
-            const customAdapter = new AWSSchedulerAdapter({
-                ...defaultParams,
-                roleArn: customRoleArn,
-            });
-
-            mockSend.mockResolvedValue({
-                ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
-            });
-
-            await customAdapter.createSchedule({
-                scriptName: 'test-script',
-                cronExpression: 'cron(0 0 * * ? *)',
-            });
-
-            const command = mockSend.mock.calls[0][0];
-            expect(command.params.Target.RoleArn).toBe(customRoleArn);
-        });
-
         it('should enable schedule by default', async () => {
             mockSend.mockResolvedValue({
                 ScheduleArn: 'arn:aws:scheduler:us-east-1:123456789012:schedule/frigg-admin-scripts/frigg-script-test-script',
@@ -326,7 +301,9 @@ describe('AWSSchedulerAdapter', () => {
 
     describe('Lazy SDK loading', () => {
         it('should load AWS SDK on first client access', () => {
-            const newAdapter = new AWSSchedulerAdapter({ ...defaultParams });
+            const newAdapter = new AWSSchedulerAdapter({
+                targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:test',
+            });
 
             expect(newAdapter.scheduler).toBeNull();
 

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

@@ -1,4 +1,7 @@
-const { createSchedulerAdapter } = require('../scheduler-adapter-factory');
+const {
+    createSchedulerAdapter,
+    detectSchedulerAdapterType,
+} = require('../scheduler-adapter-factory');
 const { AWSSchedulerAdapter } = require('../aws-scheduler-adapter');
 const { LocalSchedulerAdapter } = require('../local-scheduler-adapter');
 
@@ -14,56 +17,71 @@ jest.mock('@aws-sdk/client-scheduler', () => ({
     ListSchedulesCommand: jest.fn(),
 }));
 
-const awsAdapterParams = {
-    targetLambdaArn: 'arn:aws:lambda:us-east-1:123456789012:function:test',
-    scheduleGroupName: 'test-group',
-    roleArn: 'arn:aws:iam::123456789012:role/test-role',
-};
-
 describe('Scheduler Adapter Factory', () => {
-    const originalEnv = process.env;
+    let originalEnv;
+
+    beforeAll(() => {
+        originalEnv = { ...process.env };
+    });
 
     beforeEach(() => {
-        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
+        // Reset environment variables
+        delete process.env.SCHEDULER_ADAPTER;
+        delete process.env.STAGE;
+        delete process.env.NODE_ENV;
     });
 
-    afterEach(() => {
+    afterAll(() => {
         process.env = originalEnv;
     });
 
     describe('createSchedulerAdapter()', () => {
-        it('should throw if type is not provided', () => {
-            expect(() => createSchedulerAdapter()).toThrow();
-        });
+        it('should create local adapter by default', () => {
+            const adapter = createSchedulerAdapter();
 
-        it('should throw if type is not provided in options object', () => {
-            expect(() => createSchedulerAdapter({})).toThrow();
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+            expect(adapter.getName()).toBe('local-cron');
         });
 
-        it('should create local adapter when type is "local"', () => {
+        it('should create local adapter when explicitly specified', () => {
             const adapter = createSchedulerAdapter({ type: 'local' });
 
             expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
-            expect(adapter.getName()).toBe('local-cron');
         });
 
         it('should create AWS adapter when type is "aws"', () => {
-            const adapter = createSchedulerAdapter({ type: 'aws', ...awsAdapterParams });
+            const adapter = createSchedulerAdapter({ type: 'aws' });
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
             expect(adapter.getName()).toBe('aws-eventbridge-scheduler');
         });
 
         it('should create AWS adapter when type is "eventbridge"', () => {
-            const adapter = createSchedulerAdapter({ type: 'eventbridge', ...awsAdapterParams });
+            const adapter = createSchedulerAdapter({ type: 'eventbridge' });
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should use SCHEDULER_ADAPTER env variable', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const adapter = createSchedulerAdapter();
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
         });
 
+        it('should allow explicit type to override env variable', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const adapter = createSchedulerAdapter({ type: 'local' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+
         it('should handle case-insensitive type values', () => {
-            const adapter1 = createSchedulerAdapter({ type: 'AWS', ...awsAdapterParams });
+            const adapter1 = createSchedulerAdapter({ type: 'AWS' });
             const adapter2 = createSchedulerAdapter({ type: 'LOCAL' });
-            const adapter3 = createSchedulerAdapter({ type: 'EventBridge', ...awsAdapterParams });
+            const adapter3 = createSchedulerAdapter({ type: 'EventBridge' });
 
             expect(adapter1).toBeInstanceOf(AWSSchedulerAdapter);
             expect(adapter2).toBeInstanceOf(LocalSchedulerAdapter);
@@ -73,29 +91,17 @@ describe('Scheduler Adapter Factory', () => {
         it('should pass AWS configuration to AWS adapter', () => {
             const config = {
                 type: 'aws',
+                region: 'eu-west-1',
                 targetLambdaArn: 'arn:aws:lambda:eu-west-1:123456789012:function:test',
                 scheduleGroupName: 'custom-group',
-                roleArn: 'arn:aws:iam::123456789012:role/custom-role',
             };
 
             const adapter = createSchedulerAdapter(config);
 
             expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
-            expect(adapter.region).toBe('us-east-1'); // From process.env.AWS_REGION
+            expect(adapter.region).toBe('eu-west-1');
             expect(adapter.targetLambdaArn).toBe('arn:aws:lambda:eu-west-1:123456789012:function:test');
             expect(adapter.scheduleGroupName).toBe('custom-group');
-            expect(adapter.roleArn).toBe('arn:aws:iam::123456789012:role/custom-role');
-        });
-
-        it('should pass roleArn through to AWS adapter', () => {
-            const adapter = createSchedulerAdapter({
-                type: 'aws',
-                ...awsAdapterParams,
-                roleArn: 'arn:aws:iam::999999999999:role/scheduler-role',
-            });
-
-            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
-            expect(adapter.roleArn).toBe('arn:aws:iam::999999999999:role/scheduler-role');
         });
 
         it('should ignore AWS config for local adapter', () => {
@@ -110,8 +116,142 @@ describe('Scheduler Adapter Factory', () => {
             expect(adapter.region).toBeUndefined();
         });
 
-        it('should throw for unknown adapter type', () => {
-            expect(() => createSchedulerAdapter({ type: 'unknown-type' })).toThrow();
+        it('should handle unknown adapter type by creating local adapter', () => {
+            const adapter = createSchedulerAdapter({ type: 'unknown-type' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+    });
+
+    describe('detectSchedulerAdapterType()', () => {
+        it('should return "local" by default', () => {
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return env SCHEDULER_ADAPTER when set', () => {
+            process.env.SCHEDULER_ADAPTER = 'aws';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for production stage', () => {
+            process.env.STAGE = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for prod stage', () => {
+            process.env.STAGE = 'prod';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for staging stage', () => {
+            process.env.STAGE = 'staging';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "aws" for stage stage', () => {
+            process.env.STAGE = 'stage';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should handle case-insensitive stage values', () => {
+            process.env.STAGE = 'PRODUCTION';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should return "local" for dev stage', () => {
+            process.env.STAGE = 'dev';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for development stage', () => {
+            process.env.STAGE = 'development';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for test stage', () => {
+            process.env.STAGE = 'test';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should return "local" for local stage', () => {
+            process.env.STAGE = 'local';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+
+        it('should use NODE_ENV as fallback for STAGE', () => {
+            delete process.env.STAGE;
+            process.env.NODE_ENV = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('aws');
+        });
+
+        it('should prioritize explicit SCHEDULER_ADAPTER over auto-detection', () => {
+            process.env.SCHEDULER_ADAPTER = 'local';
+            process.env.STAGE = 'production';
+
+            const type = detectSchedulerAdapterType();
+
+            expect(type).toBe('local');
+        });
+    });
+
+    describe('Integration with createSchedulerAdapter', () => {
+        it('should auto-detect and create AWS adapter in production', () => {
+            process.env.STAGE = 'production';
+
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(AWSSchedulerAdapter);
+        });
+
+        it('should auto-detect and create local adapter in development', () => {
+            process.env.STAGE = 'development';
+
+            const adapter = createSchedulerAdapter();
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
+        });
+
+        it('should allow explicit override of auto-detection', () => {
+            process.env.STAGE = 'production';
+
+            const adapter = createSchedulerAdapter({ type: 'local' });
+
+            expect(adapter).toBeInstanceOf(LocalSchedulerAdapter);
         });
     });
 });

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

@@ -25,19 +25,12 @@ function loadSchedulerSDK() {
  * Supports cron expressions, timezone configuration, and Lambda invocation.
  */
 class AWSSchedulerAdapter extends SchedulerAdapter {
-    constructor({ credentials, targetLambdaArn, scheduleGroupName, roleArn } = {}) {
+    constructor({ region, credentials, targetLambdaArn, scheduleGroupName } = {}) {
         super();
-        if (!targetLambdaArn) throw new Error('AWSSchedulerAdapter requires targetLambdaArn');
-        if (!scheduleGroupName) throw new Error('AWSSchedulerAdapter requires scheduleGroupName');
-        if (!roleArn) throw new Error('AWSSchedulerAdapter requires roleArn');
-        // Region inherits from the service (set by Lambda runtime, same for all AWS resources)
-        const region = process.env.AWS_REGION;
-        if (!region) throw new Error('AWSSchedulerAdapter requires AWS_REGION environment variable');
-        this.region = region;
+        this.region = region || process.env.AWS_REGION || 'us-east-1';
         this.credentials = credentials;
-        this.targetLambdaArn = targetLambdaArn;
-        this.scheduleGroupName = scheduleGroupName;
-        this.roleArn = roleArn;
+        this.targetLambdaArn = targetLambdaArn || process.env.ADMIN_SCRIPT_LAMBDA_ARN;
+        this.scheduleGroupName = scheduleGroupName || process.env.SCHEDULE_GROUP_NAME || 'frigg-admin-scripts';
         this.scheduler = null;
     }
 
@@ -68,7 +61,7 @@ class AWSSchedulerAdapter extends SchedulerAdapter {
             FlexibleTimeWindow: { Mode: 'OFF' },
             Target: {
                 Arn: this.targetLambdaArn,
-                RoleArn: this.roleArn,
+                RoleArn: process.env.SCHEDULER_ROLE_ARN,
                 Input: JSON.stringify({
                     scriptName,
                     trigger: 'SCHEDULED',

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

@@ -6,44 +6,64 @@ const { LocalSchedulerAdapter } = require('./local-scheduler-adapter');
  *
  * Application Layer - Hexagonal Architecture
  *
- * Creates the appropriate scheduler adapter based on explicit configuration
- * from appDefinition. Does not auto-detect or read environment variables.
+ * 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 (from appDefinition.adminScripts.scheduler)
- * @param {string} options.type - Adapter type ('aws', 'eventbridge', 'local') - required
+ * @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 (required for AWS adapter)
- * @param {string} [options.scheduleGroupName] - EventBridge schedule group name (required for AWS adapter)
- * @param {string} [options.roleArn] - IAM role ARN for scheduler (required 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 = {}) {
-    if (!options.type) {
-        throw new Error('Scheduler adapter type is required. Configure in appDefinition.adminScripts.scheduler.type');
-    }
+    const adapterType = options.type || detectSchedulerAdapterType();
 
-    switch (options.type.toLowerCase()) {
+    switch (adapterType.toLowerCase()) {
         case 'aws':
         case 'eventbridge':
             return new AWSSchedulerAdapter({
+                region: options.region,
                 credentials: options.credentials,
                 targetLambdaArn: options.targetLambdaArn,
                 scheduleGroupName: options.scheduleGroupName,
-                roleArn: options.roleArn,
             });
 
         case 'local':
+        default:
             return new LocalSchedulerAdapter();
+    }
+}
 
-        default:
-            throw new Error(`Unknown scheduler adapter type: ${options.type}`);
+/**
+ * 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,
 };