firebase-tools 9.22.0 → 10.0.0

package/lib/emulator/pubsubEmulator.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PubsubEmulator = void 0;
 const uuid = require("uuid");
 const pubsub_1 = require("@google-cloud/pubsub");
-const api = require("../api");
 const downloadableEmulators = require("./downloadableEmulators");
+const apiv2_1 = require("../apiv2");
 const emulatorLogger_1 = require("./emulatorLogger");
 const types_1 = require("../emulator/types");
 const constants_1 = require("./constants");
@@ -87,47 +87,54 @@ class PubsubEmulator {
         this.triggersForTopic.set(topicName, triggers);
         this.subscriptionForTopic.set(topicName, sub);
     }
-    getRequestOptions(topic, message, signatureType) {
-        const baseOpts = {
-            origin: `http://${registry_1.EmulatorRegistry.getInfoHostString(registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS).getInfo())}`,
-        };
-        if (signatureType === "event") {
-            return Object.assign(Object.assign({}, baseOpts), { data: {
-                    context: {
-                        eventId: uuid.v4(),
-                        resource: {
-                            service: "pubsub.googleapis.com",
-                            name: `projects/${this.args.projectId}/topics/${topic}`,
-                        },
-                        eventType: "google.pubsub.topic.publish",
-                        timestamp: message.publishTime.toISOString(),
-                    },
-                    data: {
-                        data: message.data,
-                        attributes: message.attributes,
-                    },
-                } });
+    ensureFunctionsClient() {
+        if (this.client != undefined)
+            return;
+        const funcEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
+        if (!funcEmulator) {
+            throw new error_1.FirebaseError(`Attempted to execute pubsub trigger but could not find the Functions emulator`);
         }
-        else if (signatureType === "cloudevent") {
-            const data = {
-                message: {
-                    messageId: message.id,
-                    publishTime: message.publishTime,
-                    attributes: message.attributes,
-                    orderingKey: message.orderingKey,
-                    data: message.data.toString("base64"),
+        this.client = new apiv2_1.Client({
+            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(funcEmulator.getInfo())}`,
+            auth: false,
+        });
+    }
+    createLegacyEventRequestBody(topic, message) {
+        return {
+            context: {
+                eventId: uuid.v4(),
+                resource: {
+                    service: "pubsub.googleapis.com",
+                    name: `projects/${this.args.projectId}/topics/${topic}`,
                 },
-                subscription: this.subscriptionForTopic.get(topic).name,
-            };
-            const ce = {
-                specVersion: 1,
-                type: "google.cloud.pubsub.topic.v1.messagePublished",
-                source: `//pubsub.googleapis.com/projects/${this.args.projectId}/topics/${topic}`,
-                data,
-            };
-            return Object.assign(Object.assign({}, baseOpts), { headers: { "Content-Type": "application/cloudevents+json; charset=UTF-8" }, data: ce });
-        }
-        throw new error_1.FirebaseError(`Unsupported trigger signature: ${signatureType}`);
+                eventType: "google.pubsub.topic.publish",
+                timestamp: message.publishTime.toISOString(),
+            },
+            data: {
+                data: message.data,
+                attributes: message.attributes,
+            },
+        };
+    }
+    createCloudEventRequestBody(topic, message) {
+        const data = {
+            message: {
+                messageId: message.id,
+                publishTime: message.publishTime,
+                attributes: message.attributes,
+                orderingKey: message.orderingKey,
+                data: message.data.toString("base64"),
+            },
+            subscription: this.subscriptionForTopic.get(topic).name,
+        };
+        return {
+            specversion: "1",
+            id: uuid.v4(),
+            time: message.publishTime.toISOString(),
+            type: "google.cloud.pubsub.topic.v1.messagePublished",
+            source: `//pubsub.googleapis.com/projects/${this.args.projectId}/topics/${topic}`,
+            data,
+        };
     }
     async onMessage(topicName, message) {
         this.logger.logLabeled("DEBUG", "pubsub", `onMessage(${topicName}, ${message.id})`);
@@ -135,14 +142,20 @@ class PubsubEmulator {
         if (!triggers || triggers.length === 0) {
             throw new error_1.FirebaseError(`No trigger for topic: ${topicName}`);
         }
-        if (!registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS)) {
-            throw new error_1.FirebaseError(`Attempted to execute pubsub trigger for topic ${topicName} but could not find Functions emulator`);
-        }
         this.logger.logLabeled("DEBUG", "pubsub", `Executing ${triggers.length} matching triggers (${JSON.stringify(triggers.map((t) => t.triggerKey))})`);
+        this.ensureFunctionsClient();
         for (const { triggerKey, signatureType } of triggers) {
-            const reqOpts = this.getRequestOptions(topicName, message, signatureType);
             try {
-                await api.request("POST", `/functions/projects/${this.args.projectId}/triggers/${triggerKey}`, reqOpts);
+                const path = `/functions/projects/${this.args.projectId}/triggers/${triggerKey}`;
+                if (signatureType === "event") {
+                    await this.client.post(path, this.createLegacyEventRequestBody(topicName, message));
+                }
+                else if (signatureType === "cloudevent") {
+                    await this.client.post(path, this.createCloudEventRequestBody(topicName, message), { headers: { "Content-Type": "application/cloudevents+json; charset=UTF-8" } });
+                }
+                else {
+                    throw new error_1.FirebaseError(`Unsupported trigger signature: ${signatureType}`);
+                }
             }
             catch (e) {
                 this.logger.logLabeled("DEBUG", "pubsub", e);

package/lib/emulator/storage/cloudFunctions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageCloudFunctions = void 0;
+const uuid = require("uuid");
 const registry_1 = require("../registry");
 const types_1 = require("../types");
 const emulatorLogger_1 = require("../emulatorLogger");
@@ -57,7 +58,7 @@ class StorageCloudFunctions {
     }
     createLegacyEventRequestBody(action, objectMetadataPayload) {
         const timestamp = new Date();
-        return JSON.stringify({
+        return {
             eventId: `${timestamp.getTime()}`,
             timestamp: metadata_1.toSerializedDate(timestamp),
             eventType: `google.storage.object.${action}`,
@@ -67,20 +68,26 @@ class StorageCloudFunctions {
                 type: "storage#object",
             },
             data: objectMetadataPayload,
-        });
+        };
     }
     createCloudEventRequestBody(action, objectMetadataPayload) {
         const ceAction = STORAGE_V2_ACTION_MAP[action];
         if (!ceAction) {
-            throw new Error("Action is not definied as a CloudEvents action");
+            throw new Error("Action is not defined as a CloudEvents action");
         }
         const data = objectMetadataPayload;
-        return JSON.stringify({
-            specVersion: 1,
+        let time = new Date().toISOString();
+        if (data.updated) {
+            time = typeof data.updated === "string" ? data.updated : data.updated.toISOString();
+        }
+        return {
+            specversion: "1",
+            id: uuid.v4(),
             type: `google.cloud.storage.object.v1.${ceAction}`,
             source: `//storage.googleapis.com/projects/_/buckets/${objectMetadataPayload.bucket}/objects/${objectMetadataPayload.name}`,
+            time,
             data,
-        });
+        };
     }
 }
 exports.StorageCloudFunctions = StorageCloudFunctions;

package/lib/ensureApiEnabled.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensure = exports.enable = exports.check = exports.POLL_SETTINGS = void 0;
-const _ = require("lodash");
+exports.ensure = exports.check = exports.POLL_SETTINGS = void 0;
 const cli_color_1 = require("cli-color");
 const track = require("./track");
-const api = require("./api");
+const api_1 = require("./api");
+const apiv2_1 = require("./apiv2");
 const utils = require("./utils");
 const error_1 = require("./error");
 exports.POLL_SETTINGS = {
     pollInterval: 10000,
     pollsBeforeRetry: 12,
 };
+const apiClient = new apiv2_1.Client({
+    urlPrefix: api_1.serviceUsageOrigin,
+    apiVersion: "v1",
+});
 async function check(projectId, apiName, prefix, silent = false) {
-    const response = await api.request("GET", `/v1/projects/${projectId}/services/${apiName}`, {
-        auth: true,
-        origin: api.serviceUsageOrigin,
-    });
-    const isEnabled = _.get(response.body, "state") === "ENABLED";
+    const res = await apiClient.get(`/projects/${projectId}/services/${apiName}`);
+    const isEnabled = res.body.state === "ENABLED";
     if (isEnabled && !silent) {
         utils.logLabeledSuccess(prefix, `required API ${cli_color_1.bold(apiName)} is enabled`);
     }
@@ -25,10 +26,7 @@ async function check(projectId, apiName, prefix, silent = false) {
 exports.check = check;
 async function enable(projectId, apiName) {
     try {
-        await api.request("POST", `/v1/projects/${projectId}/services/${apiName}:enable`, {
-            auth: true,
-            origin: api.serviceUsageOrigin,
-        });
+        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`);
     }
     catch (err) {
         if (error_1.isBillingError(err)) {
@@ -39,7 +37,6 @@ https://console.firebase.google.com/project/${projectId}/usage/details`);
         throw err;
     }
 }
-exports.enable = enable;
 async function pollCheckEnabled(projectId, apiName, prefix, silent, enablementRetries, pollRetries = 0) {
     if (pollRetries > exports.POLL_SETTINGS.pollsBeforeRetry) {
         return enableApiWithRetries(projectId, apiName, prefix, silent, enablementRetries + 1);
@@ -49,7 +46,7 @@ async function pollCheckEnabled(projectId, apiName, prefix, silent, enablementRe
     });
     const isEnabled = await check(projectId, apiName, prefix, silent);
     if (isEnabled) {
-        track("api_enabled", apiName);
+        void track("api_enabled", apiName);
         return;
     }
     if (!silent) {

package/lib/extensions/askUserForParam.js

@@ -77,6 +77,7 @@ async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
                         "You may only select one option.",
                     choices: utils_1.convertExtensionOptionToLabeledList(paramSpec.options),
                 });
+                valid = checkResponse(response, paramSpec);
                 break;
             case extensionsApi_1.ParamType.MULTISELECT:
                 response = await utils_1.onceWithJoin({
@@ -95,11 +96,13 @@ async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
                         "You may select multiple options.",
                     choices: utils_1.convertExtensionOptionToLabeledList(paramSpec.options),
                 });
+                valid = checkResponse(response, paramSpec);
                 break;
             case extensionsApi_1.ParamType.SECRET:
                 response = reconfiguring
                     ? await promptReconfigureSecret(projectId, instanceId, paramSpec)
                     : await promptCreateSecret(projectId, instanceId, paramSpec);
+                valid = true;
                 break;
             default:
                 response = await prompt_1.promptOnce({
@@ -108,8 +111,8 @@ async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
                     default: paramSpec.default,
                     message: `Enter a value for ${label}:`,
                 });
+                valid = checkResponse(response, paramSpec);
         }
-        valid = checkResponse(response, paramSpec);
     }
     return response;
 }
@@ -139,10 +142,24 @@ async function promptReconfigureSecret(projectId, instanceId, paramSpec) {
                 type: "password",
                 message: `This secret will be stored in Cloud Secret Manager as ${secretName}.\nEnter new value for ${paramSpec.label.trim()}:`,
             });
-            if (!secret) {
-                secret = await secretManagerApi.createSecret(projectId, secretName, secretsUtils.getSecretLabels(instanceId));
+            if (secretValue === "" && paramSpec.required) {
+                logger_1.logger.info(`Secret value cannot be empty for required param ${paramSpec.param}`);
+                return promptReconfigureSecret(projectId, instanceId, paramSpec);
+            }
+            else if (secretValue !== "") {
+                if (checkResponse(secretValue, paramSpec)) {
+                    if (!secret) {
+                        secret = await secretManagerApi.createSecret(projectId, secretName, secretsUtils.getSecretLabels(instanceId));
+                    }
+                    return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+                }
+                else {
+                    return promptReconfigureSecret(projectId, instanceId, paramSpec);
+                }
+            }
+            else {
+                return "";
             }
-            return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
         case SecretUpdateAction.LEAVE:
         default:
             return paramSpec.default || "";
@@ -158,13 +175,20 @@ async function promptCreateSecret(projectId, instanceId, paramSpec, secretName)
     });
     if (secretValue === "" && paramSpec.required) {
         logger_1.logger.info(`Secret value cannot be empty for required param ${paramSpec.param}`);
-        return await promptCreateSecret(projectId, instanceId, paramSpec, name);
+        return promptCreateSecret(projectId, instanceId, paramSpec, name);
     }
     else if (secretValue !== "") {
-        const secret = await secretManagerApi.createSecret(projectId, name, secretsUtils.getSecretLabels(instanceId));
-        return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+        if (checkResponse(secretValue, paramSpec)) {
+            const secret = await secretManagerApi.createSecret(projectId, name, secretsUtils.getSecretLabels(instanceId));
+            return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+        }
+        else {
+            return promptCreateSecret(projectId, instanceId, paramSpec, name);
+        }
+    }
+    else {
+        return "";
     }
