firebase-tools 10.2.0 → 10.3.0

package/lib/extensions/manifest.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showPreviewWarning = exports.showDeprecationWarning = exports.readInstanceParam = exports.getInstanceRef = exports.instanceExists = exports.loadConfig = exports.removeFromManifest = exports.writeToManifest = void 0;
+const clc = require("cli-color");
+const path = require("path");
+const refs = require("./refs");
+const config_1 = require("../config");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+const paramHelper_1 = require("./paramHelper");
+const error_1 = require("../error");
+const utils = require("../utils");
+const extensionsHelper_1 = require("./extensionsHelper");
+const ENV_DIRECTORY = "extensions";
+async function writeToManifest(specs, config, options, allowOverwrite = false) {
+    if (config.has("extensions") &&
+        Object.keys(config.get("extensions")).length &&
+        !options.nonInteractive &&
+        !options.force) {
+        const currentExtensions = Object.entries(config.get("extensions"))
+            .map((i) => `${i[0]}: ${i[1]}`)
+            .join("\n\t");
+        if (allowOverwrite) {
+            const overwrite = await (0, prompt_1.promptOnce)({
+                type: "list",
+                message: `firebase.json already contains extensions:\n${currentExtensions}\nWould you like to overwrite or merge?`,
+                choices: [
+                    { name: "Overwrite", value: true },
+                    { name: "Merge", value: false },
+                ],
+            });
+            if (overwrite) {
+                config.set("extensions", {});
+            }
+        }
+    }
+    writeExtensionsToFirebaseJson(specs, config);
+    await writeEnvFiles(specs, config, options.force);
+}
+exports.writeToManifest = writeToManifest;
+function removeFromManifest(instanceId, config) {
+    if (!instanceExists(instanceId, config)) {
+        throw new error_1.FirebaseError(`Extension instance ${instanceId} not found in firebase.json.`);
+    }
+    const extensions = config.get("extensions", {});
+    extensions[instanceId] = undefined;
+    config.set("extensions", extensions);
+    config.writeProjectFile("firebase.json", config.src);
+    logger_1.logger.info(`Removed extension instance ${instanceId} from firebase.json`);
+    config.deleteProjectFile(`extensions/${instanceId}.env`);
+    logger_1.logger.info(`Removed extension instance environment config extensions/${instanceId}.env`);
+    config.deleteProjectFile(`extensions/${instanceId}.env.local`);
+    logger_1.logger.info(`Removed extension instance environment config extensions/${instanceId}.env.local`);
+}
+exports.removeFromManifest = removeFromManifest;
+function loadConfig(options) {
+    const existingConfig = config_1.Config.load(options, true);
+    if (!existingConfig) {
+        throw new error_1.FirebaseError("Not currently in a Firebase directory. Run `firebase init` to create a Firebase directory.");
+    }
+    return existingConfig;
+}
+exports.loadConfig = loadConfig;
+function instanceExists(instanceId, config) {
+    return !!config.get("extensions", {})[instanceId];
+}
+exports.instanceExists = instanceExists;
+function getInstanceRef(instanceId, config) {
+    if (!instanceExists(instanceId, config)) {
+        throw new error_1.FirebaseError(`Could not find extension instance ${instanceId} in firebase.json`);
+    }
+    const ref = config.get("extensions", {})[instanceId];
+    return refs.parse(ref);
+}
+exports.getInstanceRef = getInstanceRef;
+function writeExtensionsToFirebaseJson(specs, config) {
+    const extensions = config.get("extensions", {});
+    for (const s of specs) {
+        extensions[s.instanceId] = refs.toExtensionVersionRef(s.ref);
+    }
+    config.set("extensions", extensions);
+    config.writeProjectFile("firebase.json", config.src);
+    utils.logSuccess("Wrote extensions to " + clc.bold("firebase.json") + "...");
+}
+async function writeEnvFiles(specs, config, force) {
+    for (const spec of specs) {
+        const content = Object.entries(spec.params)
+            .sort((a, b) => {
+            return a[0].localeCompare(b[0]);
+        })
+            .map((r) => `${r[0]}=${r[1]}`)
+            .join("\n");
+        await config.askWriteProjectFile(`extensions/${spec.instanceId}.env`, content, force);
+    }
+}
+function readInstanceParam(args) {
+    var _a;
+    const aliases = (_a = args.aliases) !== null && _a !== void 0 ? _a : [];
+    const filesToCheck = [
+        `${args.instanceId}.env`,
+        ...aliases.map((alias) => `${args.instanceId}.env.${alias}`),
+        ...(args.projectNumber ? [`${args.instanceId}.env.${args.projectNumber}`] : []),
+        ...(args.projectId ? [`${args.instanceId}.env.${args.projectId}`] : []),
+    ];
+    if (args.checkLocal) {
+        filesToCheck.push(`${args.instanceId}.env.local`);
+    }
+    let noFilesFound = true;
+    const combinedParams = {};
+    for (const fileToCheck of filesToCheck) {
+        try {
+            const params = readParamsFile(args.projectDir, fileToCheck);
+            logger_1.logger.debug(`Successfully read params from ${fileToCheck}`);
+            noFilesFound = false;
+            Object.assign(combinedParams, params);
+        }
+        catch (err) {
+            logger_1.logger.debug(`${err}`);
+        }
+    }
+    if (noFilesFound) {
+        throw new error_1.FirebaseError(`No params file found for ${args.instanceId}`);
+    }
+    return combinedParams;
+}
+exports.readInstanceParam = readInstanceParam;
+function readParamsFile(projectDir, fileName) {
+    const paramPath = path.join(projectDir, ENV_DIRECTORY, fileName);
+    const params = (0, paramHelper_1.readEnvFile)(paramPath);
+    return params;
+}
+function showDeprecationWarning() {
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "The behavior of ext:install, ext:update, ext:configure, and ext:uninstall will change in firebase-tools@11.0.0. " +
+        "Instead of deploying extensions directly, " +
+        "changes to extension instances will be written to firebase.json and ./extensions/*.env. " +
+        `Then ${clc.bold("firebase deploy (--only extensions)")} will deploy the changes to your Firebase project. ` +
+        `To access this behavior now, pass the ${clc.bold("--local")} flag.`);
+}
+exports.showDeprecationWarning = showDeprecationWarning;
+function showPreviewWarning() {
+    utils.logLabeledWarning(extensionsHelper_1.logPrefix, "These changes will be reflected in your Firebase Emulator after restart. " +
+        `Run ${clc.bold("firebase deploy (--only extensions)")} to deploy the changes to your Firebase project. `);
+}
+exports.showPreviewWarning = showPreviewWarning;

