@friggframework/devtools 2.0.0-next.62 → 2.0.0-next.63

package/infrastructure/scripts/build-prisma-layer.test.js

@@ -0,0 +1,170 @@
+/**
+ * Tests for Prisma Lambda Layer Builder
+ * Validates database client selection logic
+ */
+
+const {
+    getGeneratedClientPackages,
+    getMigrationsPackages,
+    getMigrationSourcePath,
+    getMigrationDestinationPath,
+} = require('./build-prisma-layer');
+
+// Mock the log function
+jest.mock('./build-prisma-layer', () => {
+    const actual = jest.requireActual('./build-prisma-layer');
+    return {
+        ...actual,
+        getGeneratedClientPackages: actual.getGeneratedClientPackages,
+        getMigrationsPackages: actual.getMigrationsPackages,
+        getMigrationSourcePath: actual.getMigrationSourcePath,
+        getMigrationDestinationPath: actual.getMigrationDestinationPath,
+    };
+});
+
+describe('getGeneratedClientPackages()', () => {
+    it('should include MongoDB client when mongoDB.enable is true', () => {
+        const databaseConfig = {
+            mongoDB: { enable: true },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-mongodb');
+    });
+
+    it('should include MongoDB client when documentDB.enable is true', () => {
+        const databaseConfig = {
+            documentDB: { enable: true },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-mongodb');
+    });
+
+    it('should include PostgreSQL client when postgres.enable is true', () => {
+        const databaseConfig = {
+            postgres: { enable: true },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-postgresql');
+    });
+
+    it('should include both clients when both databases are enabled', () => {
+        const databaseConfig = {
+            mongoDB: { enable: true },
+            postgres: { enable: true },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-mongodb');
+        expect(packages).toContain('generated/prisma-postgresql');
+        expect(packages).toHaveLength(2);
+    });
+
+    it('should include both clients when documentDB and postgres are enabled', () => {
+        const databaseConfig = {
+            documentDB: { enable: true },
+            postgres: { enable: true },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-mongodb');
+        expect(packages).toContain('generated/prisma-postgresql');
+        expect(packages).toHaveLength(2);
+    });
+
+    it('should default to PostgreSQL when no database config provided', () => {
+        const packages = getGeneratedClientPackages({});
+
+        expect(packages).toContain('generated/prisma-postgresql');
+        expect(packages).toHaveLength(1);
+    });
+
+    it('should default to PostgreSQL when database config is null', () => {
+        const packages = getGeneratedClientPackages(null);
+
+        expect(packages).toContain('generated/prisma-postgresql');
+        expect(packages).toHaveLength(1);
+    });
+
+    it('should only include MongoDB when postgres.enable is false and mongoDB is true', () => {
+        const databaseConfig = {
+            mongoDB: { enable: true },
+            postgres: { enable: false },
+        };
+
+        const packages = getGeneratedClientPackages(databaseConfig);
+
+        expect(packages).toContain('generated/prisma-mongodb');
+        expect(packages).not.toContain('generated/prisma-postgresql');
+        expect(packages).toHaveLength(1);
+    });
+});
+
+describe('getMigrationsPackages()', () => {
+    it('should extract database types from client packages', () => {
+        const clientPackages = [
+            'generated/prisma-postgresql',
+            'generated/prisma-mongodb',
+        ];
+        const migrations = getMigrationsPackages(clientPackages);
+
+        expect(migrations).toEqual([
+            {
+                dbType: 'postgresql',
+                clientPackage: 'generated/prisma-postgresql',
+            },
+            { dbType: 'mongodb', clientPackage: 'generated/prisma-mongodb' },
+        ]);
+    });
+
+    it('should handle single client package', () => {
+        const clientPackages = ['generated/prisma-postgresql'];
+        const migrations = getMigrationsPackages(clientPackages);
+
+        expect(migrations).toEqual([
+            {
+                dbType: 'postgresql',
+                clientPackage: 'generated/prisma-postgresql',
+            },
+        ]);
+    });
+
+    it('should handle empty array', () => {
+        const migrations = getMigrationsPackages([]);
+        expect(migrations).toEqual([]);
+    });
+});
+
+describe('getMigrationSourcePath()', () => {
+    it('should return correct source path for database type', () => {
+        const searchPaths = ['/workspace/packages/core'];
+        const dbType = 'postgresql';
+
+        const sourcePath = getMigrationSourcePath(searchPaths, dbType);
+        expect(sourcePath).toBe(
+            '/workspace/packages/core/prisma-postgresql/migrations'
+        );
+    });
+});
+
+describe('getMigrationDestinationPath()', () => {
+    it('should return correct destination path for client package', () => {
+        const layerNodeModules = '/layers/prisma/nodejs/node_modules';
+        const clientPackage = 'generated/prisma-postgresql';
+
+        const destPath = getMigrationDestinationPath(
+            layerNodeModules,
+            clientPackage
+        );
+        expect(destPath).toBe(
+            '/layers/prisma/nodejs/node_modules/generated/prisma-postgresql/migrations'
+        );
+    });
+});

package/infrastructure/scripts/build-time-discovery.js

@@ -0,0 +1,238 @@
+const fs = require('fs');
+let AWSDiscovery;
+
+function loadAWSDiscovery() {
+    if (!AWSDiscovery) {
+        ({ AWSDiscovery } = require('./aws-discovery'));
+    }
+}
+
+/**
+ * Build-time AWS resource discovery and configuration injection
+ * This utility runs during the build process to discover AWS resources
+ * and inject them into the serverless configuration
+ */
+class BuildTimeDiscovery {
+    /**
+     * Creates an instance of BuildTimeDiscovery
+     * @param {string} [region=process.env.AWS_REGION || 'us-east-1'] - AWS region for discovery
+     */
+    constructor(region = process.env.AWS_REGION || 'us-east-1') {
+        loadAWSDiscovery();
+        this.region = region;
+        this.discovery = new AWSDiscovery(region);
+    }
+
+    /**
+     * Discover AWS resources and create a configuration file
+     * @param {string} [outputPath='./aws-discovery-config.json'] - Path to write the configuration file
+     * @returns {Promise<Object>} Configuration object containing discovered resources
+     * @throws {Error} If AWS resource discovery fails
+     */
+    async discoverAndCreateConfig(outputPath = './aws-discovery-config.json') {
+        try {
+            console.log('Starting AWS resource discovery for build...');
+
+            const resources = await this.discovery.discoverResources();
+
+            // Create configuration object
+            const config = {
+                awsDiscovery: resources,
+                generatedAt: new Date().toISOString(),
+                region: this.region,
+            };
+
+            // Write configuration to file
+            fs.writeFileSync(outputPath, JSON.stringify(config, null, 2));
+            console.log(
+                `AWS discovery configuration written to: ${outputPath}`,
+            );
+
+            return config;
+        } catch (error) {
+            console.error(
+                'Error during AWS resource discovery:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Replace placeholders in serverless template with discovered values
+     * @param {string} templateContent - The template content with placeholders
+     * @param {Object} discoveredResources - Object containing discovered AWS resource IDs
+     * @returns {string} Updated template content with placeholders replaced
+     */
+    replaceTemplateVariables(templateContent, discoveredResources) {
+        let updatedContent = templateContent;
+
+        // Replace AWS discovery placeholders
+        const replacements = {
+            '${self:custom.awsDiscovery.defaultVpcId}':
+                discoveredResources.defaultVpcId,
+            '${self:custom.awsDiscovery.defaultSecurityGroupId}':
+                discoveredResources.defaultSecurityGroupId,
+            '${self:custom.awsDiscovery.privateSubnetId1}':
+                discoveredResources.privateSubnetId1,
+            '${self:custom.awsDiscovery.privateSubnetId2}':
+                discoveredResources.privateSubnetId2,
+            '${self:custom.awsDiscovery.privateRouteTableId}':
+                discoveredResources.privateRouteTableId,
+            '${self:custom.awsDiscovery.defaultKmsKeyId}':
+                discoveredResources.defaultKmsKeyId,
+        };
+
+        for (const [placeholder, value] of Object.entries(replacements)) {
+            // Use a more targeted replacement to avoid replacing similar strings
+            updatedContent = updatedContent.replace(
+                new RegExp(
+                    placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+                    'g',
+                ),
+                value,
+            );
+        }
+
+        return updatedContent;
+    }
+
+    /**
+     * Process serverless configuration and inject discovered resources
+     * @param {string} configPath - Path to the serverless configuration file
+     * @param {string} [outputPath=null] - Output path for updated config (defaults to overwriting original)
+     * @returns {Promise<Object>} Object containing discovered AWS resources
+     * @throws {Error} If processing the serverless configuration fails
+     */
+    async processServerlessConfig(configPath, outputPath = null) {
+        try {
+            console.log(`Processing serverless configuration: ${configPath}`);
+
+            // Read the current serverless configuration
+            const configContent = fs.readFileSync(configPath, 'utf8');
+
+            // Discover AWS resources
+            const resources = await this.discovery.discoverResources();
+
+            // Replace placeholders with discovered values
+            const updatedContent = this.replaceTemplateVariables(
+                configContent,
+                resources,
+            );
+
+            // Write to output file or overwrite original
+            const finalPath = outputPath || configPath;
+            fs.writeFileSync(finalPath, updatedContent);
+
+            console.log(
+                `Updated serverless configuration written to: ${finalPath}`,
+            );
+
+            return resources;
+        } catch (error) {
+            console.error(
+                'Error processing serverless configuration:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+
+    /**
+     * Generate a custom serverless configuration section for discovered resources
+     * @param {Object} discoveredResources - Object containing discovered AWS resource IDs
+     * @returns {Object} Custom section object for serverless configuration
+     */
+    generateCustomSection(discoveredResources) {
+        return {
+            awsDiscovery: discoveredResources,
+        };
+    }
+
+    /**
+     * Pre-build hook to discover resources and prepare configuration
+     * @param {Object} appDefinition - Application definition object
+     * @param {string} region - AWS region for discovery
+     * @returns {Promise<Object|null>} Discovered resources or null if discovery not needed
+     * @throws {Error} If pre-build AWS discovery fails
+     */
+    async preBuildHook(appDefinition, region) {
+        try {
+            console.log('Running pre-build AWS discovery hook...');
+
+            // Only run discovery if VPC, KMS, or SSM features are enabled
+            const needsDiscovery =
+                appDefinition.vpc?.enable ||
+                appDefinition.encryption?.fieldLevelEncryptionMethod ===
+                    'kms' ||
+                appDefinition.ssm?.enable;
+
+            if (!needsDiscovery) {
+                console.log('No AWS discovery needed based on app definition');
+                return null;
+            }
+
+            // Create discovery instance with specified region
+            loadAWSDiscovery();
+            const discovery = new AWSDiscovery(region);
+            const resources = await discovery.discoverResources();
+
+            // Create environment variables for serverless
+            const envVars = {
+                AWS_DISCOVERY_VPC_ID: resources.defaultVpcId,
+                AWS_DISCOVERY_SECURITY_GROUP_ID:
+                    resources.defaultSecurityGroupId,
+                AWS_DISCOVERY_SUBNET_ID_1: resources.privateSubnetId1,
+                AWS_DISCOVERY_SUBNET_ID_2: resources.privateSubnetId2,
+                AWS_DISCOVERY_PUBLIC_SUBNET_ID: resources.publicSubnetId,
+                AWS_DISCOVERY_ROUTE_TABLE_ID: resources.privateRouteTableId,
+                AWS_DISCOVERY_KMS_KEY_ID: resources.defaultKmsKeyId, // Keep consistent naming convention (even though it's an ARN)
+            };
+
+            // Set environment variables for serverless to use
+            Object.assign(process.env, envVars);
+
+            console.log(
+                'AWS discovery completed and environment variables set',
+            );
+            return resources;
+        } catch (error) {
+            console.error(
+                'Error in pre-build AWS discovery hook:',
+                error.message,
+            );
+            throw error;
+        }
+    }
+}
+
+/**
+ * CLI utility function for build-time discovery
+ * @param {Object} [options={}] - Options for build-time discovery
+ * @param {string} [options.region=process.env.AWS_REGION || 'us-east-1'] - AWS region
+ * @param {string} [options.outputPath='./aws-discovery-config.json'] - Output path for config file
+ * @param {string} [options.configPath=null] - Path to existing serverless config to process
+ * @returns {Promise<Object>} Discovered AWS resources
+ */
+async function runBuildTimeDiscovery(options = {}) {
+    const {
+        region = process.env.AWS_REGION || 'us-east-1',
+        outputPath = './aws-discovery-config.json',
+        configPath = null,
+    } = options;
+
+    const discovery = new BuildTimeDiscovery(region);
+
+    if (configPath) {
+        // Process existing serverless configuration
+        return await discovery.processServerlessConfig(configPath);
+    } else {
+        // Just discover and create config file
+        return await discovery.discoverAndCreateConfig(outputPath);
+    }
+}
+
+module.exports = {
+    BuildTimeDiscovery,
+    runBuildTimeDiscovery,
+};