-    return secretValue;
 }
 exports.promptCreateSecret = promptCreateSecret;
 async function generateSecretName(projectId, instanceId, paramName) {

package/lib/extensions/emulator/triggerHelper.js

@@ -9,6 +9,7 @@ function functionResourceToEmulatedTriggerDefintion(resource) {
     const etd = {
         name: resource.name,
         entryPoint: resource.name,
+        platform: "gcfv1",
     };
     const properties = _.get(resource, "properties", {});
     if (properties.timeout) {

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/cloudfunctions.js

@@ -51,9 +51,10 @@ 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 headers = {};
+        if (previews_1.previews.artifactregistry) {
+            headers["X-Firebase-Artifact-Registry"] = "optin";
+        }
         const res = await api.request("POST", endpoint, {
             headers,
             auth: true,
@@ -150,9 +151,10 @@ 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 headers = {};
+        if (previews_1.previews.artifactregistry) {
+            headers["X-Firebase-Artifact-Registry"] = "optin";
+        }
         const res = await api.request("PATCH", endpoint, {
             headers,
             qs: {

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,6 +183,7 @@ 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);
         }
@@ -207,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/docker.js

@@ -1,8 +1,36 @@
 "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 !!response && Object.prototype.hasOwnProperty.call(response, "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/storage.js

@@ -1,26 +1,29 @@
 "use strict";
-var path = require("path");
-var api = require("../api");
-const { logger } = require("../logger");
-var { FirebaseError } = require("../error");
-function _getDefaultBucket(projectId) {
-    return api
-        .request("GET", "/v1/apps/" + projectId, {
-        auth: true,
-        origin: api.appengineOrigin,
-    })
-        .then(function (resp) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceAccount = exports.getBucket = exports.deleteObject = exports.uploadObject = exports.upload = exports.getDefaultBucket = void 0;
+const path = require("path");
+const api = require("../api");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+async function getDefaultBucket(projectId) {
+    try {
+        const resp = await api.request("GET", "/v1/apps/" + projectId, {
+            auth: true,
+            origin: api.appengineOrigin,
+        });
         if (resp.body.defaultBucket === "undefined") {
-            logger.debug("Default storage bucket is undefined.");
-            return Promise.reject(new FirebaseError("Your project is being set up. Please wait a minute before deploying again."));
+            logger_1.logger.debug("Default storage bucket is undefined.");
+            throw new error_1.FirebaseError("Your project is being set up. Please wait a minute before deploying again.");
         }
-        return Promise.resolve(resp.body.defaultBucket);
-    }, function (err) {
-        logger.info("\n\nThere was an issue deploying your functions. Verify that your project has a Google App Engine instance setup at https://console.cloud.google.com/appengine and try again. If this issue persists, please contact support.");
-        return Promise.reject(err);
-    });
+        return resp.body.defaultBucket;
+    }
+    catch (err) {
+        logger_1.logger.info("\n\nThere was an issue deploying your functions. Verify that your project has a Google App Engine instance setup at https://console.cloud.google.com/appengine and try again. If this issue persists, please contact support.");
+        throw err;
+    }
 }
-async function _uploadSource(source, uploadUrl, extraHeaders) {
+exports.getDefaultBucket = getDefaultBucket;
+async function upload(source, uploadUrl, extraHeaders) {
     const url = new URL(uploadUrl);
     const result = await api.request("PUT", url.pathname + url.search, {
         data: source.stream,
@@ -33,9 +36,10 @@ async function _uploadSource(source, uploadUrl, extraHeaders) {
         generation: result.response.headers["x-goog-generation"],
     };
 }
-async function _uploadObject(source, bucketName) {
+exports.upload = upload;
+async function uploadObject(source, bucketName) {
     if (path.extname(source.file) !== ".zip") {
-        throw new FirebaseError(`Expected a file name ending in .zip, got ${source.file}`);
+        throw new error_1.FirebaseError(`Expected a file name ending in .zip, got ${source.file}`);
     }
     const location = `/${bucketName}/${path.basename(source.file)}`;
     const result = await api.request("PUT", location, {
@@ -55,13 +59,15 @@ async function _uploadObject(source, bucketName) {
         generation: result.response.headers["x-goog-generation"],
     };
 }
-function _deleteObject(location) {
+exports.uploadObject = uploadObject;
+function deleteObject(location) {
     return api.request("DELETE", location, {
         auth: true,
         origin: api.storageOrigin,
     });
 }
-async function _getBucket(bucketName) {
+exports.deleteObject = deleteObject;
+async function getBucket(bucketName) {
     try {
         const result = await api.request("GET", `/storage/v1/b/${bucketName}`, {
             auth: true,
@@ -70,16 +76,26 @@ async function _getBucket(bucketName) {
         return result.body;
     }
     catch (err) {
-        logger.debug(err);
-        throw new FirebaseError("Failed to obtain the storage bucket", {
+        logger_1.logger.debug(err);
+        throw new error_1.FirebaseError("Failed to obtain the storage bucket", {
+            original: err,
+        });
+    }
+}
+exports.getBucket = getBucket;
+async function getServiceAccount(projectId) {
+    try {
+        const response = await api.request("GET", `/storage/v1/projects/${projectId}/serviceAccount`, {
+            auth: true,
+            origin: api.storageOrigin,
+        });
+        return response.body;
+    }
+    catch (err) {
+        logger_1.logger.debug(err);
+        throw new error_1.FirebaseError("Failed to obtain the Cloud Storage service agent", {
             original: err,
         });
     }
 }
-module.exports = {
-    getDefaultBucket: _getDefaultBucket,
-    deleteObject: _deleteObject,
-    upload: _uploadSource,
-    uploadObject: _uploadObject,
-    getBucket: _getBucket,
-};
+exports.getServiceAccount = getServiceAccount;