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

package/src/builtins/__tests__/oauth-token-refresh.test.js

@@ -3,10 +3,15 @@ const { OAuthTokenRefreshScript } = require('../oauth-token-refresh');
 describe('OAuthTokenRefreshScript', () => {
     describe('Definition', () => {
         it('should have correct name and metadata', () => {
-            expect(OAuthTokenRefreshScript.Definition.name).toBe('oauth-token-refresh');
+            expect(OAuthTokenRefreshScript.Definition.name).toBe(
+                'oauth-token-refresh'
+            );
             expect(OAuthTokenRefreshScript.Definition.version).toBe('1.0.0');
             expect(OAuthTokenRefreshScript.Definition.source).toBe('BUILTIN');
-            expect(OAuthTokenRefreshScript.Definition.config.requireIntegrationInstance).toBe(true);
+            expect(
+                OAuthTokenRefreshScript.Definition.config
+                    .requireIntegrationInstance
+            ).toBe(true);
         });
 
         it('should have valid input schema', () => {
@@ -27,15 +32,23 @@ describe('OAuthTokenRefreshScript', () => {
         });
 
         it('should have appropriate timeout configuration', () => {
-            expect(OAuthTokenRefreshScript.Definition.config.timeout).toBe(600000); // 10 minutes
+            expect(OAuthTokenRefreshScript.Definition.config.timeout).toBe(
+                600000
+            ); // 10 minutes
         });
 
         it('should have clean display object without redundant fields', () => {
             expect(OAuthTokenRefreshScript.Definition.display).toBeDefined();
-            expect(OAuthTokenRefreshScript.Definition.display.category).toBe('maintenance');
+            expect(OAuthTokenRefreshScript.Definition.display.category).toBe(
+                'maintenance'
+            );
             // Should NOT have redundant label/description
-            expect(OAuthTokenRefreshScript.Definition.display.label).toBeUndefined();
-            expect(OAuthTokenRefreshScript.Definition.display.description).toBeUndefined();
+            expect(
+                OAuthTokenRefreshScript.Definition.display.label
+            ).toBeUndefined();
+            expect(
+                OAuthTokenRefreshScript.Definition.display.description
+            ).toBeUndefined();
         });
     });
 
@@ -56,7 +69,9 @@ describe('OAuthTokenRefreshScript', () => {
         });
 
         it('should return empty results when no integrations found', async () => {
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                []
+            );
 
             const result = await script.execute({});
 
@@ -64,15 +79,21 @@ describe('OAuthTokenRefreshScript', () => {
             expect(result.failed).toBe(0);
             expect(result.skipped).toBe(0);
             expect(result.details).toEqual([]);
-            expect(mockContext.log).toHaveBeenCalledWith('info', expect.any(String), expect.any(Object));
+            expect(mockContext.log).toHaveBeenCalledWith(
+                'info',
+                expect.any(String),
+                expect.any(Object)
+            );
         });
 
         it('should skip integrations without OAuth credentials', async () => {
             const integration = {
                 id: 'int-1',
-                config: {} // No credentials
+                config: {}, // No credentials
             };
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
 
             const result = await script.execute({});
 
@@ -81,7 +102,7 @@ describe('OAuthTokenRefreshScript', () => {
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'skipped',
-                reason: 'No OAuth credentials found'
+                reason: 'No OAuth credentials found',
             });
         });
 
@@ -90,12 +111,14 @@ describe('OAuthTokenRefreshScript', () => {
                 id: 'int-1',
                 config: {
                     credentials: {
-                        access_token: 'token123'
+                        access_token: 'token123',
                         // No expires_at
-                    }
-                }
+                    },
+                },
             };
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
 
             const result = await script.execute({});
 
@@ -103,7 +126,7 @@ describe('OAuthTokenRefreshScript', () => {
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'skipped',
-                reason: 'No expiry time found'
+                reason: 'No expiry time found',
             });
         });
 
@@ -114,21 +137,23 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: farFutureExpiry.toISOString()
-                    }
-                }
+                        expires_at: farFutureExpiry.toISOString(),
+                    },
+                },
             };
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
 
             const result = await script.execute({
-                expiryThresholdHours: 24
+                expiryThresholdHours: 24,
             });
 
             expect(result.skipped).toBe(1);
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'skipped',
-                reason: 'Token not near expiry'
+                reason: 'Token not near expiry',
             });
         });
 