package/lib/extensions/metricsUtils.js

@@ -7,19 +7,19 @@ function parseTimeseriesResponse(series) {
     const ret = [];
     for (const s of series) {
         const ref = buildRef(s);
-        if (ref == undefined) {
+        if (ref === undefined) {
             continue;
         }
         let valueToday;
         let value7dAgo;
         let value28dAgo;
-        if (s.points.length >= 28 && s.points[27].value.int64Value != undefined) {
+        if (s.points.length >= 28 && s.points[27].value.int64Value !== undefined) {
             value28dAgo = parseBucket(s.points[27].value.int64Value);
         }
-        if (s.points.length >= 7 && s.points[6].value.int64Value != undefined) {
+        if (s.points.length >= 7 && s.points[6].value.int64Value !== undefined) {
             value7dAgo = parseBucket(s.points[6].value.int64Value);
         }
-        if (s.points.length >= 1 && s.points[0].value.int64Value != undefined) {
+        if (s.points.length >= 1 && s.points[0].value.int64Value !== undefined) {
             valueToday = parseBucket(s.points[0].value.int64Value);
         }
         ret.push({

package/lib/extensions/paramHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readEnvFile = exports.getParamsFromFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
+exports.readEnvFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = exports.setNewDefaults = void 0;
 const _ = require("lodash");
 const path = require("path");
 const clc = require("cli-color");
@@ -19,6 +19,7 @@ function setNewDefaults(params, newDefaults) {
     });
     return params;
 }
+exports.setNewDefaults = setNewDefaults;
 function getParamsWithCurrentValuesAsDefaults(extensionInstance) {
     const specParams = _.cloneDeep(_.get(extensionInstance, "config.source.spec.params", []));
     const currentParams = _.cloneDeep(_.get(extensionInstance, "config.params", {}));
@@ -49,7 +50,7 @@ async function getParams(args) {
         const firebaseProjectParams = await (0, extensionsHelper_1.getFirebaseProjectParams)(args.projectId);
         params = await askUserForParam.ask(args.projectId, args.instanceId, args.paramSpecs, firebaseProjectParams, !!args.reconfiguring);
     }
-    track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    void track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
     return params;
 }
 exports.getParams = getParams;
@@ -82,7 +83,7 @@ async function getParamsForUpdate(args) {
             instanceId: args.instanceId,
         });
     }
-    track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    void track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
     return params;
 }
 exports.getParamsForUpdate = getParamsForUpdate;
@@ -91,9 +92,10 @@ async function promptForNewParams(args) {
     const comparer = (param1, param2) => {
         return param1.type === param2.type && param1.param === param2.param;
     };
-    let paramsDiffDeletions = _.differenceWith(args.spec.params, _.get(args.newSpec, "params", []), comparer);
+    const oldParams = args.spec.params.filter((p) => Object.keys(args.currentParams).includes(p.param));
+    let paramsDiffDeletions = _.differenceWith(oldParams, args.newSpec.params, comparer);
     paramsDiffDeletions = (0, extensionsHelper_1.substituteParams)(paramsDiffDeletions, firebaseProjectParams);
-    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, _.get(args.spec, "params", []), comparer);
+    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, oldParams, comparer);
     paramsDiffAdditions = (0, extensionsHelper_1.substituteParams)(paramsDiffAdditions, firebaseProjectParams);
     if (paramsDiffDeletions.length) {
         logger_1.logger.info("The following params will no longer be used:");
@@ -116,10 +118,10 @@ function getParamsFromFile(args) {
     let envParams;
     try {
         envParams = readEnvFile(args.paramsEnvPath);
-        track("Extension Env File", "Present");
+        void track("Extension Env File", "Present");
     }
     catch (err) {
-        track("Extension Env File", "Invalid");
+        void track("Extension Env File", "Invalid");
         throw new error_1.FirebaseError(`Error reading env file: ${err.message}\n`, { original: err });
     }
     const params = (0, extensionsHelper_1.populateDefaultParams)(envParams, args.paramSpecs);
@@ -127,7 +129,6 @@ function getParamsFromFile(args) {
     logger_1.logger.info(`Using param values from ${args.paramsEnvPath}`);
     return params;
 }
-exports.getParamsFromFile = getParamsFromFile;
 function readEnvFile(envPath) {
     const buf = fs.readFileSync(path.resolve(envPath), "utf8");
     const result = env.parse(buf.toString().trim());

package/lib/extensions/refs.js

@@ -20,7 +20,7 @@ function parse(refOrName) {
 exports.parse = parse;
 function parseRef(ref) {
     const parts = refRegex.exec(ref);
-    if (parts && (parts.length == 5 || parts.length == 7)) {
+    if (parts && (parts.length === 5 || parts.length === 7)) {
         const publisherId = parts[1];
         const extensionId = parts[2];
         const version = parts[4];

package/lib/extensions/secretsUtils.js

@@ -15,7 +15,7 @@ async function ensureSecretManagerApiEnabled(options) {
 }
 exports.ensureSecretManagerApiEnabled = ensureSecretManagerApiEnabled;
 function usesSecrets(spec) {
-    return spec.params && !!spec.params.find((p) => p.type == extensionsApi.ParamType.SECRET);
+    return spec.params && !!spec.params.find((p) => p.type === extensionsApi.ParamType.SECRET);
 }
 exports.usesSecrets = usesSecrets;
 async function grantFirexServiceAgentSecretAdminRole(secret) {
@@ -38,7 +38,7 @@ async function getManagedSecrets(instance) {
 exports.getManagedSecrets = getManagedSecrets;
 function getActiveSecrets(spec, params) {
     return spec.params
-        .map((p) => (p.type == extensionsApi.ParamType.SECRET ? params[p.param] : ""))
+        .map((p) => (p.type === extensionsApi.ParamType.SECRET ? params[p.param] : ""))
         .filter((pv) => !!pv);
 }
 exports.getActiveSecrets = getActiveSecrets;
@@ -50,7 +50,7 @@ function getSecretLabels(instanceId) {
 exports.getSecretLabels = getSecretLabels;
 function prettySecretName(secretResourceName) {
     const nameTokens = secretResourceName.split("/");
-    if (nameTokens.length != 4 && nameTokens.length != 6) {
+    if (nameTokens.length !== 4 && nameTokens.length !== 6) {
         logger_1.logger.debug(`unable to parse secret secretResourceName: ${secretResourceName}`);
         return secretResourceName;
     }

package/lib/functional.js

@@ -40,7 +40,7 @@ function reduceFlat(accum, next) {
 }
 exports.reduceFlat = reduceFlat;
 function* zip(left, right) {
-    if (left.length != right.length) {
+    if (left.length !== right.length) {
         throw new Error("Cannot zip between two lists of differen lengths");
     }
     for (let i = 0; i < left.length; i++) {

package/lib/functions/env.js

@@ -12,6 +12,7 @@ const RESERVED_PREFIXES = ["X_GOOGLE_", "FIREBASE_", "EXT_"];
 const RESERVED_KEYS = [
     "FIREBASE_CONFIG",
     "CLOUD_RUNTIME_CONFIG",
+    "EVENTARC_CLOUD_EVENT_SOURCE",
     "ENTRY_POINT",
     "GCP_PROJECT",
     "GCLOUD_PROJECT",
@@ -120,15 +121,13 @@ function parseStrict(data) {
 exports.parseStrict = parseStrict;
 function findEnvfiles(functionsSource, projectId, projectAlias, isEmulator) {
     const files = [".env"];
+    files.push(`.env.${projectId}`);
+    if (projectAlias) {
+        files.push(`.env.${projectAlias}`);
+    }
     if (isEmulator) {
         files.push(FUNCTIONS_EMULATOR_DOTENV);
     }
-    else {
-        files.push(`.env.${projectId}`);
-        if (projectAlias && projectAlias.length) {
-            files.push(`.env.${projectAlias}`);
-        }
-    }
     return files
         .map((f) => path.join(functionsSource, f))
         .filter(fs.existsSync)
@@ -141,7 +140,7 @@ exports.hasUserEnvs = hasUserEnvs;
 function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
     const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
-    if (envFiles.length == 0) {
+    if (envFiles.length === 0) {
         return {};
     }
     if (projectAlias) {

package/lib/functions/events/v2.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIREBASE_ALERTS_PUBLISH_EVENT = exports.STORAGE_EVENTS = exports.PUBSUB_PUBLISH_EVENT = void 0;
+exports.PUBSUB_PUBLISH_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";
+exports.STORAGE_EVENTS = [
+    "google.cloud.storage.object.v1.finalized",
+    "google.cloud.storage.object.v1.archived",
+    "google.cloud.storage.object.v1.deleted",
+    "google.cloud.storage.object.v1.metadataUpdated",
+];
+exports.FIREBASE_ALERTS_PUBLISH_EVENT = "google.firebase.firebasealerts.alerts.v1.published";

package/lib/gcp/cloudfunctions.js

@@ -92,7 +92,7 @@ async function getIamPolicy(fnName) {
 }
 exports.getIamPolicy = getIamPolicy;
 async function setInvokerCreate(projectId, fnName, invoker) {
-    if (invoker.length == 0) {
+    if (invoker.length === 0) {
         throw new error_1.FirebaseError("Invoker cannot be an empty array");
     }
     const invokerMembers = proto.getInvokerMembers(invoker, projectId);
@@ -108,7 +108,7 @@ async function setInvokerCreate(projectId, fnName, invoker) {
 exports.setInvokerCreate = setInvokerCreate;
 async function setInvokerUpdate(projectId, fnName, invoker) {
     var _a;
-    if (invoker.length == 0) {
+    if (invoker.length === 0) {
         throw new error_1.FirebaseError("Invoker cannot be an empty array");
     }
     const invokerMembers = proto.getInvokerMembers(invoker, projectId);
@@ -202,10 +202,11 @@ async function listAllFunctions(projectId) {
 }
 exports.listAllFunctions = listAllFunctions;
 function endpointFromFunction(gcfFunction) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     let uri;
+    let securityLevel;
     if ((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
         trigger = {
             scheduleTrigger: {},
@@ -216,18 +217,27 @@ function endpointFromFunction(gcfFunction) {
             taskQueueTrigger: {},
         };
     }
+    else if ((_c = gcfFunction.labels) === null || _c === void 0 ? void 0 : _c["deployment-callable"]) {
+        trigger = {
+            callableTrigger: {},
+        };
+    }
     else if (gcfFunction.httpsTrigger) {
         trigger = { httpsTrigger: {} };
         uri = gcfFunction.httpsTrigger.url;
+        securityLevel = gcfFunction.httpsTrigger.securityLevel;
     }
     else {
         trigger = {
             eventTrigger: {
                 eventType: gcfFunction.eventTrigger.eventType,
-                eventFilters: {
-                    resource: gcfFunction.eventTrigger.resource,
-                },
-                retry: !!((_c = gcfFunction.eventTrigger.failurePolicy) === null || _c === void 0 ? void 0 : _c.retry),
+                eventFilters: [
+                    {
+                        attribute: "resource",
+                        value: gcfFunction.eventTrigger.resource,
+                    },
+                ],
+                retry: !!((_d = gcfFunction.eventTrigger.failurePolicy) === null || _d === void 0 ? void 0 : _d.retry),
             },
         };
     }
@@ -240,12 +250,19 @@ function endpointFromFunction(gcfFunction) {
     if (uri) {
         endpoint.uri = uri;
     }
-    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "labels", "environmentVariables", "secretEnvironmentVariables", "sourceUploadUrl");
+    if (securityLevel) {
+        endpoint.securityLevel = securityLevel;
+    }
+    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "ingressSettings", "labels", "environmentVariables", "secretEnvironmentVariables", "sourceUploadUrl");
+    if (gcfFunction.vpcConnector) {
+        endpoint.vpc = { connector: gcfFunction.vpcConnector };
+        proto.renameIfPresent(endpoint.vpc, gcfFunction, "egressSettings", "vpcConnectorEgressSettings");
+    }
     return endpoint;
 }
 exports.endpointFromFunction = endpointFromFunction;
 function functionFromEndpoint(endpoint, sourceUploadUrl) {
-    if (endpoint.platform != "gcfv1") {
+    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(endpoint.runtime)) {
@@ -260,9 +277,13 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
     };
     proto.copyIfPresent(gcfFunction, endpoint, "labels");
     if (backend.isEventTriggered(endpoint)) {
+        const resourceFilter = backend.findEventFilter(endpoint, "resource");
+        if (!resourceFilter) {
+            throw new error_1.FirebaseError("Invalid event trigger definition. Expected event filter with 'resource' attribute.");
+        }
         gcfFunction.eventTrigger = {
             eventType: endpoint.eventTrigger.eventType,
-            resource: endpoint.eventTrigger.eventFilters.resource,
+            resource: resourceFilter.value,
         };
         gcfFunction.eventTrigger.failurePolicy = endpoint.eventTrigger.retry
             ? { retry: {} }
@@ -282,8 +303,18 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
     }
     else {
         gcfFunction.httpsTrigger = {};
+        if (backend.isCallableTriggered(endpoint)) {
+            gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-callabled": "true" });
+        }
+        if (endpoint.securityLevel) {
+            gcfFunction.httpsTrigger.securityLevel = endpoint.securityLevel;
+        }
+    }
+    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "ingressSettings", "environmentVariables", "secretEnvironmentVariables");
+    if (endpoint.vpc) {
+        proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnector", "connector");
+        proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
     }
-    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables", "secretEnvironmentVariables");
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;

package/lib/gcp/cloudfunctionsv2.js

@@ -1,11 +1,12 @@
 "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.megabytes = 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.API_VERSION = void 0;
 const clc = require("cli-color");
 const apiv2_1 = require("../apiv2");
 const error_1 = require("../error");
 const api_1 = require("../api");
 const logger_1 = require("../logger");
+const v2_1 = require("../functions/events/v2");
 const backend = require("../deploy/functions/backend");
 const runtimes = require("../deploy/functions/runtimes");
 const proto = require("./proto");
@@ -16,7 +17,6 @@ const client = new apiv2_1.Client({
     auth: true,
     apiVersion: exports.API_VERSION,
 });
-exports.PUBSUB_PUBLISH_EVENT = "google.cloud.pubsub.topic.v1.messagePublished";
 const BYTES_PER_UNIT = {
     "": 1,
     k: 1e3,
@@ -106,7 +106,7 @@ async function listFunctionsInternal(projectId, region) {
     let pageToken = "";
     while (true) {
         const url = `projects/${projectId}/locations/${region}/functions`;
-        const opts = pageToken == "" ? {} : { queryParams: { pageToken } };
+        const opts = pageToken === "" ? {} : { queryParams: { pageToken } };
         const res = await client.get(url, opts);
         functions.push(...(res.body.functions || []));
         for (const region of res.body.unreachable || []) {
@@ -122,9 +122,10 @@ async function listFunctionsInternal(projectId, region) {
     }
 }
 async function updateFunction(cloudFunction) {
+    const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "serviceConfig.environmentVariables");
     try {
         const queryParams = {
-            updateMask: proto.fieldMasks(cloudFunction).join(","),
+            updateMask: fieldMasks.join(","),
         };
         const res = await client.patch(cloudFunction.name, cloudFunction, { queryParams });
         return res.body;
@@ -145,7 +146,7 @@ async function deleteFunction(cloudFunction) {
 }
 exports.deleteFunction = deleteFunction;
 function functionFromEndpoint(endpoint, source) {
-    if (endpoint.platform != "gcfv2") {
+    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(endpoint.runtime)) {
@@ -165,28 +166,43 @@ function functionFromEndpoint(endpoint, source) {
         serviceConfig: {},
     };
     proto.copyIfPresent(gcfFunction, endpoint, "labels");
-    proto.copyIfPresent(gcfFunction.serviceConfig, endpoint, "environmentVariables", "vpcConnector", "vpcConnectorEgressSettings", "serviceAccountEmail", "ingressSettings");
+    proto.copyIfPresent(gcfFunction.serviceConfig, endpoint, "environmentVariables", "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");
+    if (endpoint.vpc) {
+        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnector", "connector");
+        proto.renameIfPresent(gcfFunction.serviceConfig, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
+    }
     if (backend.isEventTriggered(endpoint)) {
         gcfFunction.eventTrigger = {
             eventType: endpoint.eventTrigger.eventType,
         };
-        if (gcfFunction.eventTrigger.eventType === exports.PUBSUB_PUBLISH_EVENT) {
-            gcfFunction.eventTrigger.pubsubTopic = endpoint.eventTrigger.eventFilters.resource;
+        if (gcfFunction.eventTrigger.eventType === v2_1.PUBSUB_PUBLISH_EVENT) {
+            const pubsubFilter = backend.findEventFilter(endpoint, "topic");
+            if (!pubsubFilter) {
+                throw new error_1.FirebaseError("Invalid pubsub endpoint. Expected eventFilter with 'topic' attribute but found none.");
+            }
+            gcfFunction.eventTrigger.pubsubTopic = pubsubFilter.value;
+            for (const filter of endpoint.eventTrigger.eventFilters) {
+                if (filter.attribute === "topic") {
+                    continue;
+                }
+                if (!gcfFunction.eventTrigger.eventFilters) {
+                    gcfFunction.eventTrigger.eventFilters = [];
+                }
+                gcfFunction.eventTrigger.eventFilters.push(filter);
+            }
         }
         else {
-            gcfFunction.eventTrigger.eventFilters = [];
-            for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
-                gcfFunction.eventTrigger.eventFilters.push({ attribute, value });
-            }
+            gcfFunction.eventTrigger.eventFilters = endpoint.eventTrigger.eventFilters;
         }
         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);
         }
+        gcfFunction.serviceConfig.environmentVariables = Object.assign(Object.assign({}, gcfFunction.serviceConfig.environmentVariables), { FUNCTION_SIGNATURE_TYPE: "cloudevent" });
     }
     else if (backend.isScheduleTriggered(endpoint)) {
         gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-scheduled": "true" });
@@ -194,11 +210,14 @@ function functionFromEndpoint(endpoint, source) {
     else if (backend.isTaskQueueTriggered(endpoint)) {
         gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-taskqueue": "true" });
     }
+    else if (backend.isCallableTriggered(endpoint)) {
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-callable": "true" });
+    }
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;
 function endpointFromFunction(gcfFunction) {
-    var _a, _b;
+    var _a, _b, _c;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     if (((_a = gcfFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) === "true") {
@@ -211,20 +230,28 @@ function endpointFromFunction(gcfFunction) {
             taskQueueTrigger: {},
         };
     }
+    else if (((_c = gcfFunction.labels) === null || _c === void 0 ? void 0 : _c["deployment-callable"]) === "true") {
+        trigger = {
+            callableTrigger: {},
+        };
+    }
     else if (gcfFunction.eventTrigger) {
         trigger = {
             eventTrigger: {
                 eventType: gcfFunction.eventTrigger.eventType,
-                eventFilters: {},
+                eventFilters: [],
                 retry: false,
             },
         };
         if (gcfFunction.eventTrigger.pubsubTopic) {
-            trigger.eventTrigger.eventFilters.resource = gcfFunction.eventTrigger.pubsubTopic;
+            trigger.eventTrigger.eventFilters.push({
+                attribute: "topic",
+                value: gcfFunction.eventTrigger.pubsubTopic,
+            });
         }
         else {
             for (const { attribute, value } of gcfFunction.eventTrigger.eventFilters || []) {
-                trigger.eventTrigger.eventFilters[attribute] = value;
+                trigger.eventTrigger.eventFilters.push({ attribute, value });
             }
         }
         proto.renameIfPresent(trigger.eventTrigger, gcfFunction.eventTrigger, "region", "triggerRegion");
@@ -238,12 +265,16 @@ 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", "vpcConnector", "vpcConnectorEgressSettings", "ingressSettings", "environmentVariables");
+    proto.copyIfPresent(endpoint, gcfFunction.serviceConfig, "serviceAccountEmail", "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");
     proto.copyIfPresent(endpoint, gcfFunction, "labels");
+    if (gcfFunction.serviceConfig.vpcConnector) {
+        endpoint.vpc = { connector: gcfFunction.serviceConfig.vpcConnector };
+        proto.renameIfPresent(endpoint.vpc, gcfFunction.serviceConfig, "egressSettings", "vpcConnectorEgressSettings");
+    }
     return endpoint;
 }
 exports.endpointFromFunction = endpointFromFunction;

package/lib/gcp/cloudtasks.js

@@ -102,7 +102,7 @@ async function setEnqueuer(name, invoker, assumeEmpty = false) {
     const invokerMembers = proto.getInvokerMembers(invoker, project);
     while (true) {
         const policy = {
-            bindings: existing.bindings.filter((binding) => binding.role != ENQUEUER_ROLE),
+            bindings: existing.bindings.filter((binding) => binding.role !== ENQUEUER_ROLE),
             etag: existing.etag,
             version: existing.version,
         };

package/lib/gcp/docker.js

@@ -58,7 +58,7 @@ class Client {
         if (!response.body) {
             return;
         }
-        if (((_a = response.body.errors) === null || _a === void 0 ? void 0 : _a.length) != 0) {
+        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,
             });
@@ -70,7 +70,7 @@ class Client {
         if (!response.body) {
             return;
         }
-        if (((_a = response.body.errors) === null || _a === void 0 ? void 0 : _a.length) != 0) {
+        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,
             });