@friggframework/devtools 2.0.0--canary.517.f738cdd.0 → 2.0.0--canary.531.eec57c3.0

package/infrastructure/domains/scheduler/scheduler-builder.js

@@ -0,0 +1,211 @@
+/**
+ * Scheduler Builder
+ *
+ * Domain Layer - Hexagonal Architecture
+ *
+ * Responsible for:
+ * - Creating EventBridge Scheduler ScheduleGroup resource
+ * - Creating IAM Role for EventBridge Scheduler to send messages to SQS
+ * - Adding necessary IAM statements for Lambda to create/delete schedules
+ *
+ * This builder enables integrations to schedule one-time jobs (e.g., webhook renewals)
+ * using AWS EventBridge Scheduler.
+ */
+
+const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
+
+class SchedulerBuilder extends InfrastructureBuilder {
+    constructor() {
+        super();
+        this.name = 'SchedulerBuilder';
+    }
+
+    shouldExecute(appDefinition) {
+        // Enable scheduler if explicitly enabled or if any integration has webhooks
+        // (webhooks often need renewal scheduling)
+        if (appDefinition.scheduler?.enable === true) {
+            return true;
+        }
+
+        // Check if any integration has webhooks enabled
+        if (Array.isArray(appDefinition.integrations)) {
+            return appDefinition.integrations.some(
+                (integration) =>
+                    integration?.Definition?.webhooks?.enabled === true ||
+                    integration?.Definition?.webhooks === true
+            );
+        }
+
+        return false;
+    }
+
+    getDependencies() {
+        return ['IntegrationBuilder']; // Needs integration queues to exist
+    }
+
+    validate(appDefinition) {
+        const result = new ValidationResult();
+        // No validation required - scheduler is optional
+        return result;
+    }
+
+    async build(appDefinition, discoveredResources) {
+        console.log(`\n[${this.name}] Configuring EventBridge Scheduler...`);
+
+        const result = {
+            functions: {},
+            resources: {},
+            environment: {},
+            custom: {},
+            iamStatements: [],
+        };
+
+        // Create ScheduleGroup resource
+        this.createScheduleGroup(result);
+
+        // Create IAM Role for EventBridge Scheduler
+        this.createSchedulerExecutionRole(appDefinition, result);
+
+        // Add IAM statements for Lambda to manage schedules
+        this.addSchedulerIamStatements(result);
+
+        // Add environment variables
+        this.addEnvironmentVariables(result);
+
+        console.log(`[${this.name}] ✅ Scheduler configuration completed`);
+        return result;
+    }
+
+    /**
+     * Create EventBridge Scheduler ScheduleGroup
+     * Uses stage-specific naming to allow multiple deployments in same AWS account
+     */
+    createScheduleGroup(result) {
+        const scheduleGroupName = '${self:service}-${self:provider.stage}-schedules';
+
+        result.resources.FriggScheduleGroup = {
+            Type: 'AWS::Scheduler::ScheduleGroup',
+            Properties: {
+                Name: scheduleGroupName,
+            },
+        };
+
+        console.log(`  ✓ Created ScheduleGroup: ${scheduleGroupName}`);
+    }
+
+    /**
+     * Create IAM Role for EventBridge Scheduler to send messages to SQS
+     */
+    createSchedulerExecutionRole(appDefinition, result) {
+        // Collect all integration queue ARNs
+        const queueArns = [];
+        if (Array.isArray(appDefinition.integrations)) {
+            appDefinition.integrations.forEach((integration) => {
+                const integrationName = integration?.Definition?.name;
+                if (integrationName) {
+                    const capitalizedName =
+                        integrationName.charAt(0).toUpperCase() +
+                        integrationName.slice(1);
+                    queueArns.push({
+                        'Fn::GetAtt': [`${capitalizedName}Queue`, 'Arn'],
+                    });
+                }
+            });
+        }
+
+        // If no queues found, use a placeholder (shouldn't happen if IntegrationBuilder ran)
+        if (queueArns.length === 0) {
+            console.warn(
+                '  ⚠ No integration queues found for scheduler role'
+            );
+            queueArns.push('arn:aws:sqs:*:*:*'); // Fallback
+        }
+
+        result.resources.SchedulerExecutionRole = {
+            Type: 'AWS::IAM::Role',
+            Properties: {
+                RoleName:
+                    '${self:service}-${self:provider.stage}-scheduler-role',
+                AssumeRolePolicyDocument: {
+                    Version: '2012-10-17',
+                    Statement: [
+                        {
+                            Effect: 'Allow',
+                            Principal: {
+                                Service: 'scheduler.amazonaws.com',
+                            },
+                            Action: 'sts:AssumeRole',
+                        },
+                    ],
+                },
+                Policies: [
+                    {
+                        PolicyName: 'SchedulerSQSPolicy',
+                        PolicyDocument: {
+                            Version: '2012-10-17',
+                            Statement: [
+                                {
+                                    Effect: 'Allow',
+                                    Action: ['sqs:SendMessage'],
+                                    Resource: queueArns,
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        };
+
+        console.log('  ✓ Created SchedulerExecutionRole');
+    }
+
+    /**
+     * Add IAM statements for Lambda functions to manage schedules
+     */
+    addSchedulerIamStatements(result) {
+        result.iamStatements.push(
+            {
+                Effect: 'Allow',
+                Action: [
+                    'scheduler:CreateSchedule',
+                    'scheduler:DeleteSchedule',
+                    'scheduler:GetSchedule',
+                ],
+                Resource: {
+                    'Fn::Sub': [
+                        'arn:aws:scheduler:${AWS::Region}:${AWS::AccountId}:schedule/${GroupName}/*',
+                        { GroupName: { Ref: 'FriggScheduleGroup' } },
+                    ],
+                },
+            },
+            {
+                Effect: 'Allow',
+                Action: ['iam:PassRole'],
+                Resource: { 'Fn::GetAtt': ['SchedulerExecutionRole', 'Arn'] },
+                Condition: {
+                    StringEquals: {
+                        'iam:PassedToService': 'scheduler.amazonaws.com',
+                    },
+                },
+            }
+        );
+
+        console.log('  ✓ Added scheduler IAM statements');
+    }
+
+    /**
+     * Add environment variables for scheduler configuration
+     */
+    addEnvironmentVariables(result) {
+        result.environment.SCHEDULER_ROLE_ARN = {
+            'Fn::GetAtt': ['SchedulerExecutionRole', 'Arn'],
+        };
+        result.environment.SCHEDULE_GROUP_NAME = {
+            Ref: 'FriggScheduleGroup',
+        };
+
+        console.log('  ✓ Added scheduler environment variables');
+    }
+}
+
+module.exports = { SchedulerBuilder };

package/infrastructure/domains/shared/types/app-definition.js

@@ -106,25 +106,6 @@
  * @property {string} Definition.name - Integration name
  */
 
-/**
- * Admin script definition
- * @typedef {Object} AdminScriptDefinition
- * @property {Object} Definition - Static definition from script class
- * @property {string} Definition.name - Script name identifier
- * @property {string} Definition.version - Script version (semver)
- * @property {string} [Definition.description] - Human-readable description
- * @property {Object} [Definition.schedule] - Schedule configuration
- * @property {boolean} [Definition.schedule.enabled] - Whether scheduling is enabled
- * @property {string} [Definition.schedule.cronExpression] - Cron expression
- */
-
-/**
- * Admin configuration
- * @typedef {Object} AdminConfig
- * @property {boolean} [includeBuiltinScripts] - Whether to include built-in scripts
- * @property {boolean} [enableScheduling] - Whether to enable EventBridge scheduling
- */
-
 /**
  * Complete application definition
  * @typedef {Object} AppDefinition
@@ -141,8 +122,6 @@
  * @property {MigrationDefinition} [migrations] - Database migration configuration
  * @property {WebsocketDefinition} [websockets] - WebSocket API configuration
  * @property {IntegrationDefinition[]} [integrations] - Integration definitions
- * @property {AdminScriptDefinition[]} [adminScripts] - Admin script definitions
- * @property {AdminConfig} [admin] - Admin configuration
  *
  * @property {Object} [environment] - Environment variables
  */

package/infrastructure/infrastructure-composer.js

@@ -16,7 +16,7 @@ const { MigrationBuilder } = require('./domains/database/migration-builder');
 const { SsmBuilder } = require('./domains/parameters/ssm-builder');
 const { WebsocketBuilder } = require('./domains/integration/websocket-builder');
 const { IntegrationBuilder } = require('./domains/integration/integration-builder');
-const { AdminScriptBuilder } = require('./domains/admin-scripts/admin-script-builder');
+const { SchedulerBuilder } = require('./domains/scheduler/scheduler-builder');
 
 // Utilities
 const { modifyHandlerPaths } = require('./domains/shared/utilities/handler-path-resolver');
@@ -52,7 +52,7 @@ const composeServerlessDefinition = async (AppDefinition) => {
         new SsmBuilder(),
         new WebsocketBuilder(),
         new IntegrationBuilder(),
-        new AdminScriptBuilder(),
+        new SchedulerBuilder(), // Add scheduler after IntegrationBuilder (depends on it)
     ]);
 
     // Build all infrastructure (orchestrator handles validation, dependencies, parallel execution)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.517.f738cdd.0",
+  "version": "2.0.0--canary.531.eec57c3.0",
   "bin": {
     "frigg": "./frigg-cli/index.js"
   },
@@ -25,9 +25,9 @@
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0--canary.517.f738cdd.0",
-    "@friggframework/schemas": "2.0.0--canary.517.f738cdd.0",
-    "@friggframework/test": "2.0.0--canary.517.f738cdd.0",
+    "@friggframework/core": "2.0.0--canary.531.eec57c3.0",
+    "@friggframework/schemas": "2.0.0--canary.531.eec57c3.0",
+    "@friggframework/test": "2.0.0--canary.531.eec57c3.0",
     "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
@@ -55,8 +55,8 @@
     "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.517.f738cdd.0",
-    "@friggframework/prettier-config": "2.0.0--canary.517.f738cdd.0",
+    "@friggframework/eslint-config": "2.0.0--canary.531.eec57c3.0",
+    "@friggframework/prettier-config": "2.0.0--canary.531.eec57c3.0",
     "aws-sdk-client-mock": "^4.1.0",
     "aws-sdk-client-mock-jest": "^4.1.0",
     "jest": "^30.1.3",
@@ -88,5 +88,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f738cdd2e74529b3719a974c44e39e08cbf24313"
+  "gitHead": "eec57c3f5045f0392b26b97e5a12041b14986219"
 }

package/infrastructure/domains/admin-scripts/admin-script-builder.js

@@ -1,200 +0,0 @@
-/**
- * Admin Script Builder
- *
- * Domain Layer - Hexagonal Architecture
- *
- * Responsible for:
- * - Creating SQS queue for admin script execution
- * - Creating Lambda function for script execution (worker)
- * - Creating Lambda function for admin API routes (router)
- * - Creating EventBridge Scheduler resources (Phase 2)
- * - Creating IAM roles for scheduler to invoke Lambda
- */
-
-const { InfrastructureBuilder, ValidationResult } = require('../shared/base-builder');
-
-class AdminScriptBuilder extends InfrastructureBuilder {
-    constructor() {
-        super();
-        this.name = 'AdminScriptBuilder';
-    }
-
-    shouldExecute(appDefinition) {
-        return Array.isArray(appDefinition.adminScripts) && appDefinition.adminScripts.length > 0;
-    }
-
-    getDependencies() {
-        return []; // Can run independently
-    }
-
-    validate(appDefinition) {
-        const result = new ValidationResult();
-
-        if (!appDefinition.adminScripts) {
-            return result; // Not an error, just no scripts
-        }
-
-        if (!Array.isArray(appDefinition.adminScripts)) {
-            result.addError('adminScripts must be an array');
-            return result;
-        }
-
-        // Validate each script
-        appDefinition.adminScripts.forEach((script, index) => {
-            if (!script?.Definition?.name) {
-                result.addError(`Admin script at index ${index} is missing Definition or name`);
-            }
-        });
-
-        return result;
-    }
-
-    async build(appDefinition, discoveredResources) {
-        console.log(`\n[${this.name}] Configuring admin scripts...`);
-        console.log(`  Processing ${appDefinition.adminScripts.length} scripts...`);
-
-        const usePrismaLayer = appDefinition.usePrismaLambdaLayer !== false;
-        const adminConfig = appDefinition.admin || {};
-
-        const result = {
-            functions: {},
-            resources: {},
-            environment: {},
-            custom: {},
-            iamStatements: [],
-        };
-
-        // Create admin script queue
-        this.createAdminScriptQueue(result);
-
-        // Create Lambda function for script execution
-        this.createScriptExecutorFunction(result, usePrismaLayer);
-
-        // Create API routes for script management
-        this.createAdminScriptRoutes(result, usePrismaLayer);
-
-        // Phase 2: Create EventBridge Scheduler resources
-        if (adminConfig.enableScheduling) {
-            this.createSchedulerResources(appDefinition, result);
-        }
-
-        // Log registered scripts
-        appDefinition.adminScripts.forEach(script => {
-            const name = script.Definition?.name || 'unknown';
-            const schedule = script.Definition?.schedule;
-            console.log(`    ✓ Registered: ${name}${schedule?.enabled ? ' (scheduled)' : ''}`);
-        });
-
-        console.log(`[${this.name}] ✅ Admin script configuration completed`);
-        return result;
-    }
-
-    createAdminScriptQueue(result) {
-        result.resources.AdminScriptQueue = {
-            Type: 'AWS::SQS::Queue',
-            Properties: {
-                QueueName: '${self:service}-${self:provider.stage}-AdminScriptQueue',
-                MessageRetentionPeriod: 86400, // 1 day
-                VisibilityTimeout: 900, // 15 minutes (Lambda max)
-                RedrivePolicy: {
-                    maxReceiveCount: 3,
-                    deadLetterTargetArn: {
-                        'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                    },
-                },
-            },
-        };
-
-        result.environment.ADMIN_SCRIPT_QUEUE_URL = { Ref: 'AdminScriptQueue' };
-        console.log('  ✓ Created AdminScriptQueue');
-    }
-
-    createScriptExecutorFunction(result, usePrismaLayer) {
-        result.functions.adminScriptExecutor = {
-            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/script-executor-handler.handler',
-            skipEsbuild: true,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
-            timeout: 900, // 15 minutes max
-            memorySize: 1024,
-            events: [
-                {
-                    sqs: {
-                        arn: { 'Fn::GetAtt': ['AdminScriptQueue', 'Arn'] },
-                        batchSize: 1,
-                    },
-                },
-            ],
-        };
-        console.log('  ✓ Created adminScriptExecutor function');
-    }
-
-    createAdminScriptRoutes(result, usePrismaLayer) {
-        result.functions.adminScriptRouter = {
-            handler: 'node_modules/@friggframework/admin-scripts/src/infrastructure/admin-script-router.handler',
-            skipEsbuild: true,
-            ...(usePrismaLayer && { layers: [{ Ref: 'PrismaLambdaLayer' }] }),
-            timeout: 30,
-            events: [
-                // List scripts
-                { httpApi: { path: '/admin/scripts', method: 'GET' } },
-                // Get script details
-                { httpApi: { path: '/admin/scripts/{scriptName}', method: 'GET' } },
-                // Execute script (sync or async)
-                { httpApi: { path: '/admin/scripts/{scriptName}/execute', method: 'POST' } },
-                // Get execution status
-                { httpApi: { path: '/admin/executions/{executionId}', method: 'GET' } },
-                // List executions
-                { httpApi: { path: '/admin/executions', method: 'GET' } },
-                // Schedule management (Phase 2)
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'GET' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'PUT' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'DELETE' } },
-            ],
-        };
-        console.log('  ✓ Created adminScriptRouter function');
-    }
-
-    createSchedulerResources(appDefinition, result) {
-        // Create IAM role for EventBridge Scheduler
-        result.resources.AdminScriptSchedulerRole = {
-            Type: 'AWS::IAM::Role',
-            Properties: {
-                RoleName: '${self:service}-${self:provider.stage}-admin-script-scheduler',
-                AssumeRolePolicyDocument: {
-                    Version: '2012-10-17',
-                    Statement: [{
-                        Effect: 'Allow',
-                        Principal: { Service: 'scheduler.amazonaws.com' },
-                        Action: 'sts:AssumeRole',
-                    }],
-                },
-                Policies: [{
-                    PolicyName: 'InvokeLambda',
-                    PolicyDocument: {
-                        Version: '2012-10-17',
-                        Statement: [{
-                            Effect: 'Allow',
-                            Action: 'lambda:InvokeFunction',
-                            Resource: { 'Fn::GetAtt': ['AdminScriptExecutorLambdaFunction', 'Arn'] },
-                        }],
-                    },
-                }],
-            },
-        };
-
-        // Create schedule group
-        result.resources.AdminScriptScheduleGroup = {
-            Type: 'AWS::Scheduler::ScheduleGroup',
-            Properties: {
-                Name: '${self:service}-${self:provider.stage}-admin-scripts',
-            },
-        };
-
-        result.environment.SCHEDULER_ROLE_ARN = { 'Fn::GetAtt': ['AdminScriptSchedulerRole', 'Arn'] };
-        result.environment.SCHEDULE_GROUP_NAME = { Ref: 'AdminScriptScheduleGroup' };
-
-        console.log('  ✓ Created EventBridge Scheduler resources');
-    }
-}
-
-module.exports = { AdminScriptBuilder };

package/infrastructure/domains/admin-scripts/admin-script-builder.test.js

@@ -1,499 +0,0 @@
-/**
- * Tests for Admin Script Builder
- *
- * Tests admin script infrastructure generation including:
- * - SQS queue for script execution
- * - Lambda executor function
- * - Lambda router function with HTTP routes
- * - EventBridge Scheduler resources (optional)
- */
-
-const { AdminScriptBuilder } = require('./admin-script-builder');
-const { ValidationResult } = require('../shared/base-builder');
-
-describe('AdminScriptBuilder', () => {
-    let adminScriptBuilder;
-
-    beforeEach(() => {
-        adminScriptBuilder = new AdminScriptBuilder();
-    });
-
-    describe('shouldExecute()', () => {
-        it('should return false when no adminScripts', () => {
-            const appDefinition = {};
-
-            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
-        });
-
-        it('should return false when adminScripts is empty array', () => {
-            const appDefinition = {
-                adminScripts: [],
-            };
-
-            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
-        });
-
-        it('should return true when adminScripts has items', () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(true);
-        });
-
-        it('should return false when adminScripts is not an array', () => {
-            const appDefinition = {
-                adminScripts: { name: 'test' },
-            };
-
-            expect(adminScriptBuilder.shouldExecute(appDefinition)).toBe(false);
-        });
-    });
-
-    describe('getDependencies()', () => {
-        it('should have no dependencies', () => {
-            const deps = adminScriptBuilder.getDependencies();
-
-            expect(deps).toEqual([]);
-        });
-    });
-
-    describe('validate()', () => {
-        it('should pass validation with valid adminScripts', () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'oauth-refresh' } },
-                    { Definition: { name: 'health-check' } },
-                ],
-            };
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result).toBeInstanceOf(ValidationResult);
-            expect(result.valid).toBe(true);
-            expect(result.errors).toEqual([]);
-        });
-
-        it('should pass when adminScripts is undefined', () => {
-            const appDefinition = {};
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result.valid).toBe(true);
-        });
-
-        it('should fail when adminScripts is not an array', () => {
-            const appDefinition = {
-                adminScripts: 'invalid',
-            };
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain('adminScripts must be an array');
-        });
-
-        it('should fail when script missing Definition.name', () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: {} },
-                ],
-            };
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain(
-                'Admin script at index 0 is missing Definition or name'
-            );
-        });
-
-        it('should fail when script missing Definition', () => {
-            const appDefinition = {
-                adminScripts: [
-                    { someOtherField: 'value' },
-                ],
-            };
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain(
-                'Admin script at index 0 is missing Definition or name'
-            );
-        });
-
-        it('should validate all scripts', () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'valid' } },
-                    { Definition: {} }, // Invalid - no name
-                    { someField: 'value' }, // Invalid - no Definition
-                ],
-            };
-
-            const result = adminScriptBuilder.validate(appDefinition);
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toHaveLength(2);
-        });
-    });
-
-    describe('build()', () => {
-        it('should create AdminScriptQueue resource', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.resources.AdminScriptQueue).toBeDefined();
-            expect(result.resources.AdminScriptQueue.Type).toBe('AWS::SQS::Queue');
-        });
-
-        it('should configure AdminScriptQueue with correct retention and timeout', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.resources.AdminScriptQueue.Properties.MessageRetentionPeriod).toBe(86400); // 1 day
-            expect(result.resources.AdminScriptQueue.Properties.VisibilityTimeout).toBe(900); // 15 minutes
-        });
-
-        it('should configure AdminScriptQueue redrive policy to InternalErrorQueue', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.resources.AdminScriptQueue.Properties.RedrivePolicy).toEqual({
-                maxReceiveCount: 3,
-                deadLetterTargetArn: {
-                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                },
-            });
-        });
-
-        it('should add ADMIN_SCRIPT_QUEUE_URL to environment variables', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.environment.ADMIN_SCRIPT_QUEUE_URL).toEqual({
-                Ref: 'AdminScriptQueue',
-            });
-        });
-
-        it('should create adminScriptExecutor function', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor).toBeDefined();
-            expect(result.functions.adminScriptExecutor.handler).toBe(
-                'node_modules/@friggframework/admin-scripts/src/infrastructure/script-executor-handler.handler'
-            );
-        });
-
-        it('should configure adminScriptExecutor with SQS event', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.events).toEqual([
-                {
-                    sqs: {
-                        arn: { 'Fn::GetAtt': ['AdminScriptQueue', 'Arn'] },
-                        batchSize: 1,
-                    },
-                },
-            ]);
-        });
-
-        it('should set adminScriptExecutor timeout to 900 seconds', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.timeout).toBe(900); // 15 minutes (Lambda max)
-        });
-
-        it('should set adminScriptExecutor memory size', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.memorySize).toBe(1024);
-        });
-
-        it('should attach Prisma layer to adminScriptExecutor', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.layers).toEqual([
-                { Ref: 'PrismaLambdaLayer' }
-            ]);
-        });
-
-        it('should create adminScriptRouter function', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptRouter).toBeDefined();
-            expect(result.functions.adminScriptRouter.handler).toBe(
-                'node_modules/@friggframework/admin-scripts/src/infrastructure/admin-script-router.handler'
-            );
-        });
-
-        it('should configure adminScriptRouter with correct HTTP routes', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptRouter.events).toEqual([
-                // List scripts
-                { httpApi: { path: '/admin/scripts', method: 'GET' } },
-                // Get script details
-                { httpApi: { path: '/admin/scripts/{scriptName}', method: 'GET' } },
-                // Execute script (sync or async)
-                { httpApi: { path: '/admin/scripts/{scriptName}/execute', method: 'POST' } },
-                // Get execution status
-                { httpApi: { path: '/admin/executions/{executionId}', method: 'GET' } },
-                // List executions
-                { httpApi: { path: '/admin/executions', method: 'GET' } },
-                // Schedule management (Phase 2)
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'GET' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'PUT' } },
-                { httpApi: { path: '/admin/scripts/{scriptName}/schedule', method: 'DELETE' } },
-            ]);
-        });
-
-        it('should set adminScriptRouter timeout to 30 seconds', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptRouter.timeout).toBe(30);
-        });
-
-        it('should attach Prisma layer to adminScriptRouter', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptRouter.layers).toEqual([
-                { Ref: 'PrismaLambdaLayer' }
-            ]);
-        });
-
-        it('should create scheduler resources when admin.enableScheduling is true', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-                admin: {
-                    enableScheduling: true,
-                },
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            // Check for scheduler IAM role
-            expect(result.resources.AdminScriptSchedulerRole).toBeDefined();
-            expect(result.resources.AdminScriptSchedulerRole.Type).toBe('AWS::IAM::Role');
-
-            // Check for schedule group
-            expect(result.resources.AdminScriptScheduleGroup).toBeDefined();
-            expect(result.resources.AdminScriptScheduleGroup.Type).toBe('AWS::Scheduler::ScheduleGroup');
-
-            // Check for environment variables
-            expect(result.environment.SCHEDULER_ROLE_ARN).toEqual({
-                'Fn::GetAtt': ['AdminScriptSchedulerRole', 'Arn'],
-            });
-            expect(result.environment.SCHEDULE_GROUP_NAME).toEqual({
-                Ref: 'AdminScriptScheduleGroup',
-            });
-        });
-
-        it('should not create scheduler resources when enableScheduling is false', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-                admin: {
-                    enableScheduling: false,
-                },
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.resources.AdminScriptSchedulerRole).toBeUndefined();
-            expect(result.resources.AdminScriptScheduleGroup).toBeUndefined();
-            expect(result.environment.SCHEDULER_ROLE_ARN).toBeUndefined();
-            expect(result.environment.SCHEDULE_GROUP_NAME).toBeUndefined();
-        });
-
-        it('should not create scheduler resources when admin config is not provided', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.resources.AdminScriptSchedulerRole).toBeUndefined();
-            expect(result.resources.AdminScriptScheduleGroup).toBeUndefined();
-        });
-
-        it('should use skipEsbuild for all functions', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.skipEsbuild).toBe(true);
-            expect(result.functions.adminScriptRouter.skipEsbuild).toBe(true);
-        });
-
-        it('should not attach Prisma layer when usePrismaLambdaLayer=false', async () => {
-            const appDefinition = {
-                usePrismaLambdaLayer: false,
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            expect(result.functions.adminScriptExecutor.layers).toBeUndefined();
-            expect(result.functions.adminScriptRouter.layers).toBeUndefined();
-        });
-
-        it('should handle multiple admin scripts', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'oauth-refresh' } },
-                    { Definition: { name: 'health-check' } },
-                    { Definition: { name: 'attio-healing' } },
-                ],
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            // Should still only create one queue and two functions
-            expect(result.resources.AdminScriptQueue).toBeDefined();
-            expect(result.functions.adminScriptExecutor).toBeDefined();
-            expect(result.functions.adminScriptRouter).toBeDefined();
-
-            // Should not create separate resources per script
-            expect(Object.keys(result.resources)).toHaveLength(1); // Only AdminScriptQueue
-            expect(Object.keys(result.functions)).toHaveLength(2); // Only executor and router
-        });
-
-        it('should configure scheduler role with correct trust policy', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-                admin: {
-                    enableScheduling: true,
-                },
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            const trustPolicy = result.resources.AdminScriptSchedulerRole.Properties.AssumeRolePolicyDocument;
-
-            expect(trustPolicy.Statement[0]).toEqual({
-                Effect: 'Allow',
-                Principal: { Service: 'scheduler.amazonaws.com' },
-                Action: 'sts:AssumeRole',
-            });
-        });
-
-        it('should configure scheduler role with Lambda invoke permission', async () => {
-            const appDefinition = {
-                adminScripts: [
-                    { Definition: { name: 'test-script' } },
-                ],
-                admin: {
-                    enableScheduling: true,
-                },
-            };
-
-            const result = await adminScriptBuilder.build(appDefinition, {});
-
-            const policies = result.resources.AdminScriptSchedulerRole.Properties.Policies;
-
-            expect(policies[0].PolicyName).toBe('InvokeLambda');
-            expect(policies[0].PolicyDocument.Statement[0]).toEqual({
-                Effect: 'Allow',
-                Action: 'lambda:InvokeFunction',
-                Resource: { 'Fn::GetAtt': ['AdminScriptExecutorLambdaFunction', 'Arn'] },
-            });
-        });
-    });
-
-    describe('getName()', () => {
-        it('should return AdminScriptBuilder', () => {
-            expect(adminScriptBuilder.getName()).toBe('AdminScriptBuilder');
-        });
-    });
-});

package/infrastructure/domains/admin-scripts/index.js

@@ -1,5 +0,0 @@
-const { AdminScriptBuilder } = require('./admin-script-builder');
-
-module.exports = {
-    AdminScriptBuilder
-};