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

package/src/application/__tests__/script-factory.test.js

@@ -162,11 +162,19 @@ describe('ScriptFactory', () => {
     describe('getNames()', () => {
         it('should return array of all registered script names', () => {
             class Script1 extends AdminScriptBase {
-                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+                static Definition = {
+                    name: 'script-1',
+                    version: '1.0.0',
+                    description: 'One',
+                };
             }
 
             class Script2 extends AdminScriptBase {
-                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+                static Definition = {
+                    name: 'script-2',
+                    version: '1.0.0',
+                    description: 'Two',
+                };
             }
 
             factory.registerAll([Script1, Script2]);
@@ -272,11 +280,19 @@ describe('ScriptFactory', () => {
     describe('clear()', () => {
         it('should remove all registered scripts', () => {
             class Script1 extends AdminScriptBase {
-                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+                static Definition = {
+                    name: 'script-1',
+                    version: '1.0.0',
+                    description: 'One',
+                };
             }
 
             class Script2 extends AdminScriptBase {
-                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+                static Definition = {
+                    name: 'script-2',
+                    version: '1.0.0',
+                    description: 'Two',
+                };
             }
 
             factory.registerAll([Script1, Script2]);
@@ -295,14 +311,22 @@ describe('ScriptFactory', () => {
             expect(factory.size).toBe(0);
 
             class Script1 extends AdminScriptBase {
-                static Definition = { name: 'script-1', version: '1.0.0', description: 'One' };
+                static Definition = {
+                    name: 'script-1',
+                    version: '1.0.0',
+                    description: 'One',
+                };
             }
 
             factory.register(Script1);
             expect(factory.size).toBe(1);
 
             class Script2 extends AdminScriptBase {
-                static Definition = { name: 'script-2', version: '1.0.0', description: 'Two' };
+                static Definition = {
+                    name: 'script-2',
+                    version: '1.0.0',
+                    description: 'Two',
+                };
             }
 
             factory.register(Script2);

package/src/application/__tests__/script-runner.test.js

@@ -6,13 +6,15 @@ const { AdminScriptBase } = require('../admin-script-base');
 jest.mock('../admin-frigg-commands');
 jest.mock('@friggframework/core/application/commands/admin-script-commands');
 
-const { createAdminFriggCommands } = require('../admin-frigg-commands');
-const { createAdminScriptCommands } = require('@friggframework/core/application/commands/admin-script-commands');
+const { createAdminScriptContext } = require('../admin-frigg-commands');
+const {
+    createAdminScriptCommands,
+} = require('@friggframework/core/application/commands/admin-script-commands');
 
 describe('ScriptRunner', () => {
     let scriptFactory;
     let mockCommands;
-    let mockFrigg;
+    let mockContext;
     let testScript;
 
     class TestScript extends AdminScriptBase {
@@ -41,13 +43,14 @@ describe('ScriptRunner', () => {
             completeAdminProcess: jest.fn(),
         };
 
-        mockFrigg = {
+        mockContext = {
             log: jest.fn(),
             getExecutionId: jest.fn(),
+            getLogs: jest.fn(() => []),
         };
 
         createAdminScriptCommands.mockReturnValue(mockCommands);
-        createAdminFriggCommands.mockReturnValue(mockFrigg);
+        createAdminScriptContext.mockReturnValue(mockContext);
 
         mockCommands.createAdminProcess.mockResolvedValue({
             id: 'exec-123',
@@ -62,17 +65,27 @@ describe('ScriptRunner', () => {
 
     describe('execute()', () => {
         it('should execute script successfully', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('test-script', { foo: 'bar' }, {
-                trigger: 'MANUAL',
-                mode: 'async',
-                audit: { apiKeyName: 'test-key' },
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
             });
 
+            const result = await runner.execute(
+                'test-script',
+                { foo: 'bar' },
+                {
+                    trigger: 'MANUAL',
+                    mode: 'async',
+                    audit: { apiKeyName: 'test-key' },
+                }
+            );
+
             expect(result.status).toBe('COMPLETED');
             expect(result.scriptName).toBe('test-script');
-            expect(result.output).toEqual({ success: true, params: { foo: 'bar' } });
+            expect(result.output).toEqual({
+                success: true,
+                params: { foo: 'bar' },
+            });
             expect(result.executionId).toBe('exec-123');
             expect(result.metrics.durationMs).toBeGreaterThanOrEqual(0);
 
@@ -103,7 +116,10 @@ describe('ScriptRunner', () => {
         });
 
         it('should throw error if trigger is not provided', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+            });
 
             await expect(
                 runner.execute('test-script', { foo: 'bar' }, {})
@@ -111,7 +127,10 @@ describe('ScriptRunner', () => {
         });
 
         it('should throw error if options are omitted entirely', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+            });
 
             await expect(
                 runner.execute('test-script', { foo: 'bar' })
@@ -133,13 +152,20 @@ describe('ScriptRunner', () => {
             }
 
             scriptFactory.register(FailingScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('failing-script', {}, {
-                trigger: 'MANUAL',
-                mode: 'sync',
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
             });
 
+            const result = await runner.execute(
+                'failing-script',
+                {},
+                {
+                    trigger: 'MANUAL',
+                    mode: 'sync',
+                }
+            );
+
             expect(result.status).toBe('FAILED');
             expect(result.scriptName).toBe('failing-script');
             expect(result.error.message).toBe('Script failed');
@@ -186,13 +212,20 @@ describe('ScriptRunner', () => {
         });
 
         it('should reuse existing execution ID when provided', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('test-script', { foo: 'bar' }, {
-                trigger: 'QUEUE',
-                executionId: 'existing-exec-456',
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
             });
 
+            const result = await runner.execute(
+                'test-script',
+                { foo: 'bar' },
+                {
+                    trigger: 'QUEUE',
+                    executionId: 'existing-exec-456',
+                }
+            );
+
             expect(result.executionId).toBe('existing-exec-456');
             expect(mockCommands.createAdminProcess).not.toHaveBeenCalled();
             expect(mockCommands.updateAdminProcessState).toHaveBeenCalledWith(
@@ -200,6 +233,62 @@ describe('ScriptRunner', () => {
                 'RUNNING'
             );
         });
+
+        it('reports COMPLETED even when persisting completion fails', async () => {
+            // Commands return an error object (never throw). A successful script
+            // must not be misreported as FAILED if the completion write fails.
+            mockCommands.completeAdminProcess.mockResolvedValue({
+                error: 500,
+                reason: 'DB write failed',
+            });
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+            });
+
+            const result = await runner.execute(
+                'test-script',
+                {},
+                { trigger: 'MANUAL' }
+            );
+
+            expect(result.status).toBe('COMPLETED');
+            expect(result.stateUpdateFailed).toBe(true);
+        });
+
+        it('throws when the execution record cannot be created', async () => {
+            mockCommands.createAdminProcess.mockResolvedValue({
+                error: 500,
+                reason: 'DB down',
+            });
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+            });
+
+            await expect(
+                runner.execute('test-script', {}, { trigger: 'MANUAL' })
+            ).rejects.toThrow('DB down');
+        });
+
+        it('persists collected logs on completion', async () => {
+            mockContext.getLogs.mockReturnValue([
+                { level: 'info', message: 'hi' },
+            ]);
+            const runner = new ScriptRunner({
+                scriptFactory,
+                commands: mockCommands,
+            });
+
+            await runner.execute('test-script', {}, { trigger: 'MANUAL' });
+
+            expect(mockCommands.completeAdminProcess).toHaveBeenCalledWith(
+                'exec-123',
+                expect.objectContaining({
+                    logs: [{ level: 'info', message: 'hi' }],
+                })
+            );
+        });
     });
 
     describe('createScriptRunner()', () => {

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

@@ -1,4 +1,8 @@
-const { validateScriptInput, validateParams, validateType } = require('../validate-script-input');
+const {
+    validateScriptInput,
+    validateParams,
+    validateType,
+} = require('../validate-script-input');
 const { ScriptFactory } = require('../script-factory');
 const { AdminScriptBase } = require('../admin-script-base');
 
@@ -61,12 +65,18 @@ describe('validateScriptInput', () => {
     }
 
     beforeEach(() => {
-        scriptFactory = new ScriptFactory([TestScript, SchemaScript, TypedScript]);
+        scriptFactory = new ScriptFactory([
+            TestScript,
+            SchemaScript,
+            TypedScript,
+        ]);
     });
 
     describe('validateScriptInput()', () => {
         it('should return VALID for script without schema', () => {
-            const result = validateScriptInput(scriptFactory, 'test-script', { foo: 'bar' });
+            const result = validateScriptInput(scriptFactory, 'test-script', {
+                foo: 'bar',
+            });
 
             expect(result.status).toBe('VALID');
             expect(result.scriptName).toBe('test-script');
@@ -77,11 +87,17 @@ describe('validateScriptInput', () => {
         });
 
         it('should return INVALID when required parameters are missing', () => {
-            const result = validateScriptInput(scriptFactory, 'schema-script', {});
+            const result = validateScriptInput(
+                scriptFactory,
+                'schema-script',
+                {}
+            );
 
             expect(result.status).toBe('INVALID');
             expect(result.preview.validation.valid).toBe(false);
-            expect(result.preview.validation.errors).toContain('Missing required parameter: requiredParam');
+            expect(result.preview.validation.errors).toContain(
+                'Missing required parameter: requiredParam'
+            );
         });
 
         it('should return INVALID for wrong parameter types', () => {
@@ -122,7 +138,11 @@ describe('validateScriptInput', () => {
         });
 
         it('should return null inputSchema when script has no schema', () => {
-            const result = validateScriptInput(scriptFactory, 'test-script', {});
+            const result = validateScriptInput(
+                scriptFactory,
+                'test-script',
+                {}
+            );
 
             expect(result.preview.inputSchema).toBeNull();
         });
@@ -130,7 +150,10 @@ describe('validateScriptInput', () => {
 
     describe('validateParams()', () => {
         it('should return valid when no schema defined', () => {
-            const result = validateParams({ name: 'test' }, { anything: 'goes' });
+            const result = validateParams(
+                { name: 'test' },
+                { anything: 'goes' }
+            );
 
             expect(result.valid).toBe(true);
             expect(result.errors).toHaveLength(0);
@@ -158,35 +181,51 @@ describe('validateScriptInput', () => {
     describe('validateType()', () => {
         it('should validate integer type', () => {
             expect(validateType('x', 42, { type: 'integer' })).toBeNull();
-            expect(validateType('x', 3.14, { type: 'integer' })).toContain('must be an integer');
-            expect(validateType('x', 'foo', { type: 'integer' })).toContain('must be an integer');
+            expect(validateType('x', 3.14, { type: 'integer' })).toContain(
+                'must be an integer'
+            );
+            expect(validateType('x', 'foo', { type: 'integer' })).toContain(
+                'must be an integer'
+            );
         });
 
         it('should validate number type', () => {
             expect(validateType('x', 3.14, { type: 'number' })).toBeNull();
             expect(validateType('x', 42, { type: 'number' })).toBeNull();
-            expect(validateType('x', 'foo', { type: 'number' })).toContain('must be a number');
+            expect(validateType('x', 'foo', { type: 'number' })).toContain(
+                'must be a number'
+            );
         });
 
         it('should validate string type', () => {
             expect(validateType('x', 'hello', { type: 'string' })).toBeNull();
-            expect(validateType('x', 123, { type: 'string' })).toContain('must be a string');
+            expect(validateType('x', 123, { type: 'string' })).toContain(
+                'must be a string'
+            );
         });
 
         it('should validate boolean type', () => {
             expect(validateType('x', true, { type: 'boolean' })).toBeNull();
-            expect(validateType('x', 'true', { type: 'boolean' })).toContain('must be a boolean');
+            expect(validateType('x', 'true', { type: 'boolean' })).toContain(
+                'must be a boolean'
+            );
         });
 
         it('should validate array type', () => {
             expect(validateType('x', [1, 2], { type: 'array' })).toBeNull();
-            expect(validateType('x', 'not-array', { type: 'array' })).toContain('must be an array');
+            expect(validateType('x', 'not-array', { type: 'array' })).toContain(
+                'must be an array'
+            );
         });
 
         it('should validate object type', () => {
             expect(validateType('x', { a: 1 }, { type: 'object' })).toBeNull();
-            expect(validateType('x', [1, 2], { type: 'object' })).toContain('must be an object');
-            expect(validateType('x', 'string', { type: 'object' })).toContain('must be an object');
+            expect(validateType('x', [1, 2], { type: 'object' })).toContain(
+                'must be an object'
+            );
+            expect(validateType('x', 'string', { type: 'object' })).toContain(
+                'must be an object'
+            );
         });
 
         it('should return null when no type specified', () => {

package/src/application/admin-frigg-commands.js

@@ -34,7 +34,9 @@ class AdminScriptContext {
 
     get integrationRepository() {
         if (!this._integrationRepository) {
-            const { createIntegrationRepository } = require('@friggframework/core/integrations/repositories/integration-repository-factory');
+            const {
+                createIntegrationRepository,
+            } = require('@friggframework/core/integrations/repositories/integration-repository-factory');
             this._integrationRepository = createIntegrationRepository();
         }
         return this._integrationRepository;
@@ -42,7 +44,9 @@ class AdminScriptContext {
 
     get userRepository() {
         if (!this._userRepository) {
-            const { createUserRepository } = require('@friggframework/core/user/repositories/user-repository-factory');
+            const {
+                createUserRepository,
+            } = require('@friggframework/core/user/repositories/user-repository-factory');
             this._userRepository = createUserRepository();
         }
         return this._userRepository;
@@ -50,7 +54,9 @@ class AdminScriptContext {
 
     get moduleRepository() {
         if (!this._moduleRepository) {
-            const { createModuleRepository } = require('@friggframework/core/modules/repositories/module-repository-factory');
+            const {
+                createModuleRepository,
+            } = require('@friggframework/core/modules/repositories/module-repository-factory');
             this._moduleRepository = createModuleRepository();
         }
         return this._moduleRepository;
@@ -58,7 +64,9 @@ class AdminScriptContext {
 
     get credentialRepository() {
         if (!this._credentialRepository) {
-            const { createCredentialRepository } = require('@friggframework/core/credential/repositories/credential-repository-factory');
+            const {
+                createCredentialRepository,
+            } = require('@friggframework/core/credential/repositories/credential-repository-factory');
             this._credentialRepository = createCredentialRepository();
         }
         return this._credentialRepository;
@@ -74,12 +82,12 @@ class AdminScriptContext {
         if (!this.integrationFactory) {
             throw new Error(
                 'instantiate() requires integrationFactory. ' +
-                'Set Definition.config.requireIntegrationInstance = true'
+                    'Set Definition.config.requireIntegrationInstance = true'
             );
         }
         return this.integrationFactory.getInstanceFromIntegrationId({
             integrationId,
-            _isAdminContext: true,  // Bypass user ownership check
+            _isAdminContext: true, // Bypass user ownership check
         });
     }
 
@@ -88,7 +96,9 @@ class AdminScriptContext {
     async queueScript(scriptName, params = {}) {
         const queueUrl = process.env.ADMIN_SCRIPT_QUEUE_URL;
         if (!queueUrl) {
-            throw new Error('ADMIN_SCRIPT_QUEUE_URL environment variable not set');
+            throw new Error(
+                'ADMIN_SCRIPT_QUEUE_URL environment variable not set'
+            );
         }
 
         await QueuerUtil.send(
@@ -107,10 +117,12 @@ class AdminScriptContext {
     async queueScriptBatch(entries) {
         const queueUrl = process.env.ADMIN_SCRIPT_QUEUE_URL;
         if (!queueUrl) {
-            throw new Error('ADMIN_SCRIPT_QUEUE_URL environment variable not set');
+            throw new Error(
+                'ADMIN_SCRIPT_QUEUE_URL environment variable not set'
+            );
         }
 
-        const messages = entries.map(entry => ({
+        const messages = entries.map((entry) => ({
             scriptName: entry.scriptName,
             trigger: 'QUEUE',
             params: entry.params || {},

package/src/application/admin-script-base.js

@@ -15,7 +15,6 @@ class AdminScriptBase {
 
         config: {
             timeout: 300000,
-            maxRetries: 0,
             requireIntegrationInstance: false,
         },
 
@@ -32,7 +31,9 @@ class AdminScriptBase {
     }
 
     async execute(params) {
-        throw new Error('AdminScriptBase.execute() must be implemented by subclass');
+        throw new Error(
+            'AdminScriptBase.execute() must be implemented by subclass'
+        );
     }
 }
 

package/src/application/script-factory.js

@@ -26,7 +26,9 @@ class ScriptFactory {
      */
     register(ScriptClass) {
         if (!ScriptClass || !ScriptClass.Definition) {
-            throw new Error('Script class must have a static Definition property');
+            throw new Error(
+                'Script class must have a static Definition property'
+            );
         }
 
         const definition = ScriptClass.Definition;