firebase-tools 11.29.0 → 11.30.0

package/lib/frameworks/utils.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simpleProxy = exports.warnIfCustomBuildScript = exports.readJSON = exports.isUrl = void 0;
+exports.frameworksCallToAction = exports.conjoinOptions = exports.relativeRequire = exports.findDependency = exports.getNodeModuleBin = exports.getNpmRoot = exports.simpleProxy = exports.warnIfCustomBuildScript = exports.readJSON = exports.isUrl = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const promises_1 = require("fs/promises");
 const http_1 = require("http");
+const child_process_1 = require("child_process");
+const clc = require("colorette");
 const logger_1 = require("../logger");
+const error_1 = require("../error");
+const fsutils_1 = require("../fsutils");
+const url_1 = require("url");
+const constants_1 = require("./constants");
+const { dynamicImport } = require(true && "../dynamicImport");
+const NPM_ROOT_TIMEOUT_MILLIES = 2000;
 function isUrl(url) {
     return /^https?:\/\//.test(url);
 }
@@ -67,3 +75,95 @@ function simpleProxy(hostOrRequestHandler) {
     };
 }
 exports.simpleProxy = simpleProxy;
+function scanDependencyTree(searchingFor, dependencies = {}) {
+    for (const [name, dependency] of Object.entries(dependencies)) {
+        if (name === searchingFor)
+            return dependency;
+        const result = scanDependencyTree(searchingFor, dependency.dependencies);
+        if (result)
+            return result;
+    }
+    return;
+}
+function getNpmRoot(cwd) {
+    var _a;
+    return (_a = (0, child_process_1.spawnSync)("npm", ["root"], { cwd, timeout: NPM_ROOT_TIMEOUT_MILLIES })
+        .stdout) === null || _a === void 0 ? void 0 : _a.toString().trim();
+}
+exports.getNpmRoot = getNpmRoot;
+function getNodeModuleBin(name, cwd) {
+    const cantFindExecutable = new error_1.FirebaseError(`Could not find the ${name} executable.`);
+    const npmRoot = getNpmRoot(cwd);
+    if (!npmRoot) {
+        throw cantFindExecutable;
+    }
+    const path = (0, path_1.join)(npmRoot, ".bin", name);
+    if (!(0, fsutils_1.fileExistsSync)(path)) {
+        throw cantFindExecutable;
+    }
+    return path;
+}
+exports.getNodeModuleBin = getNodeModuleBin;
+const DEFAULT_FIND_DEP_OPTIONS = {
+    cwd: process.cwd(),
+    omitDev: true,
+};
+function findDependency(name, options = {}) {
+    const { cwd: dir, depth, omitDev } = Object.assign(Object.assign({}, DEFAULT_FIND_DEP_OPTIONS), options);
+    const cwd = getNpmRoot(dir);
+    if (!cwd)
+        return;
+    const env = Object.assign({}, process.env);
+    delete env.NODE_ENV;
+    const result = (0, child_process_1.spawnSync)("npm", [
+        "list",
+        name,
+        "--json=true",
+        ...(omitDev ? ["--omit", "dev"] : []),
+        ...(depth === undefined ? [] : ["--depth", depth.toString(10)]),
+    ], { cwd, env, timeout: constants_1.NPM_COMMAND_TIMEOUT_MILLIES });
+    if (!result.stdout)
+        return;
+    const json = JSON.parse(result.stdout.toString());
+    return scanDependencyTree(name, json.dependencies);
+}
+exports.findDependency = findDependency;
+function relativeRequire(dir, mod) {
+    try {
+        const path = require.resolve(mod, { paths: [dir] });
+        if ((0, path_1.extname)(path) === ".mjs") {
+            return dynamicImport((0, url_1.pathToFileURL)(path).toString());
+        }
+        else {
+            return require(path);
+        }
+    }
+    catch (e) {
+        const path = (0, path_1.relative)(process.cwd(), dir);
+        console.error(`Could not load dependency ${mod} in ${path.startsWith("..") ? path : `./${path}`}, have you run \`npm install\`?`);
+        throw e;
+    }
+}
+exports.relativeRequire = relativeRequire;
+function conjoinOptions(opts, conjunction = "and", separator = ",") {
+    if (!opts.length)
+        return;
+    if (opts.length === 1)
+        return opts[0].toString();
+    if (opts.length === 2)
+        return `${opts[0].toString()} ${conjunction} ${opts[1].toString()}`;
+    const lastElement = opts.slice(-1)[0].toString();
+    const allButLast = opts.slice(0, -1).map((it) => it.toString());
+    return `${allButLast.join(`${separator} `)}${separator} ${conjunction} ${lastElement}`;
+}
+exports.conjoinOptions = conjoinOptions;
+function frameworksCallToAction(message, docsUrl = constants_1.DEFAULT_DOCS_URL, prefix = "") {
+    return `${prefix}${message}
+
+${prefix}${clc.bold("Documentation:")} ${docsUrl}
+${prefix}${clc.bold("File a bug:")} ${constants_1.FILE_BUG_URL}
+${prefix}${clc.bold("Submit a feature request:")} ${constants_1.FEATURE_REQUEST_URL}
+
+${prefix}We'd love to learn from you. Express your interest in helping us shape the future of Firebase Hosting: ${constants_1.MAILING_LIST_URL}`;
+}
+exports.frameworksCallToAction = frameworksCallToAction;