@@ -139,32 +164,38 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: soonExpiry.toISOString()
-                    }
-                }
+                        expires_at: soonExpiry.toISOString(),
+                    },
+                },
             };
 
             const mockInstance = {
                 primary: {
                     api: {
-                        refreshAccessToken: jest.fn().mockResolvedValue(undefined)
-                    }
-                }
+                        refreshAccessToken: jest
+                            .fn()
+                            .mockResolvedValue(undefined),
+                    },
+                },
             };
 
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
             mockContext.instantiate.mockResolvedValue(mockInstance);
 
             const result = await script.execute({
-                expiryThresholdHours: 24
+                expiryThresholdHours: 24,
             });
 
             expect(result.refreshed).toBe(1);
             expect(result.skipped).toBe(0);
-            expect(mockInstance.primary.api.refreshAccessToken).toHaveBeenCalled();
+            expect(
+                mockInstance.primary.api.refreshAccessToken
+            ).toHaveBeenCalled();
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
-                action: 'refreshed'
+                action: 'refreshed',
             });
         });
 
@@ -175,16 +206,18 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: soonExpiry.toISOString()
-                    }
-                }
+                        expires_at: soonExpiry.toISOString(),
+                    },
+                },
             };
 
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
 
             const result = await script.execute({
                 expiryThresholdHours: 24,
-                dryRun: true
+                dryRun: true,
             });
 
             expect(result.refreshed).toBe(0);
@@ -193,7 +226,7 @@ describe('OAuthTokenRefreshScript', () => {
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'skipped',
-                reason: 'Dry run - would have refreshed'
+                reason: 'Dry run - would have refreshed',
             });
         });
 
@@ -204,24 +237,28 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: soonExpiry.toISOString()
-                    }
-                }
+                        expires_at: soonExpiry.toISOString(),
+                    },
+                },
             };
 
             const mockInstance = {
                 primary: {
                     api: {
-                        refreshAccessToken: jest.fn().mockRejectedValue(new Error('API Error'))
-                    }
-                }
+                        refreshAccessToken: jest
+                            .fn()
+                            .mockRejectedValue(new Error('API Error')),
+                    },
+                },
             };
 
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
             mockContext.instantiate.mockResolvedValue(mockInstance);
 
             const result = await script.execute({
-                expiryThresholdHours: 24
+                expiryThresholdHours: 24,
             });
 
             expect(result.failed).toBe(1);
@@ -229,7 +266,7 @@ describe('OAuthTokenRefreshScript', () => {
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'failed',
-                reason: 'API Error'
+                reason: 'API Error',
             });
         });
 
@@ -240,57 +277,67 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: soonExpiry.toISOString()
-                    }
-                }
+                        expires_at: soonExpiry.toISOString(),
+                    },
+                },
             };
 
             const mockInstance = {
                 primary: {
                     api: {
                         // No refreshAccessToken method
-                    }
-                }
+                    },
+                },
             };
 
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
             mockContext.instantiate.mockResolvedValue(mockInstance);
 
             const result = await script.execute({
-                expiryThresholdHours: 24
+                expiryThresholdHours: 24,
             });
 
             expect(result.skipped).toBe(1);
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'skipped',
-                reason: 'API does not support token refresh'
+                reason: 'API does not support token refresh',
             });
         });
 
         it('should filter by specific integration IDs', async () => {
             const integration1 = {
                 id: 'int-1',
-                config: { credentials: { access_token: 'token1' } }
+                config: { credentials: { access_token: 'token1' } },
             };
             const integration2 = {
                 id: 'int-2',
-                config: { credentials: { access_token: 'token2' } }
+                config: { credentials: { access_token: 'token2' } },
             };
 
-            mockContext.integrationRepository.findIntegrationById.mockImplementation((id) => {
-                if (id === 'int-1') return Promise.resolve(integration1);
-                if (id === 'int-2') return Promise.resolve(integration2);
-                return Promise.reject(new Error('Not found'));
-            });
+            mockContext.integrationRepository.findIntegrationById.mockImplementation(
+                (id) => {
+                    if (id === 'int-1') return Promise.resolve(integration1);
+                    if (id === 'int-2') return Promise.resolve(integration2);
+                    return Promise.reject(new Error('Not found'));
+                }
+            );
 
             const result = await script.execute({
-                integrationIds: ['int-1', 'int-2']
+                integrationIds: ['int-1', 'int-2'],
             });
 
-            expect(mockContext.integrationRepository.findIntegrationById).toHaveBeenCalledWith('int-1');
-            expect(mockContext.integrationRepository.findIntegrationById).toHaveBeenCalledWith('int-2');
-            expect(mockContext.integrationRepository.findIntegrations).not.toHaveBeenCalled();
+            expect(
+                mockContext.integrationRepository.findIntegrationById
+            ).toHaveBeenCalledWith('int-1');
+            expect(
+                mockContext.integrationRepository.findIntegrationById
+            ).toHaveBeenCalledWith('int-2');
+            expect(
+                mockContext.integrationRepository.findIntegrations
+            ).not.toHaveBeenCalled();
             expect(result.details).toHaveLength(2);
         });
 
