firebase-tools 11.5.0 → 11.8.0

package/lib/deploy/functions/build.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBackend = exports.resolveBackend = exports.of = exports.empty = void 0;
+exports.toBackend = exports.resolveBackend = exports.AllIngressSettings = exports.AllVpcEgressSettings = exports.AllFunctionsPlatforms = exports.isValidMemoryOption = exports.isBlockingTriggered = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isCallableTriggered = exports.isHttpsTriggered = exports.of = exports.empty = void 0;
 const backend = require("./backend");
 const proto = require("../../gcp/proto");
 const api = require("../../.../../api");
@@ -8,6 +8,7 @@ const params = require("./params");
 const previews_1 = require("../../previews");
 const error_1 = require("../../error");
 const functional_1 = require("../../functional");
+const env_1 = require("../../functions/env");
 const logger_1 = require("../../logger");
 function empty() {
     return {
@@ -23,15 +24,79 @@ function of(endpoints) {
     return build;
 }
 exports.of = of;
-async function resolveBackend(build, userEnvOpt, userEnvs) {
+function isHttpsTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "httpsTrigger");
+}
+exports.isHttpsTriggered = isHttpsTriggered;
+function isCallableTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "callableTrigger");
+}
+exports.isCallableTriggered = isCallableTriggered;
+function isEventTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "eventTrigger");
+}
+exports.isEventTriggered = isEventTriggered;
+function isScheduleTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "scheduleTrigger");
+}
+exports.isScheduleTriggered = isScheduleTriggered;
+function isTaskQueueTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "taskQueueTrigger");
+}
+exports.isTaskQueueTriggered = isTaskQueueTriggered;
+function isBlockingTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "blockingTrigger");
+}
+exports.isBlockingTriggered = isBlockingTriggered;
+const allMemoryOptions = [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+function isValidMemoryOption(mem) {
+    return allMemoryOptions.includes(mem);
+}
+exports.isValidMemoryOption = isValidMemoryOption;
+exports.AllFunctionsPlatforms = ["gcfv1", "gcfv2"];
+exports.AllVpcEgressSettings = ["PRIVATE_RANGES_ONLY", "ALL_TRAFFIC"];
+exports.AllIngressSettings = [
+    "ALLOW_ALL",
+    "ALLOW_INTERNAL_ONLY",
+    "ALLOW_INTERNAL_AND_GCLB",
+];
+async function resolveBackend(build, userEnvOpt, userEnvs, nonInteractive) {
+    var _a;
     const projectId = userEnvOpt.projectId;
     let paramValues = {};
     if (previews_1.previews.functionsparams) {
-        paramValues = await params.resolveParams(build.params, projectId, userEnvs);
+        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(userEnvs), nonInteractive);
+        const toWrite = {};
+        for (const paramName of Object.keys(paramValues)) {
+            if (userEnvs.hasOwnProperty(paramName)) {
+                continue;
+            }
+            toWrite[paramName] = ((_a = paramValues[paramName]) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+        }
+        (0, env_1.writeUserEnvs)(toWrite, userEnvOpt);
     }
     return toBackend(build, paramValues);
 }
 exports.resolveBackend = resolveBackend;
+function envWithTypes(rawEnvs) {
+    const out = {};
+    for (const envName of Object.keys(rawEnvs)) {
+        const value = rawEnvs[envName];
+        if (!isNaN(+value) && isFinite(+value) && !value.includes("e")) {
+            out[envName] = +value;
+        }
+        else if (value === "true") {
+            out[envName] = true;
+        }
+        else if (value === "false") {
+            out[envName] = false;
+        }
+        else {
+            out[envName] = value;
+        }
+    }
+    return out;
+}
 class Resolver {
     constructor(paramValues) {
         this.paramValues = paramValues;
@@ -127,7 +192,7 @@ function toBackend(build, paramValues) {
 }
 exports.toBackend = toBackend;
 function discoverTrigger(endpoint, region, r) {
-    if ("httpsTrigger" in endpoint) {
+    if (isHttpsTriggered(endpoint)) {
         const httpsTrigger = {};
         if (endpoint.httpsTrigger.invoker === null) {
             httpsTrigger.invoker = null;
@@ -137,13 +202,13 @@ function discoverTrigger(endpoint, region, r) {
         }
         return { httpsTrigger };
     }
-    else if ("callableTrigger" in endpoint) {
+    else if (isCallableTriggered(endpoint)) {
         return { callableTrigger: {} };
     }
-    else if ("blockingTrigger" in endpoint) {
+    else if (isBlockingTriggered(endpoint)) {
         return { blockingTrigger: endpoint.blockingTrigger };
     }
-    else if ("eventTrigger" in endpoint) {
+    else if (isEventTriggered(endpoint)) {
         const eventTrigger = {
             eventType: endpoint.eventTrigger.eventType,
             retry: r.resolveBoolean(endpoint.eventTrigger.retry) || false,
@@ -157,11 +222,13 @@ function discoverTrigger(endpoint, region, r) {
         r.resolveStrings(eventTrigger, endpoint.eventTrigger, "serviceAccount", "region", "channel");
         return { eventTrigger };
     }
-    else if ("scheduleTrigger" in endpoint) {
+    else if (isScheduleTriggered(endpoint)) {
         const bkSchedule = {
             schedule: r.resolveString(endpoint.scheduleTrigger.schedule),
-            timeZone: r.resolveString(endpoint.scheduleTrigger.timeZone),
         };
+        if (endpoint.scheduleTrigger.timeZone !== undefined) {
+            bkSchedule.timeZone = r.resolveString(endpoint.scheduleTrigger.timeZone);
+        }
         if (endpoint.scheduleTrigger.retryConfig) {
             const bkRetry = {};
             r.resolveInts(bkRetry, endpoint.scheduleTrigger.retryConfig, "maxBackoffSeconds", "minBackoffSeconds", "maxRetrySeconds", "retryCount", "maxDoublings");

package/lib/deploy/functions/checkIam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.getDefaultComputeServiceAgent = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
 const colorette_1 = require("colorette");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
@@ -68,11 +68,12 @@ async function checkHttpIam(context, options, payload) {
 }
 exports.checkHttpIam = checkHttpIam;
 function getPubsubServiceAgent(projectNumber) {
-    return `serviceAccount:service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
+    return `service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
 }
 function getDefaultComputeServiceAgent(projectNumber) {
-    return `serviceAccount:${projectNumber}-compute@developer.gserviceaccount.com`;
+    return `${projectNumber}-compute@developer.gserviceaccount.com`;
 }
+exports.getDefaultComputeServiceAgent = getDefaultComputeServiceAgent;
 function reduceEventsToServices(services, endpoint) {
     const service = (0, services_1.serviceForEndpoint)(endpoint);
     if (service.requiredProjectBindings && !services.find((s) => s.name === service.name)) {
@@ -83,13 +84,13 @@ function reduceEventsToServices(services, endpoint) {
 function obtainPubSubServiceAgentBindings(projectNumber) {
     const serviceAccountTokenCreatorBinding = {
         role: exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE,
-        members: [getPubsubServiceAgent(projectNumber)],
+        members: [`serviceAccount:${getPubsubServiceAgent(projectNumber)}`],
     };
     return [serviceAccountTokenCreatorBinding];
 }
 exports.obtainPubSubServiceAgentBindings = obtainPubSubServiceAgentBindings;
 function obtainDefaultComputeServiceAgentBindings(projectNumber) {
-    const defaultComputeServiceAgent = getDefaultComputeServiceAgent(projectNumber);
+    const defaultComputeServiceAgent = `serviceAccount:${getDefaultComputeServiceAgent(projectNumber)}`;
     const runInvokerBinding = {
         role: exports.RUN_INVOKER_ROLE,
         members: [defaultComputeServiceAgent],

package/lib/deploy/functions/params.js

@@ -21,7 +21,7 @@ function resolveInt(from, paramValues) {
     if (typeof from === "number") {
         return from;
     }
-    const match = /\A{{ params\.(\w+) }}\z/.exec(from);
+    const match = /{{ params\.(\w+) }}/.exec(from);
     if (!match) {
         throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
     }
@@ -102,20 +102,26 @@ function canSatisfyParam(param, value) {
     }
     (0, functional_1.assertExhaustive)(param);
 }
-async function resolveParams(params, projectId, userEnvs) {
+async function resolveParams(params, projectId, userEnvs, nonInteractive) {
     const paramValues = {};
     const [provided, outstanding] = (0, functional_1.partition)(params, (param) => {
-        return {}.hasOwnProperty.call(userEnvs, param.param);
+        return {}.hasOwnProperty.call(userEnvs, param.name);
     });
     for (const param of provided) {
-        if (!canSatisfyParam(param, userEnvs[param.param])) {
+        if (!canSatisfyParam(param, userEnvs[param.name])) {
             throw new error_1.FirebaseError("Parameter " +
-                param.param +
+                param.name +
                 " resolved to value from dotenv files " +
-                userEnvs[param.param] +
+                userEnvs[param.name] +
                 " of wrong type");
         }
-        paramValues[param.param] = userEnvs[param.param];
+        paramValues[param.name] = userEnvs[param.name];
+    }
+    if (nonInteractive && outstanding.length > 0) {
+        const envNames = outstanding.map((p) => p.name).join(", ");
+        throw new error_1.FirebaseError(`In non-interactive mode but have no value for the following environment variables: ${envNames}\n` +
+            "To continue, either run `firebase deploy` with an interactive terminal, or add values to a dotenv file. " +
+            "For information regarding how to use dotenv files, see https://firebase.google.com/docs/functions/config-env");
     }
     for (const param of outstanding) {
         let paramDefault = param.default;
@@ -123,9 +129,9 @@ async function resolveParams(params, projectId, userEnvs) {
             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");
+            throw new error_1.FirebaseError("Parameter " + param.name + " has default value " + paramDefault + " of wrong type");
         }
-        paramValues[param.param] = await promptParam(param, paramDefault);
+        paramValues[param.name] = await promptParam(param, paramDefault);
     }
     return paramValues;
 }
@@ -146,15 +152,15 @@ async function promptStringParam(param, resolvedDefault) {
     }
     switch (param.input.type) {
         case "select":
-            throw new error_1.FirebaseError("Build specified string parameter " + param.param + " with unsupported input type 'select'");
+            throw new error_1.FirebaseError("Build specified string parameter " + param.name + " with unsupported input type 'select'");
         case "text":
         default:
-            let prompt = `Enter a value for ${param.label || param.param}`;
+            let prompt = `Enter a value for ${param.label || param.name}:`;
             if (param.description) {
                 prompt += ` \n(${param.description})`;
             }
             return await (0, prompt_1.promptOnce)({
-                name: param.param,
+                name: param.name,
                 type: "input",
                 default: resolvedDefault,
                 message: prompt,
@@ -168,17 +174,17 @@ async function promptIntParam(param, resolvedDefault) {
     }
     switch (param.input.type) {
         case "select":
-            throw new error_1.FirebaseError("Build specified int parameter " + param.param + " with unsupported input type 'select'");
+            throw new error_1.FirebaseError("Build specified int parameter " + param.name + " with unsupported input type 'select'");
         case "text":
         default:
-            let prompt = `Enter a value for ${param.label || param.param}`;
+            let prompt = `Enter a value for ${param.label || param.name}:`;
             if (param.description) {
                 prompt += ` \n(${param.description})`;
             }
             let res;
             while (true) {
                 res = await (0, prompt_1.promptOnce)({
-                    name: param.param,
+                    name: param.name,
                     type: "number",
                     default: resolvedDefault,
                     message: prompt,
@@ -186,7 +192,7 @@ async function promptIntParam(param, resolvedDefault) {
                 if (Number.isInteger(res)) {
                     return res;
                 }
-                logger_1.logger.error(`${param.label || param.param} must be an integer; retrying...`);
+                logger_1.logger.error(`${param.label || param.name} 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 = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
+        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs, options.nonInteractive);
         wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;

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

@@ -24,6 +24,7 @@ const utils = require("../../../utils");
 const services = require("../services");
 const v1_1 = require("../../../functions/events/v1");
 const throttler_1 = require("../../../throttler/throttler");
+const checkIam_1 = require("../checkIam");
 const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
@@ -46,6 +47,7 @@ class Fabricator {
         this.functionExecutor = args.functionExecutor;
         this.sources = args.sources;
         this.appEngineLocation = args.appEngineLocation;
+        this.projectNumber = args.projectNumber;
     }
     async applyPlan(plan) {
         const timer = new timer_1.Timer();
@@ -270,6 +272,12 @@ class Fabricator {
                 .run(() => run.setInvokerCreate(endpoint.project, serviceName, ["public"]))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
+        else if (backend.isScheduleTriggered(endpoint)) {
+            const invoker = [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+            await this.executor
+                .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
         const hasCustomCPU = endpoint.cpu !== backend.memoryToGen1Cpu(mem);
         if (!endpoint.concurrency) {
@@ -346,6 +354,9 @@ class Fabricator {
             v1_1.AUTH_BLOCKING_EVENTS.includes(endpoint.blockingTrigger.eventType)) {
             invoker = ["public"];
         }
+        else if (backend.isScheduleTriggered(endpoint)) {
+            invoker = [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+        }
         if (invoker) {
             await this.executor
                 .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
@@ -452,13 +463,16 @@ class Fabricator {
         }
     }
     async upsertScheduleV1(endpoint) {
-        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
+        const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation, this.projectNumber);
         await this.executor
             .run(() => scheduler.createOrReplaceJob(job))
             .catch(rethrowAs(endpoint, "upsert schedule"));
     }
-    upsertScheduleV2(endpoint) {
-        return Promise.reject(new reporter.DeploymentError(endpoint, "upsert schedule", new Error("Not implemented")));
+    async upsertScheduleV2(endpoint) {
+        const job = scheduler.jobFromEndpoint(endpoint, endpoint.region, this.projectNumber);
+        await this.executor
+            .run(() => scheduler.createOrReplaceJob(job))
+            .catch(rethrowAs(endpoint, "upsert schedule"));
     }
     async upsertTaskQueue(endpoint) {
         const queue = cloudtasks.queueFromEndpoint(endpoint);
@@ -486,8 +500,11 @@ class Fabricator {
             .run(() => pubsub.deleteTopic(topicName))
             .catch(rethrowAs(endpoint, "delete topic"));
     }
-    deleteScheduleV2(endpoint) {
-        return Promise.reject(new reporter.DeploymentError(endpoint, "delete schedule", new Error("Not implemented")));
+    async deleteScheduleV2(endpoint) {
+        const jobName = scheduler.jobNameForEndpoint(endpoint, endpoint.region);
+        await this.executor
+            .run(() => scheduler.deleteJob(jobName))
+            .catch(rethrowAs(endpoint, "delete schedule"));
     }
     async disableTaskQueue(endpoint) {
         const update = {

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

@@ -14,6 +14,7 @@ const prompts = require("../prompts");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
+const getProjectNumber_1 = require("../../../getProjectNumber");
 async function release(context, options, payload) {
     if (!context.config) {
         return;
@@ -53,6 +54,7 @@ async function release(context, options, payload) {
         executor: new executor.QueueExecutor({}),
         sources: context.sources,
         appEngineLocation: (0, functionsConfig_1.getAppEngineLocation)(context.firebaseConfig),
+        projectNumber: options.projectNumber || (await (0, getProjectNumber_1.getProjectNumber)(context.projectId)),
     });
     const summary = await fab.applyPlan(plan);
     await reporter.logAndTrackDeployStats(summary);

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.yamlToBuild = exports.yamlToBackend = exports.readFileAsync = void 0;
+exports.detectFromPort = exports.detectFromYaml = exports.yamlToBuild = exports.readFileAsync = void 0;
 const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
 const path = require("path");
@@ -11,21 +11,6 @@ const api = require("../../.../../../../api");
 const v1alpha1 = require("./v1alpha1");
 const error_1 = require("../../../../error");
 exports.readFileAsync = (0, util_1.promisify)(fs.readFile);
-function yamlToBackend(yaml, project, region, runtime) {
-    try {
-        if (!yaml.specVersion) {
-            throw new error_1.FirebaseError("Expect backend yaml to specify a version number");
-        }
-        if (yaml.specVersion === "v1alpha1") {
-            return v1alpha1.backendFromV1Alpha1(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 backend specification", { children: [err] });
-    }
-}
-exports.yamlToBackend = yamlToBackend;
 function yamlToBuild(yaml, project, region, runtime) {
     try {
         if (!yaml.specVersion) {

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

@@ -31,6 +31,22 @@ function assertKeyTypes(prefix, yaml, schema) {
             }
             continue;
         }
+        if (value === null) {
+            if (schemaType.endsWith("?")) {
+                continue;
+            }
+            throw new error_1.FirebaseError(`Expected ${fullKey} to be type ${schemaType}; was null`);
+        }
+        if (schemaType.endsWith("?")) {
+            schemaType = schemaType.slice(0, schemaType.length - 1);
+        }
+        if (schemaType.includes("Field")) {
+            const match = /^Field<(\w+)>$/.exec(schemaType);
+            if (match && typeof value !== "string" && typeof value !== match[1]) {
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be Field<${match[1]}>; was ${typeof value}`);
+            }
+            continue;
+        }
         if (value === null) {
             if (schemaType.endsWith("?")) {
                 continue;