@friggframework/devtools 2.0.0--canary.517.179491e.0 → 2.0.0--canary.522.893db5d.0

package/frigg-cli/validate-command/domain/value-objects/validation-error.js

@@ -0,0 +1,68 @@
+const VALID_SEVERITIES = ['error', 'warning', 'info'];
+
+class ValidationError {
+    constructor({ path, message, severity, code, fix }) {
+        if (!path) {
+            throw new Error('path is required');
+        }
+        if (!message) {
+            throw new Error('message is required');
+        }
+        if (severity && !VALID_SEVERITIES.includes(severity)) {
+            throw new Error(`Invalid severity: ${severity}. Must be one of: ${VALID_SEVERITIES.join(', ')}`);
+        }
+
+        this.path = path;
+        this.message = message;
+        this.severity = severity || 'error';
+        this.code = code || null;
+        this.fix = fix || null;
+    }
+
+    static create(props) {
+        return new ValidationError(props);
+    }
+
+    getPathSegments() {
+        return this.path
+            .replace(/\[(\d+)\]/g, '.$1')
+            .split('.')
+            .filter(Boolean);
+    }
+
+    getRootPath() {
+        return this.getPathSegments()[0];
+    }
+
+    isError() {
+        return this.severity === 'error';
+    }
+
+    isWarning() {
+        return this.severity === 'warning';
+    }
+
+    isInfo() {
+        return this.severity === 'info';
+    }
+
+    hasFix() {
+        return this.fix !== null;
+    }
+
+    equals(other) {
+        return this.path === other.path && this.message === other.message;
+    }
+
+    toJSON() {
+        return {
+            path: this.path,
+            message: this.message,
+            severity: this.severity,
+            code: this.code,
+            fix: this.fix ? this.fix.toJSON() : null
+        };
+    }
+}
+
+module.exports = { ValidationError };

package/frigg-cli/validate-command/infrastructure/validators/api-module-validator.js

