@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/orchestration/openNextBuild.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OpenNext build orchestration for Next.js and Payload applications.
+ *
+ * Resolves `@opennextjs/aws` from the app's own node_modules (not from
+ * deploy-core's dependencies) and runs the build with timeout handling,
+ * stream cleanup, and credential masking.
+ *
+ * For Payload apps, generates the import map before building.
+ */
+import { type Result } from "@fjall/generator";
+import type { DeployCallbacks } from "../types/callbacks.js";
+import type { DeployOptions } from "../types/params.js";
+import type { ApplicationOperation } from "../types/operations.js";
+/** Default build timeout: 10 minutes */
+export declare const BUILD_TIMEOUT_MS = 600000;
+/** Timeout for Payload import map generation: 30 seconds */
+export declare const IMPORT_MAP_TIMEOUT_MS = 30000;
+/**
+ * Run the OpenNext build for a Next.js or Payload application.
+ *
+ * Checks pattern and options internally — returns `success(undefined)`
+ * when build is not needed (wrong pattern, skipBuild, infraOnly).
+ *
+ * Must be called BEFORE the detection pipeline and BEFORE the
+ * `deployOnly` early-return check, so built artefacts are available
+ * for CDK synth.
+ */
+export declare function runOpenNextBuild(operation: ApplicationOperation, pattern: string | null | undefined, callbacks: DeployCallbacks, options?: DeployOptions): Promise<Result<void>>;

package/dist/src/orchestration/openNextBuild.js

