firebase-tools 11.0.0 → 11.2.0

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;

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

@@ -45,7 +45,7 @@ function parseTriggers(projectId, sourceDir, configValues, envs) {
         });
     });
 }
-function useStrategy(context) {
+function useStrategy() {
     return Promise.resolve(true);
 }
 exports.useStrategy = useStrategy;
@@ -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,12 @@
 "use strict";
-const _ = require("lodash");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycleHooks = void 0;
 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 +17,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));
             }
@@ -52,7 +53,7 @@ function getChildEnvironment(target, overallOptions, config) {
         default:
             resourceDir = overallOptions.config.path(overallOptions.config.projectDir);
     }
-    return _.assign({}, process.env, {
+    return Object.assign({}, process.env, {
         GCLOUD_PROJECT: projectId,
         PROJECT_DIR: projectDir,
         RESOURCE_DIR: resourceDir,
@@ -72,21 +73,19 @@ function runTargetCommands(target, hook, overallOptions, config) {
         shell: true,
         stdio: [0, 1, 2],
     };
-    const runAllCommands = _.reduce(commands, function (soFar, command) {
-        return soFar.then(function () {
-            return runCommand(command, childOptions);
-        });
+    const runAllCommands = commands.reduce((soFar, command) => {
+        return soFar.then(() => runCommand(command, childOptions));
     }, Promise.resolve());
     let logIdentifier = target;
     if (config.target) {
         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) {
@@ -94,33 +93,34 @@ function getReleventConfigs(target, options) {
     if (!targetConfigs) {
         return [];
     }
-    if (!_.isArray(targetConfigs)) {
+    if (!Array.isArray(targetConfigs)) {
         targetConfigs = [targetConfigs];
     }
     if (!options.only) {
         return targetConfigs;
     }
-    var onlyTargets = options.only.split(",");
-    if (_.includes(onlyTargets, target)) {
+    let onlyTargets = options.only.split(",");
+    if (onlyTargets.includes(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 !config.target || _.includes(onlyTargets, config.target);
+    return targetConfigs.filter((config) => {
+        return !config.target || onlyTargets.includes(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 getReleventConfigs(target, options).reduce((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;
 }