firebase-tools 11.0.1 → 11.2.1

package/lib/deploy/firestore/prepare.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require("lodash");
 const clc = require("cli-color");
-const loadCJSON = require("../../loadCJSON");
+const loadCJSON_1 = require("../../loadCJSON");
 const rulesDeploy_1 = require("../../rulesDeploy");
 const utils = require("../../utils");
 async function prepareRules(context, options) {
@@ -22,7 +22,7 @@ function prepareIndexes(context, options) {
     }
     const indexesFileName = options.config.src.firestore.indexes;
     const indexesPath = options.config.path(indexesFileName);
-    const parsedSrc = loadCJSON(indexesPath);
+    const parsedSrc = (0, loadCJSON_1.loadCJSON)(indexesPath);
     utils.logBullet(`${clc.bold.cyan("firestore:")} reading indexes from ${clc.bold(indexesFileName)}...`);
     context.firestore = context.firestore || {};
     context.firestore.indexes = {

package/lib/deploy/functions/build.js

@@ -56,44 +56,46 @@ function resolveBackend(build, userEnvs) {
         if (!userEnvs.hasOwnProperty(expectedEnv)) {
             throw new error_1.FirebaseError("Build specified parameter " +
                 expectedEnv +
-                " but it was not present in the user dotenv files");
+                " but it was not present in the user dotenv files or Cloud Secret Manager");
         }
     }
     const bkEndpoints = [];
     for (const endpointId of Object.keys(build.endpoints)) {
-        const endpoint = build.endpoints[endpointId];
-        let regions = endpoint.region;
+        const bdEndpoint = build.endpoints[endpointId];
+        let regions = bdEndpoint.region;
         if (typeof regions === "undefined") {
             regions = [api.functionsDefaultRegion];
         }
         for (const region of regions) {
-            const trigger = discoverTrigger(endpoint);
-            if (typeof endpoint.platform === "undefined") {
+            const trigger = discoverTrigger(bdEndpoint);
+            if (typeof bdEndpoint.platform === "undefined") {
                 throw new error_1.FirebaseError("platform can't be undefined");
             }
-            if (!isMemoryOption(endpoint.availableMemoryMb)) {
+            if (!isMemoryOption(bdEndpoint.availableMemoryMb)) {
                 throw new error_1.FirebaseError("available memory must be a supported value, if present");
             }
             let timeout;
-            if (endpoint.timeoutSeconds) {
-                timeout = resolveInt(endpoint.timeoutSeconds);
+            if (bdEndpoint.timeoutSeconds) {
+                timeout = resolveInt(bdEndpoint.timeoutSeconds);
             }
             else {
                 timeout = 60;
             }
-            const bkEndpoint = Object.assign({ id: endpointId, project: endpoint.project, region: region, entryPoint: endpoint.entryPoint, platform: endpoint.platform, runtime: endpoint.runtime, timeoutSeconds: timeout }, trigger);
-            proto.renameIfPresent(bkEndpoint, endpoint, "maxInstances", "maxInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, endpoint, "minInstances", "minInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, endpoint, "concurrency", "concurrency", resolveInt);
-            proto.copyIfPresent(bkEndpoint, endpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
-            if (endpoint.vpc) {
+            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.copyIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
+            proto.copyIfPresent(bkEndpoint, bdEndpoint, "secretEnvironmentVariables");
+            if (bdEndpoint.vpc) {
                 bkEndpoint.vpc = {
-                    connector: resolveString(endpoint.vpc.connector).replace("$REGION", region),
+                    connector: resolveString(bdEndpoint.vpc.connector).replace("$REGION", region),
                 };
-                proto.copyIfPresent(bkEndpoint.vpc, endpoint.vpc, "egressSettings");
+                proto.copyIfPresent(bkEndpoint.vpc, bdEndpoint.vpc, "egressSettings");
             }
-            if (endpoint.serviceAccount) {
-                bkEndpoint.serviceAccountEmail = endpoint.serviceAccount;
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "serviceAccountEmail", "serviceAccount");
+            if ("serviceAccountEmail" in bkEndpoint && !bdEndpoint.serviceAccount) {
+                delete bkEndpoint.serviceAccountEmail;
             }
             bkEndpoints.push(bkEndpoint);
         }
@@ -116,7 +118,7 @@ function discoverTrigger(endpoint) {
         trigger = { callableTrigger: {} };
     }
     else if ("blockingTrigger" in endpoint) {
-        throw new error_1.FirebaseError("blocking triggers not supported");
+        trigger = { blockingTrigger: endpoint.blockingTrigger };
     }
     else if ("eventTrigger" in endpoint) {
         const bkEventFilters = {};
@@ -143,7 +145,18 @@ function discoverTrigger(endpoint) {
             schedule: resolveString(endpoint.scheduleTrigger.schedule),
             timeZone: resolveString(endpoint.scheduleTrigger.timeZone),
         };
-        proto.renameIfPresent(bkSchedule, endpoint.scheduleTrigger, "retryConfig", "retryConfig", resolveInt);
+        const bkRetry = {};
+        if (endpoint.scheduleTrigger.retryConfig.maxBackoffSeconds) {
+            bkRetry.maxBackoffDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.maxBackoffSeconds));
+        }
+        if (endpoint.scheduleTrigger.retryConfig.minBackoffSeconds) {
+            bkRetry.minBackoffDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.minBackoffSeconds));
+        }
+        if (endpoint.scheduleTrigger.retryConfig.maxRetrySeconds) {
+            bkRetry.maxRetryDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.maxRetrySeconds));
+        }
+        proto.copyIfPresent(bkRetry, endpoint.scheduleTrigger.retryConfig, "retryCount", "maxDoublings");
+        bkSchedule.retryConfig = bkRetry;
         trigger = { scheduleTrigger: bkSchedule };
     }
     else if ("taskQueueTrigger" in endpoint) {

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/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 = build.resolveBackend(wantBuild, 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;

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

@@ -1,7 +1,19 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.backendFromV1Alpha1 = void 0;
+exports.backendFromV1Alpha1 = exports.buildFromV1Alpha1 = void 0;
 const backend = require("../../backend");
+const build = require("../../build");
 const proto_1 = require("../../../../gcp/proto");
 const parsing_1 = require("./parsing");
 const error_1 = require("../../../../error");
@@ -11,6 +23,25 @@ const CHANNEL_NAME_REGEX = new RegExp("(projects\\/" +
     "(?<location>[A-Za-z\\d\\-_]+)\\/" +
     "channels\\/" +
     "(?<channel>[A-Za-z\\d\\-_]+)");
+function buildFromV1Alpha1(yaml, project, region, runtime) {
+    const manifest = JSON.parse(JSON.stringify(yaml));
+    (0, parsing_1.requireKeys)("", manifest, "endpoints");
+    (0, parsing_1.assertKeyTypes)("", manifest, {
+        specVersion: "string",
+        requiredAPIs: "array",
+        endpoints: "object",
+    });
+    const bd = build.empty();
+    bd.requiredAPIs = parseRequiredAPIs(manifest);
+    for (const id of Object.keys(manifest.endpoints)) {
+        const me = manifest.endpoints[id];
+        assertManifestEndpoint(me, id);
+        const be = parseEndpointForBuild(id, me, project, region, runtime);
+        bd.endpoints[id] = be;
+    }
+    return bd;
+}
+exports.buildFromV1Alpha1 = buildFromV1Alpha1;
 function backendFromV1Alpha1(yaml, project, region, runtime) {
     const manifest = JSON.parse(JSON.stringify(yaml));
     const bkend = backend.empty();
@@ -42,10 +73,8 @@ function parseRequiredAPIs(manifest) {
     }
     return requiredAPIs;
 }
-function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
-    const allParsed = [];
+function assertManifestEndpoint(ep, id) {
     const prefix = `endpoints[${id}]`;
-    const ep = manifest.endpoints[id];
     (0, parsing_1.assertKeyTypes)(prefix, ep, {
         region: "array",
         platform: (platform) => backend.AllFunctionsPlatforms.includes(platform),
@@ -101,19 +130,164 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
     if (triggerCount > 1) {
         throw new error_1.FirebaseError("Multiple triggers defined for endpoint" + id);
     }
+    if (backend.isEventTriggered(ep)) {
+        (0, parsing_1.requireKeys)(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
+        (0, parsing_1.assertKeyTypes)(prefix + ".eventTrigger", ep.eventTrigger, {
+            eventFilters: "object",
+            eventFilterPathPatterns: "object",
+            eventType: "string",
+            retry: "boolean",
+            region: "string",
+            serviceAccountEmail: "string",
+            channel: "string",
+        });
+    }
+    else if (backend.isHttpsTriggered(ep)) {
+        (0, parsing_1.assertKeyTypes)(prefix + ".httpsTrigger", ep.httpsTrigger, {
+            invoker: "array",
+        });
+    }
+    else if (backend.isCallableTriggered(ep)) {
+    }
+    else if (backend.isScheduleTriggered(ep)) {
+        (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
+            schedule: "string",
+            timeZone: "string",
+            retryConfig: "object",
+        });
+        (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
+            retryCount: "number",
+            maxDoublings: "number",
+            minBackoffDuration: "string",
+            maxBackoffDuration: "string",
+            maxRetryDuration: "string",
+        });
+    }
+    else if (backend.isTaskQueueTriggered(ep)) {
+        (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
+            rateLimits: "object",
+            retryConfig: "object",
+            invoker: "array",
+        });
+        if (ep.taskQueueTrigger.rateLimits) {
+            (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
+                maxConcurrentDispatches: "number",
+                maxDispatchesPerSecond: "number",
+            });
+        }
+        if (ep.taskQueueTrigger.retryConfig) {
+            (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
+                maxAttempts: "number",
+                maxRetrySeconds: "number",
+                minBackoffSeconds: "number",
+                maxBackoffSeconds: "number",
+                maxDoublings: "number",
+            });
+        }
+    }
+    else if (backend.isBlockingTriggered(ep)) {
+        (0, parsing_1.requireKeys)(prefix + ".blockingTrigger", ep.blockingTrigger, "eventType");
+        (0, parsing_1.assertKeyTypes)(prefix + ".blockingTrigger", ep.blockingTrigger, {
+            eventType: "string",
+            options: "object",
+        });
+    }
+    else {
+        throw new error_1.FirebaseError(`Do not recognize trigger type for endpoint ${id}. Try upgrading ` +
+            "firebase-tools with npm install -g firebase-tools@latest");
+    }
+}
+function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
+    let triggered;
+    if (backend.isEventTriggered(ep)) {
+        const newTrigger = __rest(ep.eventTrigger, []);
+        delete newTrigger.serviceAccountEmail;
+        triggered = { eventTrigger: newTrigger };
+        triggered.eventTrigger.serviceAccount = ep.eventTrigger.serviceAccountEmail;
+        (0, proto_1.renameIfPresent)(triggered.eventTrigger, ep.eventTrigger, "channel", "channel", (c) => resolveChannelName(project, c, defaultRegion));
+        for (const [k, v] of Object.entries(triggered.eventTrigger.eventFilters)) {
+            if (k === "topic" && !v.startsWith("projects/")) {
+                triggered.eventTrigger.eventFilters[k] = `projects/${project}/topics/${v}`;
+            }
+        }
+    }
+    else if (backend.isHttpsTriggered(ep)) {
+        triggered = { httpsTrigger: {} };
+        (0, proto_1.copyIfPresent)(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
+    }
+    else if (backend.isCallableTriggered(ep)) {
+        triggered = { callableTrigger: {} };
+    }
+    else if (backend.isScheduleTriggered(ep)) {
+        const st = {
+            schedule: ep.scheduleTrigger.schedule || "",
+            timeZone: ep.scheduleTrigger.timeZone || "",
+            retryConfig: {},
+        };
+        if (ep.scheduleTrigger.retryConfig) {
+            st.retryConfig = {
+                retryCount: ep.scheduleTrigger.retryConfig.retryCount,
+                maxDoublings: ep.scheduleTrigger.retryConfig.maxDoublings,
+            };
+            if (ep.scheduleTrigger.retryConfig.maxRetryDuration) {
+                st.retryConfig.maxRetrySeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.maxRetryDuration);
+            }
+            if (ep.scheduleTrigger.retryConfig.maxBackoffDuration) {
+                st.retryConfig.maxBackoffSeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.maxBackoffDuration);
+            }
+            if (ep.scheduleTrigger.retryConfig.minBackoffDuration) {
+                st.retryConfig.minBackoffSeconds = (0, proto_1.secondsFromDuration)(ep.scheduleTrigger.retryConfig.minBackoffDuration);
+            }
+        }
+        triggered = { scheduleTrigger: st };
+    }
+    else if (backend.isTaskQueueTriggered(ep)) {
+        const tq = {
+            invoker: ep.taskQueueTrigger.invoker,
+            rateLimits: ep.taskQueueTrigger.rateLimits,
+        };
+        if (ep.taskQueueTrigger.retryConfig) {
+            tq.retryConfig = {
+                maxRetryDurationSeconds: ep.taskQueueTrigger.retryConfig.maxRetrySeconds,
+                maxBackoffSeconds: ep.taskQueueTrigger.retryConfig.maxBackoffSeconds,
+                minBackoffSeconds: ep.taskQueueTrigger.retryConfig.minBackoffSeconds,
+                maxDoublings: ep.taskQueueTrigger.retryConfig.maxDoublings,
+                maxAttempts: ep.taskQueueTrigger.retryConfig.maxAttempts,
+            };
+        }
+        triggered = { taskQueueTrigger: tq };
+    }
+    else if (backend.isBlockingTriggered(ep)) {
+        triggered = { blockingTrigger: ep.blockingTrigger };
+    }
+    else {
+        throw new error_1.FirebaseError(`Do not recognize trigger type for endpoint ${id}. Try upgrading ` +
+            "firebase-tools with npm install -g firebase-tools@latest");
+    }
+    const parsed = Object.assign({ platform: ep.platform || "gcfv2", region: ep.region || [defaultRegion], project,
+        runtime, entryPoint: ep.entryPoint, serviceAccount: ep.serviceAccountEmail || null }, triggered);
+    (0, proto_1.copyIfPresent)(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables");
+    (0, proto_1.renameIfPresent)(parsed, ep, "secretEnvironmentVariables", "secretEnvironmentVariables", (senvs) => {
+        const secretEnvironmentVariables = [];
+        for (const { key, secret } of senvs) {
+            secretEnvironmentVariables.push({
+                key,
+                secret: secret || key,
+                projectId: project,
+            });
+        }
+        return secretEnvironmentVariables;
+    });
+    return parsed;
+}
+function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
+    const allParsed = [];
+    const prefix = `endpoints[${id}]`;
+    const ep = manifest.endpoints[id];
+    assertManifestEndpoint(ep, prefix);
     for (const region of ep.region || [defaultRegion]) {
         let triggered;
         if (backend.isEventTriggered(ep)) {
-            (0, parsing_1.requireKeys)(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
-            (0, parsing_1.assertKeyTypes)(prefix + ".eventTrigger", ep.eventTrigger, {
-                eventFilters: "object",
-                eventFilterPathPatterns: "object",
-                eventType: "string",
-                retry: "boolean",
-                region: "string",
-                serviceAccountEmail: "string",
-                channel: "string",
-            });
             triggered = { eventTrigger: ep.eventTrigger };
             (0, proto_1.renameIfPresent)(triggered.eventTrigger, ep.eventTrigger, "channel", "channel", (c) => resolveChannelName(project, c, defaultRegion));
             for (const [k, v] of Object.entries(triggered.eventTrigger.eventFilters)) {
@@ -123,9 +297,6 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
             }
         }
         else if (backend.isHttpsTriggered(ep)) {
-            (0, parsing_1.assertKeyTypes)(prefix + ".httpsTrigger", ep.httpsTrigger, {
-                invoker: "array",
-            });
             triggered = { httpsTrigger: {} };
             (0, proto_1.copyIfPresent)(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
         }
@@ -133,49 +304,12 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
             triggered = { callableTrigger: {} };
         }
         else if (backend.isScheduleTriggered(ep)) {
-            (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
-                schedule: "string",
-                timeZone: "string",
-                retryConfig: "object",
-            });
-            (0, parsing_1.assertKeyTypes)(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
-                retryCount: "number",
-                maxDoublings: "number",
-                minBackoffDuration: "string",
-                maxBackoffDuration: "string",
-                maxRetryDuration: "string",
-            });
             triggered = { scheduleTrigger: ep.scheduleTrigger };
         }
         else if (backend.isTaskQueueTriggered(ep)) {
-            (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
-                rateLimits: "object",
-                retryConfig: "object",
-                invoker: "array",
-            });
-            if (ep.taskQueueTrigger.rateLimits) {
-                (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
-                    maxConcurrentDispatches: "number",
-                    maxDispatchesPerSecond: "number",
-                });
-            }
-            if (ep.taskQueueTrigger.retryConfig) {
-                (0, parsing_1.assertKeyTypes)(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
-                    maxAttempts: "number",
-                    maxRetrySeconds: "number",
-                    minBackoffSeconds: "number",
-                    maxBackoffSeconds: "number",
-                    maxDoublings: "number",
-                });
-            }
             triggered = { taskQueueTrigger: ep.taskQueueTrigger };
         }
         else if (backend.isBlockingTriggered(ep)) {
-            (0, parsing_1.requireKeys)(prefix + ".blockingTrigger", ep.blockingTrigger, "eventType");
-            (0, parsing_1.assertKeyTypes)(prefix + ".blockingTrigger", ep.blockingTrigger, {
-                eventType: "string",
-                options: "object",
-            });
             triggered = { blockingTrigger: ep.blockingTrigger };
         }
         else {

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

@@ -5,11 +5,9 @@ const util_1 = require("util");
 const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
 const path = require("path");
-const portfinder = require("portfinder");
 const spawn = require("cross-spawn");
 const error_1 = require("../../../../error");
 const logger_1 = require("../../../../logger");
-const discovery = require("../discovery");
 const gomod = require("./gomod");
 const VERSION_TO_RUNTIME = {
     "1.13": "go113",
@@ -105,26 +103,8 @@ class Delegate {
             return p;
         });
     }
-    async discoverBuild(configValues, envs) {
-        return { requiredAPIs: [], endpoints: {}, params: [] };
-    }
-    async discoverSpec(configValues, envs) {
-        let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
-        if (!discovered) {
-            const getPort = (0, util_1.promisify)(portfinder.getPort);
-            const port = await getPort();
-            portfinder.basePort = port + 1;
-            const adminPort = await getPort();
-            const kill = await this.serve(port, adminPort, envs);
-            try {
-                discovered = await discovery.detectFromPort(adminPort, this.projectId, this.runtime);
-            }
-            finally {
-                await kill();
-            }
-        }
-        discovered.environmentVariables = envs;
-        return discovered;
+    async discoverBuild() {
+        return Promise.resolve({ requiredAPIs: [], endpoints: {}, params: [] });
     }
 }
 exports.Delegate = Delegate;

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

@@ -85,15 +85,15 @@ class Delegate {
             return p;
         });
     }
-    async discoverSpec(config, env) {
+    async discoverBuild(config, env) {
         if (!semver.valid(this.sdkVersion)) {
             logger_1.logger.debug(`Could not parse firebase-functions version '${this.sdkVersion}' into semver. Falling back to parseTriggers.`);
-            return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
+            return parseTriggers.discoverBuild(this.projectId, this.sourceDir, this.runtime, config, env);
         }
         if (semver.lt(this.sdkVersion, MIN_FUNCTIONS_SDK_VERSION)) {
             (0, utils_1.logLabeledWarning)("functions", `You are using an old version of firebase-functions SDK (${this.sdkVersion}). ` +
                 `Please update firebase-functions SDK to >=${MIN_FUNCTIONS_SDK_VERSION}`);
-            return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
+            return parseTriggers.discoverBuild(this.projectId, this.sourceDir, this.runtime, config, env);
         }
         let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
         if (!discovered) {
@@ -107,11 +107,7 @@ class Delegate {
                 await kill();
             }
         }
-        discovered.environmentVariables = env;
         return discovered;
     }
-    async discoverBuild(config, env) {
-        return parseTriggers.discoverBuild(this.projectId, this.sourceDir, this.runtime, config, env);
-    }
 }
 exports.Delegate = Delegate;