@@ -0,0 +1,181 @@
+const { validateApiModuleDefinition } = require('@friggframework/schemas');
+const { ValidationResult } = require('../../domain/entities/validation-result');
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+
+const REQUIRED_MODULE_METHODS = ['getToken', 'getEntityDetails', 'getCredentialDetails'];
+
+class ApiModuleValidator {
+    /**
+     * Validate API module definitions within an integration
+     * @param {object} integrationDefinition - The integration's Definition object
+     * @param {number} integrationIndex - Index of the integration in the app
+     * @returns {ValidationResult}
+     */
+    validate(integrationDefinition, integrationIndex) {
+        const result = ValidationResult.create();
+        const prefix = `integrations[${integrationIndex}].Definition.modules`;
+
+        if (!integrationDefinition.modules || typeof integrationDefinition.modules !== 'object') {
+            return result;
+        }
+
+        Object.entries(integrationDefinition.modules).forEach(([moduleName, moduleConfig]) => {
+            const modulePath = `${prefix}.${moduleName}`;
+
+            if (!moduleConfig.definition) {
+                result.addError(ValidationError.create({
+                    path: `${modulePath}.definition`,
+                    message: `Module '${moduleName}' must have a definition property`,
+                    severity: 'error',
+                    code: 'MISSING_DEFINITION'
+                }));
+                return;
+            }
+
+            this._validateModuleDefinitionWithSchema(moduleConfig.definition, modulePath, moduleName, result);
+            this._validateRequiredMethods(moduleConfig.definition, modulePath, moduleName, result);
+            this._validateApiPropertiesToPersist(moduleConfig.definition, modulePath, moduleName, result);
+        });
+
+        return result;
+    }
+
+    _validateModuleDefinitionWithSchema(definition, modulePath, moduleName, result) {
+        // Sanitize the definition before JSON Schema validation
+        // API module definitions contain functions and classes that JSON Schema can't validate
+        const sanitizedDefinition = this._sanitizeForSchemaValidation(definition);
+        const schemaResult = validateApiModuleDefinition(sanitizedDefinition);
+
+        if (!schemaResult.valid && schemaResult.errors) {
+            schemaResult.errors.forEach(error => {
+                const path = error.instancePath
+                    ? `${modulePath}.definition${error.instancePath.replace(/\//g, '.')}`
+                    : `${modulePath}.definition`;
+
+                result.addError(ValidationError.create({
+                    path,
+                    message: this._formatSchemaErrorMessage(error),
+                    severity: 'error',
+                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
+                }));
+            });
+        }
+    }
+
+    /**
+     * Create a copy of the module definition safe for JSON Schema validation.
+     * Converts functions to descriptors but preserves all properties so that
+     * unknown properties can be properly rejected by the schema.
+     */
+    _sanitizeForSchemaValidation(definition) {
+        if (!definition) return definition;
+
+        const sanitized = {};
+
+        // Copy ALL properties, converting functions/classes to descriptors
+        // This allows JSON Schema to properly reject unknown properties
+        for (const key of Object.keys(definition)) {
+            sanitized[key] = this._sanitizeValue(definition[key]);
+        }
+
+        return sanitized;
+    }
+
+    /**
+     * Recursively sanitize a value for JSON Schema validation.
+     * Functions become {type: "function"} descriptors.
+     * Classes become {type: "object"} descriptors.
+     */
+    _sanitizeValue(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+
+        // Convert functions to descriptors
+        if (typeof value === 'function') {
+            return { type: 'function', name: value.name || 'anonymous' };
+        }
+
+        // Handle arrays
+        if (Array.isArray(value)) {
+            return value.map(item => this._sanitizeValue(item));
+        }
+
+        // Handle objects (but not class instances with constructors other than Object)
+        if (typeof value === 'object') {
+            // Check if it's a class instance (not a plain object)
+            if (value.constructor && value.constructor.name !== 'Object') {
+                return { type: 'object', className: value.constructor.name };
+            }
+
+            // Recursively sanitize plain objects
+            const sanitizedObj = {};
+            for (const [key, val] of Object.entries(value)) {
+                sanitizedObj[key] = this._sanitizeValue(val);
+            }
+            return sanitizedObj;
+        }
+
+        // Primitives pass through unchanged
+        return value;
+    }
+
+    _formatSchemaErrorMessage(error) {
+        let message = error.message;
+        if (error.params?.allowedValues) {
+            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
+        }
+        if (error.params?.additionalProperty) {
+            message += `: ${error.params.additionalProperty}`;
+        }
+        if (error.params?.missingProperty) {
+            message = `must have required property '${error.params.missingProperty}'`;
+        }
+        return message;
+    }
+
+    _validateRequiredMethods(definition, modulePath, moduleName, result) {
+        if (!definition.requiredAuthMethods) {
+            return;
+        }
+
+        REQUIRED_MODULE_METHODS.forEach(method => {
+            if (!definition.requiredAuthMethods[method]) {
+                result.addError(ValidationError.create({
+                    path: `${modulePath}.definition.requiredAuthMethods.${method}`,
+                    message: `Module '${moduleName}' should implement ${method} method`,
+                    severity: 'warning',
+                    code: 'MISSING_METHOD'
+                }));
+            }
+        });
+    }
+
+    _validateApiPropertiesToPersist(definition, modulePath, moduleName, result) {
+        const props = definition.requiredAuthMethods?.apiPropertiesToPersist;
+
+        if (!props) {
+            return;
+        }
+
+        if (!props.credential || !Array.isArray(props.credential) || props.credential.length === 0) {
+            result.addError(ValidationError.create({
+                path: `${modulePath}.definition.requiredAuthMethods.apiPropertiesToPersist.credential`,
+                message: `Module '${moduleName}' should specify credential properties to persist`,
+                severity: 'warning',
+                code: 'MISSING_CREDENTIAL_PROPS'
+            }));
+        }
+
+        if (!props.entity || !Array.isArray(props.entity) || props.entity.length === 0) {
+            result.addError(ValidationError.create({
+                path: `${modulePath}.definition.requiredAuthMethods.apiPropertiesToPersist.entity`,
+                message: `Module '${moduleName}' should specify entity properties to persist`,
+                severity: 'warning',
+                code: 'MISSING_ENTITY_PROPS'
+            }));
+        }
+    }
+}
+
+module.exports = { ApiModuleValidator };

package/frigg-cli/validate-command/infrastructure/validators/app-definition-validator.js

