firebase-tools 11.2.1 → 11.2.2

package/lib/checkValidTargetFilters.js

@@ -28,10 +28,10 @@ async function checkValidTargetFilters(options) {
         if (options.except) {
             return reject(new error_1.FirebaseError("Cannot specify both --only and --except"));
         }
-        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !["hosting", "functions"].includes(t));
+        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !["hosting", "functions", "firestore"].includes(t));
         const targetsForNonFilteredTypes = targetsForTypes(only, ...nonFilteredTypes);
         if (targetsForNonFilteredTypes.length && targetsHaveFilters(...targetsForNonFilteredTypes)) {
-            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions and hosting"));
+            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions, hosting, and firestore"));
         }
         const targetsForFunctions = targetsForTypes(only, "functions");
         if (targetsForFunctions.length &&

package/lib/commands/ext-export.js

@@ -4,6 +4,7 @@ exports.command = void 0;
 const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
 const command_1 = require("../command");
 const planner = require("../deploy/extensions/planner");
+const etags_1 = require("../extensions/etags");
 const export_1 = require("../extensions/export");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const manifest = require("../extensions/manifest");
@@ -63,4 +64,5 @@ exports.command = new command_1.Command("ext:export")
         nonInteractive: options.nonInteractive,
         force: options.force,
     }, true);
+    (0, etags_1.saveEtags)(options.rc, projectId, have);
 });

package/lib/deploy/extensions/planner.js

