firebase-tools 11.1.0 → 11.2.2

package/lib/config.js

@@ -18,6 +18,7 @@ const loadCJSON_1 = require("./loadCJSON");
 const parseBoltRules = require("./parseBoltRules");
 class Config {
     constructor(src, options = {}) {
+        var _a;
         this.data = {};
         this.defaults = {};
         this.notes = {};
@@ -31,8 +32,8 @@ class Config {
                 clc.bold("firebase use --add") +
                 " instead");
         }
-        if (_.has(this._src, "rules")) {
-            _.set(this._src, "database.rules", this._src.rules);
+        if ((_a = this._src) === null || _a === void 0 ? void 0 : _a.rules) {
+            this._src.database = Object.assign(Object.assign({}, this._src.database), { rules: this._src.rules });
         }
         Config.MATERIALIZE_TARGETS.forEach((target) => {
             if (_.get(this._src, target)) {
@@ -58,7 +59,7 @@ class Config {
             let out = this.parseFile(target, val);
             const segments = target.split(".");
             const lastSegment = segments[segments.length - 1];
-            if (Object.keys(out).length === 1 && _.has(out, lastSegment)) {
+            if (Object.keys(out).length === 1 && out[lastSegment]) {
                 out = out[lastSegment];
             }
             return out;

package/lib/deploy/database/prepare.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepare = void 0;
-const _ = require("lodash");
 const clc = require("cli-color");
 const path = require("path");
 const error_1 = require("../../error");
@@ -24,7 +23,7 @@ function prepare(context, options) {
         ruleFiles[ruleConfig.rules] = null;
         deploys.push(ruleConfig);
     });
-    _.forEach(ruleFiles, (v, file) => {
+    for (const file of Object.keys(ruleFiles)) {
         switch (path.extname(file)) {
             case ".json":
                 ruleFiles[file] = options.config.readProjectFile(file);
@@ -35,7 +34,7 @@ function prepare(context, options) {
             default:
                 throw new error_1.FirebaseError("Unexpected rules format " + path.extname(file));
         }
-    });
+    }
     context.database = {
         deploys: deploys,
         ruleFiles: ruleFiles,

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/extensions/secrets.js

@@ -6,7 +6,7 @@ const secretUtils = require("../../extensions/secretsUtils");
 const secretManager = require("../../gcp/secretManager");
 const planner_1 = require("./planner");
 const askUserForParam_1 = require("../../extensions/askUserForParam");
-const extensionsApi_1 = require("../../extensions/extensionsApi");
+const types_1 = require("../../extensions/types");
 const error_1 = require("../../error");
 const logger_1 = require("../../logger");
 const utils_1 = require("../../utils");
@@ -34,7 +34,7 @@ async function checkSpecForSecrets(i) {
 }
 exports.checkSpecForSecrets = checkSpecForSecrets;
 const secretsInSpec = (spec) => {
-    return spec.params.filter((p) => p.type === extensionsApi_1.ParamType.SECRET);
+    return spec.params.filter((p) => p.type === types_1.ParamType.SECRET);
 };
 async function handleSecretsCreateInstance(i, nonInteractive) {
     const extensionVersion = await (0, planner_1.getExtensionVersion)(i);
@@ -49,7 +49,7 @@ async function handleSecretsUpdateInstance(i, prevSpec, nonInteractive) {
     const secretParams = secretsInSpec(extensionVersion.spec);
     for (const s of secretParams) {
         const prevParam = prevExtensionVersion.spec.params.find((p) => p.param === s.param);
-        if ((prevParam === null || prevParam === void 0 ? void 0 : prevParam.type) === extensionsApi_1.ParamType.SECRET && prevSpec.params[prevParam === null || prevParam === void 0 ? void 0 : prevParam.param]) {
+        if ((prevParam === null || prevParam === void 0 ? void 0 : prevParam.type) === types_1.ParamType.SECRET && prevSpec.params[prevParam === null || prevParam === void 0 ? void 0 : prevParam.param]) {
             await handleSecretParamForUpdate(s, i, prevSpec.params[prevParam === null || prevParam === void 0 ? void 0 : prevParam.param], nonInteractive);
         }
         else {

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,25 +52,30 @@ 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");
             }
-            if (bdEndpoint.serviceAccount) {
-                bkEndpoint.serviceAccountEmail = bdEndpoint.serviceAccount;
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "serviceAccountEmail", "serviceAccount");
+            if ("serviceAccountEmail" in bkEndpoint && !bdEndpoint.serviceAccount) {
+                delete bkEndpoint.serviceAccountEmail;
             }
             bkEndpoints.push(bkEndpoint);
         }
@@ -103,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 = {};
@@ -121,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/ensure.js

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.secretAccess = exports.maybeEnableAR = exports.cloudBuildEnabled = exports.defaultServiceAccount = void 0;
+exports.secretAccess = exports.cloudBuildEnabled = exports.defaultServiceAccount = void 0;
 const clc = require("cli-color");
 const ensureApiEnabled_1 = require("../../ensureApiEnabled");
 const error_1 = require("../../error");
 const utils_1 = require("../../utils");
 const secretManager_1 = require("../../gcp/secretManager");
-const previews_1 = require("../../previews");
 const projects_1 = require("../../management/projects");
 const functional_1 = require("../../functional");
 const track_1 = require("../../track");
 const backend = require("./backend");
-const ensureApiEnabled = require("../../ensureApiEnabled");
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
 const CLOUD_BUILD_API = "cloudbuild.googleapis.com";
 async function defaultServiceAccount(e) {
@@ -66,14 +64,6 @@ async function cloudBuildEnabled(projectId) {
     }
 }
 exports.cloudBuildEnabled = cloudBuildEnabled;
-async function maybeEnableAR(projectId) {
-    if (!previews_1.previews.artifactregistry) {
-        return ensureApiEnabled.check(projectId, "artifactregistry.googleapis.com", "functions", true);
-    }
-    await ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "functions");
-    return true;
-}
-exports.maybeEnableAR = maybeEnableAR;
 async function secretsToServiceAccounts(b) {
     const secretsToSa = {};
     for (const e of backend.allEndpoints(b)) {

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

@@ -21,7 +21,6 @@ const triggerRegionHelper_1 = require("./triggerRegionHelper");
 const checkIam_1 = require("./checkIam");
 const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
-const previews_1 = require("../../previews");
 const v1_1 = require("../../functions/events/v1");
 const serviceusage_1 = require("../../gcp/serviceusage");
 function hasUserConfig(config) {
@@ -40,9 +39,8 @@ async function prepare(context, options, payload) {
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensure.cloudBuildEnabled(projectId),
-        ensure.maybeEnableAR(projectId),
+        ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "artifactregistry"),
     ]);
-    context.artifactRegistryEnabled = checkAPIsEnabled[3];
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
     let runtimeConfig = { firebase: firebaseConfig };
@@ -79,15 +77,8 @@ async function prepare(context, options, payload) {
         };
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
-        let wantBackend;
-        if (previews_1.previews.functionsparams) {
-            const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
-            wantBackend = build.resolveBackend(wantBuild, userEnvs);
-        }
-        else {
-            logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
-            wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
-        }
+        const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
+        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
         wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;
@@ -145,7 +136,6 @@ async function prepare(context, options, payload) {
     }));
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         const V2_APIS = [
-            "artifactregistry.googleapis.com",
             "run.googleapis.com",
             "eventarc.googleapis.com",
             "pubsub.googleapis.com",

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareFunctionsUpload = exports.getFunctionsConfig = void 0;
-const _ = require("lodash");
 const archiver = require("archiver");
 const clc = require("cli-color");
 const filesize = require("filesize");
@@ -54,12 +53,12 @@ async function packageSource(sourceDir, config, runtimeConfig) {
     ignore.push("firebase-debug.log", "firebase-debug.*.log", CONFIG_DEST_FILE);
     try {
         const files = await fsAsync.readdirRecursive({ path: sourceDir, ignore: ignore });
-        _.forEach(files, (file) => {
+        for (const file of files) {
             archive.file(file.name, {
                 name: path.relative(sourceDir, file.name),
                 mode: file.mode,
             });
-        });
+        }
         if (typeof runtimeConfig !== "undefined") {
             archive.append(JSON.stringify(runtimeConfig, null, 2), {
                 name: CONFIG_DEST_FILE,

package/lib/deploy/functions/release/fabricator.js

@@ -36,7 +36,6 @@ const gcfV2PollerOptions = {
     masterTimeout: 25 * 60 * 1000,
     maxBackoff: 10000,
 };
-const DEFAULT_GCFV2_CONCURRENCY = 80;
 const rethrowAs = (endpoint, op) => (err) => {
     logger_1.logger.error(err.message);
     throw new reporter.DeploymentError(endpoint, op, err);

package/lib/deploy/functions/release/index.js

@@ -63,11 +63,7 @@ async function release(context, options, payload) {
     const deletedEndpoints = Object.values(plan)
         .map((r) => r.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
-    const opts = {};
-    if (!context.artifactRegistryEnabled) {
-        opts.ar = new containerCleaner.NoopArtifactRegistryCleaner();
-    }
-    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints, opts);
+    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints);
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };

package/lib/deploy/functions/runtimes/discovery/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFromPort = exports.detectFromYaml = exports.yamlToBackend = exports.readFileAsync = void 0;
+exports.detectFromPort = exports.detectFromYaml = exports.yamlToBuild = exports.yamlToBackend = exports.readFileAsync = void 0;
 const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
 const path = require("path");
@@ -26,6 +26,21 @@ function yamlToBackend(yaml, project, region, runtime) {
     }
 }
 exports.yamlToBackend = yamlToBackend;
+function yamlToBuild(yaml, project, region, runtime) {
+    try {
+        if (!yaml.specVersion) {
+            throw new error_1.FirebaseError("Expect manifest yaml to specify a version number");
+        }
+        if (yaml.specVersion === "v1alpha1") {
+            return v1alpha1.buildFromV1Alpha1(yaml, project, region, runtime);
+        }
+        throw new error_1.FirebaseError("It seems you are using a newer SDK than this version of the CLI can handle. Please update your CLI with `npm install -g firebase-tools`");
+    }
+    catch (err) {
+        throw new error_1.FirebaseError("Failed to parse build specification", { children: [err] });
+    }
+}
+exports.yamlToBuild = yamlToBuild;
 async function detectFromYaml(directory, project, runtime) {
     let text;
     try {
@@ -42,7 +57,7 @@ async function detectFromYaml(directory, project, runtime) {
     }
     logger_1.logger.debug("Found functions.yaml. Got spec:", text);
     const parsed = yaml.load(text);
-    return yamlToBackend(parsed, project, api.functionsDefaultRegion, runtime);
+    return yamlToBuild(parsed, project, api.functionsDefaultRegion, runtime);
 }
 exports.detectFromYaml = detectFromYaml;
 async function detectFromPort(port, project, runtime, timeout = 30000) {
@@ -74,6 +89,6 @@ async function detectFromPort(port, project, runtime, timeout = 30000) {
         logger_1.logger.debug("Failed to parse functions.yaml", err);
         throw new error_1.FirebaseError(`Failed to load function definition from source: ${text}`);
     }
-    return yamlToBackend(parsed, project, api.functionsDefaultRegion, runtime);
+    return yamlToBuild(parsed, project, api.functionsDefaultRegion, runtime);
 }
 exports.detectFromPort = detectFromPort;