package/lib/frameworks/vite/index.js

@@ -6,7 +6,6 @@ const cross_spawn_1 = require("cross-spawn");
 const fs_1 = require("fs");
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
-const __1 = require("..");
 const prompt_1 = require("../../prompt");
 const utils_1 = require("../utils");
 exports.name = "Vite";
@@ -39,14 +38,14 @@ exports.vitePluginDiscover = vitePluginDiscover;
 async function discover(dir, plugin, npmDependency) {
     if (!(0, fs_1.existsSync)((0, path_1.join)(dir, "package.json")))
         return;
-    const additionalDep = npmDependency && (0, __1.findDependency)(npmDependency, { cwd: dir, depth: 0, omitDev: false });
+    const additionalDep = npmDependency && (0, utils_1.findDependency)(npmDependency, { cwd: dir, depth: 0, omitDev: false });
     const depth = plugin ? undefined : 0;
     const configFilesExist = await Promise.all([
         (0, fs_extra_1.pathExists)((0, path_1.join)(dir, "vite.config.js")),
         (0, fs_extra_1.pathExists)((0, path_1.join)(dir, "vite.config.ts")),
     ]);
     const anyConfigFileExists = configFilesExist.some((it) => it);
-    if (!anyConfigFileExists && !(0, __1.findDependency)("vite", { cwd: dir, depth, omitDev: false }))
+    if (!anyConfigFileExists && !(0, utils_1.findDependency)("vite", { cwd: dir, depth, omitDev: false }))
         return;
     if (npmDependency && !additionalDep)
         return;
@@ -57,7 +56,7 @@ async function discover(dir, plugin, npmDependency) {
 }
 exports.discover = discover;
 async function build(root) {
-    const { build } = (0, __1.relativeRequire)(root, "vite");
+    const { build } = (0, utils_1.relativeRequire)(root, "vite");
     await (0, utils_1.warnIfCustomBuildScript)(root, exports.name, exports.DEFAULT_BUILD_SCRIPT);
     const cwd = process.cwd();
     process.chdir(root);
@@ -73,7 +72,7 @@ async function ɵcodegenPublicDirectory(root, dest) {
 exports.ɵcodegenPublicDirectory = ɵcodegenPublicDirectory;
 async function getDevModeHandle(dir) {
     const host = new Promise((resolve) => {
-        const cli = (0, __1.getNodeModuleBin)("vite", dir);
+        const cli = (0, utils_1.getNodeModuleBin)("vite", dir);
         const serve = (0, cross_spawn_1.spawn)(cli, [], { cwd: dir });
         serve.stdout.on("data", (data) => {
             process.stdout.write(data);
@@ -89,7 +88,7 @@ async function getDevModeHandle(dir) {
 }
 exports.getDevModeHandle = getDevModeHandle;
 async function getConfig(root) {
-    const { resolveConfig } = (0, __1.relativeRequire)(root, "vite");
+    const { resolveConfig } = (0, utils_1.relativeRequire)(root, "vite");
     const cwd = process.cwd();
     process.chdir(root);
     const config = await resolveConfig({ root }, "build", "production");

package/lib/functions/ensureTargeted.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureTargeted = void 0;
-function ensureTargeted(only, codebase, id) {
+function ensureTargeted(only, codebaseOrFunction, functionId) {
     const parts = only.split(",");
     if (parts.includes("functions")) {
         return only;
     }
-    let newTarget = `functions:${codebase}`;
+    let newTarget = `functions:${codebaseOrFunction}`;
     if (parts.includes(newTarget)) {
         return only;
     }
-    if (id) {
-        newTarget = `${newTarget}:${id}`;
+    if (functionId) {
+        newTarget = `${newTarget}:${functionId}`;
         if (parts.includes(newTarget)) {
             return only;
         }

package/lib/functions/python.js

@@ -1,15 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runWithVirtualEnv = void 0;
+exports.runWithVirtualEnv = exports.virtualEnvCmd = exports.DEFAULT_VENV_DIR = void 0;
 const path = require("path");
 const spawn = require("cross-spawn");
 const logger_1 = require("../logger");
-const DEFAULT_VENV_DIR = "venv";
-function runWithVirtualEnv(commandAndArgs, cwd, envs, spawnOpts = {}, venvDir = DEFAULT_VENV_DIR) {
+exports.DEFAULT_VENV_DIR = "venv";
+function virtualEnvCmd(cwd, venvDir) {
     const activateScriptPath = process.platform === "win32" ? ["Scripts", "activate.bat"] : ["bin", "activate"];
     const venvActivate = path.join(cwd, venvDir, ...activateScriptPath);
-    const command = process.platform === "win32" ? venvActivate : "source";
-    const args = [process.platform === "win32" ? "" : venvActivate, "&&", ...commandAndArgs];
+    return {
+        command: process.platform === "win32" ? venvActivate : "source",
+        args: [process.platform === "win32" ? "" : venvActivate],
+    };
+}
+exports.virtualEnvCmd = virtualEnvCmd;
+function runWithVirtualEnv(commandAndArgs, cwd, envs, spawnOpts = {}, venvDir = exports.DEFAULT_VENV_DIR) {
+    const { command, args } = virtualEnvCmd(cwd, venvDir);
+    args.push("&&", ...commandAndArgs);
     logger_1.logger.debug(`Running command with virtualenv: command=${command}, args=${JSON.stringify(args)}`);
     return spawn(command, args, Object.assign(Object.assign({ shell: true, cwd, stdio: ["pipe", "pipe", "pipe", "pipe"] }, spawnOpts), { env: envs }));
 }

package/lib/gcp/resourceManager.js

@@ -10,6 +10,7 @@ const apiClient = new apiv2_1.Client({ urlPrefix: api_1.resourceManagerOrigin, a
 exports.firebaseRoles = {
     apiKeysViewer: "roles/serviceusage.apiKeysViewer",
     authAdmin: "roles/firebaseauth.admin",
+    functionsDeveloper: "roles/cloudfunctions.developer",
     hostingAdmin: "roles/firebasehosting.admin",
     runViewer: "roles/run.viewer",
 };

package/lib/hosting/config.js

@@ -8,7 +8,6 @@ const functional_1 = require("../functional");
 const fsutils_1 = require("../fsutils");
 const projectPath_1 = require("../projectPath");
 const path = require("node:path");
-const experiments = require("../experiments");
 const logger_1 = require("../logger");
 function matchingConfigs(configs, targets, assertMatches) {
     const matches = [];
@@ -95,15 +94,12 @@ function validateOne(config, options) {
     if (config.source && config.public) {
         throw new error_1.FirebaseError('Can only specify "source" or "public" in a Hosting config, not both');
     }
-    const root = experiments.isEnabled("webframeworks")
-        ? config.source || config.public
-        : config.public;
-    const orSource = experiments.isEnabled("webframeworks") ? ' or "source"' : "";
+    const root = config.source || config.public;
     if (!root && hasAnyStaticRewrites) {
-        throw new error_1.FirebaseError(`Must supply a "public"${orSource} directory when using "destination" rewrites.`);
+        throw new error_1.FirebaseError(`Must supply a "public" or "source" directory when using "destination" rewrites.`);
     }
     if (!root && !hasAnyDynamicRewrites && !hasAnyRedirects) {
-        throw new error_1.FirebaseError(`Must supply a "public"${orSource} directory or at least one rewrite or redirect in each "hosting" config.`);
+        throw new error_1.FirebaseError(`Must supply a "public" or "source" directory or at least one rewrite or redirect in each "hosting" config.`);
     }
     if (root && !(0, fsutils_1.dirExistsSync)((0, projectPath_1.resolveProjectPath)(options, root))) {
         logger_1.logger.debug(`Specified "${config.source ? "source" : "public"}" directory "${root}" does not exist; Deploy to Hosting site "${config.site || config.target || ""}" may fail or be empty.`);
@@ -115,7 +111,7 @@ function validateOne(config, options) {
     }
     if (config.i18n) {
         if (!root) {
-            throw new error_1.FirebaseError(`Must supply a "public"${orSource} directory when using "i18n" configuration.`);
+            throw new error_1.FirebaseError(`Must supply a "public" or "source" directory when using "i18n" configuration.`);
         }
         if (!config.i18n.root) {
             throw new error_1.FirebaseError('Must supply a "root" in "i18n" config.');

package/lib/init/features/functions/index.js

@@ -8,7 +8,6 @@ const requirePermissions_1 = require("../../../requirePermissions");
 const ensureApiEnabled_1 = require("../../../ensureApiEnabled");
 const projectConfig_1 = require("../../../functions/projectConfig");
 const error_1 = require("../../../error");
-const experiments_1 = require("../../../experiments");
 const MAX_ATTEMPTS = 5;
 async function doSetup(setup, config, options) {
     var _a, _b;
@@ -140,12 +139,10 @@ async function languageSetup(setup, config) {
             value: "typescript",
         },
     ];
-    if ((0, experiments_1.isEnabled)("pythonfunctions")) {
-        choices.push({
-            name: "Python",
-            value: "python",
-        });
-    }
+    choices.push({
+        name: "Python",
+        value: "python",
+    });
     const language = await (0, prompt_1.promptOnce)({
         type: "list",
         message: "What language would you like to use to write Cloud Functions?",

package/lib/init/features/hosting/github.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initGitHub = void 0;
+exports.isRunningInGithubAction = exports.initGitHub = void 0;
 const colorette_1 = require("colorette");
 const fs = require("fs");
 const yaml = require("js-yaml");
@@ -355,7 +355,7 @@ async function createServiceAccountAndKeyWithRetry(options, repo, accountId) {
 }
 async function createServiceAccountAndKey(options, repo, accountId) {
     try {
-        await (0, iam_1.createServiceAccount)(options.projectId, accountId, `A service account with permission to deploy to Firebase Hosting for the GitHub repository ${repo}`, `GitHub Actions (${repo})`);
+        await (0, iam_1.createServiceAccount)(options.projectId, accountId, `A service account with permission to deploy to Firebase Hosting and Cloud Functions for the GitHub repository ${repo}`, `GitHub Actions (${repo})`);
     }
     catch (e) {
         if (!e.message.includes("409")) {
@@ -367,6 +367,7 @@ async function createServiceAccountAndKey(options, repo, accountId) {
         resourceManager_1.firebaseRoles.apiKeysViewer,
         resourceManager_1.firebaseRoles.hostingAdmin,
         resourceManager_1.firebaseRoles.runViewer,
+        resourceManager_1.firebaseRoles.functionsDeveloper,
     ];
     await (0, resourceManager_1.addServiceAccountToRoles)(options.projectId, accountId, requiredRoles);
     const serviceAccountKey = await (0, iam_1.createServiceAccountKey)(options.projectId, accountId);
@@ -381,3 +382,7 @@ async function encryptServiceAccountJSON(serviceAccountJSON, key) {
     const encryptedBytes = libsodium.crypto_box_seal(messageBytes, keyBytes);
     return Buffer.from(encryptedBytes).toString("base64");
 }
+function isRunningInGithubAction() {
+    return process.env.GITHUB_ACTION_REPOSITORY === HOSTING_GITHUB_ACTION_NAME.split("@")[0];
+}
+exports.isRunningInGithubAction = isRunningInGithubAction;

package/lib/init/features/hosting/index.js

@@ -9,6 +9,7 @@ const github_1 = require("./github");
 const prompt_1 = require("../../../prompt");
 const logger_1 = require("../../../logger");
 const frameworks_1 = require("../../../frameworks");
+const constants_1 = require("../../../frameworks/constants");
 const experiments = require("../../../experiments");
 const path_1 = require("path");
 const INDEX_TEMPLATE = fs.readFileSync(__dirname + "/../../../../templates/init/hosting/index.html", "utf8");
@@ -90,8 +91,8 @@ async function doSetup(setup, config) {
             name: "region",
             type: "list",
             message: "In which region would you like to host server-side content, if applicable?",
-            default: frameworks_1.DEFAULT_REGION,
-            choices: frameworks_1.ALLOWED_SSR_REGIONS,
+            default: constants_1.DEFAULT_REGION,
+            choices: constants_1.ALLOWED_SSR_REGIONS,
         }, setup.hosting);
         setup.config.hosting = {
             source: setup.hosting.source,

package/lib/serve/index.js

@@ -14,7 +14,8 @@ const TARGETS = {
     functions: new FunctionsServer(),
 };
 async function serve(options) {
-    const targetNames = options.targets || [];
+    options.targets || (options.targets = []);
+    const targetNames = options.targets;
     options.port = parseInt(options.port, 10);
     if (targetNames.includes("hosting") && config.extract(options).some((it) => it.source)) {
         experiments.assertEnabled("webframeworks", "emulate a web framework");

package/lib/unzip.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnzipTransform = exports.unzip = void 0;
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const error_1 = require("./error");
+const stream_2 = require("stream");
+const logger_1 = require("./logger");
+const pipelineAsync = (0, util_1.promisify)(stream_2.pipeline);
+const readUInt32LE = (buf, offset) => {
+    return ((buf[offset] | (buf[offset + 1] << 8) | (buf[offset + 2] << 16) | (buf[offset + 3] << 24)) >>> 0);
+};
+const findNextDataDescriptor = (data, offset) => {
+    const dataDescriptorSignature = 0x08074b50;
+    let position = offset;
+    while (position < data.length) {
+        const potentialDescriptor = data.slice(position, position + 16);
+        if (readUInt32LE(potentialDescriptor, 0) === dataDescriptorSignature) {
+            logger_1.logger.debug(`[unzip] found data descriptor signature @ ${position}`);
+            const compressedSize = readUInt32LE(potentialDescriptor, 8);
+            const uncompressedSize = readUInt32LE(potentialDescriptor, 12);
+            return [compressedSize, uncompressedSize];
+        }
+        position++;
+    }
+    throw new error_1.FirebaseError("Unable to find compressed and uncompressed size of file in ZIP archive.");
+};
+const extractEntriesFromBuffer = async (data, outputDir) => {
+    let position = 0;
+    logger_1.logger.debug(`Data is ${data.length}`);
+    while (position < data.length) {
+        const entryHeader = data.slice(position, position + 30);
+        const entry = {};
+        if (readUInt32LE(entryHeader, 0) !== 0x04034b50) {
+            break;
+        }
+        entry.generalPurposeBitFlag = entryHeader.readUint16LE(6);
+        entry.compressedSize = readUInt32LE(entryHeader, 18);
+        entry.uncompressedSize = readUInt32LE(entryHeader, 22);
+        entry.fileNameLength = entryHeader.readUInt16LE(26);
+        entry.extraLength = entryHeader.readUInt16LE(28);
+        entry.fileName = data.toString("utf-8", position + 30, position + 30 + entry.fileNameLength);
+        entry.headerSize = 30 + entry.fileNameLength + entry.extraLength;
+        let dataDescriptorSize = 0;
+        if (entry.generalPurposeBitFlag === 8 &&
+            entry.compressedSize === 0 &&
+            entry.uncompressedSize === 0) {
+            const [compressedSize, uncompressedSize] = findNextDataDescriptor(data, position);
+            entry.compressedSize = compressedSize;
+            entry.uncompressedSize = uncompressedSize;
+            dataDescriptorSize = 16;
+        }
+        entry.compressedData = data.slice(position + entry.headerSize, position + entry.headerSize + entry.compressedSize);
+        logger_1.logger.debug(`[unzip] Entry: ${entry.fileName} (compressed_size=${entry.compressedSize} bytes, uncompressed_size=${entry.uncompressedSize} bytes)`);
+        entry.fileName = entry.fileName.replace(/\//g, path.sep);
+        const outputFilePath = path.normalize(path.join(outputDir, entry.fileName));
+        logger_1.logger.debug(`[unzip] Processing entry: ${entry.fileName}`);
+        if (entry.fileName.endsWith(path.sep)) {
+            logger_1.logger.debug(`[unzip] mkdir: ${outputFilePath}`);
+            await fs.promises.mkdir(outputFilePath, { recursive: true });
+        }
+        else {
+            const parentDir = outputFilePath.substring(0, outputFilePath.lastIndexOf(path.sep));
+            logger_1.logger.debug(`[unzip] else mkdir: ${parentDir}`);
+            await fs.promises.mkdir(parentDir, { recursive: true });
+            const compressionMethod = entryHeader.readUInt16LE(8);
+            if (compressionMethod === 0) {
+                logger_1.logger.debug(`[unzip] Writing file: ${outputFilePath}`);
+                await fs.promises.writeFile(outputFilePath, entry.compressedData);
+            }
+            else if (compressionMethod === 8) {
+                logger_1.logger.debug(`[unzip] deflating: ${outputFilePath}`);
+                await pipelineAsync(stream_1.Readable.from(entry.compressedData), zlib.createInflateRaw(), fs.createWriteStream(outputFilePath));
+            }
+            else {
+                throw new error_1.FirebaseError(`Unsupported compression method: ${compressionMethod}`);
+            }
+        }
+        position += entry.headerSize + entry.compressedSize + dataDescriptorSize;
+    }
+};
+const unzip = async (inputPath, outputDir) => {
+    const data = await fs.promises.readFile(inputPath);
+    await extractEntriesFromBuffer(data, outputDir);
+};
+exports.unzip = unzip;
+class UnzipTransform extends stream_1.Transform {
+    constructor(outputDir) {
+        super();
+        this.outputDir = outputDir;
+        this.chunks = [];
+    }
+    _transform(chunk, _, callback) {
+        this.chunks.push(chunk);
+        callback();
+    }
+    async _flush(callback) {
+        var _a, _b;
+        try {
+            await extractEntriesFromBuffer(Buffer.concat(this.chunks), this.outputDir);
+            callback();
+            (_a = this._resolve) === null || _a === void 0 ? void 0 : _a.call(this);
+        }
+        catch (error) {
+            const firebaseError = new error_1.FirebaseError("Unable to unzip the target", {
+                children: [error],
+                original: error instanceof Error ? error : undefined,
+            });
+            callback(firebaseError);
+            (_b = this._reject) === null || _b === void 0 ? void 0 : _b.call(this, firebaseError);
+        }
+    }
+    async promise() {
+        return new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+    }
+}
+const createUnzipTransform = (outputDir) => {
+    return new UnzipTransform(outputDir);
+};
+exports.createUnzipTransform = createUnzipTransform;