firebase-tools 10.9.2 → 11.1.0

package/lib/deploy/functions/build.js

@@ -56,44 +56,45 @@ 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;
+            if (bdEndpoint.serviceAccount) {
+                bkEndpoint.serviceAccountEmail = bdEndpoint.serviceAccount;
             }
             bkEndpoints.push(bkEndpoint);
         }
@@ -116,7 +117,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 +144,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/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,163 @@ 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 _a = ep.eventTrigger, { serviceAccountEmail } = _a, newTrigger = __rest(_a, ["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 || "default" }, 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 +296,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 +303,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/node/parseTriggers.js

@@ -139,10 +139,22 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         triggered = {
             scheduleTrigger: {
                 schedule: annotation.schedule.schedule,
-                timeZone: annotation.schedule.timeZone || "what's the default timezone?",
-                retryConfig: annotation.schedule.retryConfig || {},
+                timeZone: annotation.schedule.timeZone || "America/Los_Angeles",
+                retryConfig: {},
             },
         };
+        if (annotation.schedule.retryConfig) {
+            if (annotation.schedule.retryConfig.maxBackoffDuration) {
+                triggered.scheduleTrigger.retryConfig.maxBackoffSeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.maxBackoffDuration);
+            }
+            if (annotation.schedule.retryConfig.minBackoffDuration) {
+                triggered.scheduleTrigger.retryConfig.minBackoffSeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.minBackoffDuration);
+            }
+            if (annotation.schedule.retryConfig.maxRetryDuration) {
+                triggered.scheduleTrigger.retryConfig.maxRetrySeconds = proto.secondsFromDuration(annotation.schedule.retryConfig.maxRetryDuration);
+            }
+            proto.copyIfPresent(triggered.scheduleTrigger.retryConfig, annotation.schedule.retryConfig, "maxDoublings", "retryCount");
+        }
     }
     else if (annotation.blockingTrigger) {
         if (events.v1.AUTH_BLOCKING_EVENTS.includes(annotation.blockingTrigger.eventType)) {

package/lib/deploy/functions/services/database.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDatabaseTriggerRegion = void 0;
+const error_1 = require("../../../error");
+function ensureDatabaseTriggerRegion(endpoint) {
+    if (!endpoint.eventTrigger.region) {
+        endpoint.eventTrigger.region = endpoint.region;
+    }
+    if (endpoint.eventTrigger.region !== endpoint.region) {
+        throw new error_1.FirebaseError("A database trigger location must match the function region.");
+    }
+    return Promise.resolve();
+}
+exports.ensureDatabaseTriggerRegion = ensureDatabaseTriggerRegion;

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

@@ -5,6 +5,7 @@ const backend = require("../backend");
 const auth_1 = require("./auth");
 const storage_1 = require("./storage");
 const firebaseAlerts_1 = require("./firebaseAlerts");
+const database_1 = require("./database");
 const noop = () => Promise.resolve();
 exports.noop = noop;
 const noopProjectBindings = () => Promise.resolve([]);
@@ -45,6 +46,15 @@ const firebaseAlertsService = {
     unregisterTrigger: exports.noop,
 };
 const authBlockingService = new auth_1.AuthBlockingService();
+const databaseService = {
+    name: "database",
+    api: "firebasedatabase.googleapis.com",
+    requiredProjectBindings: exports.noopProjectBindings,
+    ensureTriggerRegion: database_1.ensureDatabaseTriggerRegion,
+    validateTrigger: exports.noop,
+    registerTrigger: exports.noop,
+    unregisterTrigger: exports.noop,
+};
 const EVENT_SERVICE_MAPPING = {
     "google.cloud.pubsub.topic.v1.messagePublished": pubSubService,
     "google.cloud.storage.object.v1.finalized": storageService,
@@ -54,6 +64,10 @@ const EVENT_SERVICE_MAPPING = {
     "google.firebase.firebasealerts.alerts.v1.published": firebaseAlertsService,
     "providers/cloud.auth/eventTypes/user.beforeCreate": authBlockingService,
     "providers/cloud.auth/eventTypes/user.beforeSignIn": authBlockingService,
+    "google.firebase.database.ref.v1.written": databaseService,
+    "google.firebase.database.ref.v1.created": databaseService,
+    "google.firebase.database.ref.v1.updated": databaseService,
+    "google.firebase.database.ref.v1.deleted": databaseService,
 };
 function serviceForEndpoint(endpoint) {
     if (backend.isEventTriggered(endpoint)) {

package/lib/deploy/index.js

@@ -9,7 +9,7 @@ const projectUtils_1 = require("../projectUtils");
 const utils_1 = require("../utils");
 const error_1 = require("../error");
 const track_1 = require("../track");
-const lifecycleHooks = require("./lifecycleHooks");
+const lifecycleHooks_1 = require("./lifecycleHooks");
 const previews_1 = require("../previews");
 const HostingTarget = require("./hosting");
 const DatabaseTarget = require("./database");
@@ -54,11 +54,11 @@ const deploy = async function (targetNames, options, customContext = {}) {
         if (!target) {
             return Promise.reject(new error_1.FirebaseError((0, cli_color_1.bold)(targetName) + " is not a valid deploy target", { exit: 1 }));
         }
-        predeploys.push(lifecycleHooks(targetName, "predeploy"));
+        predeploys.push((0, lifecycleHooks_1.lifecycleHooks)(targetName, "predeploy"));
         prepares.push(target.prepare);
         deploys.push(target.deploy);
         releases.push(target.release);
-        postdeploys.push(lifecycleHooks(targetName, "postdeploy"));
+        postdeploys.push((0, lifecycleHooks_1.lifecycleHooks)(targetName, "postdeploy"));
     }
     logger_1.logger.info();
     logger_1.logger.info((0, cli_color_1.bold)((0, cli_color_1.white)("===") + " Deploying to '" + projectId + "'..."));

package/lib/deploy/lifecycleHooks.js

@@ -1,11 +1,13 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycleHooks = void 0;
 const _ = require("lodash");
 const utils = require("../utils");
 const clc = require("cli-color");
 const childProcess = require("child_process");
-const { FirebaseError } = require("../error");
+const error_1 = require("../error");
 const needProjectId = require("../projectUtils").needProjectId;
-const { logger } = require("../logger");
+const logger_1 = require("../logger");
 const path = require("path");
 function runCommand(command, childOptions) {
     const escapedCommand = command.replace(/\"/g, '\\"');
@@ -16,16 +18,16 @@ function runCommand(command, childOptions) {
         '" "' +
         escapedCommand +
         '"';
-    return new Promise(function (resolve, reject) {
-        logger.info("Running command: " + command);
+    return new Promise((resolve, reject) => {
+        logger_1.logger.info("Running command: " + command);
         if (translatedCommand === "") {
-            resolve();
+            return resolve();
         }
         const child = childProcess.spawn(translatedCommand, [], childOptions);
-        child.on("error", function (err) {
+        child.on("error", (err) => {
             reject(err);
         });
-        child.on("exit", function (code, signal) {
+        child.on("exit", (code, signal) => {
             if (signal) {
                 reject(new Error("Command terminated with signal " + signal));
             }
@@ -72,8 +74,8 @@ function runTargetCommands(target, hook, overallOptions, config) {
         shell: true,
         stdio: [0, 1, 2],
     };
-    const runAllCommands = _.reduce(commands, function (soFar, command) {
-        return soFar.then(function () {
+    const runAllCommands = _.reduce(commands, (soFar, command) => {
+        return soFar.then(() => {
             return runCommand(command, childOptions);
         });
     }, Promise.resolve());
@@ -82,11 +84,11 @@ function runTargetCommands(target, hook, overallOptions, config) {
         logIdentifier += `[${config.target}]`;
     }
     return runAllCommands
-        .then(function () {
+        .then(() => {
         utils.logSuccess(clc.green.bold(logIdentifier + ":") + " Finished running " + clc.bold(hook) + " script.");
     })
-        .catch(function (err) {
-        throw new FirebaseError(logIdentifier + " " + hook + " error: " + err.message);
+        .catch((err) => {
+        throw new error_1.FirebaseError(logIdentifier + " " + hook + " error: " + err.message);
     });
 }
 function getReleventConfigs(target, options) {
@@ -100,27 +102,28 @@ function getReleventConfigs(target, options) {
     if (!options.only) {
         return targetConfigs;
     }
-    var onlyTargets = options.only.split(",");
+    let onlyTargets = options.only.split(",");
     if (_.includes(onlyTargets, target)) {
         return targetConfigs;
     }
     onlyTargets = onlyTargets
-        .filter(function (individualOnly) {
+        .filter((individualOnly) => {
         return individualOnly.indexOf(`${target}:`) === 0;
     })
-        .map(function (individualOnly) {
+        .map((individualOnly) => {
         return individualOnly.replace(`${target}:`, "");
     });
-    return targetConfigs.filter(function (config) {
+    return targetConfigs.filter((config) => {
         return !config.target || _.includes(onlyTargets, config.target);
     });
 }
-module.exports = function (target, hook) {
+function lifecycleHooks(target, hook) {
     return function (context, options) {
-        return _.reduce(getReleventConfigs(target, options), function (previousCommands, individualConfig) {
-            return previousCommands.then(function () {
+        return _.reduce(getReleventConfigs(target, options), (previousCommands, individualConfig) => {
+            return previousCommands.then(() => {
                 return runTargetCommands(target, hook, options, individualConfig);
             });
         }, Promise.resolve());
     };
-};
+}
+exports.lifecycleHooks = lifecycleHooks;

package/lib/deploy/remoteconfig/functions.js

@@ -1,21 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.publishTemplate = exports.deployTemplate = exports.validateInputRemoteConfigTemplate = exports.getEtag = void 0;
+const api_1 = require("../../api");
+const apiv2_1 = require("../../apiv2");
 const error_1 = require("../../error");
-const api = require("../../api");
 const TIMEOUT = 30000;
+const client = new apiv2_1.Client({ urlPrefix: api_1.remoteConfigApiOrigin, apiVersion: "v1" });
 async function getEtag(projectNumber, versionNumber) {
-    let reqPath = `/v1/projects/${projectNumber}/remoteConfig`;
+    const reqPath = `/projects/${projectNumber}/remoteConfig`;
+    const queryParams = {};
     if (versionNumber) {
-        reqPath = reqPath + "?versionNumber=" + versionNumber;
+        queryParams.versionNumber = versionNumber;
     }
-    const response = await api.request("GET", reqPath, {
-        auth: true,
-        origin: api.remoteConfigApiOrigin,
-        timeout: TIMEOUT,
+    const response = await client.request({
+        method: "GET",
+        path: reqPath,
+        queryParams,
         headers: { "Accept-Encoding": "gzip" },
+        timeout: TIMEOUT,
     });
-    return response.response.headers.etag;
+    return response.response.headers.get("etag") || "";
 }
 exports.getEtag = getEtag;
 function validateInputRemoteConfigTemplate(template) {
@@ -33,20 +37,20 @@ function validateInputRemoteConfigTemplate(template) {
 }
 exports.validateInputRemoteConfigTemplate = validateInputRemoteConfigTemplate;
 async function deployTemplate(projectNumber, template, etag, options) {
-    const reqPath = `/v1/projects/${projectNumber}/remoteConfig`;
+    const reqPath = `/projects/${projectNumber}/remoteConfig`;
     if (options === null || options === void 0 ? void 0 : options.force) {
         etag = "*";
     }
-    const response = await api.request("PUT", reqPath, {
-        auth: true,
-        origin: api.remoteConfigApiOrigin,
-        timeout: TIMEOUT,
+    const response = await client.request({
+        method: "PUT",
+        path: reqPath,
         headers: { "If-Match": etag },
-        data: {
+        body: {
             conditions: template.conditions,
             parameters: template.parameters,
             parameterGroups: template.parameterGroups,
         },
+        timeout: TIMEOUT,
     });
     return response.body;
 }

package/lib/deploy/remoteconfig/prepare.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const projectUtils_1 = require("../../projectUtils");
-const loadCJSON = require("../../loadCJSON");
+const loadCJSON_1 = require("../../loadCJSON");
 const functions_1 = require("./functions");
 const functions_2 = require("./functions");
 async function default_1(context, options) {
@@ -13,7 +13,7 @@ async function default_1(context, options) {
     if (!filePath) {
         return;
     }
-    const template = loadCJSON(filePath);
+    const template = (0, loadCJSON_1.loadCJSON)(filePath);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
     template.etag = await (0, functions_1.getEtag)(projectNumber);
     (0, functions_2.validateInputRemoteConfigTemplate)(template);