@friggframework/devtools 2.0.0--canary.463.62579dd.0 → 2.0.0--canary.461.ec909cf.0

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

@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+
+/**
+ * Build Prisma Lambda Layer
+ *
+ * Creates a Lambda Layer containing Prisma packages and rhel-openssl-3.0.x binaries.
+ * This reduces individual Lambda function sizes by ~60% (120MB → 45MB).
+ *
+ * The layer is configured based on AppDefinition database settings:
+ * - PostgreSQL: Includes PostgreSQL client + query engine
+ * - MongoDB: Includes MongoDB client + query engine (if needed)
+ * - Defaults to PostgreSQL only if not specified
+ *
+ * Usage:
+ *   node scripts/build-prisma-layer.js [--mongodb] [--postgresql]
+ *   npm run build:prisma-layer
+ *
+ * Output:
+ *   layers/prisma/nodejs/node_modules/
+ *   ├── @prisma/client
+ *   ├── @prisma/engines
+ *   ├── generated/prisma-postgresql (if PostgreSQL enabled)
+ *   ├── generated/prisma-mongodb (if MongoDB enabled)
+ *   └── prisma (CLI for 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
+    const mongoEnabled = databaseConfig?.mongodb?.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;
+}
+
+// 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
+];
+
+// 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 CLI and client directly into layer
+ * @param {Boolean} includeCLI - Whether to include Prisma CLI (needed for migrations)
+ */
+async function installPrismaPackages(includeCLI = false) {
+    logStep(3, `Installing Prisma packages (${includeCLI ? 'with CLI' : 'runtime only'})`);
+
+    // Create a minimal package.json in the layer
+    const dependencies = {
+        '@prisma/client': '^6.16.3',
+        '@prisma/engines': '^6.16.3',
+    };
+
+    // Only include CLI if needed (saves 50MB + 32MB effect dependency)
+    if (includeCLI) {
+        dependencies['prisma'] = '^6.16.3';
+        log('  Including Prisma CLI for migrations', 'yellow');
+    } else {
+        log('  Runtime 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
+    log('Installing prisma and @prisma/client...');
+    try {
+        execSync('npm install --production --no-package-lock', {
+            cwd: path.join(LAYER_OUTPUT_PATH, 'nodejs'),
+            stdio: 'inherit'
+        });
+        logSuccess('Prisma packages installed');
+    } 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`);
+}
+
+/**
+ * Remove unnecessary files to reduce layer size
+ */
+async function removeUnnecessaryFiles() {
+    logStep(5, '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(6, '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(7, '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
+ * @param {Boolean} includeCLI - Whether CLI files should be present
+ */
+async function verifyLayerStructure(includeCLI) {
+    logStep(8, 'Verifying layer structure');
+
+    const requiredPaths = [
+        '@prisma/client/runtime',
+        '@prisma/client/index.d.ts',
+        '@prisma/engines',
+        'generated/prisma-postgresql/schema.prisma',  // PostgreSQL
+    ];
+
+    // Only check for CLI files if CLI was included
+    if (includeCLI) {
+        requiredPaths.push('prisma/build');
+        requiredPaths.push('.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 files present');
+}
+
+/**
+ * Calculate and display final layer size
+ */
+async function displayLayerSummary() {
+    logStep(9, '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 (CLI - installed)', 'reset');
+    log('  - @prisma/client (runtime - installed)', 'reset');
+    log('  - @prisma/engines (binaries - installed)', 'reset');
+    log('  - generated/prisma-postgresql (PostgreSQL only)', 'reset');
+    log('\nNote: MongoDB support excluded (not used in this project)', '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
+ * @param {Boolean} includeCLI - Whether to include Prisma CLI (false = runtime only)
+ */
+async function buildPrismaLayer(databaseConfig = {}, includeCLI = false) {
+    const startTime = Date.now();
+
+    log('\n' + '='.repeat(60), 'bright');
+    log(`  Building Prisma Lambda Layer ${includeCLI ? '(with CLI)' : '(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(includeCLI);    // Install Prisma packages (CLI optional)
+        await copyPrismaPackages(clientPackages);   // Copy generated clients 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(includeCLI);     // Verify structure (conditional on CLI)
+        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 };