@@ -54,6 +54,7 @@ async function have(projectId) {
             params: i.config.params,
             allowedEventTypes: i.config.allowedEventTypes,
             eventarcChannel: i.config.eventarcChannel,
+            etag: i.etag,
         };
         if (i.config.extensionRef) {
             const ref = refs.parse(i.config.extensionRef);

package/lib/deploy/extensions/prepare.js

@@ -13,6 +13,7 @@ const extensionsHelper_1 = require("../../extensions/extensionsHelper");
 const secretsUtils_1 = require("../../extensions/secretsUtils");
 const secrets_1 = require("./secrets");
 const warnings_1 = require("../../extensions/warnings");
+const etags_1 = require("../../extensions/etags");
 async function prepare(context, options, payload) {
     var _a;
     const projectId = (0, projectUtils_1.needProjectId)(options);
@@ -28,6 +29,22 @@ async function prepare(context, options, payload) {
         projectDir: options.config.projectDir,
         extensions: options.config.get("extensions"),
     });
+    const etagsChanged = (0, etags_1.detectEtagChanges)(options.rc, projectId, context.have);
+    if (etagsChanged.length) {
+        (0, warnings_1.outOfBandChangesWarning)(etagsChanged);
+        if (!options.force && options.nonInteractive) {
+            throw new error_1.FirebaseError("Pass the --force flag to overwrite out of band changes in non-interactive mode");
+        }
+        else if (!options.force &&
+            !options.nonInteractive &&
+            !(await prompt.promptOnce({
+                type: "confirm",
+                message: `Do you wish to continue deploying these extension instances?`,
+                default: false,
+            }))) {
+            throw new error_1.FirebaseError("Deployment cancelled");
+        }
+    }
     const usingSecrets = await Promise.all((_a = context.want) === null || _a === void 0 ? void 0 : _a.map(secrets_1.checkSpecForSecrets));
     if (usingSecrets.some((i) => i)) {
         await (0, secretsUtils_1.ensureSecretManagerApiEnabled)(options);
@@ -44,7 +61,7 @@ async function prepare(context, options, payload) {
             !options.nonInteractive &&
             !(await prompt.promptOnce({
                 type: "confirm",
-                message: `Do you wish to continue deploying these extensions?`,
+                message: `Do you wish to continue deploying these extension instances?`,
                 default: true,
             }))) {
             throw new error_1.FirebaseError("Deployment cancelled");

package/lib/deploy/extensions/release.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.release = void 0;
 const queue_1 = require("../../throttler/queue");
 const tasks = require("./tasks");
+const planner = require("./planner");
 const error_1 = require("../../error");
 const errors_1 = require("./errors");
 const projectUtils_1 = require("../../projectUtils");
+const etags_1 = require("../../extensions/etags");
 async function release(context, options, payload) {
     var _a, _b, _c, _d;
     const projectId = (0, projectUtils_1.needProjectId)(options);
@@ -35,6 +37,8 @@ async function release(context, options, payload) {
     deploymentQueue.process();
     deploymentQueue.close();
     await deploymentPromise;
+    const newHave = await planner.have(projectId);
+    (0, etags_1.saveEtags)(options.rc, projectId, newHave);
     if (errorHandler.hasErrors()) {
         errorHandler.print();
         throw new error_1.FirebaseError(`Extensions deployment failed.`);

package/lib/deploy/functions/build.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveBackend = exports.of = exports.empty = void 0;
+exports.toBackend = exports.resolveBackend = exports.of = exports.empty = void 0;
 const backend = require("./backend");
 const proto = require("../../gcp/proto");
 const api = require("../../.../../api");
+const params = require("./params");
+const previews_1 = require("../../previews");
 const error_1 = require("../../error");
 const functional_1 = require("../../functional");
 function empty() {
@@ -20,45 +22,19 @@ function of(endpoints) {
     return build;
 }
 exports.of = of;
-function resolveInt(from) {
-    if (from == null) {
-        return 0;
-    }
-    else if (typeof from === "string") {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
-function resolveString(from) {
-    if (from == null) {
-        return "";
-    }
-    else if (from.includes("{{") && from.includes("}}")) {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
-function resolveBoolean(from) {
-    if (from == null) {
-        return false;
-    }
-    else if (typeof from === "string") {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
 function isMemoryOption(value) {
     return value == null || [128, 256, 512, 1024, 2048, 4096, 8192].includes(value);
 }
-function resolveBackend(build, userEnvs) {
-    for (const param of build.params) {
-        const expectedEnv = param.param;
-        if (!userEnvs.hasOwnProperty(expectedEnv)) {
-            throw new error_1.FirebaseError("Build specified parameter " +
-                expectedEnv +
-                " but it was not present in the user dotenv files or Cloud Secret Manager");
-        }
+async function resolveBackend(build, userEnvOpt, userEnvs) {
+    const projectId = userEnvOpt.projectId;
+    let paramValues = {};
+    if (previews_1.previews.functionsparams) {
+        paramValues = await params.resolveParams(build.params, projectId, userEnvs);
     }
+    return toBackend(build, paramValues);
+}
+exports.resolveBackend = resolveBackend;
+function toBackend(build, paramValues) {
     const bkEndpoints = [];
     for (const endpointId of Object.keys(build.endpoints)) {
         const bdEndpoint = build.endpoints[endpointId];
@@ -67,7 +43,7 @@ function resolveBackend(build, userEnvs) {
             regions = [api.functionsDefaultRegion];
         }
         for (const region of regions) {
-            const trigger = discoverTrigger(bdEndpoint);
+            const trigger = discoverTrigger(bdEndpoint, paramValues);
             if (typeof bdEndpoint.platform === "undefined") {
                 throw new error_1.FirebaseError("platform can't be undefined");
             }
@@ -76,21 +52,25 @@ function resolveBackend(build, userEnvs) {
             }
             let timeout;
             if (bdEndpoint.timeoutSeconds) {
-                timeout = resolveInt(bdEndpoint.timeoutSeconds);
+                timeout = params.resolveInt(bdEndpoint.timeoutSeconds, paramValues);
             }
             else {
                 timeout = 60;
             }
             const bkEndpoint = Object.assign({ id: endpointId, project: bdEndpoint.project, region: region, entryPoint: bdEndpoint.entryPoint, platform: bdEndpoint.platform, runtime: bdEndpoint.runtime, timeoutSeconds: timeout }, trigger);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "maxInstances", "maxInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "minInstances", "minInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "concurrency", "concurrency", resolveInt);
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "maxInstances", "maxInstances", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "minInstances", "minInstances", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "concurrency", "concurrency", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
             proto.copyIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
             proto.copyIfPresent(bkEndpoint, bdEndpoint, "secretEnvironmentVariables");
             if (bdEndpoint.vpc) {
-                bkEndpoint.vpc = {
-                    connector: resolveString(bdEndpoint.vpc.connector).replace("$REGION", region),
-                };
+                bkEndpoint.vpc = { connector: params.resolveString(bdEndpoint.vpc.connector, paramValues) };
                 proto.copyIfPresent(bkEndpoint.vpc, bdEndpoint.vpc, "egressSettings");
             }
             proto.renameIfPresent(bkEndpoint, bdEndpoint, "serviceAccountEmail", "serviceAccount");
@@ -104,8 +84,11 @@ function resolveBackend(build, userEnvs) {
     bkend.requiredAPIs = build.requiredAPIs;
     return bkend;
 }
-exports.resolveBackend = resolveBackend;
-function discoverTrigger(endpoint) {
+exports.toBackend = toBackend;
+function discoverTrigger(endpoint, paramValues) {
+    const resolveInt = (from) => params.resolveInt(from, paramValues);
+    const resolveString = (from) => params.resolveString(from, paramValues);
+    const resolveBoolean = (from) => params.resolveBoolean(from, paramValues);
     let trigger;
     if ("httpsTrigger" in endpoint) {
         const bkHttps = {};
@@ -122,15 +105,13 @@ function discoverTrigger(endpoint) {
     }
     else if ("eventTrigger" in endpoint) {
         const bkEventFilters = {};
-        for (const key in endpoint.eventTrigger.eventFilters) {
-            if (typeof key === "string") {
-                bkEventFilters[key] = resolveString(endpoint.eventTrigger.eventFilters[key]);
-            }
+        for (const [key, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
+            bkEventFilters[key] = params.resolveString(value, paramValues);
         }
         const bkEvent = {
             eventType: endpoint.eventTrigger.eventType,
             eventFilters: bkEventFilters,
-            retry: resolveBoolean(endpoint.eventTrigger.retry),
+            retry: resolveBoolean(endpoint.eventTrigger.retry || false),
         };
         if (endpoint.eventTrigger.serviceAccount) {
             bkEvent.serviceAccountEmail = endpoint.eventTrigger.serviceAccount;

package/lib/deploy/functions/params.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveParams = exports.resolveBoolean = exports.resolveString = exports.resolveInt = void 0;
+const logger_1 = require("../../logger");
+const error_1 = require("../../error");
+const prompt_1 = require("../../prompt");
+const functional_1 = require("../../functional");
+function isCEL(expr) {
+    return typeof expr === "string" && expr.includes("{{") && expr.includes("}}");
+}
+function dependenciesCEL(expr) {
+    const deps = [];
+    const paramCapture = /{{ params\.(\w+) }}/g;
+    let match;
+    while ((match = paramCapture.exec(expr)) != null) {
+        deps.push(match[1]);
+    }
+    return deps;
+}
+function resolveInt(from, paramValues) {
+    if (typeof from === "number") {
+        return from;
+    }
+    const match = /\A{{ params\.(\w+) }}\z/.exec(from);
+    if (!match) {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    const referencedParamValue = paramValues[match[1]];
+    if (typeof referencedParamValue !== "number") {
+        throw new error_1.FirebaseError("Referenced numeric parameter '" +
+            match +
+            "' resolved to non-number value " +
+            referencedParamValue);
+    }
+    return referencedParamValue;
+}
+exports.resolveInt = resolveInt;
+function resolveString(from, paramValues) {
+    if (!isCEL(from)) {
+        return from;
+    }
+    let output = from;
+    const paramCapture = /{{ params\.(\w+) }}/g;
+    let match;
+    while ((match = paramCapture.exec(from)) != null) {
+        const referencedParamValue = paramValues[match[1]];
+        if (typeof referencedParamValue !== "string") {
+            throw new error_1.FirebaseError("Referenced string parameter '" +
+                match[1] +
+                "' resolved to non-string value " +
+                referencedParamValue);
+        }
+        output = output.replace(`{{ params.${match[1]} }}`, referencedParamValue);
+    }
+    if (isCEL(output)) {
+        throw new error_1.FirebaseError("CEL evaluation of non-identity expression '" + from + "' not yet supported");
+    }
+    return output;
+}
+exports.resolveString = resolveString;
+function resolveBoolean(from, paramValues) {
+    if (typeof from === "string" && /{{ params\.(\w+) }}/.test(from)) {
+        const match = /{{ params\.(\w+) }}/.exec(from);
+        const referencedParamValue = paramValues[match[1]];
+        if (typeof referencedParamValue !== "boolean") {
+            throw new error_1.FirebaseError("Referenced boolean parameter '" +
+                match +
+                "' resolved to non-boolean value " +
+                referencedParamValue);
+        }
+        return referencedParamValue;
+    }
+    else if (typeof from === "string") {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    return from;
+}
+exports.resolveBoolean = resolveBoolean;
+function resolveDefaultCEL(type, expr, currentEnv) {
+    const deps = dependenciesCEL(expr);
+    const allDepsFound = deps.every((dep) => !!currentEnv[dep]);
+    if (!allDepsFound) {
+        throw new error_1.FirebaseError("Build specified parameter with un-resolvable default value " +
+            expr +
+            "; dependencies missing.");
+    }
+    switch (type) {
+        case "string":
+            return resolveString(expr, currentEnv);
+        case "int":
+            return resolveInt(expr, currentEnv);
+        default:
+            throw new error_1.FirebaseError("Build specified parameter with default " + expr + " of unsupported type");
+    }
+}
+function canSatisfyParam(param, value) {
+    if (param.type === "string") {
+        return typeof value === "string";
+    }
+    else if (param.type === "int") {
+        return typeof value === "number" && Number.isInteger(value);
+    }
+    (0, functional_1.assertExhaustive)(param);
+}
+async function resolveParams(params, projectId, userEnvs) {
+    const paramValues = {};
+    for (const param of params.filter((param) => userEnvs.hasOwnProperty(param.param))) {
+        if (!canSatisfyParam(param, userEnvs[param.param])) {
+            throw new error_1.FirebaseError("Parameter " +
+                param.param +
+                " resolved to value from dotenv files " +
+                userEnvs[param.param] +
+                " of wrong type");
+        }
+        paramValues[param.param] = userEnvs[param.param];
+    }
+    for (const param of params.filter((param) => !userEnvs.hasOwnProperty(param.param))) {
+        let paramDefault = param.default;
+        if (paramDefault && isCEL(paramDefault)) {
+            paramDefault = resolveDefaultCEL(param.type, paramDefault, paramValues);
+        }
+        if (paramDefault && !canSatisfyParam(param, paramDefault)) {
+            throw new error_1.FirebaseError("Parameter " + param.param + " has default value " + paramDefault + " of wrong type");
+        }
+        paramValues[param.param] = await promptParam(param, paramDefault);
+    }
+    return paramValues;
+}
+exports.resolveParams = resolveParams;
+async function promptParam(param, resolvedDefault) {
+    if (param.type === "string") {
+        return promptStringParam(param, resolvedDefault);
+    }
+    else if (param.type === "int") {
+        return promptIntParam(param, resolvedDefault);
+    }
+    (0, functional_1.assertExhaustive)(param);
+}
+async function promptStringParam(param, resolvedDefault) {
+    if (!param.input) {
+        const defaultToText = { type: "text", text: {} };
+        param.input = defaultToText;
+    }
+    switch (param.input.type) {
+        case "select":
+            throw new error_1.FirebaseError("Build specified string parameter " + param.param + " with unsupported input type 'select'");
+        case "text":
+        default:
+            let prompt = `Enter a value for ${param.label || param.param}`;
+            if (param.description) {
+                prompt += ` \n(${param.description})`;
+            }
+            return await (0, prompt_1.promptOnce)({
+                name: param.param,
+                type: "input",
+                default: resolvedDefault,
+                message: prompt,
+            });
+    }
+}
+async function promptIntParam(param, resolvedDefault) {
+    if (!param.input) {
+        const defaultToText = { type: "text", text: {} };
+        param.input = defaultToText;
+    }
+    switch (param.input.type) {
+        case "select":
+            throw new error_1.FirebaseError("Build specified int parameter " + param.param + " with unsupported input type 'select'");
+        case "text":
+        default:
+            let prompt = `Enter a value for ${param.label || param.param}`;
+            if (param.description) {
+                prompt += ` \n(${param.description})`;
+            }
+            let res;
+            while (true) {
+                res = await (0, prompt_1.promptOnce)({
+                    name: param.param,
+                    type: "number",
+                    default: resolvedDefault,
+                    message: prompt,
+                });
+                if (Number.isInteger(res)) {
+                    return res;
+                }
+                logger_1.logger.error(`${param.label || param.param} must be an integer; retrying...`);
+            }
+    }
+}

package/lib/deploy/functions/prepare.js

@@ -78,7 +78,7 @@ async function prepare(context, options, payload) {
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
         const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
-        const wantBackend = build.resolveBackend(wantBuild, userEnvs);
+        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
         wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;

package/lib/deploy/lifecycleHooks.js

@@ -31,7 +31,7 @@ function runCommand(command, childOptions) {
                 reject(new Error("Command terminated with signal " + signal));
             }
             else if (code !== 0) {
-                reject(new Error("Command terminated with non-zero exit code" + code));
+                reject(new Error("Command terminated with non-zero exit code " + code));
             }
             else {
                 resolve();

package/lib/deploy/storage/prepare.js

@@ -11,7 +11,7 @@ async function default_1(context, options) {
     _.set(context, "storage.rules", rulesConfig);
     const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.FIREBASE_STORAGE);
     _.set(context, "storage.rulesDeploy", rulesDeploy);
-    if (_.isPlainObject(rulesConfig)) {
+    if (typeof rulesConfig === "object" && rulesConfig !== null) {
         const defaultBucket = await gcp.storage.getDefaultBucket(options.project);
         rulesConfig = [Object.assign(rulesConfig, { bucket: defaultBucket })];
         _.set(context, "storage.rules", rulesConfig);

package/lib/emulator/downloadableEmulators.js

@@ -164,7 +164,7 @@ const Commands = {
     },
     ui: {
         binary: "node",
-        args: ["--dns-result-order=ipv4first", getExecPath(types_1.Emulators.UI)],
+        args: [getExecPath(types_1.Emulators.UI)],
         optionalArgs: [],
         joinArgs: false,
     },

package/lib/emulator/functionsEmulator.js

@@ -272,8 +272,13 @@ class FunctionsEmulator {
             await runtimeDelegate.build();
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
             const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env);
+            const userEnvOpt = {
+                functionsSource: emulatableBackend.functionsDir,
+                projectId: this.args.projectId,
+                projectAlias: this.args.projectAlias,
+            };
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const discoveredBackend = (0, build_1.resolveBackend)(discoveredBuild, environment);
+            const discoveredBackend = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
             for (const e of endpoints) {

package/lib/extensions/etags.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEtagChanges = exports.saveEtags = void 0;
+function saveEtags(rc, projectId, instances) {
+    rc.setEtags(projectId, "extensionInstances", etagsMap(instances));
+}
+exports.saveEtags = saveEtags;
+function detectEtagChanges(rc, projectId, instances) {
+    const lastDeployedEtags = rc.getEtags(projectId).extensionInstances;
+    const currentEtags = etagsMap(instances);
+    if (!lastDeployedEtags || !Object.keys(lastDeployedEtags).length) {
+        return [];
+    }
+    const changedExtensionInstances = Object.entries(lastDeployedEtags)
+        .filter(([instanceName, etag]) => etag !== currentEtags[instanceName])
+        .map((i) => i[0]);
+    const newExtensionInstances = Object.keys(currentEtags).filter((instanceName) => !lastDeployedEtags[instanceName]);
+    return newExtensionInstances.concat(changedExtensionInstances);
+}
+exports.detectEtagChanges = detectEtagChanges;
+function etagsMap(instances) {
+    return instances.reduce((acc, i) => {
+        if (i.etag) {
+            acc[i.instanceId] = i.etag;
+        }
+        return acc;
+    }, {});
+}

package/lib/extensions/warnings.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.paramsFlagDeprecationWarning = exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
+exports.outOfBandChangesWarning = exports.paramsFlagDeprecationWarning = exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
 const { marked } = require("marked");
 const clc = require("cli-color");
 const types_1 = require("./types");
@@ -75,3 +75,9 @@ function paramsFlagDeprecationWarning() {
         "See https://firebase.google.com/docs/extensions/manifest for more details");
 }
 exports.paramsFlagDeprecationWarning = paramsFlagDeprecationWarning;
+function outOfBandChangesWarning(instanceIds) {
+    logger_1.logger.warn("The following instances may have been changed in the Firebase console or by another machine since the last deploy from this machine.\n\t" +
+        clc.bold(instanceIds.join("\n\t")) +
+        "\nIf you proceed with this deployment, those changes will be overwritten. To avoid this, run `firebase ext:export` to sync these changes to your local extensions manifest.");
+}
+exports.outOfBandChangesWarning = outOfBandChangesWarning;

package/lib/functions/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.parseStrict = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
+exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.writeUserEnvs = exports.hasUserEnvs = exports.parseStrict = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
 const clc = require("cli-color");
 const fs = require("fs");
 const path = require("path");
@@ -145,6 +145,10 @@ function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, })
     return findEnvfiles(functionsSource, projectId, projectAlias, isEmulator).length > 0;
 }
 exports.hasUserEnvs = hasUserEnvs;
+function writeUserEnvs(toWrite, envOpts) {
+    throw new error_1.FirebaseError("Persisting user-defined parameters to .env files is not yet implemented.");
+}
+exports.writeUserEnvs = writeUserEnvs;
 function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
     const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);

package/lib/functionsConfig.js

@@ -70,7 +70,7 @@ async function setVariablesRecursive(projectId, configId, varPath, val) {
         catch (e) {
         }
     }
-    if (_.isPlainObject(parsed)) {
+    if (typeof parsed === "object" && parsed !== null) {
         return Promise.all(Object.entries(parsed).map(([key, item]) => {
             const newVarPath = varPath ? [varPath, key].join("/") : key;
             return setVariablesRecursive(projectId, configId, newVarPath, item);

package/lib/gcp/rules.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testRuleset = exports.updateOrCreateRelease = exports.updateRelease = exports.createRelease = exports.createRuleset = exports.deleteRuleset = exports.getRulesetId = exports.listAllRulesets = exports.listRulesets = exports.getRulesetContent = exports.listAllReleases = exports.listReleases = exports.getLatestRulesetName = void 0;
-const _ = require("lodash");
 const api_1 = require("../api");
 const apiv2_1 = require("../apiv2");
 const logger_1 = require("../logger");
@@ -51,7 +50,7 @@ async function listAllReleases(projectId) {
         }
         pageToken = response.nextPageToken;
     } while (pageToken);
-    return _.orderBy(releases, ["createTime"], ["desc"]);
+    return releases.sort((a, b) => b.createTime.localeCompare(a.createTime));
 }
 exports.listAllReleases = listAllReleases;
 async function getRulesetContent(name) {
@@ -90,7 +89,7 @@ async function listAllRulesets(projectId) {
         }
         pageToken = response.nextPageToken;
     } while (pageToken);
-    return _.orderBy(rulesets, ["createTime"], ["desc"]);
+    return rulesets.sort((a, b) => b.createTime.localeCompare(a.createTime));
 }
 exports.listAllRulesets = listAllRulesets;
 function getRulesetId(ruleset) {

package/lib/hosting/api.js

@@ -43,7 +43,7 @@ async function getChannel(project = "-", site, channelId) {
         return res.body;
     }
     catch (e) {
-        if (e.status === 404) {
+        if (e instanceof error_1.FirebaseError && e.status === 404) {
             return null;
         }
         throw e;
@@ -51,23 +51,22 @@ async function getChannel(project = "-", site, channelId) {
 }
 exports.getChannel = getChannel;
 async function listChannels(project = "-", site) {
-    var _a, _b;
     const channels = [];
     let nextPageToken = "";
     for (;;) {
         try {
             const res = await apiClient.get(`/projects/${project}/sites/${site}/channels`, { queryParams: { pageToken: nextPageToken, pageSize: 10 } });
-            const c = (_a = res.body) === null || _a === void 0 ? void 0 : _a.channels;
+            const c = res.body.channels;
             if (c) {
                 channels.push(...c);
             }
-            nextPageToken = ((_b = res.body) === null || _b === void 0 ? void 0 : _b.nextPageToken) || "";
+            nextPageToken = res.body.nextPageToken || "";
             if (!nextPageToken) {
                 return channels;
             }
         }
         catch (e) {
-            if (e.status === 404) {
+            if (e instanceof error_1.FirebaseError && e.status === 404) {
                 throw new error_1.FirebaseError(`could not find channels for site "${site}"`, {
                     original: e,
                 });
@@ -116,23 +115,22 @@ async function createRelease(site, channel, version) {
 }
 exports.createRelease = createRelease;
 async function listSites(project) {
-    var _a, _b;
     const sites = [];
     let nextPageToken = "";
     for (;;) {
         try {
             const res = await apiClient.get(`/projects/${project}/sites`, { queryParams: { pageToken: nextPageToken, pageSize: 10 } });
-            const c = (_a = res.body) === null || _a === void 0 ? void 0 : _a.sites;
+            const c = res.body.sites;
             if (c) {
                 sites.push(...c);
             }
-            nextPageToken = ((_b = res.body) === null || _b === void 0 ? void 0 : _b.nextPageToken) || "";
+            nextPageToken = res.body.nextPageToken || "";
             if (!nextPageToken) {
                 return sites;
             }
         }
         catch (e) {
-            if (e.status === 404) {
+            if (e instanceof error_1.FirebaseError && e.status === 404) {
                 throw new error_1.FirebaseError(`could not find sites for project "${project}"`, {
                     original: e,
                 });
@@ -148,7 +146,7 @@ async function getSite(project, site) {
         return res.body;
     }
     catch (e) {
-        if (e.status === 404) {
+        if (e instanceof error_1.FirebaseError && e.status === 404) {
             throw new error_1.FirebaseError(`could not find site "${site}" for project "${project}"`, {
                 original: e,
             });
@@ -158,7 +156,7 @@ async function getSite(project, site) {
 }
 exports.getSite = getSite;
 async function createSite(project, site, appId = "") {
-    const res = await apiClient.post(`/projects/${project}/sites`, { appId: appId }, { queryParams: { site_id: site } });
+    const res = await apiClient.post(`/projects/${project}/sites`, { appId: appId }, { queryParams: { siteId: site } });
     return res.body;
 }
 exports.createSite = createSite;

package/lib/hosting/expireUtils.js

@@ -16,8 +16,8 @@ const DURATIONS = {
 };
 exports.MAX_DURATION = 30 * Duration.DAY;
 exports.DEFAULT_DURATION = 7 * Duration.DAY;
-function calculateChannelExpireTTL(flag) {
-    const match = exports.DURATION_REGEX.exec(flag || "");
+function calculateChannelExpireTTL(flag = "") {
+    const match = exports.DURATION_REGEX.exec(flag);
     if (!match) {
         throw new error_1.FirebaseError(`"expires" flag must be a duration string (e.g. 24h or 7d) at most 30d`);
     }

package/lib/management/projects.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFirebaseProject = exports.listFirebaseProjects = exports.getAvailableCloudProjectPage = exports.getFirebaseProjectPage = exports.addFirebaseToCloudProject = exports.createCloudProject = exports.promptAvailableProjectId = exports.getOrPromptProject = exports.addFirebaseToCloudProjectAndLog = exports.createFirebaseProjectAndLog = exports.PROJECTS_CREATE_QUESTIONS = exports.ProjectParentResourceType = void 0;
-const _ = require("lodash");
 const clc = require("cli-color");
 const ora = require("ora");
 const apiv2_1 = require("../apiv2");
@@ -110,15 +109,15 @@ async function selectProjectByPrompting() {
     return await getFirebaseProject(projectId);
 }
 async function selectProjectFromList(projects = []) {
-    let choices = projects
+    const choices = projects
         .filter((p) => !!p)
         .map((p) => {
         return {
             name: p.projectId + (p.displayName ? ` (${p.displayName})` : ""),
             value: p.projectId,
         };
-    });
-    choices = _.orderBy(choices, ["name"], ["asc"]);
+    })
+        .sort((a, b) => a.name.localeCompare(b.name));
     if (choices.length >= 25) {
         utils.logBullet(`Don't want to scroll through all your projects? If you know your project ID, ` +
             `you can initialize it directly using ${clc.bold("firebase init --project <project_id>")}.\n`);
@@ -151,7 +150,7 @@ async function promptAvailableProjectId() {
         });
     }
     else {
-        let choices = projects
+        const choices = projects
             .filter((p) => !!p)
             .map((p) => {
             const projectId = getProjectId(p);
@@ -159,8 +158,8 @@ async function promptAvailableProjectId() {
                 name: projectId + (p.displayName ? ` (${p.displayName})` : ""),
                 value: projectId,
             };
-        });
-        choices = _.orderBy(choices, ["name"], ["asc"]);
+        })
+            .sort((a, b) => a.name.localeCompare(b.name));
         return await (0, prompt_1.promptOnce)({
             type: "list",
             name: "id",

package/lib/profileReport.js

@@ -303,14 +303,14 @@ class ProfileReport {
             });
         });
         const paths = Object.keys(unindexed);
-        paths.forEach((path) => {
+        for (const path of paths) {
             const indices = Object.keys(unindexed[path]);
-            indices.forEach((index) => {
+            for (const index of indices) {
                 const data = unindexed[path][index];
                 const row = [path, extractReadableIndex(data.query), formatNumber(data.times)];
                 table.push(row);
-            });
-        });
+            }
+        }
         return table;
     }
     renderBandwidth(pureData) {
@@ -327,8 +327,10 @@ class ProfileReport {
                 times: b1.times + b2.times,
             };
         });
-        const paths = _.orderBy(Object.keys(data), [(p) => data[p].bytes], ["desc"]);
-        paths.forEach((path) => {
+        const paths = Object.keys(data).sort((a, b) => {
+            return data[b].bytes - data[a].bytes;
+        });
+        for (const path of paths) {
             const bandwidth = data[path];
             const row = [
                 path,
@@ -337,7 +339,7 @@ class ProfileReport {
                 formatBytes(bandwidth.bytes / bandwidth.times),
             ];
             table.push(row);
-        });
+        }
         return table;
     }
     renderOutgoingBandwidth() {
@@ -392,12 +394,12 @@ class ProfileReport {
                 rejected: s1.rejected + s2.rejected,
             };
         });
-        let paths = Object.keys(data);
-        paths = _.orderBy(paths, (path) => {
-            const speed = data[path];
-            return speed.millis / speed.times;
-        }, ["desc"]);
-        paths.forEach((path) => {
+        const paths = Object.keys(data).sort((a, b) => {
+            const speedA = data[a].millis / data[a].times;
+            const speedB = data[b].millis / data[b].times;
+            return speedB - speedA;
+        });
+        for (const path of paths) {
             const speed = data[path];
             const row = [
                 path,
@@ -409,7 +411,7 @@ class ProfileReport {
                 row.push(formatNumber(speed.rejected));
             }
             table.push(row);
-        });
+        }
         return table;
     }
     renderReadSpeed() {

package/lib/rc.js

@@ -25,7 +25,7 @@ exports.loadRC = loadRC;
 class RC {
     constructor(rcpath, data) {
         this.path = rcpath;
-        this.data = Object.assign({ projects: {}, targets: {} }, data);
+        this.data = Object.assign({ projects: {}, targets: {}, etags: {} }, data);
     }
     static loadFile(rcpath) {
         let data = {};
@@ -148,6 +148,16 @@ class RC {
         }
         return target;
     }
+    getEtags(projectId) {
+        return this.data.etags[projectId] || { extensionInstances: {} };
+    }
+    setEtags(projectId, resourceType, etagData) {
+        if (!this.data.etags[projectId]) {
+            this.data.etags[projectId] = {};
+        }
+        this.data.etags[projectId][resourceType] = etagData;
+        this.save();
+    }
     save() {
         if (this.path) {
             fs.writeFileSync(this.path, JSON.stringify(this.data, null, 2), {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "firebase-tools",
-  "version": "11.2.1",
+  "version": "11.2.2",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-tools",
-      "version": "11.2.1",
+      "version": "11.2.2",
       "license": "MIT",
       "dependencies": {
         "@google-cloud/pubsub": "^3.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "11.2.1",
+  "version": "11.2.2",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {