firebase-tools 9.21.0 → 9.23.2

package/lib/extensions/secretsUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prettySecretName = exports.getSecretLabels = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = void 0;
+exports.prettySecretName = exports.getSecretLabels = exports.getActiveSecrets = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = exports.SECRET_LABEL = void 0;
 const getProjectNumber_1 = require("../getProjectNumber");
 const utils = require("../utils");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
@@ -8,7 +8,7 @@ const projectUtils_1 = require("../projectUtils");
 const extensionsApi = require("./extensionsApi");
 const secretManagerApi = require("../gcp/secretManager");
 const logger_1 = require("../logger");
-const SECRET_LABEL = "firebase-extensions-managed";
+exports.SECRET_LABEL = "firebase-extensions-managed";
 async function ensureSecretManagerApiEnabled(options) {
     const projectId = projectUtils_1.needProjectId(options);
     return await ensureApiEnabled_1.ensure(projectId, "secretmanager.googleapis.com", "extensions", options.markdown);
@@ -26,24 +26,25 @@ async function grantFirexServiceAgentSecretAdminRole(secret) {
 }
 exports.grantFirexServiceAgentSecretAdminRole = grantFirexServiceAgentSecretAdminRole;
 async function getManagedSecrets(instance) {
-    return (await Promise.all(getActiveSecrets(instance).map(async (secretResourceName) => {
+    return (await Promise.all(getActiveSecrets(instance.config.source.spec, instance.config.params).map(async (secretResourceName) => {
         const secret = secretManagerApi.parseSecretResourceName(secretResourceName);
-        const labels = await secretManagerApi.getSecretLabels(secret.projectId, secret.name);
-        if (labels && labels[SECRET_LABEL]) {
+        const labels = (await secretManagerApi.getSecret(secret.projectId, secret.name)).labels;
+        if (labels && labels[exports.SECRET_LABEL]) {
             return secretResourceName;
         }
         return Promise.resolve("");
     }))).filter((secretId) => !!secretId);
 }
 exports.getManagedSecrets = getManagedSecrets;
-function getActiveSecrets(instance) {
-    return instance.config.source.spec.params
-        .map((p) => p.type == extensionsApi.ParamType.SECRET && instance.config.params[p.param])
+function getActiveSecrets(spec, params) {
+    return spec.params
+        .map((p) => (p.type == extensionsApi.ParamType.SECRET ? params[p.param] : ""))
         .filter((pv) => !!pv);
 }
+exports.getActiveSecrets = getActiveSecrets;
 function getSecretLabels(instanceId) {
     const labels = {};
-    labels[SECRET_LABEL] = instanceId;
+    labels[exports.SECRET_LABEL] = instanceId;
     return labels;
 }
 exports.getSecretLabels = getSecretLabels;

package/lib/extensions/updateHelper.js

@@ -62,10 +62,20 @@ exports.displayChanges = displayChanges;
 async function update(updateOptions) {
     const { projectId, instanceId, source, extRef, params } = updateOptions;
     if (extRef) {
-        return await extensionsApi.updateInstanceFromRegistry(projectId, instanceId, extRef, params);
+        return await extensionsApi.updateInstanceFromRegistry({
+            projectId,
+            instanceId,
+            extRef,
+            params,
+        });
     }
     else if (source) {
-        return await extensionsApi.updateInstance(projectId, instanceId, source, params);
+        return await extensionsApi.updateInstance({
+            projectId,
+            instanceId,
+            extensionSource: source,
+            params,
+        });
     }
     throw new error_1.FirebaseError(`Neither a source nor a version of the extension was supplied for ${instanceId}. Please make sure this is a valid extension and try again.`);
 }

package/lib/extensions/versionHelper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersionPredicate = void 0;
+const error_1 = require("../error");
+function parseVersionPredicate(versionPredicate) {
+    const versionPredicateRegex = "^(?<comparator>>=|<=|>|<)?(?<targetSemVer>.*)";
+    const matches = versionPredicate.match(versionPredicateRegex);
+    if (!matches || !matches.groups.targetSemVer) {
+        throw new error_1.FirebaseError("Invalid version predicate.");
+    }
+    const comparator = matches.groups.comparator || "=";
+    return { comparator, targetSemVer: matches.groups.targetSemVer };
+}
+exports.parseVersionPredicate = parseVersionPredicate;

package/lib/extensions/warnings.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayWarningPrompts = void 0;
+exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
 const marked = require("marked");
 const clc = require("cli-color");
 const extensionsApi_1 = require("./extensionsApi");
 const displayExtensionInfo_1 = require("./displayExtensionInfo");
 const extensionsHelper_1 = require("./extensionsHelper");
 const resolveSource_1 = require("./resolveSource");
+const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
+const planner_1 = require("../deploy/extensions/planner");
+const functional_1 = require("../functional");
 const utils = require("../utils");
 function displayEAPWarning({ publisherId, sourceDownloadUri, githubLink, }) {
     const publisherNameLink = githubLink ? `[${publisherId}](${githubLink})` : publisherId;
@@ -35,3 +38,32 @@ async function displayWarningPrompts(publisherId, launchStage, extensionVersion)
     }
 }
 exports.displayWarningPrompts = displayWarningPrompts;
+const toListEntry = (i) => {
+    var _a, _b, _c, _d;
+    const idAndRef = deploymentSummary_1.humanReadable(i);
+    const sourceCodeLink = `\n\t[Source Code](${(_a = i.extensionVersion) === null || _a === void 0 ? void 0 : _a.sourceDownloadUri})`;
+    const githubLink = ((_c = (_b = i.extensionVersion) === null || _b === void 0 ? void 0 : _b.spec) === null || _c === void 0 ? void 0 : _c.sourceUrl) ? `\n\t[Publisher Contact](${(_d = i.extensionVersion) === null || _d === void 0 ? void 0 : _d.spec.sourceUrl})`
+        : "";
+    return `${idAndRef}${sourceCodeLink}${githubLink}`;
+};
+async function displayWarningsForDeploy(instancesToCreate) {
+    const trustedPublishers = await resolveSource_1.getTrustedPublishers();
+    for (const i of instancesToCreate) {
+        await planner_1.getExtension(i);
+        await planner_1.getExtensionVersion(i);
+    }
+    const [eapExtensions, nonEapExtensions] = functional_1.partition(instancesToCreate, (i) => { var _a, _b; return !trustedPublishers.includes((_b = (_a = i.ref) === null || _a === void 0 ? void 0 : _a.publisherId) !== null && _b !== void 0 ? _b : ""); });
+    const experimental = nonEapExtensions.filter((i) => i.extension.registryLaunchStage === extensionsApi_1.RegistryLaunchStage.EXPERIMENTAL);
+    if (experimental.length) {
+        const humanReadableList = experimental.map((i) => `\t${deploymentSummary_1.humanReadable(i)}`).join("\n");
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`));
+    }
+    if (eapExtensions.length) {
+        const humanReadableList = eapExtensions.map(toListEntry).join("\n");
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider. Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
+            ` They are provided “AS IS”, without any warranty, express or implied, from Google.` +
+            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`));
+    }
+    return experimental.length > 0 || eapExtensions.length > 0;
+}
+exports.displayWarningsForDeploy = displayWarningsForDeploy;

package/lib/functions/env.js

@@ -32,11 +32,11 @@ const RESERVED_KEYS = [
 const LINE_RE = new RegExp("^" +
     "\\s*" +
     "(\\w+)" +
-    "\\s*=\\s*" +
+    "\\s*=[\\f\\t\\v]*" +
     "(" +
     "\\s*'(?:\\\\'|[^'])*'|" +
     '\\s*"(?:\\\\"|[^"])*"|' +
-    "[^#\\r\\n]+" +
+    "[^#\\r\\n]*" +
     ")?" +
     "\\s*" +
     "(?:#[^\\n]*)?" +

package/lib/gcp/artifactregistry.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePackage = exports.API_VERSION = void 0;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+exports.API_VERSION = "v1beta2";
+const client = new apiv2_1.Client({
+    urlPrefix: api_1.artifactRegistryDomain,
+    auth: true,
+    apiVersion: exports.API_VERSION,
+});
+async function deletePackage(name) {
+    const res = await client.delete(name);
+    return res.body;
+}
+exports.deletePackage = deletePackage;

package/lib/gcp/cloudfunctions.js

@@ -4,6 +4,7 @@ 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 api = require("../api");
 const backend = require("../deploy/functions/backend");
 const utils = require("../utils");
@@ -50,7 +51,12 @@ async function createFunction(cloudFunction) {
     const apiPath = cloudFunction.name.substring(0, cloudFunction.name.lastIndexOf("/"));
     const endpoint = `/${exports.API_VERSION}/${apiPath}`;
     try {
+        const headers = {};
+        if (previews_1.previews.artifactregistry) {
+            headers["X-Firebase-Artifact-Registry"] = "optin";
+        }
         const res = await api.request("POST", endpoint, {
+            headers,
             auth: true,
             data: cloudFunction,
             origin: api.functionsOrigin,
@@ -145,7 +151,12 @@ async function updateFunction(cloudFunction) {
     const endpoint = `/${exports.API_VERSION}/${cloudFunction.name}`;
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables");
     try {
+        const headers = {};
+        if (previews_1.previews.artifactregistry) {
+            headers["X-Firebase-Artifact-Registry"] = "optin";
+        }
         const res = await api.request("PATCH", endpoint, {
+            headers,
             qs: {
                 updateMask: fieldMasks.join(","),
             },
@@ -215,19 +226,24 @@ async function listAllFunctions(projectId) {
 }
 exports.listAllFunctions = listAllFunctions;
 function endpointFromFunction(gcfFunction) {
-    var _a, _b;
+    var _a, _b, _c;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     let uri;
-    if (gcfFunction.httpsTrigger) {
-        trigger = { httpsTrigger: {} };
-        uri = gcfFunction.httpsTrigger.url;
-    }
-    else if ((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
+    if ((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
         trigger = {
             scheduleTrigger: {},
         };
     }
+    else if ((_b = gcfFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-taskqueue"]) {
+        trigger = {
+            taskQueueTrigger: {},
+        };
+    }
+    else if (gcfFunction.httpsTrigger) {
+        trigger = { httpsTrigger: {} };
+        uri = gcfFunction.httpsTrigger.url;
+    }
     else {
         trigger = {
             eventTrigger: {
@@ -235,7 +251,7 @@ function endpointFromFunction(gcfFunction) {
                 eventFilters: {
                     resource: gcfFunction.eventTrigger.resource,
                 },
-                retry: !!((_b = gcfFunction.eventTrigger.failurePolicy) === null || _b === void 0 ? void 0 : _b.retry),
+                retry: !!((_c = gcfFunction.eventTrigger.failurePolicy) === null || _c === void 0 ? void 0 : _c.retry),
             },
         };
     }
@@ -284,6 +300,10 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
         };
         gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-scheduled": "true" });
     }
+    else if (backend.isTaskQueueTriggered(endpoint)) {
+        gcfFunction.httpsTrigger = {};
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-taskqueue": "true" });
+    }
     else {
         gcfFunction.httpsTrigger = {};
     }

package/lib/gcp/cloudfunctionsv2.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.endpointFromFunction = exports.functionFromEndpoint = exports.deleteFunction = exports.updateFunction = exports.listAllFunctions = exports.listFunctions = exports.getFunction = exports.createFunction = exports.generateUploadUrl = exports.PUBSUB_PUBLISH_EVENT = exports.API_VERSION = void 0;
+exports.endpointFromFunction = exports.functionFromEndpoint = exports.deleteFunction = exports.updateFunction = exports.listAllFunctions = exports.listFunctions = exports.getFunction = exports.createFunction = exports.generateUploadUrl = exports.megabytes = exports.PUBSUB_PUBLISH_EVENT = exports.API_VERSION = void 0;
 const clc = require("cli-color");
 const apiv2_1 = require("../apiv2");
 const error_1 = require("../error");
@@ -17,6 +17,35 @@ const client = new apiv2_1.Client({
     apiVersion: exports.API_VERSION,
 });
 exports.PUBSUB_PUBLISH_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";
+const BYTES_PER_UNIT = {
+    "": 1,
+    k: 1e3,
+    M: 1e6,
+    G: 1e9,
+    T: 1e12,
+    Ki: 1 << 10,
+    Mi: 1 << 20,
+    Gi: 1 << 30,
+    Ti: 1 << 40,
+};
+function megabytes(memory) {
+    const re = /^([0-9]+(\.[0-9]*)?)(Ki|Mi|Gi|Ti|k|M|G|T|([eE]([0-9]+)))?$/;
+    const matches = re.exec(memory);
+    if (!matches) {
+        throw new Error(`Invalid memory quantity "${memory}""`);
+    }
+    const quantity = Number.parseFloat(matches[1]);
+    let bytes;
+    if (matches[5]) {
+        bytes = quantity * Math.pow(10, Number.parseFloat(matches[5]));
+    }
+    else {
+        const suffix = matches[3] || "";
+        bytes = quantity * BYTES_PER_UNIT[suffix];
+    }
+    return bytes / 1e6;
+}
+exports.megabytes = megabytes;
 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) {
@@ -136,7 +165,8 @@ function functionFromEndpoint(endpoint, source) {
         serviceConfig: {},
     };
     proto.copyIfPresent(gcfFunction, endpoint, "labels");
-    proto.copyIfPresent(gcfFunction.serviceConfig, endpoint, "availableMemoryMb", "environmentVariables", "vpcConnector", "vpcConnectorEgressSettings", "serviceAccountEmail", "ingressSettings");
+    proto.copyIfPresent(gcfFunction.serviceConfig, endpoint, "environmentVariables", "vpcConnector", "vpcConnectorEgressSettings", "serviceAccountEmail", "ingressSettings");
+    proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "availableMemory", "availableMemoryMb", (mb) => `${mb}M`);
     proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "timeoutSeconds", "timeout", proto.secondsFromDuration);
     proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "minInstanceCount", "minInstances");
     proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "maxInstanceCount", "maxInstances");
@@ -153,18 +183,22 @@ function functionFromEndpoint(endpoint, source) {
                 gcfFunction.eventTrigger.eventFilters.push({ attribute, value });
             }
         }
+        proto.renameIfPresent(gcfFunction.eventTrigger, endpoint.eventTrigger, "triggerRegion", "region");
         if (endpoint.eventTrigger.retry) {
             logger_1.logger.warn("Cannot set a retry policy on Cloud Function", endpoint.id);
         }
     }
     else if (backend.isScheduleTriggered(endpoint)) {
-        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { ["deployment-scheduled"]: "true" });
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-scheduled": "true" });
+    }
+    else if (backend.isTaskQueueTriggered(endpoint)) {
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-taskqueue": "true" });
     }
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;
 function endpointFromFunction(gcfFunction) {
-    var _a;
+    var _a, _b;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     if (((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) === "true") {
@@ -172,6 +206,11 @@ function endpointFromFunction(gcfFunction) {
             scheduleTrigger: {},
         };
     }
+    else if (((_b = gcfFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-taskqueue"]) === "true") {
+        trigger = {
+            taskQueueTrigger: {},
+        };
+    }
     else if (gcfFunction.eventTrigger) {
         trigger = {
             eventTrigger: {
@@ -199,7 +238,8 @@ function endpointFromFunction(gcfFunction) {
     const endpoint = Object.assign(Object.assign({ platform: "gcfv2", id,
         project,
         region }, trigger), { entryPoint: gcfFunction.buildConfig.entryPoint, runtime: gcfFunction.buildConfig.runtime, uri: gcfFunction.serviceConfig.uri });
-    proto.copyIfPresent(endpoint, gcfFunction.serviceConfig, "serviceAccountEmail", "availableMemoryMb", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
+    proto.copyIfPresent(endpoint, gcfFunction.serviceConfig, "serviceAccountEmail", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
+    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "availableMemoryMb", "availableMemory", megabytes);
     proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "timeout", "timeoutSeconds", proto.durationFromSeconds);
     proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "minInstances", "minInstanceCount");
     proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "maxInstances", "maxInstanceCount");

package/lib/gcp/cloudtasks.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueFromEndpoint = exports.queueNameForEndpoint = exports.setEnqueuer = exports.getIamPolicy = exports.setIamPolicy = exports.deleteQueue = exports.purgeQueue = exports.upsertQueue = exports.updateQueue = exports.getQueue = exports.createQueue = exports.DEFAULT_SETTINGS = void 0;
+const proto = require("./proto");
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+const API_VERSION = "v2";
+const client = new apiv2_1.Client({
+    urlPrefix: api_1.cloudTasksOrigin,
+    auth: true,
+    apiVersion: API_VERSION,
+});
+exports.DEFAULT_SETTINGS = {
+    rateLimits: {
+        maxConcurrentDispatches: 1000,
+        maxBurstSize: 100,
+        maxDispatchesPerSecond: 500,
+    },
+    state: "RUNNING",
+    retryConfig: {
+        maxDoublings: 16,
+        maxAttempts: 3,
+        maxBackoff: "3600s",
+        minBackoff: "0.100s",
+    },
+};
+async function createQueue(queue) {
+    const path = queue.name.substring(0, queue.name.lastIndexOf("/"));
+    const res = await client.post(path, queue);
+    return res.body;
+}
+exports.createQueue = createQueue;
+async function getQueue(name) {
+    const res = await client.get(name);
+    return res.body;
+}
+exports.getQueue = getQueue;
+async function updateQueue(queue) {
+    const res = await client.patch(queue.name, queue, {
+        queryParams: { updateMask: proto.fieldMasks(queue).join(",") },
+    });
+    return res.body;
+}
+exports.updateQueue = updateQueue;
+async function upsertQueue(queue) {
+    var _a, _b;
+    try {
+        const existing = await module.exports.getQueue(queue.name);
+        if (JSON.stringify(queue) === JSON.stringify(existing)) {
+            return false;
+        }
+        if (existing.state === "DISABLED") {
+            await module.exports.purgeQueue(queue.name);
+        }
+        await module.exports.updateQueue(queue);
+        return false;
+    }
+    catch (err) {
+        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) === 404) {
+            await module.exports.createQueue(queue);
+            return true;
+        }
+        throw err;
+    }
+}
+exports.upsertQueue = upsertQueue;
+async function purgeQueue(name) {
+    await client.post(`${name}:purge`);
+}
+exports.purgeQueue = purgeQueue;
+async function deleteQueue(name) {
+    await client.delete(name);
+}
+exports.deleteQueue = deleteQueue;
+async function setIamPolicy(name, policy) {
+    const res = await client.post(`${name}:setIamPolicy`, {
+        policy,
+    });
+    return res.body;
+}
+exports.setIamPolicy = setIamPolicy;
+async function getIamPolicy(name) {
+    const res = await client.post(`${name}:getIamPolicy`);
+    return res.body;
+}
+exports.getIamPolicy = getIamPolicy;
+const ENQUEUER_ROLE = "roles/cloudtasks.enqueuer";
+async function setEnqueuer(name, invoker, assumeEmpty = false) {
+    var _a, _b;
+    let existing;
+    if (assumeEmpty) {
+        existing = {
+            bindings: [],
+            etag: "",
+            version: 3,
+        };
+    }
+    else {
+        existing = await module.exports.getIamPolicy(name);
+    }
+    const [, project] = name.split("/");
+    const invokerMembers = proto.getInvokerMembers(invoker, project);
+    while (true) {
+        const policy = {
+            bindings: existing.bindings.filter((binding) => binding.role != ENQUEUER_ROLE),
+            etag: existing.etag,
+            version: existing.version,
+        };
+        if (invokerMembers.length) {
+            policy.bindings.push({ role: ENQUEUER_ROLE, members: invokerMembers });
+        }
+        if (JSON.stringify(policy) === JSON.stringify(existing)) {
+            return;
+        }
+        try {
+            await module.exports.setIamPolicy(name, policy);
+            return;
+        }
+        catch (err) {
+            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) {
+                existing = await module.exports.getIamPolicy(name);
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+exports.setEnqueuer = setEnqueuer;
+function queueNameForEndpoint(endpoint) {
+    return `projects/${endpoint.project}/locations/${endpoint.region}/queues/${endpoint.id}`;
+}
+exports.queueNameForEndpoint = queueNameForEndpoint;
+function queueFromEndpoint(endpoint) {
+    const queue = Object.assign(Object.assign({}, JSON.parse(JSON.stringify(exports.DEFAULT_SETTINGS))), { name: queueNameForEndpoint(endpoint) });
+    if (endpoint.taskQueueTrigger.rateLimits) {
+        proto.copyIfPresent(queue.rateLimits, endpoint.taskQueueTrigger.rateLimits, "maxBurstSize", "maxConcurrentDispatches", "maxDispatchesPerSecond");
+    }
+    if (endpoint.taskQueueTrigger.retryConfig) {
+        proto.copyIfPresent(queue.retryConfig, endpoint.taskQueueTrigger.retryConfig, "maxAttempts", "maxBackoff", "maxDoublings", "maxRetryDuration", "minBackoff");
+    }
+    return queue;
+}
+exports.queueFromEndpoint = queueFromEndpoint;

package/lib/gcp/docker.js

@@ -1,10 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = void 0;
+exports.Client = exports.GCR_SUBDOMAIN_MAPPING = void 0;
 const error_1 = require("../error");
 const api = require("../apiv2");
+exports.GCR_SUBDOMAIN_MAPPING = {
+    "us-west1": "us",
+    "us-west2": "us",
+    "us-west3": "us",
+    "us-west4": "us",
+    "us-central1": "us",
+    "us-central2": "us",
+    "us-east1": "us",
+    "us-east4": "us",
+    "northamerica-northeast1": "us",
+    "southamerica-east1": "us",
+    "europe-west1": "eu",
+    "europe-west2": "eu",
+    "europe-west3": "eu",
+    "europe-west4": "eu",
+    "europe-west5": "eu",
+    "europe-west6": "eu",
+    "europe-central2": "eu",
+    "europe-north1": "eu",
+    "asia-east1": "asia",
+    "asia-east2": "asia",
+    "asia-northeast1": "asia",
+    "asia-northeast2": "asia",
+    "asia-northeast3": "asia",
+    "asia-south1": "asia",
+    "asia-southeast2": "asia",
+    "australia-southeast1": "asia",
+};
 function isErrors(response) {
-    return Object.prototype.hasOwnProperty.call(response, "errors");
+    return !!response && Object.prototype.hasOwnProperty.call(response, "errors");
 }
 const API_VERSION = "v2";
 class Client {
@@ -27,6 +55,9 @@ class Client {
     async deleteTag(path, tag) {
         var _a;
         const response = await this.client.delete(`${path}/manifests/${tag}`);
+        if (!response.body) {
+            return;
+        }
         if (((_a = response.body.errors) === null || _a === void 0 ? void 0 : _a.length) != 0) {
             throw new error_1.FirebaseError(`Failed to delete tag ${tag} at path ${path}`, {
                 children: response.body.errors,
@@ -36,6 +67,9 @@ class Client {
     async deleteImage(path, digest) {
         var _a;
         const response = await this.client.delete(`${path}/manifests/${digest}`);
+        if (!response.body) {
+            return;
+        }
         if (((_a = response.body.errors) === null || _a === void 0 ? void 0 : _a.length) != 0) {
             throw new error_1.FirebaseError(`Failed to delete image ${digest} at path ${path}`, {
                 children: response.body.errors,

package/lib/gcp/location.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regionInLocation = exports.DUAL_REGION_MAPPING = exports.MULTI_REGION_MAPPING = void 0;
+exports.MULTI_REGION_MAPPING = {
+    "us-central1": "us",
+    "us-east1": "us",
+    "us-east4": "us",
+    "us-west1": "us",
+    "us-west2": "us",
+    "us-west3": "us",
+    "us-west4": "us",
+    "europe-central2": "eu",
+    "europe-north1": "eu",
+    "europe-west1": "eu",
+    "europe-west3": "eu",
+    "europe-west4": "eu",
+    "europe-west5": "eu",
+    "asia-east1": "asia",
+    "asia-east2": "asia",
+    "asia-northeast1": "asia",
+    "asia-northeast2": "asia",
+    "asia-northeast3": "asia",
+    "asia-south1": "asia",
+    "asia-south2": "asia",
+    "asia-southeast1": "asia",
+    "asia-southeast2": "asia",
+};
+exports.DUAL_REGION_MAPPING = {
+    "asia-northeast1": "asia1",
+    "asia-northeast2": "asia1",
+    "europe-north1": "eur4",
+    "europe-west4": "eur4",
+    "us-central1": "nam4",
+    "us-east1": "nam4",
+};
+function regionInLocation(region, location) {
+    region = region.toLowerCase();
+    location = location.toLowerCase();
+    if (exports.MULTI_REGION_MAPPING[region] === location || exports.DUAL_REGION_MAPPING[region] === location) {
+        return true;
+    }
+    return false;
+}
+exports.regionInLocation = regionInLocation;

package/lib/gcp/proto.js

@@ -67,10 +67,10 @@ function fieldMasksHelper(prefixes, cursor, doNotRecurseIn, masks) {
     }
 }
 function getInvokerMembers(invoker, projectId) {
-    if (invoker[0] === "private") {
+    if (invoker.includes("private")) {
         return [];
     }
-    if (invoker[0] === "public") {
+    if (invoker.includes("public")) {
         return ["allUsers"];
     }
     return invoker.map((inv) => formatServiceAccount(inv, projectId));