firebase-tools 12.2.1 → 12.3.1

package/lib/frameworks/compose/driver/docker.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerDriver = exports.DockerfileBuilder = void 0;
+const fs = require("node:fs");
+const path = require("node:path");
+const spawn = require("cross-spawn");
+const hooks_1 = require("./hooks");
+const ADAPTER_SCRIPTS_PATH = "./.firebase/adapters";
+const DOCKER_STAGE_INSTALL = "installer";
+const DOCKER_STAGE_BUILD = "builder";
+class DockerfileBuilder {
+    constructor() {
+        this.dockerfile = "";
+        this.lastStage = "";
+    }
+    from(image, name) {
+        this.dockerfile += `FROM ${image}`;
+        if (name) {
+            this.dockerfile += ` AS ${name}`;
+            this.lastStage = name;
+        }
+        this.dockerfile += "\n";
+        return this;
+    }
+    fromLastStage(name) {
+        return this.from(this.lastStage, name);
+    }
+    tempFrom(image, name) {
+        this.dockerfile += `FROM ${image}`;
+        if (name) {
+            this.dockerfile += ` AS ${name}`;
+        }
+        this.dockerfile += "\n";
+        return this;
+    }
+    workdir(dir) {
+        this.dockerfile += `WORKDIR ${dir}\n`;
+        return this;
+    }
+    copyForFirebase(src, dest, from) {
+        if (from) {
+            this.dockerfile += `COPY --chown=firebase:firebase --from=${from} ${src} ${dest}\n`;
+        }
+        else {
+            this.dockerfile += `COPY --chown=firebase:firebase ${src} ${dest}\n`;
+        }
+        return this;
+    }
+    copyFrom(src, dest, from) {
+        this.dockerfile += `COPY --from=${from} ${src} ${dest}\n`;
+        return this;
+    }
+    run(cmd, mount) {
+        if (mount) {
+            this.dockerfile += `RUN --mount=${mount} ${cmd}\n`;
+        }
+        else {
+            this.dockerfile += `RUN ${cmd}\n`;
+        }
+        return this;
+    }
+    env(key, value) {
+        this.dockerfile += `ENV ${key}="${value}"\n`;
+        return this;
+    }
+    envs(envs) {
+        for (const [key, value] of Object.entries(envs)) {
+            this.env(key, value);
+        }
+        return this;
+    }
+    cmd(cmds) {
+        this.dockerfile += `CMD [${cmds.map((c) => `"${c}"`).join(", ")}]\n`;
+        return this;
+    }
+    user(user) {
+        this.dockerfile += `USER ${user}\n`;
+        return this;
+    }
+    toString() {
+        return this.dockerfile;
+    }
+}
+exports.DockerfileBuilder = DockerfileBuilder;
+class DockerDriver {
+    constructor(spec) {
+        this.spec = spec;
+        this.dockerfileBuilder = new DockerfileBuilder();
+        this.dockerfileBuilder.from(spec.baseImage, "base").user("firebase");
+    }
+    execDockerPush(args) {
+        console.log(`executing docker build: ${args.join(" ")}`);
+        return spawn.sync("docker", ["push", ...args], {
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+    }
+    execDockerBuild(args, contextDir) {
+        console.log(`executing docker build: ${args.join(" ")} ${contextDir}`);
+        console.log(this.dockerfileBuilder.toString());
+        return spawn.sync("docker", ["buildx", "build", ...args, "-f", "-", contextDir], {
+            env: Object.assign(Object.assign({}, process.env), this.spec.environmentVariables),
+            input: this.dockerfileBuilder.toString(),
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+    }
+    buildStage(stage, contextDir, tag) {
+        console.log(`Building stage: ${stage}`);
+        const args = ["--target", stage];
+        if (tag) {
+            args.push("--tag", tag);
+        }
+        const ret = this.execDockerBuild(args, contextDir);
+        if (ret.error || ret.status !== 0) {
+            throw new Error(`Failed to execute stage ${stage}: error=${ret.error} status=${ret.status}`);
+        }
+    }
+    exportBundle(stage, contextDir) {
+        const exportStage = `${stage}-export`;
+        this.dockerfileBuilder
+            .tempFrom("scratch", exportStage)
+            .copyFrom(hooks_1.BUNDLE_PATH, "/bundle.json", stage);
+        const ret = this.execDockerBuild(["--target", exportStage, "--output", ".firebase/.output"], contextDir);
+        if (ret.error || ret.status !== 0) {
+            throw new Error(`Failed to export bundle ${stage}: error=${ret.error} status=${ret.status}`);
+        }
+        return JSON.parse(fs.readFileSync("./.firebase/.output/bundle.json", "utf8"));
+    }
+    install() {
+        this.dockerfileBuilder
+            .fromLastStage(DOCKER_STAGE_INSTALL)
+            .workdir("/home/firebase/app")
+            .envs(this.spec.environmentVariables || {})
+            .copyForFirebase("package.json", ".")
+            .run(this.spec.installCommand);
+        this.buildStage(DOCKER_STAGE_INSTALL, ".");
+    }
+    build() {
+        this.dockerfileBuilder
+            .fromLastStage(DOCKER_STAGE_BUILD)
+            .copyForFirebase(".", ".")
+            .run(this.spec.buildCommand);
+        this.buildStage(DOCKER_STAGE_BUILD, ".");
+    }
+    export(bundle) {
+        var _a;
+        const startCmd = (_a = bundle.server) === null || _a === void 0 ? void 0 : _a.start.cmd;
+        if (startCmd) {
+            const exportStage = "exporter";
+            this.dockerfileBuilder
+                .from(this.spec.baseImage, exportStage)
+                .workdir("/home/firebase/app")
+                .copyForFirebase("/home/firebase/app", ".", DOCKER_STAGE_BUILD)
+                .cmd(startCmd);
+            const imageName = `us-docker.pkg.dev/${process.env.PROJECT_ID}/test/demo-nodappe`;
+            this.buildStage(exportStage, ".", imageName);
+            const ret = this.execDockerPush([imageName]);
+            if (ret.error || ret.status !== 0) {
+                throw new Error(`Failed to push image ${imageName}: error=${ret.error} status=${ret.status}`);
+            }
+        }
+    }
+    execHook(bundle, hook) {
+        const hookScript = `hook-${Date.now()}.js`;
+        const hookScriptSrc = (0, hooks_1.genHookScript)(bundle, hook);
+        if (!fs.existsSync(ADAPTER_SCRIPTS_PATH)) {
+            fs.mkdirSync(ADAPTER_SCRIPTS_PATH, { recursive: true });
+        }
+        fs.writeFileSync(path.join(ADAPTER_SCRIPTS_PATH, hookScript), hookScriptSrc);
+        const hookStage = path.basename(hookScript, ".js");
+        this.dockerfileBuilder
+            .fromLastStage(hookStage)
+            .run(`NODE_PATH=./node_modules node /framework/adapters/${hookScript}`, `source=${ADAPTER_SCRIPTS_PATH},target=/framework/adapters`);
+        this.buildStage(hookStage, ".");
+        return this.exportBundle(hookStage, ".");
+    }
+}
+exports.DockerDriver = DockerDriver;

package/lib/frameworks/compose/driver/hooks.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genHookScript = exports.BUNDLE_PATH = void 0;
+exports.BUNDLE_PATH = "/home/firebase/app/.firebase/.output/bundle.json";
+function genHookScript(bundle, hook) {
+    let hookSrc = hook.toString().trimLeft();
+    if (!hookSrc.startsWith("(") && !hookSrc.startsWith("function ")) {
+        hookSrc = `function ${hookSrc}`;
+    }
+    return `
+const fs = require("node:fs");
+const path = require("node:path");
+
+const bundleDir = path.dirname("${exports.BUNDLE_PATH}");
+if (!fs.existsSync(bundleDir)) {
+  fs.mkdirSync(bundleDir, { recursive: true });
+}
+const bundle = (${hookSrc})(${JSON.stringify(bundle)});
+fs.writeFileSync("${exports.BUNDLE_PATH}", JSON.stringify(bundle));
+`;
+}
+exports.genHookScript = genHookScript;

package/lib/frameworks/compose/driver/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDriver = exports.SUPPORTED_MODES = void 0;
+const local_1 = require("./local");
+const docker_1 = require("./docker");
+exports.SUPPORTED_MODES = ["local", "docker"];
+function getDriver(mode, app) {
+    if (mode === "local") {
+        return new local_1.LocalDriver(app);
+    }
+    else if (mode === "docker") {
+        return new docker_1.DockerDriver(app);
+    }
+    throw new Error(`Unsupported mode ${mode}`);
+}
+exports.getDriver = getDriver;

package/lib/frameworks/compose/driver/local.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalDriver = void 0;
+const fs = require("node:fs");
+const spawn = require("cross-spawn");
+const hooks_1 = require("./hooks");
+class LocalDriver {
+    constructor(spec) {
+        this.spec = spec;
+    }
+    execCmd(cmd, args) {
+        const ret = spawn.sync(cmd, args, {
+            env: Object.assign(Object.assign({}, process.env), this.spec.environmentVariables),
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+        if (ret.error) {
+            throw ret.error;
+        }
+    }
+    install() {
+        const [cmd, ...args] = this.spec.installCommand.split(" ");
+        this.execCmd(cmd, args);
+    }
+    build() {
+        const [cmd, ...args] = this.spec.buildCommand.split(" ");
+        this.execCmd(cmd, args);
+    }
+    export(bundle) {
+    }
+    execHook(bundle, hook) {
+        const script = (0, hooks_1.genHookScript)(bundle, hook);
+        this.execCmd("node", ["-e", script]);
+        if (!fs.existsSync(hooks_1.BUNDLE_PATH)) {
+            console.warn(`Expected hook to generate app bundle at ${hooks_1.BUNDLE_PATH} but got nothing.`);
+            console.warn("Returning original bundle.");
+            return bundle;
+        }
+        const newBundle = JSON.parse(fs.readFileSync(hooks_1.BUNDLE_PATH, "utf8"));
+        return newBundle;
+    }
+}
+exports.LocalDriver = LocalDriver;

package/lib/frameworks/compose/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const driver_1 = require("./driver");
+const discover_1 = require("./discover");
+function compose(mode) {
+    let bundle = { version: "v1alpha" };
+    const spec = (0, discover_1.discover)();
+    const driver = (0, driver_1.getDriver)(mode, spec);
+    if (spec.startCommand) {
+        bundle.server = {
+            start: {
+                cmd: spec.startCommand.split(" "),
+            },
+        };
+    }
+    driver.install();
+    if (spec.afterInstall) {
+        bundle = driver.execHook(bundle, spec.afterInstall);
+    }
+    driver.build();
+    if (spec.afterBuild) {
+        bundle = driver.execHook(bundle, spec.afterBuild);
+    }
+    if (bundle.server) {
+        driver.export(bundle);
+    }
+    return bundle;
+}
+exports.compose = compose;

package/lib/frameworks/compose/interfaces.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driver = void 0;
+class Driver {
+    constructor(spec) {
+        this.spec = spec;
+    }
+    install() {
+        throw new Error("install() not implemented");
+    }
+    build() {
+        throw new Error("build() not implemented");
+    }
+    export(bundle) {
+        throw new Error("export() not implemented");
+    }
+    execHook(bundle, hook) {
+        throw new Error("execHook() not implemented");
+    }
+}
+exports.Driver = Driver;

package/lib/frameworks/index.js

@@ -8,7 +8,6 @@ const cross_spawn_1 = require("cross-spawn");
 const promises_1 = require("fs/promises");
 const fs_extra_1 = require("fs-extra");
 const process = require("node:process");
-const semver = require("semver");
 const glob = require("glob");
 const projectUtils_1 = require("../projectUtils");
 const config_1 = require("../hosting/config");
@@ -30,6 +29,8 @@ Object.defineProperty(exports, "WebFrameworks", { enumerable: true, get: functio
 const utils_2 = require("../utils");
 const ensureTargeted_1 = require("../functions/ensureTargeted");
 const util_1 = require("util");
+const projectPath_1 = require("../projectPath");
+const logger_1 = require("../logger");
 async function discover(dir, warn = true) {
     const allFrameworkTypes = [
         ...new Set(Object.values(constants_2.WebFrameworks).map(({ type }) => type)),
@@ -71,21 +72,17 @@ function memoizeBuild(dir, build, deps, target) {
     BUILD_MEMO.set(key, value);
     return value;
 }
-async function prepareFrameworks(targetNames, context, options, emulators = []) {
-    var _a, _b, _c, _d, _e;
-    var _f, _g, _h, _j, _k;
-    const nodeVersion = process.version;
-    if (!semver.satisfies(nodeVersion, ">=16.0.0")) {
-        throw new error_1.FirebaseError(`The frameworks awareness feature requires Node.JS >= 16 and npm >= 8 in order to work correctly, due to some of the downstream dependencies. Please upgrade your version of Node.JS, reinstall firebase-tools, and give it another go.`);
-    }
-    const project = (0, projectUtils_1.needProjectId)(context);
-    const { projectRoot } = options;
+async function prepareFrameworks(purpose, targetNames, context, options, emulators = []) {
+    var _a, _b, _c, _d, _e, _f;
+    var _g, _h, _j, _k, _l;
+    const project = (0, projectUtils_1.needProjectId)(context || options);
+    const projectRoot = (0, projectPath_1.resolveProjectPath)(options, ".");
     const account = (0, auth_1.getProjectDefaultAccount)(projectRoot);
     if (!options.site) {
         try {
             await (0, requireHostingSite_1.requireHostingSite)(options);
         }
-        catch (_l) {
+        catch (_m) {
             options.site = project;
         }
     }
@@ -189,13 +186,17 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
         }
         const { framework, mayWantBackend, publicDirectory } = results;
         const { build, ɵcodegenPublicDirectory, ɵcodegenFunctionsDirectory: codegenProdModeFunctionsDirectory, getDevModeHandle, name, support, docsUrl, getValidBuildTargets = constants_2.GET_DEFAULT_BUILD_TARGETS, shouldUseDevModeHandle = constants_2.DEFAULT_SHOULD_USE_DEV_MODE_HANDLE, } = constants_2.WebFrameworks[framework];
-        console.log(`\n${(0, utils_1.frameworksCallToAction)(constants_2.SupportLevelWarnings[support](name), docsUrl, "   ")}\n`);
+        logger_1.logger.info(`\n${(0, utils_1.frameworksCallToAction)(constants_2.SupportLevelWarnings[support](name), docsUrl, "   ")}\n`);
         const hostingEmulatorInfo = emulators.find((e) => e.name === types_1.Emulators.HOSTING);
-        const buildTargetPurpose = context._name === "deploy" ? "deploy" : context._name === "emulators:exec" ? "test" : "serve";
-        const validBuildTargets = await getValidBuildTargets(buildTargetPurpose, getProjectPath());
-        const frameworksBuildTarget = (0, utils_1.getFrameworksBuildTarget)(buildTargetPurpose, validBuildTargets);
-        const useDevModeHandle = await shouldUseDevModeHandle(frameworksBuildTarget, getProjectPath());
+        const validBuildTargets = await getValidBuildTargets(purpose, getProjectPath());
+        const frameworksBuildTarget = (0, utils_1.getFrameworksBuildTarget)(purpose, validBuildTargets);
+        const useDevModeHandle = purpose !== "deploy" &&
+            (await shouldUseDevModeHandle(frameworksBuildTarget, getProjectPath()));
         let codegenFunctionsDirectory;
+        let baseUrl = "";
+        const rewrites = [];
+        const redirects = [];
+        const headers = [];
         const devModeHandle = useDevModeHandle &&
             getDevModeHandle &&
             (await getDevModeHandle(getProjectPath(), frameworksBuildTarget, hostingEmulatorInfo));
@@ -208,13 +209,19 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
         }
         else {
             const buildResult = await memoizeBuild(getProjectPath(), build, [firebaseDefaults, frameworksBuildTarget], frameworksBuildTarget);
-            const { wantsBackend = false, rewrites = [], redirects = [], headers = [], trailingSlash, i18n = false, } = buildResult || {};
-            config.rewrites.push(...rewrites);
-            config.redirects.push(...redirects);
-            config.headers.push(...headers);
-            (_d = config.trailingSlash) !== null && _d !== void 0 ? _d : (config.trailingSlash = trailingSlash);
+            const { wantsBackend = false, trailingSlash, i18n = false } = buildResult || {};
+            if (buildResult) {
+                baseUrl = (_d = buildResult.baseUrl) !== null && _d !== void 0 ? _d : baseUrl;
+                if (buildResult.headers)
+                    headers.push(...buildResult.headers);
+                if (buildResult.rewrites)
+                    rewrites.push(...buildResult.rewrites);
+                if (buildResult.redirects)
+                    redirects.push(...buildResult.redirects);
+            }
+            (_e = config.trailingSlash) !== null && _e !== void 0 ? _e : (config.trailingSlash = trailingSlash);
             if (i18n)
-                (_e = config.i18n) !== null && _e !== void 0 ? _e : (config.i18n = { root: constants_2.I18N_ROOT });
+                (_f = config.i18n) !== null && _f !== void 0 ? _f : (config.i18n = { root: constants_2.I18N_ROOT });
             if (await (0, fs_extra_1.pathExists)(hostingDist))
                 await (0, promises_1.rm)(hostingDist, { recursive: true });
             await (0, fs_extra_1.mkdirp)(hostingDist);
@@ -232,7 +239,7 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
                 firebaseDefaults._authTokenSyncURL = "/__session";
                 process.env.__FIREBASE_DEFAULTS__ = JSON.stringify(firebaseDefaults);
             }
-            if (context.hostingChannel) {
+            if (context === null || context === void 0 ? void 0 : context.hostingChannel) {
                 experiments.assertEnabled("pintags", "deploy an app that requires a backend to a preview channel");
             }
             const codebase = `firebase-frameworks-${site}`;
@@ -246,10 +253,7 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
                     codebase,
                 },
             ]);
-            if (!experiments.isEnabled("pintags") ||
-                context._name === "serve" ||
-                context._name === "emulators:start" ||
-                context._name === "emulators:exec") {
+            if (!experiments.isEnabled("pintags") || purpose !== "deploy") {
                 if (!targetNames.includes("functions")) {
                     targetNames.unshift("functions");
                 }
@@ -273,38 +277,41 @@ async function prepareFrameworks(targetNames, context, options, emulators = [])
             else {
                 await (0, fs_extra_1.mkdirp)(functionsDist);
             }
-            const { packageJson, bootstrapScript, frameworksEntry = framework, baseUrl = "", dotEnv = {}, rewriteSource = path_1.posix.join(baseUrl, "**"), } = await codegenFunctionsDirectory(getProjectPath(), functionsDist, frameworksBuildTarget);
-            config.rewrites = [
-                {
-                    source: rewriteSource,
-                    function: {
-                        functionId,
-                        region: ssrRegion,
-                        pinTag: experiments.isEnabled("pintags"),
-                    },
+            const { packageJson, bootstrapScript, frameworksEntry = framework, dotEnv = {}, rewriteSource, } = await codegenFunctionsDirectory(getProjectPath(), functionsDist, frameworksBuildTarget);
+            const rewrite = {
+                source: rewriteSource || path_1.posix.join(baseUrl, "**"),
+                function: {
+                    functionId,
+                    region: ssrRegion,
+                    pinTag: experiments.isEnabled("pintags"),
                 },
-                ...config.rewrites,
-            ];
+            };
+            if (rewriteSource) {
+                config.rewrites.unshift(rewrite);
+            }
+            else {
+                rewrites.push(rewrite);
+            }
             process.env.__FIREBASE_FRAMEWORKS_ENTRY__ = frameworksEntry;
             packageJson.main = "server.js";
             packageJson.dependencies || (packageJson.dependencies = {});
-            (_f = packageJson.dependencies)["firebase-frameworks"] || (_f["firebase-frameworks"] = constants_2.FIREBASE_FRAMEWORKS_VERSION);
-            (_g = packageJson.dependencies)["firebase-functions"] || (_g["firebase-functions"] = constants_2.FIREBASE_FUNCTIONS_VERSION);
-            (_h = packageJson.dependencies)["firebase-admin"] || (_h["firebase-admin"] = constants_2.FIREBASE_ADMIN_VERSION);
+            (_g = packageJson.dependencies)["firebase-frameworks"] || (_g["firebase-frameworks"] = constants_2.FIREBASE_FRAMEWORKS_VERSION);
+            (_h = packageJson.dependencies)["firebase-functions"] || (_h["firebase-functions"] = constants_2.FIREBASE_FUNCTIONS_VERSION);
+            (_j = packageJson.dependencies)["firebase-admin"] || (_j["firebase-admin"] = constants_2.FIREBASE_ADMIN_VERSION);
             packageJson.engines || (packageJson.engines = {});
             const validEngines = constants_2.VALID_ENGINES.node.filter((it) => it <= constants_2.NODE_VERSION);
             const engine = validEngines[validEngines.length - 1] || constants_2.VALID_ENGINES.node[0];
             if (engine !== constants_2.NODE_VERSION) {
                 (0, utils_2.logWarning)(`This integration expects Node version ${(0, utils_1.conjoinOptions)(constants_2.VALID_ENGINES.node, "or")}. You're running version ${constants_2.NODE_VERSION}, problems may be encountered.`);
             }
-            (_j = packageJson.engines).node || (_j.node = engine.toString());
+            (_k = packageJson.engines).node || (_k.node = engine.toString());
             delete packageJson.scripts;
             delete packageJson.devDependencies;
             const bundledDependencies = packageJson.bundledDependencies || {};
             if (Object.keys(bundledDependencies).length) {
                 (0, utils_2.logWarning)("Bundled dependencies aren't supported in Cloud Functions, converting to dependencies.");
                 for (const [dep, version] of Object.entries(bundledDependencies)) {
-                    (_k = packageJson.dependencies)[dep] || (_k[dep] = version);
+                    (_l = packageJson.dependencies)[dep] || (_l[dep] = version);
                 }
                 delete packageJson.bundledDependencies;
             }
@@ -376,13 +383,18 @@ ${firebaseDefaults ? `__FIREBASE_DEFAULTS__=${JSON.stringify(firebaseDefaults)}\
                 await (0, promises_1.rm)(functionsDist, { recursive: true });
             }
         }
+        const ourConfigShouldComeFirst = !["", "/"].includes(baseUrl);
+        const operation = ourConfigShouldComeFirst ? "unshift" : "push";
+        config.rewrites[operation](...rewrites);
+        config.redirects[operation](...redirects);
+        config.headers[operation](...headers);
         if (firebaseDefaults) {
             const encodedDefaults = Buffer.from(JSON.stringify(firebaseDefaults)).toString("base64url");
             const expires = new Date(new Date().getTime() + 60000000000);
             const sameSite = "Strict";
             const path = `/`;
             config.headers.push({
-                source: "**/*.[jt]s",
+                source: path_1.posix.join(baseUrl, "**", "*.[jt]s"),
                 headers: [
                     {
                         key: "Set-Cookie",
@@ -392,10 +404,7 @@ ${firebaseDefaults ? `__FIREBASE_DEFAULTS__=${JSON.stringify(firebaseDefaults)}\
             });
         }
     }
-    if (process.env.DEBUG) {
-        console.log("Effective firebase.json:");
-        console.log(JSON.stringify(configs, undefined, 2));
-    }
+    logger_1.logger.debug("[web frameworks] effective firebase.json: ", JSON.stringify({ hosting: configs, functions: options.config.get("functions") }, undefined, 2));
     BUILD_MEMO.clear();
     delete process.env.__FIREBASE_DEFAULTS__;
     delete process.env.__FIREBASE_FRAMEWORKS_ENTRY__;

package/lib/frameworks/next/index.js

@@ -22,6 +22,7 @@ const utils_2 = require("./utils");
 const constants_1 = require("../constants");
 const constants_2 = require("./constants");
 const api_1 = require("../../hosting/api");
+const logger_1 = require("../../logger");
 const DEFAULT_BUILD_SCRIPT = ["next build"];
 const PUBLIC_DIR = "public";
 exports.name = "Next.js";
@@ -58,7 +59,7 @@ async function build(dir) {
         throw e;
     });
     const reasonsForBackend = new Set();
-    const { distDir, trailingSlash, basePath } = await getConfig(dir);
+    const { distDir, trailingSlash, basePath: baseUrl } = await getConfig(dir);
     if (await (0, utils_2.isUsingMiddleware)((0, path_1.join)(dir, distDir), false)) {
         reasonsForBackend.add("middleware");
     }
@@ -103,7 +104,7 @@ async function build(dir) {
         (0, utils_1.readJSON)((0, path_1.join)(dir, distDir, constants_2.APP_PATH_ROUTES_MANIFEST)).catch(() => undefined),
     ]);
     if (appPathRoutesManifest) {
-        const headersFromMetaFiles = await (0, utils_2.getHeadersFromMetaFiles)(dir, distDir, basePath, appPathRoutesManifest);
+        const headersFromMetaFiles = await (0, utils_2.getHeadersFromMetaFiles)(dir, distDir, baseUrl, appPathRoutesManifest);
         headers.push(...headersFromMetaFiles);
         if (appPathsManifest) {
             const unrenderedServerComponents = (0, utils_2.getNonStaticServerComponents)(appPathsManifest, appPathRoutesManifest, prerenderedRoutes, dynamicRoutes);
@@ -144,15 +145,17 @@ async function build(dir) {
     }));
     const wantsBackend = reasonsForBackend.size > 0;
     if (wantsBackend) {
-        const numberOfReasonsToList = process.env.DEBUG ? Infinity : DEFAULT_NUMBER_OF_REASONS_TO_LIST;
-        console.log("Building a Cloud Function to run this application. This is needed due to:");
-        for (const reason of Array.from(reasonsForBackend).slice(0, numberOfReasonsToList)) {
-            console.log(` • ${reason}`);
+        logger_1.logger.info("Building a Cloud Function to run this application. This is needed due to:");
+        for (const reason of Array.from(reasonsForBackend).slice(0, DEFAULT_NUMBER_OF_REASONS_TO_LIST)) {
+            logger_1.logger.info(` • ${reason}`);
         }
-        if (reasonsForBackend.size > numberOfReasonsToList) {
-            console.log(` • and ${reasonsForBackend.size - numberOfReasonsToList} other reasons, use --debug to see more`);
+        for (const reason of Array.from(reasonsForBackend).slice(DEFAULT_NUMBER_OF_REASONS_TO_LIST)) {
+            logger_1.logger.debug(` • ${reason}`);
         }
-        console.log("");
+        if (reasonsForBackend.size > DEFAULT_NUMBER_OF_REASONS_TO_LIST && !process.env.DEBUG) {
+            logger_1.logger.info(` • and ${reasonsForBackend.size - DEFAULT_NUMBER_OF_REASONS_TO_LIST} other reasons, use --debug to see more`);
+        }
+        logger_1.logger.info("");
     }
     const i18n = !!nextjsI18n;
     return {
@@ -162,6 +165,7 @@ async function build(dir) {
         rewrites,
         trailingSlash,
         i18n,
+        baseUrl,
     };
 }
 exports.build = build;
@@ -226,13 +230,11 @@ async function ɵcodegenPublicDirectory(sourceDir, destDir, _, context) {
     await Promise.all(Object.entries(routesToCopy).map(async ([path, route]) => {
         var _a, _b;
         if (route.initialRevalidateSeconds) {
-            if (process.env.DEBUG)
-                console.log(`skipping ${path} due to revalidate`);
+            logger_1.logger.debug(`skipping ${path} due to revalidate`);
             return;
         }
         if (pathsUsingsFeaturesNotSupportedByHosting.some((it) => path.match(it))) {
-            if (process.env.DEBUG)
-                console.log(`skipping ${path} due to it matching an unsupported rewrite/redirect/header or middlware`);
+            logger_1.logger.debug(`skipping ${path} due to it matching an unsupported rewrite/redirect/header or middlware`);
             return;
         }
         const appPathRoute = route.srcRoute && ((_a = appPathRoutesEntries.find(([, it]) => it === route.srcRoute)) === null || _a === void 0 ? void 0 : _a[0]);
@@ -245,8 +247,7 @@ async function ɵcodegenPublicDirectory(sourceDir, destDir, _, context) {
             !matchingI18nDomain.locales ||
             matchingI18nDomain.locales.includes(locale);
         if (!includeOnThisDomain) {
-            if (process.env.DEBUG)
-                console.log(`skipping ${path} since it is for a locale not deployed on this domain`);
+            logger_1.logger.debug(`skipping ${path} since it is for a locale not deployed on this domain`);
             return;
         }
         const sourcePartsOrIndex = sourceParts.length > 0 ? sourceParts : ["index"];
@@ -293,7 +294,7 @@ async function ɵcodegenPublicDirectory(sourceDir, destDir, _, context) {
 exports.ɵcodegenPublicDirectory = ɵcodegenPublicDirectory;
 const BUNDLE_NEXT_CONFIG_TIMEOUT = 10000;
 async function ɵcodegenFunctionsDirectory(sourceDir, destDir) {
-    const { distDir, basePath } = await getConfig(sourceDir);
+    const { distDir } = await getConfig(sourceDir);
     const packageJson = await (0, utils_1.readJSON)((0, path_1.join)(sourceDir, "package.json"));
     if ((0, fs_1.existsSync)((0, path_1.join)(sourceDir, "next.config.js"))) {
         try {
@@ -345,7 +346,7 @@ async function ɵcodegenFunctionsDirectory(sourceDir, destDir) {
     }
     await (0, fs_extra_1.mkdirp)((0, path_1.join)(destDir, distDir));
     await (0, fs_extra_1.copy)((0, path_1.join)(sourceDir, distDir), (0, path_1.join)(destDir, distDir));
-    return { packageJson, frameworksEntry: "next.js", basePath };
+    return { packageJson, frameworksEntry: "next.js" };
 }
 exports.ɵcodegenFunctionsDirectory = ɵcodegenFunctionsDirectory;
 async function getDevModeHandle(dir, _, hostingEmulatorInfo) {