@friggframework/admin-scripts 2.0.0--canary.517.7e78259.0 → 2.0.0--canary.517.2239974.0

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

@@ -46,104 +46,13 @@ describe('AdminScriptBase', () => {
         });
 
         it('should have clean display object without redundant fields', () => {
-            // Default display should only have UI-specific fields
             expect(AdminScriptBase.Definition.display).toBeDefined();
             expect(AdminScriptBase.Definition.display.category).toBe('maintenance');
-            // Should NOT have redundant label/description
             expect(AdminScriptBase.Definition.display.label).toBeUndefined();
             expect(AdminScriptBase.Definition.display.description).toBeUndefined();
         });
     });
 
-    describe('Static methods', () => {
-        it('getName() should return the script name', () => {
-            class TestScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'my-script',
-                    version: '1.0.0',
-                    description: 'test',
-                };
-            }
-
-            expect(TestScript.getName()).toBe('my-script');
-        });
-
-        it('getCurrentVersion() should return the version', () => {
-            class TestScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'my-script',
-                    version: '2.3.1',
-                    description: 'test',
-                };
-            }
-
-            expect(TestScript.getCurrentVersion()).toBe('2.3.1');
-        });
-
-        it('getDefinition() should return the full Definition', () => {
-            class TestScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'my-script',
-                    version: '1.0.0',
-                    description: 'test',
-                    source: 'USER_DEFINED',
-                };
-            }
-
-            const definition = TestScript.getDefinition();
-            expect(definition).toEqual({
-                name: 'my-script',
-                version: '1.0.0',
-                description: 'test',
-                source: 'USER_DEFINED',
-            });
-        });
-
-        it('getDisplayLabel() should return display.label or fall back to name', () => {
-            class ScriptWithLabel extends AdminScriptBase {
-                static Definition = {
-                    name: 'my-script',
-                    version: '1.0.0',
-                    description: 'test',
-                    display: { label: 'My Custom Label' },
-                };
-            }
-
-            class ScriptWithoutLabel extends AdminScriptBase {
-                static Definition = {
-                    name: 'another-script',
-                    version: '1.0.0',
-                    description: 'test',
-                };
-            }
-
-            expect(ScriptWithLabel.getDisplayLabel()).toBe('My Custom Label');
-            expect(ScriptWithoutLabel.getDisplayLabel()).toBe('another-script');
-        });
-
-        it('getDisplayDescription() should return display.description or fall back to description', () => {
-            class ScriptWithDisplayDesc extends AdminScriptBase {
-                static Definition = {
-                    name: 'my-script',
-                    version: '1.0.0',
-                    description: 'Technical description',
-                    display: { description: 'User-friendly description' },
-                };
-            }
-
-            class ScriptWithoutDisplayDesc extends AdminScriptBase {
-                static Definition = {
-                    name: 'another-script',
-                    version: '1.0.0',
-                    description: 'Technical description',
-                };
-            }
-
-            expect(ScriptWithDisplayDesc.getDisplayDescription()).toBe('User-friendly description');
-            expect(ScriptWithoutDisplayDesc.getDisplayDescription()).toBe('Technical description');
-        });
-    });
-
     describe('Constructor', () => {
         it('should initialize with default values', () => {
             const script = new AdminScriptBase();

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

@@ -202,139 +202,6 @@ describe('ScriptRunner', () => {
         });
     });
 
-    describe('dry-run mode', () => {
-        it('should return preview without executing script', async () => {
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('test-script', { foo: 'bar' }, {
-                trigger: 'MANUAL',
-                dryRun: true,
-            });
-
-            expect(result.dryRun).toBe(true);
-            expect(result.status).toBe('DRY_RUN_VALID');
-            expect(result.scriptName).toBe('test-script');
-            expect(result.preview.script.name).toBe('test-script');
-            expect(result.preview.script.version).toBe('1.0.0');
-            expect(result.preview.input).toEqual({ foo: 'bar' });
-            expect(result.message).toContain('validation passed');
-
-            // Should NOT create execution record or call commands
-            expect(mockCommands.createAdminProcess).not.toHaveBeenCalled();
-            expect(mockCommands.updateAdminProcessState).not.toHaveBeenCalled();
-            expect(mockCommands.completeAdminProcess).not.toHaveBeenCalled();
-        });
-
-        it('should validate required parameters in dry-run', async () => {
-            class SchemaScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'schema-script',
-                    version: '1.0.0',
-                    description: 'Script with schema',
-                    inputSchema: {
-                        type: 'object',
-                        required: ['requiredParam'],
-                        properties: {
-                            requiredParam: { type: 'string' },
-                            optionalParam: { type: 'number' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(SchemaScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            // Missing required parameter
-            const result = await runner.execute('schema-script', {}, {
-                trigger: 'MANUAL',
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_INVALID');
-            expect(result.preview.validation.valid).toBe(false);
-            expect(result.preview.validation.errors).toContain('Missing required parameter: requiredParam');
-        });
-
-        it('should validate parameter types in dry-run', async () => {
-            class TypedScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'typed-script',
-                    version: '1.0.0',
-                    description: 'Script with typed params',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            count: { type: 'integer' },
-                            name: { type: 'string' },
-                            enabled: { type: 'boolean' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(TypedScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('typed-script', {
-                count: 'not-a-number',
-                name: 123,
-                enabled: 'true',
-            }, {
-                trigger: 'MANUAL',
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_INVALID');
-            expect(result.preview.validation.errors).toHaveLength(3);
-        });
-
-        it('should pass validation with correct parameters', async () => {
-            class ValidScript extends AdminScriptBase {
-                static Definition = {
-                    name: 'valid-script',
-                    version: '1.0.0',
-                    description: 'Script for validation',
-                    inputSchema: {
-                        type: 'object',
-                        required: ['name'],
-                        properties: {
-                            name: { type: 'string' },
-                            count: { type: 'integer' },
-                        },
-                    },
-                };
-
-                async execute() {
-                    return {};
-                }
-            }
-
-            scriptFactory.register(ValidScript);
-            const runner = new ScriptRunner({ scriptFactory, commands: mockCommands });
-
-            const result = await runner.execute('valid-script', {
-                name: 'test',
-                count: 42,
-            }, {
-                trigger: 'MANUAL',
-                dryRun: true,
-            });
-
-            expect(result.status).toBe('DRY_RUN_VALID');
-            expect(result.preview.validation.valid).toBe(true);
-            expect(result.preview.validation.errors).toHaveLength(0);
-        });
-    });
-
     describe('createScriptRunner()', () => {
         it('should create runner with default factory', () => {
             const runner = createScriptRunner();

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

@@ -0,0 +1,196 @@
+const { validateScriptInput, validateParams, validateType } = require('../validate-script-input');
+const { ScriptFactory } = require('../script-factory');
+const { AdminScriptBase } = require('../admin-script-base');
+
+describe('validateScriptInput', () => {
+    let scriptFactory;
+
+    class TestScript extends AdminScriptBase {
+        static Definition = {
+            name: 'test-script',
+            version: '1.0.0',
+            description: 'Test script',
+            config: {
+                requireIntegrationInstance: false,
+            },
+        };
+
+        async execute(params) {
+            return { success: true, params };
+        }
+    }
+
+    class SchemaScript extends AdminScriptBase {
+        static Definition = {
+            name: 'schema-script',
+            version: '1.0.0',
+            description: 'Script with schema',
+            inputSchema: {
+                type: 'object',
+                required: ['requiredParam'],
+                properties: {
+                    requiredParam: { type: 'string' },
+                    optionalParam: { type: 'number' },
+                },
+            },
+        };
+
+        async execute() {
+            return {};
+        }
+    }
+
+    class TypedScript extends AdminScriptBase {
+        static Definition = {
+            name: 'typed-script',
+            version: '1.0.0',
+            description: 'Script with typed params',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    count: { type: 'integer' },
+                    name: { type: 'string' },
+                    enabled: { type: 'boolean' },
+                },
+            },
+        };
+
+        async execute() {
+            return {};
+        }
+    }
+
+    beforeEach(() => {
+        scriptFactory = new ScriptFactory([TestScript, SchemaScript, TypedScript]);
+    });
+
+    describe('validateScriptInput()', () => {
+        it('should return VALID for script without schema', () => {
+            const result = validateScriptInput(scriptFactory, 'test-script', { foo: 'bar' });
+
+            expect(result.status).toBe('VALID');
+            expect(result.scriptName).toBe('test-script');
+            expect(result.preview.script.name).toBe('test-script');
+            expect(result.preview.script.version).toBe('1.0.0');
+            expect(result.preview.input).toEqual({ foo: 'bar' });
+            expect(result.message).toContain('Validation passed');
+        });
+
+        it('should return INVALID when required parameters are missing', () => {
+            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');
+        });
+
+        it('should return INVALID for wrong parameter types', () => {
+            const result = validateScriptInput(scriptFactory, 'typed-script', {
+                count: 'not-a-number',
+                name: 123,
+                enabled: 'true',
+            });
+
+            expect(result.status).toBe('INVALID');
+            expect(result.preview.validation.errors).toHaveLength(3);
+        });
+
+        it('should return VALID with correct parameters', () => {
+            const result = validateScriptInput(scriptFactory, 'schema-script', {
+                requiredParam: 'hello',
+                optionalParam: 42,
+            });
+
+            expect(result.status).toBe('VALID');
+            expect(result.preview.validation.valid).toBe(true);
+            expect(result.preview.validation.errors).toHaveLength(0);
+        });
+
+        it('should include inputSchema in preview', () => {
+            const result = validateScriptInput(scriptFactory, 'schema-script', {
+                requiredParam: 'test',
+            });
+
+            expect(result.preview.inputSchema).toEqual({
+                type: 'object',
+                required: ['requiredParam'],
+                properties: {
+                    requiredParam: { type: 'string' },
+                    optionalParam: { type: 'number' },
+                },
+            });
+        });
+
+        it('should return null inputSchema when script has no schema', () => {
+            const result = validateScriptInput(scriptFactory, 'test-script', {});
+
+            expect(result.preview.inputSchema).toBeNull();
+        });
+    });
+
+    describe('validateParams()', () => {
+        it('should return valid when no schema defined', () => {
+            const result = validateParams({ name: 'test' }, { anything: 'goes' });
+
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+
+        it('should check required fields', () => {
+            const definition = {
+                inputSchema: {
+                    type: 'object',
+                    required: ['a', 'b'],
+                    properties: {
+                        a: { type: 'string' },
+                        b: { type: 'string' },
+                    },
+                },
+            };
+
+            const result = validateParams(definition, { a: 'yes' });
+
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('Missing required parameter: b');
+        });
+    });
+
+    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');
+        });
+
+        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');
+        });
+
+        it('should validate string type', () => {
+            expect(validateType('x', 'hello', { type: 'string' })).toBeNull();
+            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');
+        });
+
+        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');
+        });
+
+        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');
+        });
+
+        it('should return null when no type specified', () => {
+            expect(validateType('x', 'anything', {})).toBeNull();
+        });
+    });
+});

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

@@ -1,5 +1,20 @@
 const { QueuerUtil } = require('@friggframework/core/queues');
 
+/**
+ * AdminScriptContext - Execution environment for admin scripts
+ *
+ * Provides a controlled surface area for scripts to interact with
+ * the Frigg platform. Unique capabilities vs direct repo access:
+ *
+ * - **Admin bypass**: `instantiate()` passes `_isAdminContext: true` to
+ *   skip user-ownership checks when loading integration instances
+ * - **Script chaining**: `queueScript()` / `queueScriptBatch()` let scripts
+ *   enqueue follow-up work with parent execution tracking
+ * - **Execution-scoped logging**: `log()` collects structured entries tied
+ *   to the current execution for post-run inspection
+ * - **Lazy-loaded repositories**: Repos are exposed directly as getters
+ *   so scripts can query any data they need without wrapper indirection
+ */
 class AdminScriptContext {
     constructor(params = {}) {
         this.executionId = params.executionId || null;
@@ -13,7 +28,6 @@ class AdminScriptContext {
         this._userRepository = null;
         this._moduleRepository = null;
         this._credentialRepository = null;
-        this._adminProcessRepository = null;
     }
 
     // ==================== LAZY-LOADED REPOSITORIES ====================
@@ -50,76 +64,6 @@ class AdminScriptContext {
         return this._credentialRepository;
     }
 
-    get adminProcessRepository() {
-        if (!this._adminProcessRepository) {
-            const { createAdminProcessRepository } = require('@friggframework/core/admin-scripts/repositories/admin-process-repository-factory');
-            this._adminProcessRepository = createAdminProcessRepository();
-        }
-        return this._adminProcessRepository;
-    }
-
-    // ==================== INTEGRATION QUERIES ====================
-
-    async listIntegrations(filter = {}) {
-        if (filter.userId) {
-            return this.integrationRepository.findIntegrationsByUserId(filter.userId);
-        }
-        return this.integrationRepository.findIntegrations(filter);
-    }
-
-    async findIntegrationById(id) {
-        return this.integrationRepository.findIntegrationById(id);
-    }
-
-    async findIntegrationsByUserId(userId) {
-        return this.integrationRepository.findIntegrationsByUserId(userId);
-    }
-
-    async updateIntegrationConfig(integrationId, config) {
-        return this.integrationRepository.updateIntegrationConfig(integrationId, config);
-    }
-
-    async updateIntegrationStatus(integrationId, status) {
-        return this.integrationRepository.updateIntegrationStatus(integrationId, status);
-    }
-
-    // ==================== USER QUERIES ====================
-
-    async findUserById(userId) {
-        return this.userRepository.findIndividualUserById(userId);
-    }
-
-    async findUserByAppUserId(appUserId) {
-        return this.userRepository.findIndividualUserByAppUserId(appUserId);
-    }
-
-    async findUserByUsername(username) {
-        return this.userRepository.findIndividualUserByUsername(username);
-    }
-
-    // ==================== ENTITY QUERIES ====================
-
-    async listEntities(filter = {}) {
-        if (filter.userId) {
-            return this.moduleRepository.findEntitiesByUserId(filter.userId);
-        }
-        return this.moduleRepository.findEntity(filter);
-    }
-
-    async findEntityById(entityId) {
-        return this.moduleRepository.findEntityById(entityId);
-    }
-
-    // ==================== CREDENTIAL QUERIES ====================
-
-    async findCredential(filter) {
-        return this.credentialRepository.findCredential(filter);
-    }
-
-    async updateCredential(credentialId, updates) {
-        return this.credentialRepository.updateCredential(credentialId, updates);
-    }
-
     // ==================== INTEGRATION INSTANTIATION ====================
 
     /**
@@ -187,13 +131,6 @@ class AdminScriptContext {
             timestamp: new Date().toISOString(),
         };
         this.logs.push(entry);
-
-        // Persist to execution record if we have an executionId
-        if (this.executionId) {
-            this.adminProcessRepository.appendProcessLog(this.executionId, entry)
-                .catch(err => console.error('Failed to persist log:', err));
-        }
-
         return entry;
     }
 

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

@@ -25,26 +25,6 @@ class AdminScriptBase {
         },
     };
 
-    static getName() {
-        return this.Definition.name;
-    }
-
-    static getCurrentVersion() {
-        return this.Definition.version;
-    }
-
-    static getDefinition() {
-        return this.Definition;
-    }
-
-    static getDisplayLabel() {
-        return this.Definition.display?.label || this.Definition.name;
-    }
-
-    static getDisplayDescription() {
-        return this.Definition.display?.description || this.Definition.description;
-    }
-
     constructor(params = {}) {
         this.context = params.context || null;
         this.executionId = params.executionId || null;