firebase-tools 11.0.1 → 11.2.1

package/lib/fsAsync.js

@@ -8,7 +8,7 @@ const minimatch = require("minimatch");
 async function readdirRecursiveHelper(options) {
     const dirContents = (0, fs_extra_1.readdirSync)(options.path);
     const fullPaths = dirContents.map((n) => (0, path_1.join)(options.path, n));
-    const filteredPaths = _.reject(fullPaths, options.filter);
+    const filteredPaths = fullPaths.filter((p) => !options.filter(p));
     const filePromises = [];
     for (const p of filteredPaths) {
         const fstat = (0, fs_extra_1.statSync)(p);
@@ -22,12 +22,12 @@ async function readdirRecursiveHelper(options) {
     }
     const files = await Promise.all(filePromises);
     let flatFiles = _.flattenDeep(files);
-    flatFiles = _.reject(flatFiles, (f) => _.isNull(f));
+    flatFiles = flatFiles.filter((f) => f !== null);
     return flatFiles;
 }
 async function readdirRecursive(options) {
     const mmopts = { matchBase: true, dot: true };
-    const rules = _.map(options.ignore || [], (glob) => {
+    const rules = (options.ignore || []).map((glob) => {
         return (p) => minimatch(p, glob, mmopts);
     });
     const filter = (t) => {

package/lib/functions/events/v2.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIREBASE_ALERTS_PUBLISH_EVENT = exports.STORAGE_EVENTS = exports.PUBSUB_PUBLISH_EVENT = void 0;
+exports.DATABASE_EVENTS = exports.FIREBASE_ALERTS_PUBLISH_EVENT = exports.STORAGE_EVENTS = exports.PUBSUB_PUBLISH_EVENT = void 0;
 exports.PUBSUB_PUBLISH_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";
 exports.STORAGE_EVENTS = [
     "google.cloud.storage.object.v1.finalized",
@@ -9,3 +9,9 @@ exports.STORAGE_EVENTS = [
     "google.cloud.storage.object.v1.metadataUpdated",
 ];
 exports.FIREBASE_ALERTS_PUBLISH_EVENT = "google.firebase.firebasealerts.alerts.v1.published";
+exports.DATABASE_EVENTS = [
+    "google.firebase.database.ref.v1.written",
+    "google.firebase.database.ref.v1.created",
+    "google.firebase.database.ref.v1.updated",
+    "google.firebase.database.ref.v1.deleted",
+];

package/lib/functionsConfig.js

@@ -27,7 +27,7 @@ function setVariable(projectId, configId, varPath, val) {
     return runtimeconfig.variables.set(projectId, configId, varPath, val);
 }
 function isReservedNamespace(id) {
-    return _.some(exports.RESERVED_NAMESPACES, (reserved) => {
+    return exports.RESERVED_NAMESPACES.some((reserved) => {
         return id.config.toLowerCase().startsWith(reserved);
     });
 }
@@ -44,7 +44,7 @@ function varNameToIds(varName) {
 }
 exports.varNameToIds = varNameToIds;
 function idsToVarName(projectId, configId, varId) {
-    return _.join(["projects", projectId, "configs", configId, "variables", varId], "/");
+    return ["projects", projectId, "configs", configId, "variables", varId].join("/");
 }
 exports.idsToVarName = idsToVarName;
 function getAppEngineLocation(config) {
@@ -63,7 +63,7 @@ async function getFirebaseConfig(options) {
 exports.getFirebaseConfig = getFirebaseConfig;
 async function setVariablesRecursive(projectId, configId, varPath, val) {
     let parsed = val;
-    if (_.isString(val)) {
+    if (typeof val === "string") {
         try {
             parsed = JSON.parse(val);
         }
@@ -71,8 +71,8 @@ async function setVariablesRecursive(projectId, configId, varPath, val) {
         }
     }
     if (_.isPlainObject(parsed)) {
-        return Promise.all(_.map(parsed, (item, key) => {
-            const newVarPath = varPath ? _.join([varPath, key], "/") : key;
+        return Promise.all(Object.entries(parsed).map(([key, item]) => {
+            const newVarPath = varPath ? [varPath, key].join("/") : key;
             return setVariablesRecursive(projectId, configId, newVarPath, item);
         }));
     }
@@ -87,7 +87,7 @@ async function materializeConfig(configName, output) {
         _.set(output, key, variable.text);
     };
     const traverseVariables = async function (variables) {
-        return Promise.all(_.map(variables, (variable) => {
+        return Promise.all(variables.map((variable) => {
             return materializeVariable(variable.name);
         }));
     };
@@ -99,7 +99,10 @@ exports.materializeConfig = materializeConfig;
 async function materializeAll(projectId) {
     const output = {};
     const configs = await runtimeconfig.configs.list(projectId);
-    await Promise.all(_.map(configs, (config) => {
+    if (!Array.isArray(configs) || !configs.length) {
+        return output;
+    }
+    await Promise.all(configs.map((config) => {
         if (config.name.match(new RegExp("configs/firebase"))) {
             return;
         }
@@ -110,7 +113,7 @@ async function materializeAll(projectId) {
 exports.materializeAll = materializeAll;
 function parseSetArgs(args) {
     const parsed = [];
-    _.forEach(args, (arg) => {
+    for (const arg of args) {
         const parts = arg.split("=");
         const key = parts[0];
         if (parts.length < 2) {
@@ -129,17 +132,17 @@ function parseSetArgs(args) {
             varId: id.variable,
             val: val,
         });
-    });
+    }
     return parsed;
 }
 exports.parseSetArgs = parseSetArgs;
 function parseUnsetArgs(args) {
     const parsed = [];
     let splitArgs = [];
-    _.forEach(args, (arg) => {
-        splitArgs = _.union(splitArgs, arg.split(","));
-    });
-    _.forEach(splitArgs, (key) => {
+    for (const arg of args) {
+        splitArgs = Array.from(new Set([...splitArgs, ...arg.split(",")]));
+    }
+    for (const key of splitArgs) {
         const id = keyToIds(key);
         if (isReservedNamespace(id)) {
             throw new error_1.FirebaseError("Cannot unset reserved namespace " + clc.bold(id.config));
@@ -148,7 +151,7 @@ function parseUnsetArgs(args) {
             configId: id.config,
             varId: id.variable,
         });
-    });
+    }
     return parsed;
 }
 exports.parseUnsetArgs = parseUnsetArgs;

package/lib/functionsConfigClone.js

@@ -1,68 +1,68 @@
 "use strict";
-var _ = require("lodash");
-var clc = require("cli-color");
-var { FirebaseError } = require("./error");
-var functionsConfig = require("./functionsConfig");
-var runtimeconfig = require("./gcp/runtimeconfig");
-var _matchPrefix = function (short, long) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsConfigClone = void 0;
+const _ = require("lodash");
+const clc = require("cli-color");
+const error_1 = require("./error");
+const functionsConfig = require("./functionsConfig");
+const runtimeconfig = require("./gcp/runtimeconfig");
+function matchPrefix(short, long) {
     if (short.length > long.length) {
         return false;
     }
-    return _.reduce(short, function (accum, x, i) {
-        return accum && x === long[i];
-    }, true);
-};
-var _applyExcept = function (json, except) {
-    _.forEach(except, function (key) {
+    return short.reduce((accum, x, i) => accum && x === long[i], true);
+}
+function applyExcept(json, except) {
+    for (const key of except) {
         _.unset(json, key);
-    });
-};
-var _cloneVariable = function (varName, toProject) {
-    return runtimeconfig.variables.get(varName).then(function (variable) {
-        var id = functionsConfig.varNameToIds(variable.name);
+    }
+}
+function cloneVariable(varName, toProject) {
+    return runtimeconfig.variables.get(varName).then((variable) => {
+        const id = functionsConfig.varNameToIds(variable.name);
         return runtimeconfig.variables.set(toProject, id.config, id.variable, variable.text);
     });
-};
-var _cloneConfig = function (configName, toProject) {
-    return runtimeconfig.variables.list(configName).then(function (variables) {
-        return Promise.all(_.map(variables, function (variable) {
-            return _cloneVariable(variable.name, toProject);
+}
+function cloneConfig(configName, toProject) {
+    return runtimeconfig.variables.list(configName).then((variables) => {
+        return Promise.all(variables.map((variable) => {
+            return cloneVariable(variable.name, toProject);
         }));
     });
-};
-var _cloneConfigOrVariable = function (key, fromProject, toProject) {
-    var parts = key.split(".");
-    if (_.includes(functionsConfig.RESERVED_NAMESPACES, parts[0])) {
-        throw new FirebaseError("Cannot clone reserved namespace " + clc.bold(parts[0]));
+}
+async function cloneConfigOrVariable(key, fromProject, toProject) {
+    const parts = key.split(".");
+    if (functionsConfig.RESERVED_NAMESPACES.includes(parts[0])) {
+        throw new error_1.FirebaseError("Cannot clone reserved namespace " + clc.bold(parts[0]));
     }
-    var configName = _.join(["projects", fromProject, "configs", parts[0]], "/");
+    const configName = ["projects", fromProject, "configs", parts[0]].join("/");
     if (parts.length === 1) {
-        return _cloneConfig(configName, toProject);
+        return cloneConfig(configName, toProject);
     }
-    return runtimeconfig.variables.list(configName).then(function (variables) {
-        var promises = [];
-        _.forEach(variables, function (variable) {
-            var varId = functionsConfig.varNameToIds(variable.name).variable;
-            var variablePrefixFilter = parts.slice(1);
-            if (_matchPrefix(variablePrefixFilter, varId.split("/"))) {
-                promises.push(_cloneVariable(variable.name, toProject));
+    return runtimeconfig.variables.list(configName).then((variables) => {
+        const promises = [];
+        for (const variable of variables) {
+            const varId = functionsConfig.varNameToIds(variable.name).variable;
+            const variablePrefixFilter = parts.slice(1);
+            if (matchPrefix(variablePrefixFilter, varId.split("/"))) {
+                promises.push(cloneVariable(variable.name, toProject));
             }
-        });
+        }
         return Promise.all(promises);
     });
-};
-module.exports = function (fromProject, toProject, only, except) {
-    except = except || [];
+}
+async function functionsConfigClone(fromProject, toProject, only, except = []) {
     if (only) {
-        return Promise.all(_.map(only, function (key) {
-            return _cloneConfigOrVariable(key, fromProject, toProject);
+        return Promise.all(only.map((key) => {
+            return cloneConfigOrVariable(key, fromProject, toProject);
         }));
     }
-    return functionsConfig.materializeAll(fromProject).then(function (toClone) {
+    return functionsConfig.materializeAll(fromProject).then((toClone) => {
         _.unset(toClone, "firebase");
-        _applyExcept(toClone, except);
-        return Promise.all(_.map(toClone, function (val, configId) {
+        applyExcept(toClone, except);
+        return Promise.all(Object.entries(toClone).map(([configId, val]) => {
             return functionsConfig.setVariablesRecursive(toProject, configId, "", val);
         }));
     });
-};
+}
+exports.functionsConfigClone = functionsConfigClone;

package/lib/gcp/cloudfunctions.js

@@ -4,7 +4,6 @@ exports.functionFromEndpoint = exports.endpointFromFunction = exports.listAllFun
 const clc = require("cli-color");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
-const previews_1 = require("../previews");
 const backend = require("../deploy/functions/backend");
 const utils = require("../utils");
 const proto = require("./proto");
@@ -24,10 +23,6 @@ const BLOCKING_EVENT_TO_LABEL_KEY = {
     "providers/cloud.auth/eventTypes/user.beforeCreate": "before-create",
     "providers/cloud.auth/eventTypes/user.beforeSignIn": "before-sign-in",
 };
-function validateFunction(func) {
-    proto.assertOneOf("Cloud Function", func, "sourceCode", "sourceArchiveUrl", "sourceRepository", "sourceUploadUrl");
-    proto.assertOneOf("Cloud Function", func, "trigger", "httpsTrigger", "eventTrigger");
-}
 function functionsOpLogReject(funcName, type, err) {
     var _a, _b;
     if (((_b = (_a = err === null || err === void 0 ? void 0 : err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) === 429) {
@@ -58,11 +53,7 @@ async function createFunction(cloudFunction) {
     const apiPath = cloudFunction.name.substring(0, cloudFunction.name.lastIndexOf("/"));
     const endpoint = `/${apiPath}`;
     try {
-        const headers = {};
-        if (previews_1.previews.artifactregistry) {
-            headers["X-Firebase-Artifact-Registry"] = "optin";
-        }
-        const res = await client.post(endpoint, cloudFunction, { headers });
+        const res = await client.post(endpoint, cloudFunction);
         return {
             name: res.body.name,
             type: "create",
@@ -147,12 +138,7 @@ async function updateFunction(cloudFunction) {
     const endpoint = `/${cloudFunction.name}`;
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables", "secretEnvironmentVariables");
     try {
-        const headers = {};
-        if (previews_1.previews.artifactregistry) {
-            headers["X-Firebase-Artifact-Registry"] = "optin";
-        }
         const res = await client.patch(endpoint, cloudFunction, {
-            headers,
             queryParams: {
                 updateMask: fieldMasks.join(","),
             },
@@ -293,6 +279,7 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
         sourceUploadUrl: sourceUploadUrl,
         entryPoint: endpoint.entryPoint,
         runtime: endpoint.runtime,
+        dockerRegistry: "ARTIFACT_REGISTRY",
     };
     proto.copyIfPresent(gcfFunction, endpoint, "labels");
     if (backend.isEventTriggered(endpoint)) {

package/lib/gcp/cloudfunctionsv2.js

@@ -209,6 +209,13 @@ function functionFromEndpoint(endpoint, source) {
             for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
                 gcfFunction.eventTrigger.eventFilters.push({ attribute, value });
             }
+            for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilterPathPatterns || {})) {
+                gcfFunction.eventTrigger.eventFilters.push({
+                    attribute,
+                    value,
+                    operator: "match-path-pattern",
+                });
+            }
         }
         proto.renameIfPresent(gcfFunction.eventTrigger, endpoint.eventTrigger, "triggerRegion", "region");
         proto.copyIfPresent(gcfFunction.eventTrigger, endpoint.eventTrigger, "channel");
@@ -277,8 +284,16 @@ function endpointFromFunction(gcfFunction) {
             trigger.eventTrigger.eventFilters.topic = gcfFunction.eventTrigger.pubsubTopic;
         }
         else {
-            for (const { attribute, value } of gcfFunction.eventTrigger.eventFilters || []) {
-                trigger.eventTrigger.eventFilters[attribute] = value;
+            for (const eventFilter of gcfFunction.eventTrigger.eventFilters || []) {
+                if (eventFilter.operator === "match-path-pattern") {
+                    if (!trigger.eventTrigger.eventFilterPathPatterns) {
+                        trigger.eventTrigger.eventFilterPathPatterns = {};
+                    }
+                    trigger.eventTrigger.eventFilterPathPatterns[eventFilter.attribute] = eventFilter.value;
+                }
+                else {
+                    trigger.eventTrigger.eventFilters[eventFilter.attribute] = eventFilter.value;
+                }
             }
         }
         proto.copyIfPresent(trigger.eventTrigger, gcfFunction.eventTrigger, "channel");

package/lib/gcp/iam.js

@@ -14,7 +14,7 @@ async function createServiceAccount(projectId, accountId, description, displayNa
             displayName,
             description,
         },
-    });
+    }, { skipLog: { resBody: true } });
     return response.body;
 }
 exports.createServiceAccount = createServiceAccount;

package/lib/gcp/index.js

@@ -1,11 +1,11 @@
 "use strict";
-module.exports = {
-    cloudbilling: require("./cloudbilling"),
-    cloudfunctions: require("./cloudfunctions"),
-    cloudscheduler: require("./cloudscheduler"),
-    cloudlogging: require("./cloudlogging"),
-    iam: require("./iam"),
-    pubsub: require("./pubsub"),
-    storage: require("./storage"),
-    rules: require("./rules"),
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = exports.storage = exports.pubsub = exports.iam = exports.cloudlogging = exports.cloudscheduler = exports.cloudfunctions = exports.cloudbilling = void 0;
+exports.cloudbilling = require("./cloudbilling");
+exports.cloudfunctions = require("./cloudfunctions");
+exports.cloudscheduler = require("./cloudscheduler");
+exports.cloudlogging = require("./cloudlogging");
+exports.iam = require("./iam");
+exports.pubsub = require("./pubsub");
+exports.storage = require("./storage");
+exports.rules = require("./rules");

package/lib/gcp/rules.js

@@ -20,7 +20,7 @@ function _handleErrorResponse(response) {
 async function getLatestRulesetName(projectId, service) {
     const releases = await listAllReleases(projectId);
     const prefix = `projects/${projectId}/releases/${service}`;
-    const release = _.find(releases, (r) => r.name.startsWith(prefix));
+    const release = releases.find((r) => r.name.startsWith(prefix));
     if (!release) {
         return null;
     }

package/lib/gcp/runtimeconfig.js

@@ -1,66 +1,66 @@
 "use strict";
-const { runtimeconfigOrigin } = require("../api");
-const { Client } = require("../apiv2");
-const { logger } = require("../logger");
-var _ = require("lodash");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variables = exports.configs = void 0;
+const _ = require("lodash");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
+const logger_1 = require("../logger");
 const API_VERSION = "v1beta1";
-const apiClient = new Client({ urlPrefix: runtimeconfigOrigin, apiVersion: API_VERSION });
-function _listConfigs(projectId) {
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.runtimeconfigOrigin, apiVersion: API_VERSION });
+function listConfigs(projectId) {
     return apiClient
         .get(`/projects/${projectId}/configs`, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
-        return resp.body.configs;
-    });
+        .then((resp) => resp.body.configs);
 }
-function _createConfig(projectId, configId) {
-    var path = _.join(["projects", projectId, "configs"], "/");
+function createConfig(projectId, configId) {
+    const path = ["projects", projectId, "configs"].join("/");
     return apiClient
         .post(`/projects/${projectId}/configs`, {
         name: path + "/" + configId,
     }, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 409) {
             return Promise.resolve();
         }
         return Promise.reject(err);
     });
 }
-function _deleteConfig(projectId, configId) {
+function deleteConfig(projectId, configId) {
     return apiClient
         .delete(`/projects/${projectId}/configs/${configId}`, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            logger.debug("Config already deleted.");
+            logger_1.logger.debug("Config already deleted.");
             return Promise.resolve();
         }
-        return Promise.reject(err);
+        throw err;
     });
 }
-function _listVariables(configPath) {
+function listVariables(configPath) {
     return apiClient
         .get(`${configPath}/variables`, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
+        .then((resp) => {
         return Promise.resolve(resp.body.variables);
     });
 }
-function _getVariable(varPath) {
+function getVariable(varPath) {
     return apiClient
         .get(varPath, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
+        .then((resp) => {
         return Promise.resolve(resp.body);
     });
 }
-function _createVariable(projectId, configId, varId, value) {
+function createVariable(projectId, configId, varId, value) {
     const path = `/projects/${projectId}/configs/${configId}/variables`;
     return apiClient
         .post(path, {
@@ -69,16 +69,16 @@ function _createVariable(projectId, configId, varId, value) {
     }, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            return _createConfig(projectId, configId).then(function () {
-                return _createVariable(projectId, configId, varId, value);
+            return createConfig(projectId, configId).then(() => {
+                return createVariable(projectId, configId, varId, value);
             });
         }
         return Promise.reject(err);
     });
 }
-function _updateVariable(projectId, configId, varId, value) {
+function updateVariable(projectId, configId, varId, value) {
     const path = `/projects/${projectId}/configs/${configId}/variables/${varId}`;
     return apiClient.put(path, {
         name: path,
@@ -87,43 +87,41 @@ function _updateVariable(projectId, configId, varId, value) {
         retryCodes: [500, 503],
     });
 }
-function _setVariable(projectId, configId, varId, value) {
-    var path = _.join(["projects", projectId, "configs", configId, "variables", varId], "/");
-    return _getVariable(path)
-        .then(function () {
-        return _updateVariable(projectId, configId, varId, value);
+function setVariable(projectId, configId, varId, value) {
+    const path = ["projects", projectId, "configs", configId, "variables", varId].join("/");
+    return getVariable(path)
+        .then(() => {
+        return updateVariable(projectId, configId, varId, value);
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            return _createVariable(projectId, configId, varId, value);
+            return createVariable(projectId, configId, varId, value);
         }
         return Promise.reject(err);
     });
 }
-function _deleteVariable(projectId, configId, varId) {
+function deleteVariable(projectId, configId, varId) {
     return apiClient
         .delete(`/projects/${projectId}/configs/${configId}/variables/${varId}`, {
         retryCodes: [500, 503],
         queryParams: { recursive: "true" },
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            logger.debug("Variable already deleted.");
+            logger_1.logger.debug("Variable already deleted.");
             return Promise.resolve();
         }
         return Promise.reject(err);
     });
 }
-module.exports = {
-    configs: {
-        list: _listConfigs,
-        create: _createConfig,
-        delete: _deleteConfig,
-    },
-    variables: {
-        list: _listVariables,
-        get: _getVariable,
-        set: _setVariable,
-        delete: _deleteVariable,
-    },
+exports.configs = {
+    list: listConfigs,
+    create: createConfig,
+    delete: deleteConfig,
+};
+exports.variables = {
+    list: listVariables,
+    get: getVariable,
+    set: setVariable,
+    delete: deleteVariable,
 };

package/lib/hosting/proxy.js

@@ -133,7 +133,7 @@ function proxyRequestHandler(url, rewriteIdentifier) {
 }
 exports.proxyRequestHandler = proxyRequestHandler;
 function errorRequestHandler(error) {
-    return (req, res, next) => {
+    return (req, res) => {
         res.statusCode = 500;
         const out = `A problem occurred while trying to handle a proxied rewrite: ${error}`;
         logger_1.logger.error(out);