firebase-tools 9.18.0 → 9.22.0

package/lib/gcp/cloudfunctions.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionFromSpec = exports.specFromFunction = exports.listAllFunctions = exports.listFunctions = exports.deleteFunction = exports.updateFunction = exports.setInvokerUpdate = exports.setInvokerCreate = exports.getIamPolicy = exports.setIamPolicy = exports.createFunction = exports.generateUploadUrl = exports.API_VERSION = void 0;
+exports.functionFromEndpoint = exports.endpointFromFunction = exports.listAllFunctions = exports.listFunctions = exports.deleteFunction = exports.updateFunction = exports.setInvokerUpdate = exports.setInvokerCreate = exports.getIamPolicy = exports.setIamPolicy = exports.createFunction = exports.generateUploadUrl = exports.API_VERSION = void 0;
 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,11 @@ async function createFunction(cloudFunction) {
     const apiPath = cloudFunction.name.substring(0, cloudFunction.name.lastIndexOf("/"));
     const endpoint = `/${exports.API_VERSION}/${apiPath}`;
     try {
+        const headers = previews_1.previews.artifactregistry
+            ? { "X-Firebase-Artifact-Registry": "optin" }
+            : undefined;
         const res = await api.request("POST", endpoint, {
+            headers,
             auth: true,
             data: cloudFunction,
             origin: api.functionsOrigin,
@@ -145,7 +150,11 @@ async function updateFunction(cloudFunction) {
     const endpoint = `/${exports.API_VERSION}/${cloudFunction.name}`;
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables");
     try {
+        const headers = previews_1.previews.artifactregistry
+            ? { "X-Firebase-Artifact-Registry": "optin" }
+            : undefined;
         const res = await api.request("PATCH", endpoint, {
+            headers,
             qs: {
                 updateMask: fieldMasks.join(","),
             },
@@ -198,9 +207,11 @@ async function list(projectId, region) {
         };
     }
     catch (err) {
-        logger_1.logger.debug("[functions] failed to list functions for " + projectId);
+        logger_1.logger.debug(`[functions] failed to list functions for ${projectId}`);
         logger_1.logger.debug(`[functions] ${err === null || err === void 0 ? void 0 : err.message}`);
-        return Promise.reject(err === null || err === void 0 ? void 0 : err.message);
+        throw new error_1.FirebaseError(`Failed to list functions for ${projectId}`, {
+            original: err,
+        });
     }
 }
 async function listFunctions(projectId, region) {
@@ -212,70 +223,89 @@ async function listAllFunctions(projectId) {
     return list(projectId, "-");
 }
 exports.listAllFunctions = listAllFunctions;
-function specFromFunction(gcfFunction) {
-    var _a;
+function endpointFromFunction(gcfFunction) {
+    var _a, _b, _c;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     let uri;
-    if (gcfFunction.httpsTrigger) {
-        trigger = {};
+    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 = {
-            eventType: gcfFunction.eventTrigger.eventType,
-            eventFilters: {
-                resource: gcfFunction.eventTrigger.resource,
+            eventTrigger: {
+                eventType: gcfFunction.eventTrigger.eventType,
+                eventFilters: {
+                    resource: gcfFunction.eventTrigger.resource,
+                },
+                retry: !!((_c = gcfFunction.eventTrigger.failurePolicy) === null || _c === void 0 ? void 0 : _c.retry),
             },
-            retry: !!((_a = gcfFunction.eventTrigger.failurePolicy) === null || _a === void 0 ? void 0 : _a.retry),
         };
     }
     if (!runtimes.isValidRuntime(gcfFunction.runtime)) {
         logger_1.logger.debug("GCFv1 function has a deprecated runtime:", JSON.stringify(gcfFunction, null, 2));
     }
-    const cloudFunction = {
-        platform: "gcfv1",
-        id,
+    const endpoint = Object.assign(Object.assign({ platform: "gcfv1", id,
         project,
-        region,
-        trigger,
-        entryPoint: gcfFunction.entryPoint,
-        runtime: gcfFunction.runtime,
-    };
+        region }, trigger), { entryPoint: gcfFunction.entryPoint, runtime: gcfFunction.runtime });
     if (uri) {
-        cloudFunction.uri = uri;
+        endpoint.uri = uri;
     }
-    proto.copyIfPresent(cloudFunction, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "sourceUploadUrl");
-    return cloudFunction;
+    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "sourceUploadUrl");
+    return endpoint;
 }
-exports.specFromFunction = specFromFunction;
-function functionFromSpec(cloudFunction, sourceUploadUrl) {
-    if (cloudFunction.platform != "gcfv1") {
+exports.endpointFromFunction = endpointFromFunction;
+function functionFromEndpoint(endpoint, sourceUploadUrl) {
+    if (endpoint.platform != "gcfv1") {
         throw new error_1.FirebaseError("Trying to create a v1 CloudFunction with v2 API. This should never happen");
     }
-    if (!runtimes.isValidRuntime(cloudFunction.runtime)) {
+    if (!runtimes.isValidRuntime(endpoint.runtime)) {
         throw new error_1.FirebaseError("Failed internal assertion. Trying to deploy a new function with a deprecated runtime." +
             " This should never happen");
     }
     const gcfFunction = {
-        name: backend.functionName(cloudFunction),
+        name: backend.functionName(endpoint),
         sourceUploadUrl: sourceUploadUrl,
-        entryPoint: cloudFunction.entryPoint,
-        runtime: cloudFunction.runtime,
+        entryPoint: endpoint.entryPoint,
+        runtime: endpoint.runtime,
     };
-    if (backend.isEventTrigger(cloudFunction.trigger)) {
+    proto.copyIfPresent(gcfFunction, endpoint, "labels");
+    if (backend.isEventTriggered(endpoint)) {
         gcfFunction.eventTrigger = {
-            eventType: cloudFunction.trigger.eventType,
-            resource: cloudFunction.trigger.eventFilters.resource,
+            eventType: endpoint.eventTrigger.eventType,
+            resource: endpoint.eventTrigger.eventFilters.resource,
         };
-        gcfFunction.eventTrigger.failurePolicy = cloudFunction.trigger.retry
+        gcfFunction.eventTrigger.failurePolicy = endpoint.eventTrigger.retry
             ? { retry: {} }
             : undefined;
     }
+    else if (backend.isScheduleTriggered(endpoint)) {
+        const id = backend.scheduleIdForFunction(endpoint);
+        gcfFunction.eventTrigger = {
+            eventType: "google.pubsub.topic.publish",
+            resource: `projects/${endpoint.project}/topics/${id}`,
+        };
+        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 = {};
     }
-    proto.copyIfPresent(gcfFunction, cloudFunction, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables");
+    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
     return gcfFunction;
 }
-exports.functionFromSpec = functionFromSpec;
+exports.functionFromEndpoint = functionFromEndpoint;

package/lib/gcp/cloudfunctionsv2.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.specFromFunction = exports.functionFromSpec = 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.PUBSUB_PUBLISH_EVENT = exports.API_VERSION = void 0;
 const clc = require("cli-color");
 const apiv2_1 = require("../apiv2");
 const error_1 = require("../error");
@@ -115,19 +115,19 @@ async function deleteFunction(cloudFunction) {
     }
 }
 exports.deleteFunction = deleteFunction;
-function functionFromSpec(cloudFunction, source) {
-    if (cloudFunction.platform != "gcfv2") {
+function functionFromEndpoint(endpoint, source) {
+    if (endpoint.platform != "gcfv2") {
         throw new error_1.FirebaseError("Trying to create a v2 CloudFunction with v1 API. This should never happen");
     }
-    if (!runtimes.isValidRuntime(cloudFunction.runtime)) {
+    if (!runtimes.isValidRuntime(endpoint.runtime)) {
         throw new error_1.FirebaseError("Failed internal assertion. Trying to deploy a new function with a deprecated runtime." +
             " This should never happen");
     }
     const gcfFunction = {
-        name: backend.functionName(cloudFunction),
+        name: backend.functionName(endpoint),
         buildConfig: {
-            runtime: cloudFunction.runtime,
-            entryPoint: cloudFunction.entryPoint,
+            runtime: endpoint.runtime,
+            entryPoint: endpoint.entryPoint,
             source: {
                 storageSource: source,
             },
@@ -135,70 +135,83 @@ function functionFromSpec(cloudFunction, source) {
         },
         serviceConfig: {},
     };
-    proto.copyIfPresent(gcfFunction.serviceConfig, cloudFunction, "availableMemoryMb", "environmentVariables", "vpcConnector", "vpcConnectorEgressSettings", "serviceAccountEmail", "ingressSettings");
-    proto.renameIfPresent(gcfFunction.serviceConfig, cloudFunction, "timeoutSeconds", "timeout", proto.secondsFromDuration);
-    proto.renameIfPresent(gcfFunction.serviceConfig, cloudFunction, "minInstanceCount", "minInstances");
-    proto.renameIfPresent(gcfFunction.serviceConfig, cloudFunction, "maxInstanceCount", "maxInstances");
-    if (backend.isEventTrigger(cloudFunction.trigger)) {
+    proto.copyIfPresent(gcfFunction, endpoint, "labels");
+    proto.copyIfPresent(gcfFunction.serviceConfig, endpoint, "availableMemoryMb", "environmentVariables", "vpcConnector", "vpcConnectorEgressSettings", "serviceAccountEmail", "ingressSettings");
+    proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "timeoutSeconds", "timeout", proto.secondsFromDuration);
+    proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "minInstanceCount", "minInstances");
+    proto.renameIfPresent(gcfFunction.serviceConfig, endpoint, "maxInstanceCount", "maxInstances");
+    if (backend.isEventTriggered(endpoint)) {
         gcfFunction.eventTrigger = {
-            eventType: cloudFunction.trigger.eventType,
+            eventType: endpoint.eventTrigger.eventType,
         };
         if (gcfFunction.eventTrigger.eventType === exports.PUBSUB_PUBLISH_EVENT) {
-            gcfFunction.eventTrigger.pubsubTopic = cloudFunction.trigger.eventFilters.resource;
+            gcfFunction.eventTrigger.pubsubTopic = endpoint.eventTrigger.eventFilters.resource;
         }
         else {
             gcfFunction.eventTrigger.eventFilters = [];
-            for (const [attribute, value] of Object.entries(cloudFunction.trigger.eventFilters)) {
+            for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
                 gcfFunction.eventTrigger.eventFilters.push({ attribute, value });
             }
         }
-        if (cloudFunction.trigger.retry) {
-            logger_1.logger.warn("Cannot set a retry policy on Cloud Function", cloudFunction.id);
+        if (endpoint.eventTrigger.retry) {
+            logger_1.logger.warn("Cannot set a retry policy on Cloud Function", endpoint.id);
         }
     }
-    proto.copyIfPresent(gcfFunction, cloudFunction, "labels");
+    else if (backend.isScheduleTriggered(endpoint)) {
+        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.functionFromSpec = functionFromSpec;
-function specFromFunction(gcfFunction) {
+exports.functionFromEndpoint = functionFromEndpoint;
+function endpointFromFunction(gcfFunction) {
+    var _a, _b;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
-    if (gcfFunction.eventTrigger) {
+    if (((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) === "true") {
+        trigger = {
+            scheduleTrigger: {},
+        };
+    }
+    else if (((_b = gcfFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-taskqueue"]) === "true") {
         trigger = {
-            eventType: gcfFunction.eventTrigger.eventType,
-            eventFilters: {},
-            retry: false,
+            taskQueueTrigger: {},
+        };
+    }
+    else if (gcfFunction.eventTrigger) {
+        trigger = {
+            eventTrigger: {
+                eventType: gcfFunction.eventTrigger.eventType,
+                eventFilters: {},
+                retry: false,
+            },
         };
         if (gcfFunction.eventTrigger.pubsubTopic) {
-            trigger.eventFilters.resource = gcfFunction.eventTrigger.pubsubTopic;
+            trigger.eventTrigger.eventFilters.resource = gcfFunction.eventTrigger.pubsubTopic;
         }
         else {
             for (const { attribute, value } of gcfFunction.eventTrigger.eventFilters || []) {
-                trigger.eventFilters[attribute] = value;
+                trigger.eventTrigger.eventFilters[attribute] = value;
             }
         }
+        proto.renameIfPresent(trigger.eventTrigger, gcfFunction.eventTrigger, "region", "triggerRegion");
     }
     else {
-        trigger = {};
+        trigger = { httpsTrigger: {} };
     }
     if (!runtimes.isValidRuntime(gcfFunction.buildConfig.runtime)) {
         logger_1.logger.debug("GCFv2 function has a deprecated runtime:", JSON.stringify(gcfFunction, null, 2));
     }
-    const cloudFunction = {
-        platform: "gcfv2",
-        id,
+    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(cloudFunction, gcfFunction.serviceConfig, "serviceAccountEmail", "availableMemoryMb", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
-    proto.renameIfPresent(cloudFunction, gcfFunction.serviceConfig, "timeout", "timeoutSeconds", proto.durationFromSeconds);
-    proto.renameIfPresent(cloudFunction, gcfFunction.serviceConfig, "minInstances", "minInstanceCount");
-    proto.renameIfPresent(cloudFunction, gcfFunction.serviceConfig, "maxInstances", "maxInstanceCount");
-    proto.copyIfPresent(cloudFunction, gcfFunction, "labels");
-    return cloudFunction;
+        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.renameIfPresent(endpoint, gcfFunction.serviceConfig, "timeout", "timeoutSeconds", proto.durationFromSeconds);
+    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "minInstances", "minInstanceCount");
+    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "maxInstances", "maxInstanceCount");
+    proto.copyIfPresent(endpoint, gcfFunction, "labels");
+    return endpoint;
 }
-exports.specFromFunction = specFromFunction;
+exports.endpointFromFunction = endpointFromFunction;

package/lib/gcp/cloudscheduler.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jobFromSpec = exports.createOrReplaceJob = exports.updateJob = exports.getJob = exports.deleteJob = exports.createJob = exports.assertValidJob = void 0;
+exports.jobFromEndpoint = exports.createOrReplaceJob = exports.updateJob = exports.getJob = exports.deleteJob = exports.createJob = exports.assertValidJob = void 0;
 const _ = require("lodash");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
 const api = require("../api");
 const backend = require("../deploy/functions/backend");
 const proto = require("./proto");
+const functional_1 = require("../functional");
 const VERSION = "v1beta1";
 const DEFAULT_TIME_ZONE = "America/Los_Angeles";
 function assertValidJob(job) {
@@ -86,21 +87,26 @@ function isIdentical(job, otherJob) {
         job.timeZone === otherJob.timeZone &&
         _.isEqual(job.retryConfig, otherJob.retryConfig));
 }
-function jobFromSpec(schedule, appEngineLocation) {
-    const job = {
-        name: backend.scheduleName(schedule, appEngineLocation),
-        schedule: schedule.schedule,
-    };
-    proto.copyIfPresent(job, schedule, "timeZone", "retryConfig");
-    if (schedule.transport === "https") {
-        throw new error_1.FirebaseError("HTTPS transport for scheduled functions is not yet supported");
+function jobFromEndpoint(endpoint, appEngineLocation) {
+    const job = {};
+    if (endpoint.platform === "gcfv1") {
+        const id = backend.scheduleIdForFunction(endpoint);
+        const region = appEngineLocation;
+        job.name = `projects/${endpoint.project}/locations/${region}/jobs/${id}`;
+        job.pubsubTarget = {
+            topicName: `projects/${endpoint.project}/topics/${id}`,
+            attributes: {
+                scheduled: "true",
+            },
+        };
     }
-    job.pubsubTarget = {
-        topicName: backend.topicName(schedule),
-        attributes: {
-            scheduled: "true",
-        },
-    };
+    else if (endpoint.platform === "gcfv2") {
+        throw new error_1.FirebaseError("Do not know how to create a scheduled GCFv2 function");
+    }
+    else {
+        functional_1.assertExhaustive(endpoint.platform);
+    }
+    proto.copyIfPresent(job, endpoint.scheduleTrigger, "schedule", "retryConfig", "timeZone");
     return job;
 }
-exports.jobFromSpec = jobFromSpec;
+exports.jobFromEndpoint = jobFromEndpoint;

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

@@ -4,7 +4,7 @@ exports.Client = void 0;
 const error_1 = require("../error");
 const api = require("../apiv2");
 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 +27,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 +39,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/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));

package/lib/gcp/pubsub.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.topicFromSpec = exports.deleteTopic = exports.updateTopic = exports.getTopic = exports.createTopic = void 0;
+exports.deleteTopic = exports.updateTopic = exports.getTopic = exports.createTopic = void 0;
 const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
-const backend = require("../deploy/functions/backend");
 const proto = require("./proto");
 const API_VERSION = "v1";
 const client = new apiv2_1.Client({
@@ -33,10 +32,3 @@ async function deleteTopic(name) {
     await client.delete(name);
 }
 exports.deleteTopic = deleteTopic;
-function topicFromSpec(spec) {
-    return {
-        name: backend.topicName(spec),
-        labels: Object.assign({}, spec.labels),
-    };
-}
-exports.topicFromSpec = topicFromSpec;