@friggframework/admin-scripts 2.0.0--canary.545.b4ca16d.0 → 2.0.0--canary.517.8eaf5df.0

package/src/application/script-runner.js

@@ -1,6 +1,8 @@
 const { getScriptFactory } = require('./script-factory');
 const { createAdminScriptContext } = require('./admin-frigg-commands');
-const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+const {
+    createAdminScriptCommands,
+} = require('@friggframework/core/application/commands/admin-script-commands');
 
 /**
  * Script Runner
@@ -31,10 +33,17 @@ class ScriptRunner {
      *   Pass this when resuming a queued execution to continue using the same execution record.
      */
     async execute(scriptName, params = {}, options = {}) {
-        const { trigger, audit = {}, executionId: existingExecutionId } = options;
+        const {
+            trigger,
+            audit = {},
+            executionId: existingExecutionId,
+            parentExecutionId,
+        } = options;
 
         if (!trigger) {
-            throw new Error('options.trigger is required (MANUAL | SCHEDULED | QUEUE)');
+            throw new Error(
+                'options.trigger is required (MANUAL | SCHEDULED | QUEUE)'
+            );
         }
 
         // Get script class
@@ -42,7 +51,10 @@ class ScriptRunner {
         const definition = scriptClass.Definition;
 
         // Validate integrationFactory requirement
-        if (definition.config?.requireIntegrationInstance && !this.integrationFactory) {
+        if (
+            definition.config?.requireIntegrationInstance &&
+            !this.integrationFactory
+        ) {
             throw new Error(
                 `Script "${scriptName}" requires integrationFactory but none was provided`
             );
@@ -59,21 +71,30 @@ class ScriptRunner {
                 mode: options.mode || 'async',
                 input: params,
                 audit,
+                parentExecutionId,
             });
+            // Commands return an error object (never throw) — fail loudly rather
+            // than tracking an `undefined` execution id.
+            if (execution.error) {
+                throw new Error(
+                    execution.reason || 'Failed to create admin process record'
+                );
+            }
             executionId = execution.id;
         }
 
         const startTime = new Date();
 
+        // Created up front so collected logs can be persisted on both paths.
+        const context = createAdminScriptContext({
+            executionId,
+            integrationFactory: this.integrationFactory,
+        });
+
+        let output;
         try {
             await this.commands.updateAdminProcessState(executionId, 'RUNNING');
 
-            // Create context for the script (facade over repositories, queue, logging)
-            const context = createAdminScriptContext({
-                executionId,
-                integrationFactory: this.integrationFactory,
-            });
-
             // Create script instance with context injected via constructor
             const script = this.scriptFactory.createInstance(scriptName, {
                 context,
@@ -82,46 +103,33 @@ class ScriptRunner {
             });
 
             // Execute the script
-            const output = await script.execute(params);
-
-            // Calculate metrics
-            const endTime = new Date();
-            const durationMs = endTime - startTime;
-
-            await this.commands.completeAdminProcess(executionId, {
-                state: 'COMPLETED',
-                output,
-                metrics: {
-                    startTime: startTime.toISOString(),
-                    endTime: endTime.toISOString(),
-                    durationMs,
-                },
-            });
-
-            return {
-                executionId,
-                status: 'COMPLETED',
-                scriptName,
-                output,
-                metrics: { durationMs },
-            };
+            output = await script.execute(params);
         } catch (error) {
-            const endTime = new Date();
-            const durationMs = endTime - startTime;
+            const durationMs = new Date() - startTime;
 
-            await this.commands.completeAdminProcess(executionId, {
-                state: 'FAILED',
-                error: {
-                    name: error.name,
-                    message: error.message,
-                    stack: error.stack,
-                },
-                metrics: {
-                    startTime: startTime.toISOString(),
-                    endTime: endTime.toISOString(),
-                    durationMs,
-                },
-            });
+            const completion = await this.commands.completeAdminProcess(
+                executionId,
+                {
+                    state: 'FAILED',
+                    error: {
+                        name: error.name,
+                        message: error.message,
+                        stack: error.stack,
+                    },
+                    metrics: {
+                        startTime: startTime.toISOString(),
+                        endTime: new Date().toISOString(),
+                        durationMs,
+                    },
+                    logs: context.getLogs(),
+                }
+            );
+            if (completion?.error) {
+                console.error(
+                    `Failed to persist FAILED state for execution ${executionId}:`,
+                    completion.reason
+                );
+            }
 
             return {
                 executionId,
@@ -134,6 +142,40 @@ class ScriptRunner {
                 metrics: { durationMs },
             };
         }
+
+        // Script succeeded. Persist completion OUTSIDE the try above so a
+        // persistence failure here is never misreported as a script failure.
+        const durationMs = new Date() - startTime;
+        const result = {
+            executionId,
+            status: 'COMPLETED',
+            scriptName,
+            output,
+            metrics: { durationMs },
+        };
+
+        const completion = await this.commands.completeAdminProcess(
+            executionId,
+            {
+                state: 'COMPLETED',
+                output,
+                metrics: {
+                    startTime: startTime.toISOString(),
+                    endTime: new Date().toISOString(),
+                    durationMs,
+                },
+                logs: context.getLogs(),
+            }
+        );
+        if (completion?.error) {
+            console.error(
+                `Script "${scriptName}" ran successfully but persisting COMPLETED state failed for execution ${executionId}:`,
+                completion.reason
+            );
+            result.stateUpdateFailed = true;
+        }
+
+        return result;
     }
 }
 

package/src/application/use-cases/__tests__/delete-schedule-use-case.test.js

@@ -31,7 +31,8 @@ describe('DeleteScheduleUseCase', () => {
         it('should delete schedule and cleanup external scheduler', async () => {
             const deletedSchedule = {
                 scriptName: 'test-script',
-                externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+                externalScheduleId:
+                    'arn:aws:scheduler:us-east-1:123:schedule/test',
             };
 
             mockScriptFactory.has.mockReturnValue(true);
@@ -47,7 +48,9 @@ describe('DeleteScheduleUseCase', () => {
             expect(result.success).toBe(true);
             expect(result.deletedCount).toBe(1);
             expect(result.message).toBe('Schedule override removed');
-            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith('test-script');
+            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith(
+                'test-script'
+            );
         });
 
         it('should not call scheduler when no external rule exists', async () => {
@@ -71,7 +74,8 @@ describe('DeleteScheduleUseCase', () => {
                 deletedCount: 1,
                 deleted: {
                     scriptName: 'test-script',
-                    externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+                    externalScheduleId:
+                        'arn:aws:scheduler:us-east-1:123:schedule/test',
                 },
             });
             mockSchedulerAdapter.deleteSchedule.mockRejectedValue(
@@ -105,13 +109,17 @@ describe('DeleteScheduleUseCase', () => {
             expect(result.effectiveSchedule.source).toBe('definition');
             expect(result.effectiveSchedule.enabled).toBe(true);
             expect(result.effectiveSchedule.cronExpression).toBe('0 6 * * *');
-            expect(result.effectiveSchedule.timezone).toBe('America/Los_Angeles');
+            expect(result.effectiveSchedule.timezone).toBe(
+                'America/Los_Angeles'
+            );
         });
 
         it('should default timezone to UTC when not in definition', async () => {
             mockScriptFactory.has.mockReturnValue(true);
             mockScriptFactory.get.mockReturnValue({
-                Definition: { schedule: { enabled: true, cronExpression: '0 6 * * *' } },
+                Definition: {
+                    schedule: { enabled: true, cronExpression: '0 6 * * *' },
+                },
             });
             mockCommands.deleteSchedule.mockResolvedValue({
                 deletedCount: 1,
@@ -155,8 +163,9 @@ describe('DeleteScheduleUseCase', () => {
         it('should throw SCRIPT_NOT_FOUND error when script does not exist', async () => {
             mockScriptFactory.has.mockReturnValue(false);
 
-            await expect(useCase.execute('non-existent'))
-                .rejects.toThrow('Script "non-existent" not found');
+            await expect(useCase.execute('non-existent')).rejects.toThrow(
+                'Script "non-existent" not found'
+            );
 
             try {
                 await useCase.execute('non-existent');

package/src/application/use-cases/__tests__/get-effective-schedule-use-case.test.js

@@ -1,4 +1,6 @@
-const { GetEffectiveScheduleUseCase } = require('../get-effective-schedule-use-case');
+const {
+    GetEffectiveScheduleUseCase,
+} = require('../get-effective-schedule-use-case');
 
 describe('GetEffectiveScheduleUseCase', () => {
     let useCase;
@@ -64,7 +66,9 @@ describe('GetEffectiveScheduleUseCase', () => {
         it('should default timezone to UTC when not specified in definition', async () => {
             mockScriptFactory.has.mockReturnValue(true);
             mockScriptFactory.get.mockReturnValue({
-                Definition: { schedule: { enabled: true, cronExpression: '0 12 * * *' } },
+                Definition: {
+                    schedule: { enabled: true, cronExpression: '0 12 * * *' },
+                },
             });
             mockCommands.getScheduleByScriptName.mockResolvedValue(null);
 
@@ -101,8 +105,9 @@ describe('GetEffectiveScheduleUseCase', () => {
         it('should throw SCRIPT_NOT_FOUND error when script does not exist', async () => {
             mockScriptFactory.has.mockReturnValue(false);
 
-            await expect(useCase.execute('non-existent'))
-                .rejects.toThrow('Script "non-existent" not found');
+            await expect(useCase.execute('non-existent')).rejects.toThrow(
+                'Script "non-existent" not found'
+            );
 
             try {
                 await useCase.execute('non-existent');

package/src/application/use-cases/__tests__/upsert-schedule-use-case.test.js

@@ -46,7 +46,8 @@ describe('UpsertScheduleUseCase', () => {
             });
             mockCommands.updateScheduleExternalInfo.mockResolvedValue({
                 ...savedSchedule,
-                externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+                externalScheduleId:
+                    'arn:aws:scheduler:us-east-1:123:schedule/test',
             });
 
             const result = await useCase.execute('test-script', {
@@ -96,7 +97,8 @@ describe('UpsertScheduleUseCase', () => {
                 enabled: false,
                 cronExpression: null,
                 timezone: 'UTC',
-                externalScheduleId: 'arn:aws:scheduler:us-east-1:123:schedule/test',
+                externalScheduleId:
+                    'arn:aws:scheduler:us-east-1:123:schedule/test',
             };
 
             mockScriptFactory.has.mockReturnValue(true);
@@ -112,7 +114,9 @@ describe('UpsertScheduleUseCase', () => {
             });
 
             expect(result.success).toBe(true);
-            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith('test-script');
+            expect(mockSchedulerAdapter.deleteSchedule).toHaveBeenCalledWith(
+                'test-script'
+            );
         });
 
         it('should handle scheduler errors gracefully with warning', async () => {
@@ -142,8 +146,9 @@ describe('UpsertScheduleUseCase', () => {
         it('should throw SCRIPT_NOT_FOUND error when script does not exist', async () => {
             mockScriptFactory.has.mockReturnValue(false);
 
-            await expect(useCase.execute('non-existent', { enabled: true }))
-                .rejects.toThrow('Script "non-existent" not found');
+            await expect(
+                useCase.execute('non-existent', { enabled: true })
+            ).rejects.toThrow('Script "non-existent" not found');
 
             try {
                 await useCase.execute('non-existent', { enabled: true });
@@ -155,8 +160,9 @@ describe('UpsertScheduleUseCase', () => {
         it('should throw INVALID_INPUT error when enabled is not a boolean', async () => {
             mockScriptFactory.has.mockReturnValue(true);
 
-            await expect(useCase.execute('test-script', { enabled: 'yes' }))
-                .rejects.toThrow('enabled must be a boolean');
+            await expect(
+                useCase.execute('test-script', { enabled: 'yes' })
+            ).rejects.toThrow('enabled must be a boolean');
 
             try {
                 await useCase.execute('test-script', { enabled: 'yes' });
@@ -168,8 +174,11 @@ describe('UpsertScheduleUseCase', () => {
         it('should throw INVALID_INPUT error when enabled without cronExpression', async () => {
             mockScriptFactory.has.mockReturnValue(true);
 
-            await expect(useCase.execute('test-script', { enabled: true }))
-                .rejects.toThrow('cronExpression is required when enabled is true');
+            await expect(
+                useCase.execute('test-script', { enabled: true })
+            ).rejects.toThrow(
+                'cronExpression is required when enabled is true'
+            );
 
             try {
                 await useCase.execute('test-script', { enabled: true });
@@ -187,7 +196,9 @@ describe('UpsertScheduleUseCase', () => {
                 timezone: 'UTC',
             });
 
-            const result = await useCase.execute('test-script', { enabled: false });
+            const result = await useCase.execute('test-script', {
+                enabled: false,
+            });
 
             expect(result.success).toBe(true);
             expect(mockCommands.upsertSchedule).toHaveBeenCalledWith({

package/src/application/use-cases/delete-schedule-use-case.js

@@ -31,14 +31,16 @@ class DeleteScheduleUseCase {
         );
 
         // Determine effective schedule after deletion
-        const effectiveSchedule = this._getEffectiveScheduleAfterDeletion(scriptName);
+        const effectiveSchedule =
+            this._getEffectiveScheduleAfterDeletion(scriptName);
 
         return {
             success: true,
             deletedCount: deleteResult.deletedCount,
-            message: deleteResult.deletedCount > 0
-                ? 'Schedule override removed'
-                : 'No schedule override found',
+            message:
+                deleteResult.deletedCount > 0
+                    ? 'Schedule override removed'
+                    : 'No schedule override found',
             effectiveSchedule,
             ...(schedulerWarning && { schedulerWarning }),
         };

package/src/application/use-cases/get-effective-schedule-use-case.js

@@ -23,7 +23,9 @@ class GetEffectiveScheduleUseCase {
         this._validateScriptExists(scriptName);
 
         // Priority 1: Database override
-        const dbSchedule = await this.commands.getScheduleByScriptName(scriptName);
+        const dbSchedule = await this.commands.getScheduleByScriptName(
+            scriptName
+        );
         if (dbSchedule) {
             return {
                 source: 'database',

package/src/application/use-cases/index.js

@@ -7,7 +7,9 @@
  * - DeleteScheduleUseCase: Delete schedule with scheduler cleanup
  */
 
-const { GetEffectiveScheduleUseCase } = require('./get-effective-schedule-use-case');
+const {
+    GetEffectiveScheduleUseCase,
+} = require('./get-effective-schedule-use-case');
 const { UpsertScheduleUseCase } = require('./upsert-schedule-use-case');
 const { DeleteScheduleUseCase } = require('./delete-schedule-use-case');
 

package/src/application/use-cases/upsert-schedule-use-case.js

@@ -47,10 +47,16 @@ class UpsertScheduleUseCase {
             success: true,
             schedule: {
                 ...schedule,
-                externalScheduleId: schedulerResult.externalScheduleId || schedule.externalScheduleId,
-                externalScheduleName: schedulerResult.externalScheduleName || schedule.externalScheduleName,
+                externalScheduleId:
+                    schedulerResult.externalScheduleId ||
+                    schedule.externalScheduleId,
+                externalScheduleName:
+                    schedulerResult.externalScheduleName ||
+                    schedule.externalScheduleName,
             },
-            ...(schedulerResult.warning && { schedulerWarning: schedulerResult.warning }),
+            ...(schedulerResult.warning && {
+                schedulerWarning: schedulerResult.warning,
+            }),
         };
     }
 
@@ -76,7 +82,9 @@ class UpsertScheduleUseCase {
         }
 
         if (enabled && !cronExpression) {
-            const error = new Error('cronExpression is required when enabled is true');
+            const error = new Error(
+                'cronExpression is required when enabled is true'
+            );
             error.code = 'INVALID_INPUT';
             throw error;
         }
@@ -87,17 +95,28 @@ class UpsertScheduleUseCase {
      * Abstracts AWS EventBridge or other scheduler providers
      * @private
      */
-    async _syncExternalScheduler(scriptName, enabled, cronExpression, timezone, existingId) {
-        const result = { externalScheduleId: null, externalScheduleName: null, warning: null };
+    async _syncExternalScheduler(
+        scriptName,
+        enabled,
+        cronExpression,
+        timezone,
+        existingId
+    ) {
+        const result = {
+            externalScheduleId: null,
+            externalScheduleName: null,
+            warning: null,
+        };
 
         try {
             if (enabled && cronExpression) {
                 // Create/update external schedule
-                const schedulerInfo = await this.schedulerAdapter.createSchedule({
-                    scriptName,
-                    cronExpression,
-                    timezone: timezone || 'UTC',
-                });
+                const schedulerInfo =
+                    await this.schedulerAdapter.createSchedule({
+                        scriptName,
+                        cronExpression,
+                        timezone: timezone || 'UTC',
+                    });
 
                 if (schedulerInfo?.scheduleArn) {
                     await this.commands.updateScheduleExternalInfo(scriptName, {

package/src/application/validate-script-input.js

@@ -27,7 +27,8 @@ function validateScriptInput(scriptFactory, scriptName, params = {}) {
                 name: definition.name,
                 version: definition.version,
                 description: definition.description,
-                requireIntegrationInstance: definition.config?.requireIntegrationInstance || false,
+                requireIntegrationInstance:
+                    definition.config?.requireIntegrationInstance || false,
             },
             input: params,
             inputSchema: definition.inputSchema || null,
@@ -91,7 +92,10 @@ function validateType(key, value, schema) {
     const expectedType = schema.type;
     if (!expectedType) return null;
 
-    if (expectedType === 'integer' && (typeof value !== 'number' || !Number.isInteger(value))) {
+    if (
+        expectedType === 'integer' &&
+        (typeof value !== 'number' || !Number.isInteger(value))
+    ) {
         return `Parameter "${key}" must be an integer`;
     }
     if (expectedType === 'number' && typeof value !== 'number') {
@@ -106,7 +110,10 @@ function validateType(key, value, schema) {
     if (expectedType === 'array' && !Array.isArray(value)) {
         return `Parameter "${key}" must be an array`;
     }
-    if (expectedType === 'object' && (typeof value !== 'object' || Array.isArray(value))) {
+    if (
+        expectedType === 'object' &&
+        (typeof value !== 'object' || Array.isArray(value))
+    ) {
         return `Parameter "${key}" must be an object`;
     }