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

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

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+
+/**
+ * Build Prisma Lambda Layer
+ *
+ * Creates a MINIMAL Lambda Layer containing only Prisma runtime client and query engines.
+ * This reduces individual Lambda function sizes by ~60% (120MB → 45MB).
+ *
+ * IMPORTANT: This layer does NOT include the Prisma CLI (saves ~82MB).
+ * The CLI is only needed for migrations and is packaged separately with the dbMigrate function.
+ *
+ * The layer is configured based on AppDefinition database settings:
+ * - PostgreSQL: Includes PostgreSQL client + query engine + migrations
+ * - MongoDB: Includes MongoDB client + query engine + migrations (if needed)
+ * - Defaults to PostgreSQL only if not specified
+ *
+ * Usage:
+ *   node scripts/build-prisma-layer.js
+ *   npm run build:prisma-layer
+ *
+ * Output:
+ *   layers/prisma/nodejs/node_modules/
+ *   ├── @prisma/client (runtime only, ~10-15MB)
+ *   ├── generated/prisma-postgresql (if PostgreSQL enabled)
+ *   │   ├── schema.prisma
+ *   │   └── migrations/
+ *   └── generated/prisma-mongodb (if MongoDB enabled)
+ *       ├── schema.prisma
+ *       └── migrations/
+ *
+ * See: LAMBDA-LAYER-PRISMA.md for complete documentation
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Find @friggframework/core package, handling workspace hoisting
+ * Searches up the directory tree to find node_modules/@friggframework/core
+ */
+function findCorePackage(startDir) {
+    let currentDir = startDir;
+    const root = path.parse(currentDir).root;
+
+    while (currentDir !== root) {
+        const candidatePath = path.join(
+            currentDir,
+            'node_modules/@friggframework/core'
+        );
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+
+    throw new Error(
+        '@friggframework/core not found in node_modules.\n' +
+            'Run "npm install" to install dependencies.'
+    );
+}
+
+/**
+ * Determine which database clients to include based on configuration
+ * @param {Object} databaseConfig - Database configuration from AppDefinition
+ * @returns {Array} List of generated client packages to include
+ */
+function getGeneratedClientPackages(databaseConfig = {}) {
+    const packages = [];
+
+    // Check if MongoDB is enabled (via mongoDB or documentDB config)
+    const mongoEnabled =
+        databaseConfig?.mongoDB?.enable === true ||
+        databaseConfig?.documentDB?.enable === true;
+    if (mongoEnabled) {
+        packages.push('generated/prisma-mongodb');
+        log('Including MongoDB client (based on AppDefinition)', 'blue');
+    }
+
+    // Check if PostgreSQL is enabled (default to true if not specified)
+    const postgresEnabled = databaseConfig?.postgres?.enable !== false;
+    if (postgresEnabled) {
+        packages.push('generated/prisma-postgresql');
+        log('Including PostgreSQL client (based on AppDefinition)', 'blue');
+    }
+
+    // If neither specified, default to PostgreSQL only
+    if (packages.length === 0) {
+        packages.push('generated/prisma-postgresql');
+        log('No database specified - defaulting to PostgreSQL', 'yellow');
+    }
+
+    return packages;
+}
+
+function getMigrationsPackages(clientPackages) {
+    return clientPackages.map((pkg) => ({
+        dbType: pkg.replace('generated/prisma-', ''),
+        clientPackage: pkg,
+    }));
+}
+
+function getMigrationSourcePath(searchPaths, dbType) {
+    for (const searchPath of searchPaths) {
+        const candidatePath = path.join(
+            searchPath,
+            `prisma-${dbType}`,
+            'migrations'
+        );
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return null;
+}
+
+function getMigrationDestinationPath(layerNodeModules, clientPackage) {
+    return path.join(layerNodeModules, clientPackage, 'migrations');
+}
+
+/**
+ * Build list of required file paths for layer verification
+ * Different databases have different deployment patterns:
+ * - PostgreSQL: Uses migrations (prisma migrate) - requires migration_lock.toml
+ * - MongoDB: Uses schema push (prisma db push) - NO migrations directory
+ *
+ * @param {Array} clientPackages - Generated client packages to include (e.g., ['generated/prisma-postgresql'])
+ * @returns {Array} List of required file paths that must exist in the layer
+ */
+function getRequiredLayerPaths(clientPackages) {
+    const requiredPaths = [
+        // Base Prisma client runtime files (always required)
+        '@prisma/client/runtime',
+        '@prisma/client/index.d.ts',
+    ];
+
+    // Add schema.prisma for each database client
+    for (const pkg of clientPackages) {
+        requiredPaths.push(`${pkg}/schema.prisma`);
+    }
+
+    // Add migrations ONLY for PostgreSQL (MongoDB uses schema push, no migrations)
+    for (const pkg of clientPackages) {
+        const dbType = pkg.replace('generated/prisma-', '');
+        if (dbType === 'postgresql') {
+            requiredPaths.push(`${pkg}/migrations/migration_lock.toml`);
+        }
+    }
+
+    return requiredPaths;
+}
+
+// Configuration
+// Script runs from integration project root (e.g., backend/)
+// and reads Prisma packages from @friggframework/core
+const PROJECT_ROOT = process.cwd();
+const CORE_PACKAGE_PATH = findCorePackage(PROJECT_ROOT);
+const LAYER_OUTPUT_PATH = path.join(PROJECT_ROOT, 'layers/prisma');
+const LAYER_NODE_MODULES = path.join(LAYER_OUTPUT_PATH, 'nodejs/node_modules');
+
+// Binary patterns to remove (non-rhel)
+const BINARY_PATTERNS_TO_REMOVE = [
+    '*darwin*',
+    '*debian*',
+    '*linux-arm*',
+    '*linux-musl*',
+    '*windows*',
+];
+
+// Files to remove for size optimization
+const FILES_TO_REMOVE = [
+    '*.map', // Source maps (37MB savings)
+    '*.md', // Markdown files
+    'LICENSE*', // License files
+    'CHANGELOG*', // Changelog files
+    '*.test.js', // Test files
+    '*.spec.js', // Spec files
+    '*mysql.wasm*', // MySQL WASM files (not needed for PostgreSQL)
+    '*cockroachdb.wasm*', // CockroachDB WASM files
+    '*sqlite.wasm*', // SQLite WASM files
+    '*sqlserver.wasm*', // SQL Server WASM files
+];
+
+// ANSI color codes for output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    red: '\x1b[31m',
+};
+
+function log(message, color = 'reset') {
+    console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function logStep(step, message) {
+    log(`\n[${step}] ${message}`, 'blue');
+}
+
+function logSuccess(message) {
+    log(`✓ ${message}`, 'green');
+}
+
+function logWarning(message) {
+    log(`⚠ ${message}`, 'yellow');
+}
+
+function logError(message) {
+    log(`✗ ${message}`, 'red');
+}
+
+/**
+ * Get directory size in MB
+ */
+function getDirectorySize(dirPath) {
+    try {
+        const output = execSync(`du -sm "${dirPath}"`, { encoding: 'utf8' });
+        const size = parseInt(output.split('\t')[0], 10);
+        return size;
+    } catch (error) {
+        logWarning(`Could not calculate directory size: ${error.message}`);
+        return 0;
+    }
+}
+
+/**
+ * Clean existing layer directory
+ */
+async function cleanLayerDirectory() {
+    logStep(1, 'Cleaning existing layer directory');
+
+    if (await fs.pathExists(LAYER_OUTPUT_PATH)) {
+        await fs.remove(LAYER_OUTPUT_PATH);
+        logSuccess(`Removed existing layer at ${LAYER_OUTPUT_PATH}`);
+    } else {
+        log('No existing layer to clean');
+    }
+}
+
+/**
+ * Create layer directory structure
+ */
+async function createLayerStructure() {
+    logStep(2, 'Creating layer directory structure');
+
+    await fs.ensureDir(LAYER_NODE_MODULES);
+    logSuccess(`Created ${LAYER_NODE_MODULES}`);
+}
+
+/**
+ * Install Prisma client directly into layer (RUNTIME ONLY - NO CLI)
+ *
+ * The Prisma CLI is NOT included in this layer to keep it small.
+ * For migrations, the dbMigrate function has its own separate packaging with CLI.
+ */
+async function installPrismaPackages() {
+    logStep(3, 'Installing Prisma runtime client (CLI excluded)');
+
+    // Create a minimal package.json with ONLY the runtime client
+    const dependencies = {
+        '@prisma/client': '^6.16.3',
+    };
+
+    log('  Runtime client only - CLI excluded (saves ~82MB)', 'green');
+
+    const layerPackageJson = {
+        name: 'prisma-lambda-layer',
+        version: '1.0.0',
+        private: true,
+        dependencies,
+    };
+
+    const packageJsonPath = path.join(LAYER_OUTPUT_PATH, 'nodejs/package.json');
+    await fs.writeJson(packageJsonPath, layerPackageJson, { spaces: 2 });
+    logSuccess('Created layer package.json');
+
+    // Install Prisma packages with Lambda binary target
+    // Setting PRISMA_CLI_BINARY_TARGETS ensures only rhel-openssl-3.0.x binary is downloaded
+    log('Installing @prisma/client for AWS Lambda (rhel-openssl-3.0.x)...');
+    try {
+        const env = {
+            ...process.env,
+            PRISMA_CLI_BINARY_TARGETS: 'rhel-openssl-3.0.x',
+        };
+
+        execSync('npm install --omit=dev --no-package-lock', {
+            cwd: path.join(LAYER_OUTPUT_PATH, 'nodejs'),
+            stdio: 'inherit',
+            env,
+        });
+        logSuccess('Prisma packages installed with Lambda binary target');
+    } catch (error) {
+        throw new Error(`Failed to install Prisma packages: ${error.message}`);
+    }
+}
+
+/**
+ * Copy generated Prisma clients from @friggframework/core to layer
+ * @param {Array} clientPackages - List of generated client packages to copy
+ */
+async function copyPrismaPackages(clientPackages) {
+    logStep(4, 'Copying generated Prisma clients from @friggframework/core');
+
+    // Copy the generated clients from core based on database config
+    // Packages can be in:
+    // 1. Core's own node_modules (if not hoisted)
+    // 2. Project root node_modules (if hoisted from project)
+    // 3. Workspace root node_modules (where core is located - handles hoisting)
+    // 4. Core package itself (for generated/ directories)
+    const workspaceNodeModules = path.join(
+        path.dirname(CORE_PACKAGE_PATH),
+        '..'
+    );
+    const searchPaths = [
+        path.join(CORE_PACKAGE_PATH, 'node_modules'), // Core's own node_modules
+        path.join(PROJECT_ROOT, 'node_modules'), // Project node_modules
+        workspaceNodeModules, // Workspace root node_modules
+        CORE_PACKAGE_PATH, // Core package itself (for generated/)
+    ];
+
+    let copiedCount = 0;
+    let missingPackages = [];
+
+    for (const pkg of clientPackages) {
+        let sourcePath = null;
+
+        // Try to find package in search paths
+        for (const searchPath of searchPaths) {
+            const candidatePath = path.join(searchPath, pkg);
+            if (await fs.pathExists(candidatePath)) {
+                sourcePath = candidatePath;
+                break;
+            }
+        }
+
+        if (sourcePath) {
+            const destPath = path.join(LAYER_NODE_MODULES, pkg);
+            await fs.copy(sourcePath, destPath, {
+                dereference: true, // Follow symlinks
+                filter: (src) => {
+                    // Skip node_modules within Prisma packages
+                    return !src.includes('/node_modules/node_modules/');
+                },
+            });
+            const fromLocation = sourcePath.includes(
+                '@friggframework/core/generated'
+            )
+                ? 'core package (generated)'
+                : sourcePath.includes('@friggframework/core/node_modules')
+                ? 'core node_modules'
+                : 'workspace';
+            logSuccess(`Copied ${pkg} (from ${fromLocation})`);
+            copiedCount++;
+        } else {
+            missingPackages.push(pkg);
+            logWarning(`Package not found: ${pkg}`);
+        }
+    }
+
+    if (missingPackages.length > 0) {
+        throw new Error(
+            `Missing generated Prisma clients: ${missingPackages.join(
+                ', '
+            )}.\n` +
+                'Ensure @friggframework/core has generated Prisma clients (run "npm run prisma:generate" in core package).'
+        );
+    }
+
+    logSuccess(
+        `Copied ${copiedCount} generated client packages from @friggframework/core`
+    );
+}
+
+async function copyMigrations(clientPackages) {
+    logStep(5, 'Copying migrations from @friggframework/core');
+
+    const workspaceNodeModules = path.join(
+        path.dirname(CORE_PACKAGE_PATH),
+        '..'
+    );
+    const searchPaths = [
+        path.join(CORE_PACKAGE_PATH, 'node_modules'),
+        path.join(PROJECT_ROOT, 'node_modules'),
+        workspaceNodeModules,
+        CORE_PACKAGE_PATH,
+    ];
+
+    const migrations = getMigrationsPackages(clientPackages);
+    let copiedCount = 0;
+
+    for (const { dbType, clientPackage } of migrations) {
+        const sourcePath = getMigrationSourcePath(searchPaths, dbType);
+
+        if (sourcePath) {
+            const destPath = getMigrationDestinationPath(
+                LAYER_NODE_MODULES,
+                clientPackage
+            );
+            await fs.copy(sourcePath, destPath, { dereference: true });
+
+            const fromLocation = sourcePath.includes(
+                '@friggframework/core/prisma'
+            )
+                ? 'core package'
+                : 'workspace';
+            logSuccess(
+                `Copied migrations for ${dbType} (from ${fromLocation})`
+            );
+            copiedCount++;
+        } else {
+            logWarning(
+                `Migrations not found for ${dbType} - this may cause migration failures`
+            );
+        }
+    }
+
+    if (copiedCount > 0) {
+        logSuccess(
+            `Copied migrations for ${copiedCount} database ${
+                copiedCount === 1 ? 'type' : 'types'
+            }`
+        );
+    }
+}
+
+/**
+ * Remove unnecessary files to reduce layer size
+ */
+async function removeUnnecessaryFiles() {
+    logStep(6, 'Removing unnecessary files (source maps, docs, tests)');
+
+    let removedCount = 0;
+    let totalSize = 0;
+
+    for (const pattern of FILES_TO_REMOVE) {
+        try {
+            // Find files matching the pattern
+            const findCmd = `find "${LAYER_NODE_MODULES}" -name "${pattern}" -type f 2>/dev/null || true`;
+            const files = execSync(findCmd, { encoding: 'utf8' })
+                .split('\n')
+                .filter((f) => f.trim());
+
+            for (const file of files) {
+                if (await fs.pathExists(file)) {
+                    const stats = await fs.stat(file);
+                    totalSize += stats.size;
+                    await fs.remove(file);
+                    removedCount++;
+                }
+            }
+        } catch (error) {
+            logWarning(`Error removing ${pattern}: ${error.message}`);
+        }
+    }
+
+    if (removedCount > 0) {
+        const sizeMB = (totalSize / (1024 * 1024)).toFixed(2);
+        logSuccess(
+            `Removed ${removedCount} unnecessary files (saved ${sizeMB} MB)`
+        );
+    } else {
+        log('No unnecessary files found to remove');
+    }
+}
+
+/**
+ * Remove non-rhel engine binaries to reduce layer size
+ */
+async function removeNonRhelBinaries() {
+    logStep(7, 'Removing non-rhel engine binaries');
+
+    let removedCount = 0;
+    let totalSize = 0;
+
+    for (const pattern of BINARY_PATTERNS_TO_REMOVE) {
+        try {
+            // Find files matching the pattern
+            const findCmd = `find "${LAYER_NODE_MODULES}" -name "${pattern}" 2>/dev/null || true`;
+            const files = execSync(findCmd, { encoding: 'utf8' })
+                .split('\n')
+                .filter((f) => f.trim());
+
+            for (const file of files) {
+                if (await fs.pathExists(file)) {
+                    const stats = await fs.stat(file);
+                    totalSize += stats.size;
+                    await fs.remove(file);
+                    removedCount++;
+                }
+            }
+        } catch (error) {
+            logWarning(`Error removing ${pattern}: ${error.message}`);
+        }
+    }
+
+    if (removedCount > 0) {
+        const sizeMB = (totalSize / (1024 * 1024)).toFixed(2);
+        logSuccess(
+            `Removed ${removedCount} non-rhel binaries (saved ${sizeMB} MB)`
+        );
+    } else {
+        log('No non-rhel binaries found to remove');
+    }
+}
+
+/**
+ * Verify rhel binaries are present
+ * @param {Array} expectedClients - List of client packages that should have binaries
+ */
+async function verifyRhelBinaries(expectedClients) {
+    logStep(8, 'Verifying rhel-openssl-3.0.x binaries are present');
+
+    try {
+        const findCmd = `find "${LAYER_NODE_MODULES}" -name "*rhel-openssl-3.0.x*" 2>/dev/null || true`;
+        const rhelFiles = execSync(findCmd, { encoding: 'utf8' })
+            .split('\n')
+            .filter((f) => f.trim());
+
+        if (rhelFiles.length === 0) {
+            throw new Error(
+                'No rhel-openssl-3.0.x binaries found!\n' +
+                    'Check that Prisma schemas have binaryTargets = ["native", "rhel-openssl-3.0.x"]'
+            );
+        }
+
+        const expectedCount = expectedClients.length;
+        logSuccess(
+            `Found ${rhelFiles.length} rhel-openssl-3.0.x ${
+                rhelFiles.length === 1 ? 'binary' : 'binaries'
+            } (expected ${expectedCount})`
+        );
+
+        // Show the binaries found
+        rhelFiles.forEach((file) => {
+            const relativePath = path.relative(LAYER_NODE_MODULES, file);
+            log(`  - ${relativePath}`, 'reset');
+        });
+    } catch (error) {
+        throw new Error(`Binary verification failed: ${error.message}`);
+    }
+}
+
+/**
+ * Verify required files exist
+ * Runtime layer should NOT have CLI files
+ * @param {Array} clientPackages - Generated client packages that were included
+ */
+async function verifyLayerStructure(clientPackages) {
+    logStep(9, 'Verifying layer structure (runtime only)');
+
+    // Get required paths based on database types
+    const requiredPaths = getRequiredLayerPaths(clientPackages);
+
+    // Verify CLI is NOT present (keeps layer small)
+    const forbiddenPaths = ['prisma/build', '.bin/prisma'];
+
+    let allPresent = true;
+
+    for (const requiredPath of requiredPaths) {
+        const fullPath = path.join(LAYER_NODE_MODULES, requiredPath);
+        if (await fs.pathExists(fullPath)) {
+            log(`  ✓ ${requiredPath}`, 'green');
+        } else {
+            log(`  ✗ ${requiredPath} (missing)`, 'red');
+            allPresent = false;
+        }
+    }
+
+    if (!allPresent) {
+        throw new Error(
+            'Layer structure verification failed - missing required files'
+        );
+    }
+
+    logSuccess('All required runtime files present');
+
+    // Verify CLI is NOT present
+    for (const forbiddenPath of forbiddenPaths) {
+        const fullPath = path.join(LAYER_NODE_MODULES, forbiddenPath);
+        if (await fs.pathExists(fullPath)) {
+            logWarning(
+                `  ⚠ ${forbiddenPath} found (should be excluded for minimal layer)`
+            );
+        }
+    }
+}
+
+/**
+ * Calculate and display final layer size
+ */
+async function displayLayerSummary() {
+    logStep(10, 'Layer build summary');
+
+    const layerSizeMB = getDirectorySize(LAYER_OUTPUT_PATH);
+
+    log('\n' + '='.repeat(60), 'bright');
+    log('  Prisma Lambda Layer Built Successfully!', 'bright');
+    log('='.repeat(60), 'bright');
+
+    log(`\nLayer location: ${LAYER_OUTPUT_PATH}`, 'blue');
+    log(`Layer size: ~${layerSizeMB} MB`, 'green');
+
+    log('\nPackages included:', 'bright');
+    log('  - @prisma/client (runtime only - ~10-15MB)', 'reset');
+    log('  - generated/prisma-postgresql (PostgreSQL client)', 'reset');
+    log('\nPackages EXCLUDED for minimal size:', 'bright');
+    log('  - prisma CLI (excluded - only in dbMigrate function)', 'yellow');
+    log('  - @prisma/engines (minimal - only rhel binary)', 'yellow');
+
+    log('\nNext steps:', 'bright');
+    log(
+        '  1. Verify layer structure: ls -lah layers/prisma/nodejs/node_modules/',
+        'reset'
+    );
+    log('  2. Deploy to AWS: frigg deploy --stage dev', 'reset');
+    log(
+        '  3. Check function sizes in Lambda console (should be ~45-55MB)',
+        'reset'
+    );
+
+    log('\nSee LAMBDA-LAYER-PRISMA.md for complete documentation.', 'yellow');
+    log('='.repeat(60) + '\n', 'bright');
+}
+
+/**
+ * Main build function
+ * @param {Object} databaseConfig - Database configuration from AppDefinition.database
+ */
+async function buildPrismaLayer(databaseConfig = {}) {
+    const startTime = Date.now();
+
+    log('\n' + '='.repeat(60), 'bright');
+    log('  Building Minimal Prisma Lambda Layer (Runtime Only)', 'bright');
+    log('='.repeat(60) + '\n', 'bright');
+
+    // Log paths
+    log(`Project root: ${PROJECT_ROOT}`, 'reset');
+    log(`Core package: ${CORE_PACKAGE_PATH}`, 'reset');
+    log(`Layer output: ${LAYER_OUTPUT_PATH}\n`, 'reset');
+
+    // Determine which database clients to include
+    const clientPackages = getGeneratedClientPackages(databaseConfig);
+
+    try {
+        await cleanLayerDirectory();
+        await createLayerStructure();
+        await installPrismaPackages(); // Install runtime client only (NO CLI)
+        await copyPrismaPackages(clientPackages); // Copy generated clients from core
+        await copyMigrations(clientPackages); // Copy migrations from core
+        await removeUnnecessaryFiles(); // Remove source maps, docs, tests (37MB+)
+        await removeNonRhelBinaries(); // Remove non-Linux binaries
+        await verifyRhelBinaries(clientPackages); // Verify query engines present
+        await verifyLayerStructure(clientPackages); // Verify minimal runtime structure
+        await displayLayerSummary();
+
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+        log(`Build completed in ${duration}s\n`, 'green');
+
+        return { success: true, duration };
+    } catch (error) {
+        logError(`\nBuild failed: ${error.message}`);
+
+        if (error.stack) {
+            log('\nStack trace:', 'red');
+            console.error(error.stack);
+        }
+
+        log('\nTroubleshooting:', 'yellow');
+        log(
+            '  1. Ensure @friggframework/core has dependencies installed',
+            'reset'
+        );
+        log('  2. Run "npm run prisma:generate" in core package', 'reset');
+        log(
+            '  3. Check that Prisma schemas have correct binaryTargets',
+            'reset'
+        );
+        log('  4. See LAMBDA-LAYER-PRISMA.md for details\n', 'reset');
+
+        // Throw error instead of exit when used as module
+        throw error;
+    }
+}
+
+// Run the build when executed directly
+if (require.main === module) {
+    buildPrismaLayer()
+        .then(() => process.exit(0))
+        .catch(() => process.exit(1));
+}
+
+module.exports = {
+    buildPrismaLayer,
+    getGeneratedClientPackages,
+    getMigrationsPackages,
+    getMigrationSourcePath,
+    getMigrationDestinationPath,
+    getRequiredLayerPaths,
+};