@@ -0,0 +1,128 @@
+const { validateAppDefinition } = require('@friggframework/schemas');
+const { ValidationResult } = require('../../domain/entities/validation-result');
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+
+class AppDefinitionValidator {
+    validate(definition) {
+        const result = ValidationResult.create();
+
+        // Create a sanitized copy for JSON Schema validation
+        // Integrations contain classes/functions which JSON Schema can't validate
+        // IntegrationClassValidator handles those separately
+        const sanitizedDefinition = this._sanitizeForSchemaValidation(definition);
+        const schemaResult = validateAppDefinition(sanitizedDefinition);
+
+        if (!schemaResult.valid && schemaResult.errors) {
+            schemaResult.errors.forEach(error => {
+                result.addError(ValidationError.create({
+                    path: this._convertPath(error.instancePath) || 'root',
+                    message: this._formatErrorMessage(error),
+                    severity: 'error',
+                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
+                }));
+            });
+        }
+
+        this._validateIntegrationDuplicates(definition, result);
+        this._validateIntegrationDefinitions(definition, result);
+
+        return result;
+    }
+
+    /**
+     * Create a copy of the definition safe for JSON Schema validation.
+     * Replaces integration classes with stub objects since JSON Schema
+     * cannot validate JavaScript classes/functions.
+     */
+    _sanitizeForSchemaValidation(definition) {
+        if (!definition) return definition;
+
+        const sanitized = { ...definition };
+
+        // Replace integration classes with stub objects
+        // The actual class validation is handled by IntegrationClassValidator
+        if (Array.isArray(definition.integrations)) {
+            sanitized.integrations = definition.integrations.map(integration => {
+                if (typeof integration === 'function') {
+                    // Return a stub object representing the class
+                    return { _isClass: true, name: integration.name };
+                }
+                return integration;
+            });
+        }
+
+        return sanitized;
+    }
+
+    _convertPath(jsonPointerPath) {
+        if (!jsonPointerPath) return '';
+        return jsonPointerPath
+            .replace(/^\//, '')
+            .replace(/\/(\d+)/g, '[$1]')
+            .replace(/\//g, '.');
+    }
+
+    _formatErrorMessage(error) {
+        let message = error.message;
+        if (error.params?.allowedValues) {
+            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
+        }
+        if (error.params?.additionalProperty) {
+            message += `: ${error.params.additionalProperty}`;
+        }
+        if (error.params?.missingProperty) {
+            message = `must have required property '${error.params.missingProperty}'`;
+        }
+        return message;
+    }
+
+    _validateIntegrationDefinitions(definition, result) {
+        if (!definition.integrations || !Array.isArray(definition.integrations)) {
+            return;
+        }
+
+        definition.integrations.forEach((integration, index) => {
+            if (typeof integration === 'function') {
+                if (!integration.Definition) {
+                    result.addError(ValidationError.create({
+                        path: `integrations[${index}]`,
+                        message: 'Integration class must have a static Definition property',
+                        severity: 'error',
+                        code: 'MISSING_DEFINITION'
+                    }));
+                } else if (!integration.Definition.name) {
+                    result.addError(ValidationError.create({
+                        path: `integrations[${index}].Definition.name`,
+                        message: 'Integration Definition must have a name property',
+                        severity: 'error',
+                        code: 'REQUIRED_FIELD'
+                    }));
+                }
+            }
+        });
+    }
+
+    _validateIntegrationDuplicates(definition, result) {
+        if (!definition.integrations || !Array.isArray(definition.integrations)) {
+            return;
+        }
+
+        const names = [];
+        definition.integrations.forEach((integration, index) => {
+            const name = integration.Definition?.name;
+            if (name) {
+                if (names.includes(name)) {
+                    result.addError(ValidationError.create({
+                        path: `integrations[${index}].Definition.name`,
+                        message: `duplicate integration name: ${name}`,
+                        severity: 'warning',
+                        code: 'DUPLICATE_NAME'
+                    }));
+                }
+                names.push(name);
+            }
+        });
+    }
+}
+
+module.exports = { AppDefinitionValidator };

package/frigg-cli/validate-command/infrastructure/validators/integration-class-validator.js

@@ -0,0 +1,113 @@
+const { validateIntegrationDefinition } = require('@friggframework/schemas');
+const { ValidationResult } = require('../../domain/entities/validation-result');
+const { ValidationError } = require('../../domain/value-objects/validation-error');
+const { FixSuggestion } = require('../../domain/value-objects/fix-suggestion');
+
+const LIFECYCLE_METHODS = ['onCreate', 'getConfigOptions', 'testAuth'];
+
+class IntegrationClassValidator {
+    validate(integrationClass, index) {
+        const result = ValidationResult.create();
+        const prefix = `integrations[${index}]`;
+
+        if (typeof integrationClass !== 'function') {
+            result.addError(ValidationError.create({
+                path: prefix,
+                message: 'Integration must be a class (function)',
+                severity: 'error',
+                code: 'INVALID_TYPE'
+            }));
+            return result;
+        }
+
+        if (!integrationClass.Definition) {
+            result.addError(ValidationError.create({
+                path: `${prefix}.Definition`,
+                message: 'Integration class must have a static Definition property',
+                severity: 'error',
+                code: 'MISSING_DEFINITION',
+                fix: FixSuggestion.create({
+                    action: 'add',
+                    description: 'Add static Definition property to integration class',
+                    codeSnippet: `static Definition = {\n    name: 'my-integration',\n    version: '1.0.0',\n    modules: {}\n};`
+                })
+            }));
+            return result;
+        }
+
+        this._validateDefinitionWithSchema(integrationClass.Definition, prefix, result);
+        this._validateModuleNames(integrationClass.Definition, prefix, result);
+        this._validateLifecycleMethods(integrationClass, prefix, result);
+
+        return result;
+    }
+
+    _validateDefinitionWithSchema(definition, prefix, result) {
+        const schemaResult = validateIntegrationDefinition(definition);
+
+        if (!schemaResult.valid && schemaResult.errors) {
+            schemaResult.errors.forEach(error => {
+                const path = error.instancePath
+                    ? `${prefix}.Definition${error.instancePath.replace(/\//g, '.')}`
+                    : `${prefix}.Definition`;
+
+                result.addError(ValidationError.create({
+                    path,
+                    message: this._formatSchemaErrorMessage(error),
+                    severity: 'error',
+                    code: error.keyword?.toUpperCase() || 'SCHEMA_ERROR'
+                }));
+            });
+        }
+    }
+
+    _formatSchemaErrorMessage(error) {
+        let message = error.message;
+        if (error.params?.allowedValues) {
+            message += ` (allowed: ${error.params.allowedValues.join(', ')})`;
+        }
+        if (error.params?.additionalProperty) {
+            message += `: ${error.params.additionalProperty}`;
+        }
+        if (error.params?.missingProperty) {
+            message = `must have required property '${error.params.missingProperty}'`;
+        }
+        return message;
+    }
+
+    _validateModuleNames(definition, prefix, result) {
+        if (!definition.modules) {
+            return;
+        }
+
+        Object.entries(definition.modules).forEach(([moduleName, moduleConfig]) => {
+            // Check for moduleName (the correct property per API module schema and core Module class)
+            // Note: getName() method returns definition.moduleName, not definition.name
+            if (moduleConfig.definition && !moduleConfig.definition.moduleName) {
+                result.addError(ValidationError.create({
+                    path: `${prefix}.Definition.modules.${moduleName}.definition.moduleName`,
+                    message: `Module ${moduleName} definition should have a moduleName property`,
+                    severity: 'warning',
+                    code: 'MISSING_MODULE_NAME'
+                }));
+            }
+        });
+    }
+
+    _validateLifecycleMethods(integrationClass, prefix, result) {
+        const proto = integrationClass.prototype;
+
+        LIFECYCLE_METHODS.forEach(method => {
+            if (typeof proto[method] !== 'function') {
+                result.addError(ValidationError.create({
+                    path: `${prefix}.${method}`,
+                    message: `Integration should implement ${method}() method`,
+                    severity: 'warning',
+                    code: 'MISSING_METHOD'
+                }));
+            }
+        });
+    }
+}
+
+module.exports = { IntegrationClassValidator };

package/infrastructure/docs/iam-policy-templates.md

@@ -160,7 +160,7 @@ Consider separate policies for different environments:
 ### Validation
 Test your policy by deploying a simple Frigg app:
 ```bash
-npx create-frigg-app test-deployment
+frigg init test-deployment
 cd test-deployment
 frigg deploy
 ```

package/infrastructure/domains/networking/vpc-builder.test.js

@@ -1500,10 +1500,9 @@ describe('VpcBuilder', () => {
                 }
             };
             
-            // Discovery results matching ACTUAL Frontify production stack
             const discoveredResources = {
                 fromCloudFormationStack: true,
-                stackName: 'create-frigg-app-production',
+                stackName: 'frigg-app-production',
                 existingLogicalIds: [
                     'FriggLambdaRouteTable',
                     'FriggNATRoute',  // OLD naming
@@ -1566,10 +1565,9 @@ describe('VpcBuilder', () => {
         });
 
         it('should convert OLD logical IDs to structured discovery stackManaged array', () => {
-            // TDD test: Verify that VPCEndpointS3 in existingLogicalIds gets added to stackManaged
             const flatDiscovery = {
                 fromCloudFormationStack: true,
-                stackName: 'create-frigg-app-production',
+                stackName: 'frigg-app-production',
                 existingLogicalIds: [
                     'VPCEndpointS3',        // OLD naming
                     'VPCEndpointDynamoDB',  // OLD naming

package/infrastructure/domains/networking/vpc-resolver.test.js

@@ -746,7 +746,7 @@ describe('VpcResourceResolver', () => {
                 ],
                 external: [],
                 fromCloudFormation: true,
-                stackName: 'create-frigg-app-production'
+                stackName: 'frigg-app-production'
             };
 
             const decisions = resolver.resolveAll(appDefinition, discovery);

package/infrastructure/domains/shared/cloudformation-discovery.test.js

@@ -589,10 +589,8 @@ describe('CloudFormationDiscovery', () => {
 
     describe('External VPC with routing infrastructure pattern', () => {
         it('should discover routing resources when VPC is external', async () => {
-            // This tests the external VPC pattern: external VPC/subnets/KMS,
-            // but stack creates routing infrastructure (route table, NAT route, VPC endpoints)
             const mockStack = {
-                StackName: 'create-frigg-app-production',
+                StackName: 'frigg-app-production',
                 Outputs: [],
             };
 
@@ -638,7 +636,7 @@ describe('CloudFormationDiscovery', () => {
             mockProvider.describeStack.mockResolvedValue(mockStack);
             mockProvider.listStackResources.mockResolvedValue(mockResources);
 
-            const result = await cfDiscovery.discoverFromStack('create-frigg-app-production');
+            const result = await cfDiscovery.discoverFromStack('frigg-app-production');
 
             // Verify routing infrastructure was discovered
             expect(result.routeTableId).toBe('rtb-0b83aca77ccde20a6');
@@ -807,9 +805,8 @@ describe('CloudFormationDiscovery', () => {
 
     describe('existingLogicalIds tracking', () => {
         it('should track OLD VPC endpoint logical IDs (VPCEndpointS3 pattern) for backwards compatibility', async () => {
-            // CRITICAL: Frontify production uses OLD naming convention
             const mockStack = {
-                StackName: 'create-frigg-app-production',
+                StackName: 'frigg-app-production',
                 Outputs: []
             };
 
@@ -825,7 +822,7 @@ describe('CloudFormationDiscovery', () => {
             mockProvider.describeStack.mockResolvedValue(mockStack);
             mockProvider.listStackResources.mockResolvedValue(mockResources);
 
-            const result = await cfDiscovery.discoverFromStack('create-frigg-app-production');
+            const result = await cfDiscovery.discoverFromStack('frigg-app-production');
 
             // CRITICAL: existingLogicalIds MUST contain old VPC endpoint names
             expect(result.existingLogicalIds).toBeDefined();

package/infrastructure/domains/shared/resource-discovery.js

@@ -88,8 +88,8 @@ async function gatherDiscoveredResources(appDefinition) {
 
         // Build discovery configuration
         const stage = process.env.SLS_STAGE || 'dev';
-        const stackName = `${appDefinition.name || 'create-frigg-app'}-${stage}`;
-        const serviceName = appDefinition.name || 'create-frigg-app';
+        const stackName = `${appDefinition.name || 'frigg-app'}-${stage}`;
+        const serviceName = appDefinition.name || 'frigg-app';
 
         // Try CloudFormation-first discovery
         const cfDiscovery = new CloudFormationDiscovery(provider, { serviceName, stage });
@@ -135,9 +135,9 @@ async function gatherDiscoveredResources(appDefinition) {
             // KMS keys CAN be shared across stages (encryption keys are safe to reuse)
             const kmsDiscovery = new KmsDiscovery(provider);
             const kmsConfig = {
-                serviceName: appDefinition.name || 'create-frigg-app',
+                serviceName: appDefinition.name || 'frigg-app',
                 stage,
-                keyAlias: `alias/${appDefinition.name || 'create-frigg-app'}-${stage}-frigg-kms`,
+                keyAlias: `alias/${appDefinition.name || 'frigg-app'}-${stage}-frigg-kms`,
             };
             const kmsResult = await kmsDiscovery.discover(kmsConfig);
 
@@ -166,7 +166,7 @@ async function gatherDiscoveredResources(appDefinition) {
         const ssmDiscovery = new SsmDiscovery(provider);
 
         const config = {
-            serviceName: appDefinition.name || 'create-frigg-app',
+            serviceName: appDefinition.name || 'frigg-app',
             stage,
             vpcId: appDefinition.vpc?.vpcId,
             databaseId: appDefinition.database?.postgres?.clusterId ||

package/infrastructure/domains/shared/types/discovery-result.test.js

@@ -219,7 +219,7 @@ describe('Discovery Result Utilities', () => {
                 ],
                 external: [],
                 fromCloudFormation: true,
-                stackName: 'create-frigg-app-production'
+                stackName: 'frigg-app-production'
             };
 
             expect(discovery.fromCloudFormation).toBe(true);

package/infrastructure/domains/shared/utilities/base-definition-factory.js

@@ -165,7 +165,7 @@ function createBaseDefinition(
 
     return {
         frameworkVersion: '>=3.17.0',
-        service: AppDefinition.name || 'create-frigg-app',
+        service: AppDefinition.name || 'frigg-app',
         package: {
             individually: true,
         },
@@ -311,6 +311,15 @@ function createBaseDefinition(
                     { httpApi: { path: '/health/{proxy+}', method: 'GET' } },
                 ],
             },
+            docs: {
+                handler: 'node_modules/@friggframework/core/handlers/routers/docs.handler',
+                skipEsbuild: true,
+                package: skipEsbuildPackageConfig,
+                events: [
+                    { httpApi: { path: '/api/docs', method: 'GET' } },
+                    { httpApi: { path: '/api/openapi.json', method: 'GET' } },
+                ],
+            },
             // Note: dbMigrate removed - MigrationBuilder now handles migration infrastructure
             // See: packages/devtools/infrastructure/domains/database/migration-builder.js
         },

package/infrastructure/domains/shared/utilities/base-definition-factory.test.js

@@ -30,10 +30,10 @@ describe('Base Definition Factory', () => {
             expect(result.provider.stage).toBe('${opt:stage}');
         });
 
-        it('should default service name to create-frigg-app', () => {
+        it('should default service name to frigg-app', () => {
             const result = createBaseDefinition({}, {}, {});
 
-            expect(result.service).toBe('create-frigg-app');
+            expect(result.service).toBe('frigg-app');
         });
 
         it('should use custom provider if specified', () => {

package/infrastructure/infrastructure-composer.test.js

@@ -157,7 +157,7 @@ describe('composeServerlessDefinition', () => {
 
             const result = await composeServerlessDefinition(appDefinition);
 
-            expect(result.service).toBe('create-frigg-app');
+            expect(result.service).toBe('frigg-app');
         });
 
         it('should use custom provider when specified', async () => {
@@ -1859,7 +1859,7 @@ describe('composeServerlessDefinition', () => {
 
             await expect(composeServerlessDefinition(appDefinition)).resolves.not.toThrow();
             const result = await composeServerlessDefinition(appDefinition);
-            expect(result.service).toBe('create-frigg-app');
+            expect(result.service).toBe('frigg-app');
         });
 
         it('should handle null/undefined integrations', async () => {