firebase-tools 9.17.0 → 9.21.0

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForV2Upgrade = exports.checkForIllegalUpdate = exports.upgradedScheduleFromV1ToV2 = exports.changedV2PubSubTopic = exports.changedTriggerRegion = exports.upgradedToGCFv2WithoutSettingConcurrency = exports.createDeploymentPlan = exports.calculateUpdate = exports.calculateRegionalChanges = void 0;
+const functionsDeployHelper_1 = require("../functionsDeployHelper");
+const functionsDeployHelper_2 = require("../functionsDeployHelper");
+const deploymentTool_1 = require("../../../deploymentTool");
+const error_1 = require("../../../error");
+const utils = require("../../../utils");
+const backend = require("../backend");
+const gcfv2 = require("../../../gcp/cloudfunctionsv2");
+function calculateRegionalChanges(want, have, options) {
+    const endpointsToCreate = Object.keys(want)
+        .filter((id) => !have[id])
+        .map((id) => want[id]);
+    const endpointsToDelete = Object.keys(have)
+        .filter((id) => !want[id])
+        .filter((id) => options.deleteAll || deploymentTool_1.isFirebaseManaged(have[id].labels || {}))
+        .map((id) => have[id]);
+    const endpointsToUpdate = Object.keys(want)
+        .filter((id) => have[id])
+        .map((id) => calculateUpdate(want[id], have[id]));
+    return { endpointsToCreate, endpointsToUpdate, endpointsToDelete };
+}
+exports.calculateRegionalChanges = calculateRegionalChanges;
+function calculateUpdate(want, have) {
+    checkForIllegalUpdate(want, have);
+    const update = {
+        endpoint: want,
+    };
+    const needsDelete = changedTriggerRegion(want, have) ||
+        changedV2PubSubTopic(want, have) ||
+        upgradedScheduleFromV1ToV2(want, have);
+    if (needsDelete) {
+        update.deleteAndRecreate = have;
+    }
+    return update;
+}
+exports.calculateUpdate = calculateUpdate;
+function createDeploymentPlan(want, have, options = {}) {
+    const deployment = {};
+    want = backend.matchingBackend(want, (endpoint) => {
+        return functionsDeployHelper_1.functionMatchesAnyGroup(endpoint, options.filters || []);
+    });
+    have = backend.matchingBackend(have, (endpoint) => {
+        return functionsDeployHelper_1.functionMatchesAnyGroup(endpoint, options.filters || []);
+    });
+    const regions = new Set([...Object.keys(want.endpoints), ...Object.keys(have.endpoints)]);
+    for (const region of regions) {
+        deployment[region] = calculateRegionalChanges(want.endpoints[region] || {}, have.endpoints[region] || {}, options);
+    }
+    if (upgradedToGCFv2WithoutSettingConcurrency(want, have)) {
+        utils.logLabeledBullet("functions", "You are updating one or more functions to Google Cloud Functions v2, " +
+            "which introduces support for concurrent execution. New functions " +
+            "default to 80 concurrent executions, but existing functions keep the " +
+            "old default of 1. You can change this with the 'concurrency' option.");
+    }
+    return deployment;
+}
+exports.createDeploymentPlan = createDeploymentPlan;
+function upgradedToGCFv2WithoutSettingConcurrency(want, have) {
+    return backend.someEndpoint(want, (endpoint) => {
+        var _a, _b;
+        if (((_b = (_a = have.endpoints[endpoint.region]) === null || _a === void 0 ? void 0 : _a[endpoint.id]) === null || _b === void 0 ? void 0 : _b.platform) !== "gcfv1") {
+            return false;
+        }
+        if (endpoint.platform !== "gcfv2") {
+            return false;
+        }
+        if (endpoint.concurrency) {
+            return false;
+        }
+        return true;
+    });
+}
+exports.upgradedToGCFv2WithoutSettingConcurrency = upgradedToGCFv2WithoutSettingConcurrency;
+function changedTriggerRegion(want, have) {
+    if (want.platform != "gcfv2") {
+        return false;
+    }
+    if (have.platform != "gcfv2") {
+        return false;
+    }
+    if (!backend.isEventTriggered(want)) {
+        return false;
+    }
+    if (!backend.isEventTriggered(have)) {
+        return false;
+    }
+    return want.eventTrigger.region != have.eventTrigger.region;
+}
+exports.changedTriggerRegion = changedTriggerRegion;
+function changedV2PubSubTopic(want, have) {
+    if (want.platform !== "gcfv2") {
+        return false;
+    }
+    if (have.platform !== "gcfv2") {
+        return false;
+    }
+    if (!backend.isEventTriggered(want)) {
+        return false;
+    }
+    if (!backend.isEventTriggered(have)) {
+        return false;
+    }
+    if (want.eventTrigger.eventType != gcfv2.PUBSUB_PUBLISH_EVENT) {
+        return false;
+    }
+    if (have.eventTrigger.eventType !== gcfv2.PUBSUB_PUBLISH_EVENT) {
+        return false;
+    }
+    return have.eventTrigger.eventFilters["resource"] != want.eventTrigger.eventFilters["resource"];
+}
+exports.changedV2PubSubTopic = changedV2PubSubTopic;
+function upgradedScheduleFromV1ToV2(want, have) {
+    if (have.platform !== "gcfv1") {
+        return false;
+    }
+    if (want.platform !== "gcfv2") {
+        return false;
+    }
+    if (!backend.isScheduleTriggered(have)) {
+        return false;
+    }
+    if (!backend.isScheduleTriggered(want)) {
+        return false;
+    }
+    return true;
+}
+exports.upgradedScheduleFromV1ToV2 = upgradedScheduleFromV1ToV2;
+function checkForIllegalUpdate(want, have) {
+    const triggerType = (e) => {
+        if (backend.isHttpsTriggered(e)) {
+            return "an HTTPS";
+        }
+        else if (backend.isEventTriggered(e)) {
+            return "a background triggered";
+        }
+        else if (backend.isScheduleTriggered(e)) {
+            return "a scheduled";
+        }
+        throw Error("Functions release planner is not able to handle an unknown trigger type");
+    };
+    const wantType = triggerType(want);
+    const haveType = triggerType(have);
+    if (wantType != haveType) {
+        throw new error_1.FirebaseError(`[${functionsDeployHelper_2.getFunctionLabel(want)}] Changing from ${haveType} function to ${wantType} function is not allowed. Please delete your function and create a new one instead.`);
+    }
+    if (want.platform == "gcfv1" && have.platform == "gcfv2") {
+        throw new error_1.FirebaseError(`[${functionsDeployHelper_2.getFunctionLabel(want)}] Functions cannot be downgraded from GCFv2 to GCFv1`);
+    }
+    exports.checkForV2Upgrade(want, have);
+}
+exports.checkForIllegalUpdate = checkForIllegalUpdate;
+function checkForV2Upgrade(want, have) {
+    if (want.platform == "gcfv2" && have.platform == "gcfv1") {
+        throw new error_1.FirebaseError(`[${functionsDeployHelper_2.getFunctionLabel(have)}] Upgrading from GCFv1 to GCFv2 is not yet supported. Please delete your old function or wait for this feature to be ready.`);
+    }
+}
+exports.checkForV2Upgrade = checkForV2Upgrade;

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerTag = exports.printAbortedErrors = exports.printErrors = exports.logAndTrackDeployStats = exports.AbortedDeploymentError = exports.DeploymentError = void 0;
+const backend = require("../backend");
+const clc = require("cli-color");
+const logger_1 = require("../../../logger");
+const track = require("../../../track");
+const utils = require("../../../utils");
+const functionsDeployHelper_1 = require("../functionsDeployHelper");
+class DeploymentError extends Error {
+    constructor(endpoint, op, original) {
+        super(`Failed to ${op} function ${endpoint.id} in region ${endpoint.region}`);
+        this.endpoint = endpoint;
+        this.op = op;
+        this.original = original;
+    }
+}
+exports.DeploymentError = DeploymentError;
+class AbortedDeploymentError extends DeploymentError {
+    constructor(endpoint) {
+        super(endpoint, "delete", new Error("aborted"));
+        this.endpoint = endpoint;
+    }
+}
+exports.AbortedDeploymentError = AbortedDeploymentError;
+async function logAndTrackDeployStats(summary) {
+    let totalTime = 0;
+    let totalErrors = 0;
+    let totalSuccesses = 0;
+    let totalAborts = 0;
+    const reports = [];
+    for (const result of summary.results) {
+        const tag = triggerTag(result.endpoint);
+        totalTime += result.durationMs;
+        if (!result.error) {
+            totalSuccesses++;
+            reports.push(track.track("function_deploy_success", tag, result.durationMs));
+        }
+        else if (result.error instanceof AbortedDeploymentError) {
+            totalAborts++;
+            reports.push(track.track("function_deploy_abort", tag, result.durationMs));
+        }
+        else {
+            totalErrors++;
+            reports.push(track.track("function_deploy_failure", tag, result.durationMs));
+        }
+    }
+    const gcfv1 = summary.results.find((r) => r.endpoint.platform === "gcfv1");
+    const gcfv2 = summary.results.find((r) => r.endpoint.platform === "gcfv2");
+    const tag = gcfv1 && gcfv2 ? "v1+v2" : gcfv1 ? "v1" : "v2";
+    reports.push(track.track("functions_codebase_deploy", tag, summary.results.length));
+    const avgTime = totalTime / (totalSuccesses + totalErrors);
+    logger_1.logger.debug(`Total Function Deployment time: ${summary.totalTime}`);
+    logger_1.logger.debug(`${totalErrors + totalSuccesses + totalAborts} Functions Deployed`);
+    logger_1.logger.debug(`${totalErrors} Functions Errored`);
+    logger_1.logger.debug(`${totalAborts} Function Deployments Aborted`);
+    logger_1.logger.debug(`Average Function Deployment time: ${avgTime}`);
+    if (totalErrors + totalSuccesses > 0) {
+        if (totalErrors === 0) {
+            reports.push(track.track("functions_deploy_result", "success", totalSuccesses));
+        }
+        else if (totalSuccesses > 0) {
+            reports.push(track.track("functions_deploy_result", "partial_success", totalSuccesses));
+            reports.push(track.track("functions_deploy_result", "partial_failure", totalErrors));
+            reports.push(track.track("functions_deploy_result", "partial_error_ratio", totalErrors / (totalSuccesses + totalErrors)));
+        }
+        else {
+            reports.push(track.track("functions_deploy_result", "failure", totalErrors));
+        }
+    }
+    await utils.allSettled(reports);
+}
+exports.logAndTrackDeployStats = logAndTrackDeployStats;
+function printErrors(summary) {
+    const errored = summary.results.filter((r) => r.error);
+    if (errored.length === 0) {
+        return;
+    }
+    errored.sort((left, right) => backend.compareFunctions(left.endpoint, right.endpoint));
+    logger_1.logger.info("");
+    logger_1.logger.info("Functions deploy had errors with the following functions:" +
+        errored
+            .filter((r) => !(r.error instanceof AbortedDeploymentError))
+            .map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`)
+            .join(""));
+    printIamErrors(errored);
+    printQuotaErrors(errored);
+    printAbortedErrors(errored);
+}
+exports.printErrors = printErrors;
+function printIamErrors(results) {
+    const iamFailures = results.filter((r) => r.error instanceof DeploymentError && r.error.op === "set invoker");
+    if (!iamFailures.length) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("Unable to set the invoker for the IAM policy on the following functions:" +
+        iamFailures.map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`).join(""));
+    logger_1.logger.info("");
+    logger_1.logger.info("Some common causes of this:");
+    logger_1.logger.info("");
+    logger_1.logger.info("- You may not have the roles/functions.admin IAM role. Note that " +
+        "roles/functions.developer does not allow you to change IAM policies.");
+    logger_1.logger.info("");
+    logger_1.logger.info("- An organization policy that restricts Network Access on your project.");
+    const hadImplicitMakePublic = iamFailures.find((r) => backend.isHttpsTriggered(r.endpoint) && !r.endpoint.httpsTrigger.invoker);
+    if (!hadImplicitMakePublic) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("One or more functions were being implicitly made publicly available on function create.");
+    logger_1.logger.info("Functions are not implicitly made public on updates. To try to make " +
+        "these functions public on next deploy, configure these functions with " +
+        `${clc.bold("invoker")} set to ${clc.bold(`"public"`)}`);
+}
+function printQuotaErrors(results) {
+    const hadQuotaError = results.find((r) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (!(r.error instanceof DeploymentError)) {
+            return false;
+        }
+        const original = r.error.original;
+        const code = (original === null || original === void 0 ? void 0 : original.status) || (original === null || original === void 0 ? void 0 : original.code) || ((_b = (_a = original === null || original === void 0 ? void 0 : original.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) || ((_c = original === null || original === void 0 ? void 0 : original.original) === null || _c === void 0 ? void 0 : _c.code) || ((_f = (_e = (_d = original === null || original === void 0 ? void 0 : original.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode);
+        return code === 429 || code === 409;
+    });
+    if (!hadQuotaError) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("Exceeded maximum retries while deploying functions. " +
+        "If you are deploying a large number of functions, " +
+        "please deploy your functions in batches by using the --only flag, " +
+        "and wait a few minutes before deploying again. " +
+        "Go to https://firebase.google.com/docs/cli/#partial_deploys to learn more.");
+}
+function printAbortedErrors(results) {
+    const aborted = results.filter((r) => r.error instanceof AbortedDeploymentError);
+    if (!aborted) {
+        return;
+    }
+    logger_1.logger.info("");
+    logger_1.logger.info("Because there were errors creating or updating functions, the following " +
+        "functions were not deleted" +
+        aborted.map((result) => `\n\t${functionsDeployHelper_1.getFunctionLabel(result.endpoint)}`).join(""));
+    logger_1.logger.info(`To delete these, use ${clc.bold("firebase functions:delete")}`);
+}
+exports.printAbortedErrors = printAbortedErrors;
+function triggerTag(endpoint) {
+    var _a;
+    const prefix = endpoint.platform === "gcfv1" ? "v1" : "v2";
+    if (backend.isScheduleTriggered(endpoint)) {
+        return `${prefix}.scheduled`;
+    }
+    if (backend.isHttpsTriggered(endpoint)) {
+        if ((_a = endpoint.labels) === null || _a === void 0 ? void 0 : _a["deployment-callable"]) {
+            return `${prefix}.callable`;
+        }
+        return `${prefix}.https`;
+    }
+    return endpoint.eventTrigger.eventType;
+}
+exports.triggerTag = triggerTag;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceTokenScraper = void 0;
+const logger_1 = require("../../../logger");
+class SourceTokenScraper {
+    constructor() {
+        this.firstCall = true;
+        this.promise = new Promise((resolve) => (this.resolve = resolve));
+    }
+    tokenPromise() {
+        if (this.firstCall) {
+            this.firstCall = false;
+            return Promise.resolve(undefined);
+        }
+        return this.promise;
+    }
+    get poller() {
+        return (op) => {
+            var _a, _b, _c, _d, _e;
+            if (((_a = op.metadata) === null || _a === void 0 ? void 0 : _a.sourceToken) || op.done) {
+                const [, , , region] = ((_c = (_b = op.metadata) === null || _b === void 0 ? void 0 : _b.target) === null || _c === void 0 ? void 0 : _c.split("/")) || [];
+                logger_1.logger.debug(`Got source token ${(_d = op.metadata) === null || _d === void 0 ? void 0 : _d.sourceToken} for region ${region}`);
+                this.resolve((_e = op.metadata) === null || _e === void 0 ? void 0 : _e.sourceToken);
+            }
+        };
+    }
+}
+exports.SourceTokenScraper = SourceTokenScraper;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor() {
+        this.start = process.hrtime.bigint();
+    }
+    stop() {
+        const stop = process.hrtime.bigint();
+        const elapsedNanos = stop - this.start;
+        return Number(elapsedNanos / BigInt(1e6));
+    }
+}
+exports.Timer = Timer;

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

@@ -2,150 +2,126 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.backendFromV1Alpha1 = void 0;
 const backend = require("../../backend");
+const proto_1 = require("../../../../gcp/proto");
 const parsing_1 = require("./parsing");
+const error_1 = require("../../../../error");
 function backendFromV1Alpha1(yaml, project, region, runtime) {
-    const bkend = JSON.parse(JSON.stringify(yaml));
-    delete bkend.specVersion;
-    tryValidate(bkend);
-    fillDefaults(bkend, project, region, runtime);
+    const manifest = JSON.parse(JSON.stringify(yaml));
+    const bkend = backend.empty();
+    bkend.requiredAPIs = parseRequiredAPIs(manifest);
+    parsing_1.requireKeys("", manifest, "endpoints");
+    parsing_1.assertKeyTypes("", manifest, {
+        specVersion: "string",
+        requiredAPIs: "object",
+        endpoints: "object",
+    });
+    for (const id of Object.keys(manifest.endpoints)) {
+        for (const parsed of parseEndpoints(manifest, id, project, region, runtime)) {
+            bkend.endpoints[parsed.region] = bkend.endpoints[parsed.region] || {};
+            bkend.endpoints[parsed.region][parsed.id] = parsed;
+        }
+    }
     return bkend;
 }
 exports.backendFromV1Alpha1 = backendFromV1Alpha1;
-function tryValidate(typed) {
-    var _a, _b;
-    parsing_1.assertKeyTypes("", typed, {
-        requiredAPIs: "object",
-        cloudFunctions: "array",
-        topics: "array",
-        schedules: "array",
+function parseRequiredAPIs(manifest) {
+    const requiredAPIs = {};
+    if (typeof manifest !== "object" || Array.isArray(manifest)) {
+        throw new error_1.FirebaseError("Expected requiredApis to be a map of string to string");
+    }
+    for (const [api, reason] of Object.entries(manifest.requiredAPIs || {})) {
+        if (typeof reason !== "string") {
+            throw new error_1.FirebaseError(`Invalid reason "${JSON.stringify(reason)} for API ${api}. Expected string`);
+        }
+        requiredAPIs[api] = reason;
+    }
+    return requiredAPIs;
+}
+function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
+    const allParsed = [];
+    const prefix = `endpoints[${id}]`;
+    const ep = manifest.endpoints[id];
+    parsing_1.assertKeyTypes(prefix, ep, {
+        region: "array",
+        platform: "string",
+        entryPoint: "string",
+        availableMemoryMb: "number",
+        maxInstances: "number",
+        minInstances: "number",
+        concurrency: "number",
+        serviceAccountEmail: "string",
+        timeout: "string",
+        vpcConnector: "string",
+        vpcConnectorEgressSettings: "string",
+        labels: "object",
+        ingressSettings: "string",
         environmentVariables: "object",
+        httpsTrigger: "object",
+        eventTrigger: "object",
+        scheduleTrigger: "object",
     });
-    parsing_1.requireKeys("", typed, "cloudFunctions");
-    for (let ndx = 0; ndx < typed.cloudFunctions.length; ndx++) {
-        const prefix = `cloudFunctions[${ndx}]`;
-        const func = typed.cloudFunctions[ndx];
-        parsing_1.requireKeys(prefix, func, "platform", "id", "entryPoint", "trigger");
-        parsing_1.assertKeyTypes(prefix, func, {
-            platform: "string",
-            id: "string",
-            region: "string",
-            project: "string",
-            runtime: "string",
-            entryPoint: "string",
-            availableMemoryMb: "number",
-            maxInstances: "number",
-            minInstances: "number",
-            concurrency: "number",
-            serviceAccountEmail: "string",
-            timeout: "string",
-            trigger: "object",
-            vpcConnector: "string",
-            vpcConnectorEgressSettings: "string",
-            labels: "object",
-            ingressSettings: "string",
-            environmentVariables: "omit",
-            uri: "omit",
-            sourceUploadUrl: "omit",
-        });
-        if (backend.isEventTrigger(func.trigger)) {
-            parsing_1.requireKeys(prefix + ".trigger", func.trigger, "eventType", "eventFilters");
-            parsing_1.assertKeyTypes(prefix + ".trigger", func.trigger, {
+    let triggerCount = 0;
+    if (ep.httpsTrigger) {
+        triggerCount++;
+    }
+    if (ep.eventTrigger) {
+        triggerCount++;
+    }
+    if (ep.scheduleTrigger) {
+        triggerCount++;
+    }
+    if (!triggerCount) {
+        throw new error_1.FirebaseError("Expected trigger in endpoint" + id);
+    }
+    if (triggerCount > 1) {
+        throw new error_1.FirebaseError("Multiple triggers defined for endpoint" + id);
+    }
+    for (const region of ep.region || [defaultRegion]) {
+        let triggered;
+        if (backend.isEventTriggered(ep)) {
+            parsing_1.requireKeys(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
+            parsing_1.assertKeyTypes(prefix + ".eventTrigger", ep.eventTrigger, {
                 eventFilters: "object",
                 eventType: "string",
                 retry: "boolean",
                 region: "string",
                 serviceAccountEmail: "string",
             });
+            triggered = { eventTrigger: ep.eventTrigger };
         }
-        else {
-            parsing_1.assertKeyTypes(prefix + ".trigger", func.trigger, {
-                allowInsecure: "boolean",
+        else if (backend.isHttpsTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".httpsTrigger", ep.httpsTrigger, {
                 invoker: "array",
             });
+            triggered = { httpsTrigger: {} };
+            proto_1.copyIfPresent(triggered.httpsTrigger, ep.httpsTrigger, "invoker");
         }
-    }
-    for (let ndx = 0; ndx < ((_a = typed.topics) === null || _a === void 0 ? void 0 : _a.length); ndx++) {
-        let prefix = `topics[${ndx}]`;
-        const topic = typed.topics[ndx];
-        parsing_1.requireKeys(prefix, topic, "id", "targetService");
-        parsing_1.assertKeyTypes(prefix, topic, {
-            id: "string",
-            labels: "object",
-            project: "string",
-            targetService: "object",
-        });
-        prefix += ".targetService";
-        parsing_1.requireKeys(prefix, topic.targetService, "id");
-        parsing_1.assertKeyTypes(prefix, topic.targetService, {
-            id: "string",
-            project: "string",
-            region: "string",
-        });
-    }
-    for (let ndx = 0; ndx < ((_b = typed.schedules) === null || _b === void 0 ? void 0 : _b.length); ndx++) {
-        let prefix = `schedules[${ndx}]`;
-        const schedule = typed.schedules[ndx];
-        parsing_1.requireKeys(prefix, schedule, "id", "schedule", "transport", "targetService");
-        parsing_1.assertKeyTypes(prefix, schedule, {
-            id: "string",
-            project: "string",
-            retryConfig: "object",
-            schedule: "string",
-            timeZone: "string",
-            transport: "string",
-            targetService: "object",
-        });
-        parsing_1.assertKeyTypes(prefix + ".retryConfig", schedule.retryConfig, {
-            maxBackoffDuration: "string",
-            minBackoffDuration: "string",
-            maxDoublings: "number",
-            maxRetryDuration: "string",
-            retryCount: "number",
-        });
-        parsing_1.requireKeys((prefix = ".targetService"), schedule.targetService, "id");
-        parsing_1.assertKeyTypes(prefix + ".targetService", schedule.targetService, {
-            id: "string",
-            project: "string",
-            region: "string",
-        });
-    }
-}
-function fillDefaults(want, project, region, runtime) {
-    want.requiredAPIs = want.requiredAPIs || {};
-    want.environmentVariables = want.environmentVariables || {};
-    want.schedules = want.schedules || [];
-    want.topics = want.topics || [];
-    for (const cloudFunction of want.cloudFunctions) {
-        if (!cloudFunction.project) {
-            cloudFunction.project = project;
-        }
-        if (!cloudFunction.region) {
-            cloudFunction.region = region;
-        }
-        if (!cloudFunction.runtime) {
-            cloudFunction.runtime = runtime;
-        }
-    }
-    for (const topic of want.topics) {
-        if (!topic.project) {
-            topic.project = project;
-        }
-        if (!topic.targetService.project) {
-            topic.targetService.project = project;
-        }
-        if (!topic.targetService.region) {
-            topic.targetService.region = region;
-        }
-    }
-    for (const schedule of want.schedules) {
-        if (!schedule.project) {
-            schedule.project = project;
-        }
-        if (!schedule.targetService.project) {
-            schedule.targetService.project = project;
+        else if (backend.isScheduleTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".scheduleTrigger", ep.scheduleTrigger, {
+                schedule: "string",
+                timeZone: "string",
+                retryConfig: "object",
+            });
+            parsing_1.assertKeyTypes(prefix + ".scheduleTrigger.retryConfig", ep.scheduleTrigger.retryConfig, {
+                retryCount: "number",
+                maxDoublings: "number",
+                minBackoffDuration: "string",
+                maxBackoffDuration: "string",
+                maxRetryDuration: "string",
+            });
+            triggered = { scheduleTrigger: ep.scheduleTrigger };
         }
-        if (!schedule.targetService.region) {
-            schedule.targetService.region = region;
+        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");
         }
+        parsing_1.requireKeys(prefix, ep, "entryPoint");
+        const parsed = Object.assign({ platform: ep.platform || "gcfv2", id,
+            region,
+            project,
+            runtime, entryPoint: ep.entryPoint }, triggered);
+        proto_1.copyIfPresent(parsed, ep, "availableMemoryMb", "maxInstances", "minInstances", "concurrency", "serviceAccountEmail", "timeout", "vpcConnector", "vpcConnectorEgressSettings", "labels", "ingressSettings", "environmentVariables");
+        allParsed.push(parsed);
     }
+    return allParsed;
 }