@@ -0,0 +1,243 @@
+/**
+ * OpenNext build orchestration for Next.js and Payload applications.
+ *
+ * Resolves `@opennextjs/aws` from the app's own node_modules (not from
+ * deploy-core's dependencies) and runs the build with timeout handling,
+ * stream cleanup, and credential masking.
+ *
+ * For Payload apps, generates the import map before building.
+ */
+import { createRequire } from "module";
+import { existsSync, statSync, rmSync } from "fs";
+import { join } from "path";
+import { success, failure } from "@fjall/generator";
+import { filterDangerousEnvVars, maskSensitiveOutput, parseShellArgs } from "@fjall/util";
+import { logger } from "@fjall/util/logger";
+import { isOpenNextPattern } from "../types/patternDetection.js";
+import { spawnWithTimeout } from "./spawnHelpers.js";
+const OPENNEXT_PACKAGE = "@opennextjs/aws";
+/** Default build timeout: 10 minutes */
+export const BUILD_TIMEOUT_MS = 600_000;
+/** Timeout for Payload import map generation: 30 seconds */
+export const IMPORT_MAP_TIMEOUT_MS = 30_000;
+/**
+ * Resolve the `open-next` binary from the app's own node_modules.
+ *
+ * Uses `createRequire` anchored to the app path so that the binary
+ * comes from the project's dependencies, not deploy-core's.
+ */
+function resolveOpenNextBinary(appPath) {
+    const require = createRequire(join(appPath, "package.json"));
+    let searchPaths;
+    try {
+        searchPaths = require.resolve.paths(OPENNEXT_PACKAGE);
+    }
+    catch (err) {
+        return failure(new Error(`Cannot determine module search paths for ${OPENNEXT_PACKAGE}. ` +
+            `Ensure it is installed in your project. (${err instanceof Error ? err.message : String(err)})`));
+    }
+    if (!searchPaths || searchPaths.length === 0) {
+        return failure(new Error(`Cannot determine module search paths for ${OPENNEXT_PACKAGE}. ` +
+            "Ensure it is installed in your project."));
+    }
+    for (const nodeModulesPath of searchPaths) {
+        const packageDir = join(nodeModulesPath, "@opennextjs", "aws");
+        try {
+            const stat = statSync(packageDir);
+            if (stat.isDirectory()) {
+                const binPath = join(nodeModulesPath, ".bin", "open-next");
+                if (!existsSync(binPath)) {
+                    logger.debug("openNextBuild", "Package found but binary missing", {
+                        nodeModulesPath,
+                        binPath
+                    });
+                    continue;
+                }
+                logger.debug("openNextBuild", "Resolved OpenNext binary", {
+                    binPath
+                });
+                return success(binPath);
+            }
+        }
+        catch (err) {
+            logger.debug("openNextBuild", "Package not at location", {
+                nodeModulesPath,
+                error: String(err)
+            });
+        }
+    }
+    return failure(new Error(`Cannot find ${OPENNEXT_PACKAGE} package. ` +
+        `Ensure it is installed in your project: npm install ${OPENNEXT_PACKAGE}`));
+}
+/**
+ * Clean up the `.open-next/` directory on build failure to prevent
+ * stale artefacts from being used by a subsequent CDK synth.
+ */
+function cleanupOpenNextOutput(appPath) {
+    const openNextDir = join(appPath, ".open-next");
+    if (existsSync(openNextDir)) {
+        try {
+            rmSync(openNextDir, { recursive: true, force: true });
+            logger.debug("openNextBuild", "Cleaned up stale .open-next directory", {
+                path: openNextDir
+            });
+        }
+        catch (err) {
+            logger.debug("openNextBuild", "Failed to clean up .open-next", {
+                error: String(err)
+            });
+        }
+    }
+}
+/**
+ * Handle the common error cases (timeout, enoent, spawn_error) from spawnWithTimeout.
+ * Returns a failure Result for error cases, or undefined if the result is "success".
+ */
+function handleSpawnError(result, labels, onCleanup, onError) {
+    switch (result.type) {
+        case "timeout": {
+            onCleanup?.();
+            onError?.(labels.timeoutMsg);
+            return failure(new Error(labels.timeoutMsg));
+        }
+        case "enoent": {
+            onCleanup?.();
+            onError?.(labels.enoentMsg);
+            return failure(new Error(labels.enoentMsg));
+        }
+        case "spawn_error": {
+            const msg = `${labels.spawnErrorPrefix}: ${result.error.message}`;
+            onCleanup?.();
+            onError?.(msg);
+            return failure(new Error(msg));
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Generate the Payload CMS import map before running the OpenNext build.
+ */
+async function generatePayloadImportMap(appPath, callbacks) {
+    callbacks.onOpenNextProgress?.(maskSensitiveOutput("Generating Payload import map..."));
+    const [cmd, ...args] = parseShellArgs("npx payload generate:importmap");
+    const safeEnv = filterDangerousEnvVars(globalThis.process.env);
+    const result = await spawnWithTimeout({
+        command: cmd,
+        args,
+        cwd: appPath,
+        env: { ...safeEnv, FORCE_COLOR: "0" },
+        timeout: IMPORT_MAP_TIMEOUT_MS,
+        onStdoutData: (output) => {
+            callbacks.onOpenNextProgress?.(maskSensitiveOutput(output.trim()));
+        }
+    });
+    const spawnError = handleSpawnError(result, {
+        timeoutMsg: `Payload import map generation timed out after ${IMPORT_MAP_TIMEOUT_MS / 1000} seconds`,
+        enoentMsg: "Payload CLI not found. Ensure payload is installed: npm install payload",
+        spawnErrorPrefix: "Failed to generate Payload import map"
+    });
+    if (spawnError)
+        return spawnError;
+    if (result.type !== "success")
+        return failure(new Error("Unexpected spawn result"));
+    if (result.code !== 0) {
+        const maskedOutput = maskSensitiveOutput(result.stderr || result.stdout);
+        return failure(new Error(`Payload import map generation failed (exit code ${result.code}):\n${maskedOutput}`));
+    }
+    logger.debug("openNextBuild", "Payload import map generated", { appPath });
+    callbacks.onOpenNextProgress?.(maskSensitiveOutput("Payload import map generated"));
+    return success(undefined);
+}
+/**
+ * Run the OpenNext build for a Next.js or Payload application.
+ *
+ * Checks pattern and options internally — returns `success(undefined)`
+ * when build is not needed (wrong pattern, skipBuild, infraOnly).
+ *
+ * Must be called BEFORE the detection pipeline and BEFORE the
+ * `deployOnly` early-return check, so built artefacts are available
+ * for CDK synth.
+ */
+export async function runOpenNextBuild(operation, pattern, callbacks, options) {
+    // Guard: skip if not an OpenNext pattern
+    if (!isOpenNextPattern(pattern)) {
+        return success(undefined);
+    }
+    // Guard: skip if build explicitly disabled
+    if (options?.skipBuild || options?.infraOnly) {
+        logger.debug("openNextBuild", "Build skipped", {
+            skipBuild: options?.skipBuild,
+            infraOnly: options?.infraOnly
+        });
+        callbacks.onLog?.(options?.infraOnly
+            ? "Infrastructure-only mode — skipping OpenNext build"
+            : "Build skipped (--skip-build)", "info");
+        return success(undefined);
+    }
+    const appPath = operation.path;
+    // For Payload apps, generate import map first
+    if (pattern === "payload") {
+        const importMapResult = await generatePayloadImportMap(appPath, callbacks);
+        if (!importMapResult.success) {
+            callbacks.onOpenNextBuildError?.(importMapResult.error.message);
+            cleanupOpenNextOutput(appPath);
+            return failure(importMapResult.error);
+        }
+    }
+    // Resolve OpenNext binary from the app's node_modules
+    const binaryResult = resolveOpenNextBinary(appPath);
+    if (!binaryResult.success) {
+        callbacks.onOpenNextBuildError?.(binaryResult.error.message);
+        return failure(binaryResult.error);
+    }
+    const openNextBinary = binaryResult.data;
+    // Start build
+    callbacks.onOpenNextBuildStart?.();
+    callbacks.onOpenNextProgress?.(maskSensitiveOutput("Starting OpenNext build..."));
+    const safeEnv = filterDangerousEnvVars(globalThis.process.env);
+    const projectNodeModules = join(appPath, "node_modules");
+    const result = await spawnWithTimeout({
+        command: openNextBinary,
+        args: ["build"],
+        cwd: appPath,
+        env: {
+            ...safeEnv,
+            FORCE_COLOR: "0",
+            NODE_PATH: projectNodeModules,
+            npm_config_loglevel: "error",
+            PNPM_HOME: safeEnv.PNPM_HOME || ""
+        },
+        timeout: BUILD_TIMEOUT_MS,
+        onStdoutData: (output) => {
+            callbacks.onOpenNextProgress?.(maskSensitiveOutput(output.trim()));
+        },
+        onStderrData: (output) => {
+            callbacks.onOpenNextProgress?.(maskSensitiveOutput(output.trim()));
+        }
+    });
+    const spawnError = handleSpawnError(result, {
+        timeoutMsg: `OpenNext build timed out after ${BUILD_TIMEOUT_MS / 1000} seconds`,
+        enoentMsg: "OpenNext binary not found. Ensure Node.js is installed and in PATH.",
+        spawnErrorPrefix: "Failed to spawn OpenNext build"
+    }, () => cleanupOpenNextOutput(appPath), (msg) => callbacks.onOpenNextBuildError?.(msg));
+    if (spawnError)
+        return spawnError;
+    if (result.type !== "success")
+        return failure(new Error("Unexpected spawn result"));
+    if (result.code !== 0) {
+        cleanupOpenNextOutput(appPath);
+        const maskedOutput = maskSensitiveOutput(result.stderr || result.stdout);
+        callbacks.onOpenNextBuildError?.(`OpenNext build failed (exit code ${result.code})`);
+        return failure(new Error(`OpenNext build failed (exit code ${result.code}):\n${maskedOutput}`));
+    }
+    // Verify .open-next directory was created
+    const openNextDir = join(appPath, ".open-next");
+    if (!existsSync(openNextDir)) {
+        callbacks.onOpenNextBuildError?.("OpenNext build completed but .open-next directory not found");
+        return failure(new Error("OpenNext build completed but .open-next directory not found"));
+    }
+    callbacks.onOpenNextBuildComplete?.();
+    callbacks.onOpenNextProgress?.(maskSensitiveOutput("OpenNext build completed successfully"));
+    return success(undefined);
+}