firebase-tools 10.1.2 → 10.2.0

package/lib/extensions/resolveSource.js

@@ -1,63 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrustedPublishers = exports.getExtensionRegistry = exports.getMinRequiredVersion = exports.getTargetVersion = exports.resolveRegistryEntry = exports.isOfficialSource = exports.resolveSourceUrl = exports.confirmUpdateWarning = void 0;
+exports.getTrustedPublishers = exports.getExtensionRegistry = void 0;
 const _ = require("lodash");
-const clc = require("cli-color");
-const { marked } = require("marked");
-const error_1 = require("../error");
 const logger_1 = require("../logger");
-const prompt_1 = require("../prompt");
 const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
 const EXTENSIONS_REGISTRY_ENDPOINT = "/extensions.json";
-async function confirmUpdateWarning(updateWarning) {
-    logger_1.logger.info(marked(updateWarning.description));
-    if (updateWarning.action) {
-        logger_1.logger.info(marked(updateWarning.action));
-    }
-    const continueUpdate = await (0, prompt_1.promptOnce)({
-        type: "confirm",
-        message: "Do you wish to continue with this update?",
-        default: false,
-    });
-    if (!continueUpdate) {
-        throw new error_1.FirebaseError(`Update cancelled.`, { exit: 2 });
-    }
-}
-exports.confirmUpdateWarning = confirmUpdateWarning;
-function resolveSourceUrl(registryEntry, name, version) {
-    const targetVersion = getTargetVersion(registryEntry, version);
-    const sourceUrl = _.get(registryEntry, ["versions", targetVersion]);
-    if (!sourceUrl) {
-        throw new error_1.FirebaseError(`Could not find version ${clc.bold(version)} of extension ${clc.bold(name)}.`);
-    }
-    return sourceUrl;
-}
-exports.resolveSourceUrl = resolveSourceUrl;
-function isOfficialSource(registryEntry, sourceUrl) {
-    const versions = _.get(registryEntry, "versions");
-    return _.includes(versions, sourceUrl);
-}
-exports.isOfficialSource = isOfficialSource;
-async function resolveRegistryEntry(name) {
-    const extensionsRegistry = await getExtensionRegistry();
-    const registryEntry = _.get(extensionsRegistry, name);
-    if (!registryEntry) {
-        throw new error_1.FirebaseError(`Unable to find extension source named ${clc.bold(name)}.`);
-    }
-    return registryEntry;
-}
-exports.resolveRegistryEntry = resolveRegistryEntry;
-function getTargetVersion(registryEntry, versionOrLabel) {
-    const seekVersion = versionOrLabel || "latest";
-    const versionFromLabel = _.get(registryEntry, ["labels", seekVersion]);
-    return versionFromLabel || seekVersion;
-}
-exports.getTargetVersion = getTargetVersion;
-function getMinRequiredVersion(registryEntry) {
-    return _.get(registryEntry, ["labels", "minRequired"]);
-}
-exports.getMinRequiredVersion = getMinRequiredVersion;
 async function getExtensionRegistry(onlyFeatured) {
     const client = new apiv2_1.Client({ urlPrefix: api_1.firebaseExtensionsRegistryOrigin });
     const res = await client.get(EXTENSIONS_REGISTRY_ENDPOINT);

package/lib/extensions/secretsUtils.js

@@ -22,7 +22,7 @@ async function grantFirexServiceAgentSecretAdminRole(secret) {
     const projectNumber = await (0, getProjectNumber_1.getProjectNumber)({ projectId: secret.projectId });
     const firexSaProjectId = utils.envOverride("FIREBASE_EXTENSIONS_SA_PROJECT_ID", "gcp-sa-firebasemods");
     const saEmail = `service-${projectNumber}@${firexSaProjectId}.iam.gserviceaccount.com`;
-    return secretManagerApi.grantServiceAgentRole(secret, saEmail, "roles/secretmanager.admin");
+    return secretManagerApi.ensureServiceAgentRole(secret, [saEmail], "roles/secretmanager.admin");
 }
 exports.grantFirexServiceAgentSecretAdminRole = grantFirexServiceAgentSecretAdminRole;
 async function getManagedSecrets(instance) {

package/lib/extensions/updateHelper.js

@@ -6,7 +6,6 @@ const semver = require("semver");
 const { marked } = require("marked");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
-const resolveSource = require("./resolveSource");
 const extensionsApi = require("./extensionsApi");
 const refs = require("./refs");
 const extensionsHelper_1 = require("./extensionsHelper");
@@ -123,19 +122,6 @@ async function updateToVersionFromPublisherSource(projectId, instanceId, extVers
     catch (err) {
         throw new error_1.FirebaseError(`Could not find source '${clc.bold(extVersionRef)}' because (${clc.bold(version)}) is not a published version. To update, use the latest version of this extension (${clc.bold(extension.latestVersion)}).`);
     }
-    let registryEntry;
-    try {
-        registryEntry = await resolveSource.resolveRegistryEntry(existingSpec.name);
-    }
-    catch (err) {
-        logger_1.logger.debug(`Unable to fetch registry.json entry for ${existingSpec.name}`);
-    }
-    if (registryEntry) {
-        const minVer = resolveSource.getMinRequiredVersion(registryEntry);
-        if (minVer && semver.gt(minVer, source.spec.version)) {
-            throw new error_1.FirebaseError(`The version you are trying to update to (${clc.bold(source.spec.version)}) is less than the minimum version required (${clc.bold(minVer)}) to use this extension.`);
-        }
-    }
     showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, extVersionRef);
     warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION);
     const releaseNotes = await changelog.getReleaseNotesForUpdate({

package/lib/extensions/utils.js

@@ -22,12 +22,14 @@ function convertExtensionOptionToLabeledList(options) {
 }
 exports.convertExtensionOptionToLabeledList = convertExtensionOptionToLabeledList;
 function convertOfficialExtensionsToList(officialExts) {
-    return _.map(officialExts, (entry, key) => {
+    const l = _.map(officialExts, (entry, key) => {
         return {
             checked: false,
-            value: key,
+            value: `${entry.publisher}/${key}`,
         };
     });
+    l.sort((a, b) => a.value.localeCompare(b.value));
+    return l;
 }
 exports.convertOfficialExtensionsToList = convertOfficialExtensionsToList;
 function getRandomString(length) {

package/lib/functions/env.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
+exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.parseStrict = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
 const clc = require("cli-color");
 const fs = require("fs");
 const path = require("path");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
-const previews_1 = require("../previews");
 const utils_1 = require("../utils");
 const FUNCTIONS_EMULATOR_DOTENV = ".env.local";
+const RESERVED_PREFIXES = ["X_GOOGLE_", "FIREBASE_", "EXT_"];
 const RESERVED_KEYS = [
     "FIREBASE_CONFIG",
     "CLOUD_RUNTIME_CONFIG",
@@ -87,8 +87,8 @@ function validateKey(key) {
         throw new KeyValidationError(key, `Key ${key} must start with an uppercase ASCII letter or underscore` +
             ", and then consist of uppercase ASCII letters, digits, and underscores.");
     }
-    if (key.startsWith("X_GOOGLE_") || key.startsWith("FIREBASE_")) {
-        throw new KeyValidationError(key, `Key ${key} starts with a reserved prefix (X_GOOGLE_ or FIREBASE_)`);
+    if (RESERVED_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+        throw new KeyValidationError(key, `Key ${key} starts with a reserved prefix (${RESERVED_PREFIXES.join(" ")})`);
     }
 }
 exports.validateKey = validateKey;
@@ -117,6 +117,7 @@ function parseStrict(data) {
     }
     return envs;
 }
+exports.parseStrict = parseStrict;
 function findEnvfiles(functionsSource, projectId, projectAlias, isEmulator) {
     const files = [".env"];
     if (isEmulator) {
@@ -139,9 +140,6 @@ function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, })
 exports.hasUserEnvs = hasUserEnvs;
 function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
-    if (!previews_1.previews.dotenv) {
-        return {};
-    }
     const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
     if (envFiles.length == 0) {
         return {};

package/lib/functions/secrets.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneSecrets = exports.of = exports.ensureSecret = exports.ensureValidKey = exports.labels = exports.isFirebaseManaged = void 0;
+const secretManager_1 = require("../gcp/secretManager");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+const prompt_1 = require("../prompt");
+const env_1 = require("./env");
+const FIREBASE_MANGED = "firebase-managed";
+function isFirebaseManaged(secret) {
+    return Object.keys(secret.labels || []).includes(FIREBASE_MANGED);
+}
+exports.isFirebaseManaged = isFirebaseManaged;
+function labels() {
+    return { [FIREBASE_MANGED]: "true" };
+}
+exports.labels = labels;
+function toUpperSnakeCase(key) {
+    return key
+        .replace("-", "_")
+        .replace(".", "_")
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toUpperCase();
+}
+async function ensureValidKey(key, options) {
+    const transformedKey = toUpperSnakeCase(key);
+    if (transformedKey !== key) {
+        if (options.force) {
+            throw new error_1.FirebaseError("Secret key must be in UPPER_SNAKE_CASE.");
+        }
+        (0, utils_1.logWarning)(`By convention, secret key must be in UPPER_SNAKE_CASE.`);
+        const confirm = await (0, prompt_1.promptOnce)({
+            name: "updateKey",
+            type: "confirm",
+            default: true,
+            message: `Would you like to use ${transformedKey} as key instead?`,
+        }, options);
+        if (!confirm) {
+            throw new error_1.FirebaseError("Secret key must be in UPPER_SNAKE_CASE.");
+        }
+    }
+    try {
+        (0, env_1.validateKey)(transformedKey);
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Invalid secret key ${transformedKey}`, { children: [err] });
+    }
+    return transformedKey;
+}
+exports.ensureValidKey = ensureValidKey;
+async function ensureSecret(projectId, name, options) {
+    try {
+        const secret = await (0, secretManager_1.getSecret)(projectId, name);
+        if (!isFirebaseManaged(secret)) {
+            if (!options.force) {
+                (0, utils_1.logWarning)("Your secret is not managed by Firebase. " +
+                    "Firebase managed secrets are automatically pruned to reduce your monthly cost for using Secret Manager. ");
+                const confirm = await (0, prompt_1.promptOnce)({
+                    name: "updateLabels",
+                    type: "confirm",
+                    default: true,
+                    message: `Would you like to have your secret ${secret.name} managed by Firebase?`,
+                }, options);
+                if (confirm) {
+                    return (0, secretManager_1.patchSecret)(projectId, secret.name, Object.assign(Object.assign({}, secret.labels), labels()));
+                }
+            }
+        }
+        return secret;
+    }
+    catch (err) {
+        if (err.status !== 404) {
+            throw err;
+        }
+    }
+    return await (0, secretManager_1.createSecret)(projectId, name, labels());
+}
+exports.ensureSecret = ensureSecret;
+function of(endpoints) {
+    return endpoints.reduce((envs, endpoint) => [...envs, ...(endpoint.secretEnvironmentVariables || [])], []);
+}
+exports.of = of;
+async function pruneSecrets(projectInfo, endpoints) {
+    const { projectId, projectNumber } = projectInfo;
+    const pruneKey = (name, version) => `${name}@${version}`;
+    const prunedSecrets = new Set();
+    const haveSecrets = await (0, secretManager_1.listSecrets)(projectId, `labels.${FIREBASE_MANGED}=true`);
+    for (const secret of haveSecrets) {
+        const versions = await (0, secretManager_1.listSecretVersions)(projectId, secret.name, `state: ENABLED`);
+        for (const version of versions) {
+            prunedSecrets.add(pruneKey(secret.name, version.versionId));
+        }
+    }
+    const sevs = of(endpoints).filter((sev) => sev.projectId === projectId || sev.projectId === projectNumber);
+    for (const sev of sevs) {
+        let name = sev.secret;
+        if (name.includes("/")) {
+            const secret = (0, secretManager_1.parseSecretResourceName)(name);
+            name = secret.name;
+        }
+        let version = sev.version;
+        if (version === "latest") {
+            const resolved = await (0, secretManager_1.getSecretVersion)(projectId, name, version);
+            version = resolved.versionId;
+        }
+        prunedSecrets.delete(pruneKey(name, version));
+    }
+    return Array.from(prunedSecrets)
+        .map((key) => key.split("@"))
+        .map(([secret, version]) => ({ projectId, version, secret, key: secret }));
+}
+exports.pruneSecrets = pruneSecrets;

package/lib/gcp/cloudbilling.js

@@ -1,36 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listBillingAccounts = exports.setBillingAccount = exports.checkBillingEnabled = void 0;
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const utils = require("../utils");
 const API_VERSION = "v1";
+const client = new apiv2_1.Client({ urlPrefix: api_1.cloudbillingOrigin, apiVersion: API_VERSION });
 async function checkBillingEnabled(projectId) {
-    const res = await api.request("GET", utils.endpoint([API_VERSION, "projects", projectId, "billingInfo"]), {
-        auth: true,
-        origin: api.cloudbillingOrigin,
-        retryCodes: [500, 503],
-    });
+    const res = await client.get(utils.endpoint(["projects", projectId, "billingInfo"]), { retryCodes: [500, 503] });
     return res.body.billingEnabled;
 }
 exports.checkBillingEnabled = checkBillingEnabled;
 async function setBillingAccount(projectId, billingAccountName) {
-    const res = await api.request("PUT", utils.endpoint([API_VERSION, "projects", projectId, "billingInfo"]), {
-        auth: true,
-        origin: api.cloudbillingOrigin,
-        retryCodes: [500, 503],
-        data: {
-            billingAccountName: billingAccountName,
-        },
-    });
+    const res = await client.put(utils.endpoint(["projects", projectId, "billingInfo"]), {
+        billingAccountName: billingAccountName,
+    }, { retryCodes: [500, 503] });
     return res.body.billingEnabled;
 }
 exports.setBillingAccount = setBillingAccount;
 async function listBillingAccounts() {
-    const res = await api.request("GET", utils.endpoint([API_VERSION, "billingAccounts"]), {
-        auth: true,
-        origin: api.cloudbillingOrigin,
-        retryCodes: [500, 503],
-    });
+    const res = await client.get(utils.endpoint(["billingAccounts"]), { retryCodes: [500, 503] });
     return res.body.billingAccounts || [];
 }
 exports.listBillingAccounts = listBillingAccounts;

package/lib/gcp/cloudfunctions.js

@@ -5,12 +5,14 @@ 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");
 const proto = require("./proto");
 const runtimes = require("../deploy/functions/runtimes");
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
 exports.API_VERSION = "v1";
+const client = new apiv2_1.Client({ urlPrefix: api_1.functionsOrigin, apiVersion: exports.API_VERSION });
 function validateFunction(func) {
     proto.assertOneOf("Cloud Function", func, "sourceCode", "sourceArchiveUrl", "sourceRepository", "sourceUploadUrl");
     proto.assertOneOf("Cloud Function", func, "trigger", "httpsTrigger", "eventTrigger");
@@ -30,16 +32,10 @@ function functionsOpLogReject(funcName, type, err) {
 }
 async function generateUploadUrl(projectId, location) {
     const parent = "projects/" + projectId + "/locations/" + location;
-    const endpoint = "/" + exports.API_VERSION + "/" + parent + "/functions:generateUploadUrl";
+    const endpoint = `/${parent}/functions:generateUploadUrl`;
     try {
-        const res = await api.request("POST", endpoint, {
-            auth: true,
-            json: false,
-            origin: api.functionsOrigin,
-            retryCodes: [503],
-        });
-        const responseBody = JSON.parse(res.body);
-        return responseBody.uploadUrl;
+        const res = await client.post(endpoint, {}, { retryCodes: [503] });
+        return res.body.uploadUrl;
     }
     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.");
@@ -49,18 +45,13 @@ async function generateUploadUrl(projectId, location) {
 exports.generateUploadUrl = generateUploadUrl;
 async function createFunction(cloudFunction) {
     const apiPath = cloudFunction.name.substring(0, cloudFunction.name.lastIndexOf("/"));
-    const endpoint = `/${exports.API_VERSION}/${apiPath}`;
+    const endpoint = `/${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,
-        });
+        const res = await client.post(endpoint, cloudFunction, { headers });
         return {
             name: res.body.name,
             type: "create",
@@ -73,15 +64,11 @@ async function createFunction(cloudFunction) {
 }
 exports.createFunction = createFunction;
 async function setIamPolicy(options) {
-    const endpoint = `/${exports.API_VERSION}/${options.name}:setIamPolicy`;
+    const endpoint = `/${options.name}:setIamPolicy`;
     try {
-        await api.request("POST", endpoint, {
-            auth: true,
-            data: {
-                policy: options.policy,
-                updateMask: Object.keys(options.policy).join(","),
-            },
-            origin: api.functionsOrigin,
+        await client.post(endpoint, {
+            policy: options.policy,
+            updateMask: Object.keys(options.policy).join(","),
         });
     }
     catch (err) {
@@ -92,12 +79,10 @@ async function setIamPolicy(options) {
 }
 exports.setIamPolicy = setIamPolicy;
 async function getIamPolicy(fnName) {
-    const endpoint = `/${exports.API_VERSION}/${fnName}:getIamPolicy`;
+    const endpoint = `/${fnName}:getIamPolicy`;
     try {
-        return await api.request("GET", endpoint, {
-            auth: true,
-            origin: api.functionsOrigin,
-        });
+        const res = await client.get(endpoint);
+        return res.body;
     }
     catch (err) {
         throw new error_1.FirebaseError(`Failed to get the IAM Policy on the function ${fnName}`, {
@@ -148,21 +133,18 @@ async function setInvokerUpdate(projectId, fnName, invoker) {
 }
 exports.setInvokerUpdate = setInvokerUpdate;
 async function updateFunction(cloudFunction) {
-    const endpoint = `/${exports.API_VERSION}/${cloudFunction.name}`;
+    const endpoint = `/${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, {
+        const res = await client.patch(endpoint, cloudFunction, {
             headers,
-            qs: {
+            queryParams: {
                 updateMask: fieldMasks.join(","),
             },
-            auth: true,
-            data: cloudFunction,
-            origin: api.functionsOrigin,
         });
         return {
             done: false,
@@ -176,12 +158,9 @@ async function updateFunction(cloudFunction) {
 }
 exports.updateFunction = updateFunction;
 async function deleteFunction(name) {
-    const endpoint = `/${exports.API_VERSION}/${name}`;
+    const endpoint = `/${name}`;
     try {
-        const res = await api.request("DELETE", endpoint, {
-            auth: true,
-            origin: api.functionsOrigin,
-        });
+        const res = await client.delete(endpoint);
         return {
             done: false,
             name: res.body.name,
@@ -194,12 +173,9 @@ async function deleteFunction(name) {
 }
 exports.deleteFunction = deleteFunction;
 async function list(projectId, region) {
-    const endpoint = "/" + exports.API_VERSION + "/projects/" + projectId + "/locations/" + region + "/functions";
+    const endpoint = "/projects/" + projectId + "/locations/" + region + "/functions";
     try {
-        const res = await api.request("GET", endpoint, {
-            auth: true,
-            origin: api.functionsOrigin,
-        });
+        const res = await client.get(endpoint);
         if (res.body.unreachable && res.body.unreachable.length > 0) {
             logger_1.logger.debug(`[functions] unable to reach the following regions: ${res.body.unreachable.join(", ")}`);
         }
@@ -264,7 +240,7 @@ function endpointFromFunction(gcfFunction) {
     if (uri) {
         endpoint.uri = uri;
     }
-    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "sourceUploadUrl");
+    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "secretEnvironmentVariables", "sourceUploadUrl");
     return endpoint;
 }
 exports.endpointFromFunction = endpointFromFunction;
@@ -307,7 +283,7 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
     else {
         gcfFunction.httpsTrigger = {};
     }
-    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
+    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables", "secretEnvironmentVariables");
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;

package/lib/gcp/cloudlogging.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listEntries = void 0;
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const error_1 = require("../error");
 const API_VERSION = "v2";
 async function listEntries(projectId, filter, pageSize, order) {
-    const endpoint = `/${API_VERSION}/entries:list`;
+    const client = new apiv2_1.Client({ urlPrefix: api_1.cloudloggingOrigin, apiVersion: API_VERSION });
     try {
-        const result = await api.request("POST", endpoint, {
-            auth: true,
-            data: {
-                resourceNames: [`projects/${projectId}`],
-                filter: filter,
-                orderBy: "timestamp " + order,
-                pageSize: pageSize,
-            },
-            origin: api.cloudloggingOrigin,
+        const result = await client.post("/entries:list", {
+            resourceNames: [`projects/${projectId}`],
+            filter: filter,
+            orderBy: `timestamp ${order}`,
+            pageSize: pageSize,
         });
         return result.body.entries;
     }

package/lib/gcp/cloudmonitoring.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryTimeSeries = exports.ValueType = exports.Reducer = exports.MetricKind = exports.Aligner = exports.TimeSeriesView = exports.CLOUD_MONITORING_VERSION = void 0;
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const error_1 = require("../error");
 exports.CLOUD_MONITORING_VERSION = "v3";
 var TimeSeriesView;
@@ -57,11 +58,13 @@ var ValueType;
     ValueType["STRING"] = "STRING";
 })(ValueType = exports.ValueType || (exports.ValueType = {}));
 async function queryTimeSeries(query, projectNumber) {
+    const client = new apiv2_1.Client({
+        urlPrefix: api_1.cloudMonitoringOrigin,
+        apiVersion: exports.CLOUD_MONITORING_VERSION,
+    });
     try {
-        const res = await api.request("GET", `/${exports.CLOUD_MONITORING_VERSION}/projects/${projectNumber}/timeSeries/`, {
-            auth: true,
-            origin: api.cloudMonitoringOrigin,
-            data: query,
+        const res = await client.get(`/projects/${projectNumber}/timeSeries/`, {
+            queryParams: query,
         });
         return res.body.timeSeries;
     }

package/lib/gcp/cloudscheduler.js

@@ -4,7 +4,8 @@ exports.jobFromEndpoint = exports.createOrReplaceJob = exports.updateJob = expor
 const _ = require("lodash");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const backend = require("../deploy/functions/backend");
 const proto = require("./proto");
 const functional_1 = require("../functional");
@@ -17,36 +18,24 @@ function assertValidJob(job) {
     }
 }
 exports.assertValidJob = assertValidJob;
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.cloudschedulerOrigin, apiVersion: VERSION });
 function createJob(job) {
     const strippedName = job.name.substring(0, job.name.lastIndexOf("/"));
-    return api.request("POST", `/${VERSION}/${strippedName}`, {
-        auth: true,
-        origin: api.cloudschedulerOrigin,
-        data: Object.assign({ timeZone: DEFAULT_TIME_ZONE }, job),
-    });
+    return apiClient.post(`/${strippedName}`, Object.assign({ timeZone: DEFAULT_TIME_ZONE }, job));
 }
 exports.createJob = createJob;
 function deleteJob(name) {
-    return api.request("DELETE", `/${VERSION}/${name}`, {
-        auth: true,
-        origin: api.cloudschedulerOrigin,
-    });
+    return apiClient.delete(`/${name}`);
 }
 exports.deleteJob = deleteJob;
 function getJob(name) {
-    return api.request("GET", `/${VERSION}/${name}`, {
-        auth: true,
-        origin: api.cloudschedulerOrigin,
+    return apiClient.get(`/${name}`, {
         resolveOnHTTPError: true,
     });
 }
 exports.getJob = getJob;
 function updateJob(job) {
-    return api.request("PATCH", `/${VERSION}/${job.name}`, {
-        auth: true,
-        origin: api.cloudschedulerOrigin,
-        data: Object.assign({ timeZone: DEFAULT_TIME_ZONE }, job),
-    });
+    return apiClient.patch(`/${job.name}`, Object.assign({ timeZone: DEFAULT_TIME_ZONE }, job));
 }
 exports.updateJob = updateJob;
 async function createOrReplaceJob(job) {

package/lib/gcp/firedata.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listDatabaseInstances = void 0;
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const logger_1 = require("../logger");
 const utils = require("../utils");
 function _handleErrorResponse(response) {
@@ -14,9 +15,9 @@ function _handleErrorResponse(response) {
     });
 }
 async function listDatabaseInstances(projectNumber) {
-    const response = await api.request("GET", `/v1/projects/${projectNumber}/databases`, {
-        auth: true,
-        origin: api.firedataOrigin,
+    const client = new apiv2_1.Client({ urlPrefix: api_1.firedataOrigin, apiVersion: "v1" });
+    const response = await client.get(`/projects/${projectNumber}/databases`, {
+        resolveOnHTTPError: true,
     });
     if (response.status === 200) {
         return response.body.instance;

package/lib/gcp/firestore.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteDocuments = exports.deleteDocument = exports.listCollectionIds = void 0;
 const api_1 = require("../api");
-const apiv2 = require("../apiv2");
-const _CLIENT = new apiv2.Client({
+const apiv2_1 = require("../apiv2");
+const apiClient = new apiv2_1.Client({
     auth: true,
     apiVersion: "v1",
     urlPrefix: api_1.firestoreOriginOrEmulator,
@@ -13,13 +13,13 @@ function listCollectionIds(project) {
     const data = {
         pageSize: 2147483647,
     };
-    return _CLIENT.post(url, data).then((res) => {
+    return apiClient.post(url, data).then((res) => {
         return res.body.collectionIds || [];
     });
 }
 exports.listCollectionIds = listCollectionIds;
 async function deleteDocument(doc) {
-    return _CLIENT.delete(doc.name);
+    return apiClient.delete(doc.name);
 }
 exports.deleteDocument = deleteDocument;
 async function deleteDocuments(project, docs) {
@@ -28,7 +28,7 @@ async function deleteDocuments(project, docs) {
         return { delete: doc.name };
     });
     const data = { writes };
-    const res = await _CLIENT.post(url, data);
+    const res = await apiClient.post(url, data);
     return res.body.writeResults.length;
 }
 exports.deleteDocuments = deleteDocuments;