firebase-tools 9.19.0 → 9.23.0

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertExhaustive = exports.zipIn = exports.zip = exports.reduceFlat = exports.flatten = exports.flattenArray = exports.flattenObject = void 0;
+exports.partition = exports.assertExhaustive = exports.zipIn = exports.zip = exports.reduceFlat = exports.flatten = exports.flattenArray = exports.flattenObject = void 0;
 function* flattenObject(obj) {
     function* helper(path, obj) {
         for (const [k, v] of Object.entries(obj)) {
@@ -55,3 +55,10 @@ function assertExhaustive(val) {
     throw new Error(`Never has a value (${val}). This should be impossible`);
 }
 exports.assertExhaustive = assertExhaustive;
+function partition(arr, callbackFn) {
+    return arr.reduce((acc, elem) => {
+        acc[callbackFn(elem) ? 0 : 1].push(elem);
+        return acc;
+    }, [[], []]);
+}
+exports.partition = partition;

package/lib/functions/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.validateKey = exports.parse = void 0;
+exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
 const clc = require("cli-color");
 const fs = require("fs");
 const path = require("path");
@@ -72,17 +72,23 @@ function parse(data) {
 }
 exports.parse = parse;
 class KeyValidationError extends Error {
+    constructor(key, message) {
+        super(`Failed to validate key ${key}: ${message}`);
+        this.key = key;
+        this.message = message;
+    }
 }
+exports.KeyValidationError = KeyValidationError;
 function validateKey(key) {
     if (RESERVED_KEYS.includes(key)) {
-        throw new KeyValidationError(`Key ${key} is reserved for internal use.`);
+        throw new KeyValidationError(key, `Key ${key} is reserved for internal use.`);
     }
     if (!/^[A-Z_][A-Z0-9_]*$/.test(key)) {
-        throw new KeyValidationError(`Key ${key} must start with an uppercase ASCII letter or underscore` +
+        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} starts with a reserved prefix (X_GOOGLE_ or FIREBASE_)`);
+        throw new KeyValidationError(key, `Key ${key} starts with a reserved prefix (X_GOOGLE_ or FIREBASE_)`);
     }
 }
 exports.validateKey = validateKey;

package/lib/functions/runtimeConfigExport.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDotenvFilename = exports.toDotenvFormat = exports.hydrateEnvs = exports.configToEnv = exports.convertKey = exports.hydrateConfigs = exports.getProjectInfos = void 0;
+const clc = require("cli-color");
+const env = require("./env");
+const functionsConfig = require("../functionsConfig");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const rc_1 = require("../rc");
+const utils_1 = require("../utils");
+const functional_1 = require("../functional");
+function getProjectInfos(options) {
+    const result = {};
+    const rc = rc_1.loadRC(options);
+    if (rc.projects) {
+        for (const [alias, projectId] of Object.entries(rc.projects)) {
+            if (Object.keys(result).includes(projectId)) {
+                utils_1.logWarning(`Multiple aliases found for ${clc.bold(projectId)}. ` +
+                    `Preferring alias (${clc.bold(result[projectId])}) over (${clc.bold(alias)}).`);
+                continue;
+            }
+            result[projectId] = alias;
+        }
+    }
+    const projectId = projectUtils_1.getProjectId(options);
+    if (projectId && !Object.keys(result).includes(projectId)) {
+        result[projectId] = projectId;
+    }
+    return Object.entries(result).map(([k, v]) => {
+        const result = { projectId: k };
+        if (k !== v) {
+            result.alias = v;
+        }
+        return result;
+    });
+}
+exports.getProjectInfos = getProjectInfos;
+async function hydrateConfigs(pInfos) {
+    const hydrate = pInfos.map((info) => {
+        return functionsConfig
+            .materializeAll(info.projectId)
+            .then((config) => {
+            info.config = config;
+            return;
+        })
+            .catch((err) => {
+            logger_1.logger.debug(`Failed to fetch runtime config for project ${info.projectId}: ${err.message}`);
+        });
+    });
+    await Promise.all(hydrate);
+}
+exports.hydrateConfigs = hydrateConfigs;
+function convertKey(configKey, prefix) {
+    const baseKey = configKey
+        .toUpperCase()
+        .replace(/\./g, "_")
+        .replace(/-/g, "_");
+    let envKey = baseKey;
+    try {
+        env.validateKey(envKey);
+    }
+    catch (err) {
+        if (err instanceof env.KeyValidationError) {
+            envKey = prefix + envKey;
+            env.validateKey(envKey);
+        }
+    }
+    return envKey;
+}
+exports.convertKey = convertKey;
+function configToEnv(configs, prefix) {
+    const success = [];
+    const errors = [];
+    for (const [configKey, value] of functional_1.flatten(configs)) {
+        try {
+            const envKey = convertKey(configKey, prefix);
+            success.push({ origKey: configKey, newKey: envKey, value: value });
+        }
+        catch (err) {
+            if (err instanceof env.KeyValidationError) {
+                errors.push({
+                    origKey: configKey,
+                    newKey: err.key,
+                    err: err.message,
+                    value: value,
+                });
+            }
+            else {
+                throw new error_1.FirebaseError("Unexpected error while converting config", {
+                    exit: 2,
+                    original: err,
+                });
+            }
+        }
+    }
+    return { success, errors };
+}
+exports.configToEnv = configToEnv;
+function hydrateEnvs(pInfos, prefix) {
+    let errMsg = "";
+    for (const pInfo of pInfos) {
+        const { success, errors } = configToEnv(pInfo.config, prefix);
+        if (errors.length > 0) {
+            const msg = `${pInfo.projectId} ` +
+                `${pInfo.alias ? "(" + pInfo.alias + ")" : ""}:\n` +
+                errors.map((err) => `\t${err.origKey} => ${clc.bold(err.newKey)} (${err.err})`).join("\n") +
+                "\n";
+            errMsg += msg;
+        }
+        else {
+            pInfo.envs = success;
+        }
+    }
+    return errMsg;
+}
+exports.hydrateEnvs = hydrateEnvs;
+function escape(s) {
+    const result = s
+        .replace("\n", "\\n")
+        .replace("\r", "\\r")
+        .replace("\t", "\\t")
+        .replace("\v", "\\v");
+    return result.replace(/(['"])/g, "\\$1");
+}
+function toDotenvFormat(envs, header = "") {
+    const lines = envs.map(({ newKey, value }) => `${newKey}="${escape(value)}"`);
+    const maxLineLen = Math.max(...lines.map((l) => l.length));
+    return (`${header}\n` +
+        lines.map((line, idx) => `${line.padEnd(maxLineLen)} # from ${envs[idx].origKey}`).join("\n"));
+}
+exports.toDotenvFormat = toDotenvFormat;
+function generateDotenvFilename(pInfo) {
+    var _a;
+    return `.env.${(_a = pInfo.alias) !== null && _a !== void 0 ? _a : pInfo.projectId}`;
+}
+exports.generateDotenvFilename = generateDotenvFilename;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionFromEndpoint = exports.endpointFromFunction = 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");
@@ -51,6 +51,7 @@ async function createFunction(cloudFunction) {
     const endpoint = `/${exports.API_VERSION}/${apiPath}`;
     try {
         const res = await api.request("POST", endpoint, {
+            headers: { "X-Firebase-Artifact-Registry": "optin" },
             auth: true,
             data: cloudFunction,
             origin: api.functionsOrigin,
@@ -146,6 +147,7 @@ async function updateFunction(cloudFunction) {
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables");
     try {
         const res = await api.request("PATCH", endpoint, {
+            headers: { "X-Firebase-Artifact-Registry": "optin" },
             qs: {
                 updateMask: fieldMasks.join(","),
             },
@@ -198,9 +200,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,87 +216,25 @@ 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 = {};
-        uri = gcfFunction.httpsTrigger.url;
-    }
-    else {
+    if ((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
         trigger = {
-            eventType: gcfFunction.eventTrigger.eventType,
-            eventFilters: {
-                resource: gcfFunction.eventTrigger.resource,
-            },
-            retry: !!((_a = gcfFunction.eventTrigger.failurePolicy) === null || _a === void 0 ? void 0 : _a.retry),
+            scheduleTrigger: {},
         };
     }
-    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,
-        project,
-        region,
-        trigger,
-        entryPoint: gcfFunction.entryPoint,
-        runtime: gcfFunction.runtime,
-    };
-    if (uri) {
-        cloudFunction.uri = uri;
-    }
-    proto.copyIfPresent(cloudFunction, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "sourceUploadUrl");
-    return cloudFunction;
-}
-exports.specFromFunction = specFromFunction;
-function functionFromSpec(cloudFunction, sourceUploadUrl) {
-    if (cloudFunction.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)) {
-        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),
-        sourceUploadUrl: sourceUploadUrl,
-        entryPoint: cloudFunction.entryPoint,
-        runtime: cloudFunction.runtime,
-    };
-    if (backend.isEventTrigger(cloudFunction.trigger)) {
-        gcfFunction.eventTrigger = {
-            eventType: cloudFunction.trigger.eventType,
-            resource: cloudFunction.trigger.eventFilters.resource,
+    else if ((_b = gcfFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-taskqueue"]) {
+        trigger = {
+            taskQueueTrigger: {},
         };
-        gcfFunction.eventTrigger.failurePolicy = cloudFunction.trigger.retry
-            ? { retry: {} }
-            : undefined;
     }
-    else {
-        gcfFunction.httpsTrigger = {};
-    }
-    proto.copyIfPresent(gcfFunction, cloudFunction, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables");
-    return gcfFunction;
-}
-exports.functionFromSpec = functionFromSpec;
-function endpointFromFunction(gcfFunction) {
-    var _a, _b;
-    const [, project, , region, , id] = gcfFunction.name.split("/");
-    let trigger;
-    let uri;
-    if (gcfFunction.httpsTrigger) {
+    else if (gcfFunction.httpsTrigger) {
         trigger = { httpsTrigger: {} };
         uri = gcfFunction.httpsTrigger.url;
     }
-    else if ((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
-        trigger = {
-            scheduleTrigger: {},
-        };
-    }
     else {
         trigger = {
             eventTrigger: {
@@ -300,7 +242,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),
             },
         };
     }
@@ -349,6 +291,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.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,93 +115,6 @@ async function deleteFunction(cloudFunction) {
     }
 }
 exports.deleteFunction = deleteFunction;
-function functionFromSpec(cloudFunction, source) {
-    if (cloudFunction.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)) {
-        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),
-        buildConfig: {
-            runtime: cloudFunction.runtime,
-            entryPoint: cloudFunction.entryPoint,
-            source: {
-                storageSource: source,
-            },
-            environmentVariables: {},
-        },
-        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)) {
-        gcfFunction.eventTrigger = {
-            eventType: cloudFunction.trigger.eventType,
-        };
-        if (gcfFunction.eventTrigger.eventType === exports.PUBSUB_PUBLISH_EVENT) {
-            gcfFunction.eventTrigger.pubsubTopic = cloudFunction.trigger.eventFilters.resource;
-        }
-        else {
-            gcfFunction.eventTrigger.eventFilters = [];
-            for (const [attribute, value] of Object.entries(cloudFunction.trigger.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);
-        }
-    }
-    proto.copyIfPresent(gcfFunction, cloudFunction, "labels");
-    return gcfFunction;
-}
-exports.functionFromSpec = functionFromSpec;
-function specFromFunction(gcfFunction) {
-    const [, project, , region, , id] = gcfFunction.name.split("/");
-    let trigger;
-    if (gcfFunction.eventTrigger) {
-        trigger = {
-            eventType: gcfFunction.eventTrigger.eventType,
-            eventFilters: {},
-            retry: false,
-        };
-        if (gcfFunction.eventTrigger.pubsubTopic) {
-            trigger.eventFilters.resource = gcfFunction.eventTrigger.pubsubTopic;
-        }
-        else {
-            for (const { attribute, value } of gcfFunction.eventTrigger.eventFilters || []) {
-                trigger.eventFilters[attribute] = value;
-            }
-        }
-    }
-    else {
-        trigger = {};
-    }
-    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,
-        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;
-}
-exports.specFromFunction = specFromFunction;
 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");
@@ -245,13 +158,16 @@ function functionFromEndpoint(endpoint, source) {
         }
     }
     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") {
@@ -259,6 +175,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: {
@@ -275,6 +196,7 @@ function endpointFromFunction(gcfFunction) {
                 trigger.eventTrigger.eventFilters[attribute] = value;
             }
         }
+        proto.renameIfPresent(trigger.eventTrigger, gcfFunction.eventTrigger, "region", "triggerRegion");
     }
     else {
         trigger = { httpsTrigger: {} };

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;