@@ -300,23 +347,29 @@ describe('OAuthTokenRefreshScript', () => {
                 config: {
                     credentials: {
                         access_token: 'token123',
-                        expires_at: new Date(Date.now() + 12 * 60 * 60 * 1000).toISOString()
-                    }
-                }
+                        expires_at: new Date(
+                            Date.now() + 12 * 60 * 60 * 1000
+                        ).toISOString(),
+                    },
+                },
             };
 
-            mockContext.integrationRepository.findIntegrations.mockResolvedValue([integration]);
-            mockContext.instantiate.mockRejectedValue(new Error('Instantiation failed'));
+            mockContext.integrationRepository.findIntegrations.mockResolvedValue(
+                [integration]
+            );
+            mockContext.instantiate.mockRejectedValue(
+                new Error('Instantiation failed')
+            );
 
             const result = await script.execute({
-                expiryThresholdHours: 24
+                expiryThresholdHours: 24,
             });
 
             expect(result.failed).toBe(1);
             expect(result.details[0]).toMatchObject({
                 integrationId: 'int-1',
                 action: 'failed',
-                reason: 'Instantiation failed'
+                reason: 'Instantiation failed',
             });
         });
     });
@@ -338,12 +391,12 @@ describe('OAuthTokenRefreshScript', () => {
             // This test validates the method can be called directly
             const integration = {
                 id: 'int-1',
-                config: {}
+                config: {},
             };
 
             const result = await script.processIntegration(integration, {
                 expiryThresholdHours: 24,
-                dryRun: false
+                dryRun: false,
             });
 
             expect(result).toHaveProperty('integrationId');

package/src/builtins/index.js

@@ -7,10 +7,7 @@ const { IntegrationHealthCheckScript } = require('./integration-health-check');
  * These scripts ship with @friggframework/admin-scripts and provide
  * common maintenance and monitoring functionality.
  */
-const builtinScripts = [
-    OAuthTokenRefreshScript,
-    IntegrationHealthCheckScript,
-];
+const builtinScripts = [OAuthTokenRefreshScript, IntegrationHealthCheckScript];
 
 /**
  * Register all built-in scripts with a factory

package/src/builtins/integration-health-check.js

@@ -21,24 +21,25 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
                 integrationIds: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Specific integration IDs to check (optional, defaults to all)'
+                    description:
+                        'Specific integration IDs to check (optional, defaults to all)',
                 },
                 checkCredentials: {
                     type: 'boolean',
                     default: true,
-                    description: 'Verify credential validity'
+                    description: 'Verify credential validity',
                 },
                 checkConnectivity: {
                     type: 'boolean',
                     default: true,
-                    description: 'Test API connectivity'
+                    description: 'Test API connectivity',
                 },
                 updateStatus: {
                     type: 'boolean',
                     default: false,
-                    description: 'Update integration status based on health'
-                }
-            }
+                    description: 'Update integration status based on health',
+                },
+            },
         },
 
         outputSchema: {
@@ -47,18 +48,17 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
                 healthy: { type: 'number' },
                 unhealthy: { type: 'number' },
                 unknown: { type: 'number' },
-                results: { type: 'array' }
-            }
+                results: { type: 'array' },
+            },
         },
 
         config: {
             timeout: 900000, // 15 minutes
-            maxRetries: 0,
             requireIntegrationInstance: true,
         },
 
         schedule: {
-            enabled: false,  // Can be enabled via API
+            enabled: false, // Can be enabled via API
             cronExpression: 'cron(0 6 * * ? *)', // Daily at 6 AM UTC
         },
 
@@ -73,40 +73,47 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             integrationIds = null,
             checkCredentials = true,
             checkConnectivity = true,
-            updateStatus = false
+            updateStatus = false,
         } = params;
 
         const summary = {
             healthy: 0,
             unhealthy: 0,
             unknown: 0,
-            results: []
+            results: [],
         };
 
         this.context.log('info', 'Starting integration health check', {
             checkCredentials,
             checkConnectivity,
             updateStatus,
-            specificIds: integrationIds?.length || 'all'
+            specificIds: integrationIds?.length || 'all',
         });
 
         // Get integrations to check
         let integrations;
         if (integrationIds && integrationIds.length > 0) {
             integrations = await Promise.all(
-                integrationIds.map(id => this.context.integrationRepository.findIntegrationById(id).catch(() => null))
+                integrationIds.map((id) =>
+                    this.context.integrationRepository
+                        .findIntegrationById(id)
+                        .catch(() => null)
+                )
             );
             integrations = integrations.filter(Boolean);
         } else {
             integrations = await this.getAllIntegrations();
         }
 
-        this.context.log('info', `Checking ${integrations.length} integrations`);
+        this.context.log(
+            'info',
+            `Checking ${integrations.length} integrations`
+        );
 
         for (const integration of integrations) {
             const result = await this.checkIntegration(integration, {
                 checkCredentials,
-                checkConnectivity
+                checkConnectivity,
             });
 
             summary.results.push(result);
@@ -122,13 +129,24 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             // Optionally update integration status
             if (updateStatus && result.status !== 'unknown') {
                 try {
-                    const newStatus = result.status === 'healthy' ? 'ACTIVE' : 'ERROR';
-                    await this.context.integrationRepository.updateIntegrationStatus(integration.id, newStatus);
-                    this.context.log('info', `Updated status for ${integration.id} to ${newStatus}`);
+                    const newStatus =
+                        result.status === 'healthy' ? 'ACTIVE' : 'ERROR';
+                    await this.context.integrationRepository.updateIntegrationStatus(
+                        integration.id,
+                        newStatus
+                    );
+                    this.context.log(
+                        'info',
+                        `Updated status for ${integration.id} to ${newStatus}`
+                    );
                 } catch (error) {
-                    this.context.log('warn', `Failed to update status for ${integration.id}`, {
-                        error: error.message
-                    });
+                    this.context.log(
+                        'warn',
+                        `Failed to update status for ${integration.id}`,
+                        {
+                            error: error.message,
+                        }
+                    );
                 }
             }
         }
@@ -136,7 +154,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         this.context.log('info', 'Health check completed', {
             healthy: summary.healthy,
             unhealthy: summary.unhealthy,
-            unknown: summary.unknown
+            unknown: summary.unknown,
         });
 
         return summary;
@@ -151,7 +169,10 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         const result = this._createCheckResult(integration);
 
         try {
-            await this._runChecks(integration, result, { checkCredentials, checkConnectivity });
+            await this._runChecks(integration, result, {
+                checkCredentials,
+                checkConnectivity,
+            });
             this._determineOverallStatus(result);
         } catch (error) {
             this._handleCheckError(integration, result, error);
@@ -170,7 +191,7 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
             integrationType: integration.config?.type || 'unknown',
             status: 'unknown',
             checks: {},
-            issues: []
+            issues: [],
         };
     }
 
@@ -182,11 +203,19 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
         const { checkCredentials, checkConnectivity } = options;
 
         if (checkCredentials) {
-            this._addCheckResult(result, 'credentials', this.checkCredentialValidity(integration));
+            this._addCheckResult(
+                result,
+                'credentials',
+                this.checkCredentialValidity(integration)
+            );
         }
 
         if (checkConnectivity) {
-            this._addCheckResult(result, 'connectivity', await this.checkApiConnectivity(integration));
+            this._addCheckResult(
+                result,
+                'connectivity',
+                await this.checkApiConnectivity(integration)
+            );
         }
     }
 
@@ -214,9 +243,13 @@ class IntegrationHealthCheckScript extends AdminScriptBase {
      * @private
      */
     _handleCheckError(integration, result, error) {
-        this.context.log('error', `Error checking integration ${integration.id}`, {
-            error: error.message
-        });
+        this.context.log(
+            'error',
+            `Error checking integration ${integration.id}`,
+            {
+                error: error.message,
+            }
+        );
         result.status = 'unknown';
         result.issues.push(`Check failed: ${error.message}`);
     }