firebase-tools 10.4.2 → 10.7.0

package/lib/extensions/paramHelper.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEnvFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = exports.setNewDefaults = exports.buildBindingOptionsWithBaseValue = exports.getBaseParamBindings = void 0;
-const _ = require("lodash");
 const path = require("path");
 const clc = require("cli-color");
 const fs = require("fs-extra");
@@ -9,8 +8,9 @@ const error_1 = require("../error");
 const logger_1 = require("../logger");
 const extensionsHelper_1 = require("./extensionsHelper");
 const askUserForParam = require("./askUserForParam");
-const track = require("../track");
+const track_1 = require("../track");
 const env = require("../functions/env");
+const utils_1 = require("../utils");
 function getBaseParamBindings(params) {
     let ret = {};
     for (const [k, v] of Object.entries(params)) {
@@ -37,8 +37,9 @@ function setNewDefaults(params, newDefaults) {
 }
 exports.setNewDefaults = setNewDefaults;
 function getParamsWithCurrentValuesAsDefaults(extensionInstance) {
-    const specParams = _.cloneDeep(_.get(extensionInstance, "config.source.spec.params", []));
-    const currentParams = _.cloneDeep(_.get(extensionInstance, "config.params", {}));
+    var _a, _b, _c, _d;
+    const specParams = (0, utils_1.cloneDeep)(((_c = (_b = (_a = extensionInstance === null || extensionInstance === void 0 ? void 0 : extensionInstance.config) === null || _a === void 0 ? void 0 : _a.source) === null || _b === void 0 ? void 0 : _b.spec) === null || _c === void 0 ? void 0 : _c.params) || []);
+    const currentParams = (0, utils_1.cloneDeep)(((_d = extensionInstance === null || extensionInstance === void 0 ? void 0 : extensionInstance.config) === null || _d === void 0 ? void 0 : _d.params) || {});
     return setNewDefaults(specParams, currentParams);
 }
 exports.getParamsWithCurrentValuesAsDefaults = getParamsWithCurrentValuesAsDefaults;
@@ -71,7 +72,8 @@ async function getParams(args) {
             reconfiguring: !!args.reconfiguring,
         });
     }
-    void track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    const paramNames = Object.keys(params);
+    void (0, track_1.track)("Extension Params", paramNames.length ? "Not Present" : "Present", paramNames.length);
     return params;
 }
 exports.getParams = getParams;
@@ -103,27 +105,31 @@ async function getParamsForUpdate(args) {
             instanceId: args.instanceId,
         });
     }
-    void track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    const paramNames = Object.keys(params);
+    void (0, track_1.track)("Extension Params", paramNames.length ? "Not Present" : "Present", paramNames.length);
     return params;
 }
 exports.getParamsForUpdate = getParamsForUpdate;
 async function promptForNewParams(args) {
     const newParamBindingOptions = buildBindingOptionsWithBaseValue(args.currentParams);
     const firebaseProjectParams = await (0, extensionsHelper_1.getFirebaseProjectParams)(args.projectId);
-    const comparer = (param1, param2) => {
+    const sameParam = (param1) => (param2) => {
         return param1.type === param2.type && param1.param === param2.param;
     };
+    const paramDiff = (left, right) => {
+        return left.filter((aLeft) => !right.find(sameParam(aLeft)));
+    };
     const oldParams = args.spec.params.filter((p) => Object.keys(args.currentParams).includes(p.param));
-    let paramsDiffDeletions = _.differenceWith(oldParams, args.newSpec.params, comparer);
+    let paramsDiffDeletions = paramDiff(oldParams, args.newSpec.params);
     paramsDiffDeletions = (0, extensionsHelper_1.substituteParams)(paramsDiffDeletions, firebaseProjectParams);
-    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, oldParams, comparer);
+    let paramsDiffAdditions = paramDiff(args.newSpec.params, oldParams);
     paramsDiffAdditions = (0, extensionsHelper_1.substituteParams)(paramsDiffAdditions, firebaseProjectParams);
     if (paramsDiffDeletions.length) {
         logger_1.logger.info("The following params will no longer be used:");
-        paramsDiffDeletions.forEach((param) => {
+        for (const param of paramsDiffDeletions) {
             logger_1.logger.info(clc.red(`- ${param.param}: ${args.currentParams[param.param.toUpperCase()]}`));
             delete newParamBindingOptions[param.param.toUpperCase()];
-        });
+        }
     }
     if (paramsDiffAdditions.length) {
         logger_1.logger.info("To update this instance, configure the following new parameters:");
@@ -144,10 +150,10 @@ function getParamsFromFile(args) {
     let envParams;
     try {
         envParams = readEnvFile(args.paramsEnvPath);
-        void track("Extension Env File", "Present");
+        void (0, track_1.track)("Extension Env File", "Present");
     }
     catch (err) {
-        void track("Extension Env File", "Invalid");
+        void (0, track_1.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);

package/lib/extensions/provisioningHelper.js

@@ -19,8 +19,8 @@ async function checkProductsProvisioned(projectId, spec) {
 exports.checkProductsProvisioned = checkProductsProvisioned;
 async function bulkCheckProductsProvisioned(projectId, instanceSpecs) {
     const usedProducts = await Promise.all(instanceSpecs.map(async (i) => {
-        const extensionVersion = await (0, planner_1.getExtensionVersion)(i);
-        return getUsedProducts(extensionVersion.spec);
+        const extensionSpec = await (0, planner_1.getExtensionSpec)(i);
+        return getUsedProducts(extensionSpec);
     }));
     await checkProducts(projectId, [...(0, functional_1.flattenArray)(usedProducts)]);
 }

package/lib/extensions/warnings.js

@@ -49,11 +49,11 @@ const toListEntry = (i) => {
 };
 async function displayWarningsForDeploy(instancesToCreate) {
     const trustedPublishers = await (0, resolveSource_1.getTrustedPublishers)();
-    for (const i of instancesToCreate) {
+    const publishedExtensionInstances = instancesToCreate.filter((i) => i.ref);
+    for (const i of publishedExtensionInstances) {
         await (0, planner_1.getExtension)(i);
-        await (0, planner_1.getExtensionVersion)(i);
     }
-    const [eapExtensions, nonEapExtensions] = (0, 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 [eapExtensions, nonEapExtensions] = (0, functional_1.partition)(publishedExtensionInstances, (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${(0, deploymentSummary_1.humanReadable)(i)}`).join("\n");

package/lib/functions/env.js

@@ -42,6 +42,15 @@ const LINE_RE = new RegExp("^" +
     "\\s*" +
     "(?:#[^\\n]*)?" +
     "$", "gms");
+const ESCAPE_SEQUENCES_TO_CHARACTERS = {
+    "\\n": "\n",
+    "\\r": "\r",
+    "\\t": "\t",
+    "\\v": "\v",
+    "\\\\": "\\",
+    "\\'": "'",
+    '\\"': '"',
+};
 function parse(data) {
     const envs = {};
     const errors = [];
@@ -54,8 +63,7 @@ function parse(data) {
         if ((quotesMatch = /^(["'])(.*)\1$/ms.exec(v)) != null) {
             v = quotesMatch[2];
             if (quotesMatch[1] === '"') {
-                v = v.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\v", "\v");
-                v = v.replace(/\\([\\'"])/g, "$1");
+                v = v.replace(/\\[nrtv\\'"]/g, (match) => ESCAPE_SEQUENCES_TO_CHARACTERS[match]);
             }
         }
         envs[k] = v;

package/lib/functions/events/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v2 = exports.v1 = void 0;
+const v1 = require("./v1");
+exports.v1 = v1;
+const v2 = require("./v2");
+exports.v2 = v2;

package/lib/functions/events/v1.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_BLOCKING_EVENTS = exports.BEFORE_SIGN_IN_EVENT = exports.BEFORE_CREATE_EVENT = void 0;
+exports.BEFORE_CREATE_EVENT = "providers/cloud.auth/eventTypes/user.beforeCreate";
+exports.BEFORE_SIGN_IN_EVENT = "providers/cloud.auth/eventTypes/user.beforeSignIn";
+exports.AUTH_BLOCKING_EVENTS = [exports.BEFORE_CREATE_EVENT, exports.BEFORE_SIGN_IN_EVENT];

package/lib/functions/projectConfig.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAndValidate = exports.validate = exports.normalize = void 0;
+exports.normalizeAndValidate = exports.validate = exports.normalize = exports.DEFAULT_CODEBASE = void 0;
 const error_1 = require("../error");
+exports.DEFAULT_CODEBASE = "default";
 function normalize(config) {
     if (!config) {
         throw new error_1.FirebaseError("No valid functions configuration detected in firebase.json");
@@ -19,13 +20,33 @@ function validateSingle(config) {
     if (!config.source) {
         throw new error_1.FirebaseError("functions.source must be specified");
     }
-    return Object.assign(Object.assign({}, config), { source: config.source });
+    if (!config.codebase) {
+        config.codebase = exports.DEFAULT_CODEBASE;
+    }
+    if (config.codebase.length > 63 || !/^[a-z0-9_-]+$/.test(config.codebase)) {
+        throw new error_1.FirebaseError("Invalid codebase name. Codebase must be less than 63 characters and " +
+            "can contain only lowercase letters, numeric characters, underscores, and dashes.");
+    }
+    return Object.assign(Object.assign({}, config), { source: config.source, codebase: config.codebase });
+}
+function assertUnique(config, property) {
+    const values = new Set();
+    for (const single of config) {
+        const value = single[property];
+        if (values.has(value)) {
+            throw new error_1.FirebaseError(`functions.${property} must be unique but '${value}' was used more than once.`);
+        }
+        values.add(value);
+    }
 }
 function validate(config) {
     if (config.length > 1) {
         throw new error_1.FirebaseError("More than one functions.source detected in firebase.json.");
     }
-    return [validateSingle(config[0])];
+    const validated = validateSingle(config[0]);
+    assertUnique([validated], "source");
+    assertUnique([validated], "codebase");
+    return [validated];
 }
 exports.validate = validate;
 function normalizeAndValidate(config) {

package/lib/functions/runtimeConfigExport.js

@@ -115,13 +115,17 @@ function hydrateEnvs(pInfos, prefix) {
     return errMsg;
 }
 exports.hydrateEnvs = hydrateEnvs;
+const CHARACTERS_TO_ESCAPE_SEQUENCES = {
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\v": "\\v",
+    "\\": "\\\\",
+    '"': '\\"',
+    "'": "\\'",
+};
 function escape(s) {
-    const result = s
-        .replace("\n", "\\n")
-        .replace("\r", "\\r")
-        .replace("\t", "\\t")
-        .replace("\v", "\\v");
-    return result.replace(/(['"])/g, "\\$1");
+    return s.replace(/[\n\r\t\v\\"']/g, (ch) => CHARACTERS_TO_ESCAPE_SEQUENCES[ch]);
 }
 function toDotenvFormat(envs, header = "") {
     const lines = envs.map(({ newKey, value }) => `${newKey}="${escape(value)}"`);

package/lib/functions/secrets.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pruneSecrets = exports.of = exports.ensureSecret = exports.ensureValidKey = exports.labels = exports.isFirebaseManaged = void 0;
+exports.updateEndpointSecret = exports.pruneAndDestroySecrets = exports.pruneSecrets = exports.inUse = exports.of = exports.ensureSecret = exports.ensureValidKey = exports.labels = exports.isFirebaseManaged = void 0;
+const utils = require("../utils");
+const poller = require("../operation-poller");
+const gcf = require("../gcp/cloudfunctions");
 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 logger_1 = require("../logger");
+const api_1 = require("../api");
+const functional_1 = require("../functional");
 const FIREBASE_MANGED = "firebase-managed";
 function isFirebaseManaged(secret) {
     return Object.keys(secret.labels || []).includes(FIREBASE_MANGED);
@@ -17,8 +23,7 @@ function labels() {
 exports.labels = labels;
 function toUpperSnakeCase(key) {
     return key
-        .replace("-", "_")
-        .replace(".", "_")
+        .replace(/[.-]/g, "_")
         .replace(/([a-z])([A-Z])/g, "$1_$2")
         .toUpperCase();
 }
@@ -80,19 +85,40 @@ function of(endpoints) {
     return endpoints.reduce((envs, endpoint) => [...envs, ...(endpoint.secretEnvironmentVariables || [])], []);
 }
 exports.of = of;
+function inUse(projectInfo, secret, endpoint) {
+    const { projectId, projectNumber } = projectInfo;
+    for (const sev of of([endpoint])) {
+        if ((sev.projectId === projectId || sev.projectId === projectNumber) &&
+            sev.secret === secret.name) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.inUse = inUse;
 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`);
+        const versions = await (0, secretManager_1.listSecretVersions)(projectId, secret.name, `NOT state: DESTROYED`);
         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) {
+    const secrets = [];
+    for (const secret of of(endpoints)) {
+        if (!secret.version) {
+            throw new error_1.FirebaseError(`Secret ${secret.secret} version is unexpectedly empty.`);
+        }
+        if (secret.projectId === projectId || secret.projectId === projectNumber) {
+            if (secret.version) {
+                secrets.push(Object.assign(Object.assign({}, secret), { version: secret.version }));
+            }
+        }
+    }
+    for (const sev of secrets) {
         let name = sev.secret;
         if (name.includes("/")) {
             const secret = (0, secretManager_1.parseSecretResourceName)(name);
@@ -110,3 +136,70 @@ async function pruneSecrets(projectInfo, endpoints) {
         .map(([secret, version]) => ({ projectId, version, secret, key: secret }));
 }
 exports.pruneSecrets = pruneSecrets;
+async function pruneAndDestroySecrets(projectInfo, endpoints) {
+    const { projectId, projectNumber } = projectInfo;
+    logger_1.logger.debug("Pruning secrets to find unused secret versions...");
+    const unusedSecrets = await module.exports.pruneSecrets({ projectId, projectNumber }, endpoints);
+    if (unusedSecrets.length === 0) {
+        return { destroyed: [], erred: [] };
+    }
+    const destroyed = [];
+    const erred = [];
+    const msg = unusedSecrets.map((s) => `${s.secret}@${s.version}`);
+    logger_1.logger.debug(`Found unused secret versions: ${msg}. Destroying them...`);
+    const destroyResults = await utils.allSettled(unusedSecrets.map(async (sev) => {
+        await (0, secretManager_1.destroySecretVersion)(sev.projectId, sev.secret, sev.version);
+        return sev;
+    }));
+    for (const result of destroyResults) {
+        if (result.status === "fulfilled") {
+            destroyed.push(result.value);
+        }
+        else {
+            erred.push(result.reason);
+        }
+    }
+    return { destroyed, erred };
+}
+exports.pruneAndDestroySecrets = pruneAndDestroySecrets;
+async function updateEndpointSecret(projectInfo, secretVersion, endpoint) {
+    const { projectId, projectNumber } = projectInfo;
+    if (!inUse(projectInfo, secretVersion.secret, endpoint)) {
+        return endpoint;
+    }
+    const updatedSevs = [];
+    for (const sev of of([endpoint])) {
+        const updatedSev = Object.assign({}, sev);
+        if ((updatedSev.projectId === projectId || updatedSev.projectId === projectNumber) &&
+            updatedSev.secret === secretVersion.secret.name) {
+            updatedSev.version = secretVersion.versionId;
+        }
+        updatedSevs.push(updatedSev);
+    }
+    if (endpoint.platform === "gcfv1") {
+        const fn = gcf.functionFromEndpoint(endpoint, "");
+        const op = await gcf.updateFunction({
+            name: fn.name,
+            runtime: fn.runtime,
+            entryPoint: fn.entryPoint,
+            secretEnvironmentVariables: updatedSevs,
+        });
+        const gcfV1PollerOptions = {
+            apiOrigin: api_1.functionsOrigin,
+            apiVersion: gcf.API_VERSION,
+            masterTimeout: 25 * 60 * 1000,
+            maxBackoff: 10000,
+            pollerName: `update-${endpoint.region}-${endpoint.id}`,
+            operationResourceName: op.name,
+        };
+        const cfn = await poller.pollOperation(gcfV1PollerOptions);
+        return gcf.endpointFromFunction(cfn);
+    }
+    else if (endpoint.platform === "gcfv2") {
+        throw new error_1.FirebaseError(`Unsupported platform ${endpoint.platform}`);
+    }
+    else {
+        (0, functional_1.assertExhaustive)(endpoint.platform);
+    }
+}
+exports.updateEndpointSecret = updateEndpointSecret;

package/lib/gcp/cloudfunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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.BLOCKING_LABEL = exports.CODEBASE_LABEL = exports.API_VERSION = void 0;
 const clc = require("cli-color");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
@@ -9,10 +9,21 @@ const backend = require("../deploy/functions/backend");
 const utils = require("../utils");
 const proto = require("./proto");
 const runtimes = require("../deploy/functions/runtimes");
+const projectConfig = require("../functions/projectConfig");
 const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
 exports.API_VERSION = "v1";
+exports.CODEBASE_LABEL = "firebase-functions-codebase";
 const client = new apiv2_1.Client({ urlPrefix: api_1.functionsOrigin, apiVersion: exports.API_VERSION });
+exports.BLOCKING_LABEL = "deployment-blocking";
+const BLOCKING_LABEL_KEY_TO_EVENT = {
+    "before-create": "providers/cloud.auth/eventTypes/user.beforeCreate",
+    "before-sign-in": "providers/cloud.auth/eventTypes/user.beforeSignIn",
+};
+const BLOCKING_EVENT_TO_LABEL_KEY = {
+    "providers/cloud.auth/eventTypes/user.beforeCreate": "before-create",
+    "providers/cloud.auth/eventTypes/user.beforeSignIn": "before-sign-in",
+};
 function validateFunction(func) {
     proto.assertOneOf("Cloud Function", func, "sourceCode", "sourceArchiveUrl", "sourceRepository", "sourceUploadUrl");
     proto.assertOneOf("Cloud Function", func, "trigger", "httpsTrigger", "eventTrigger");
@@ -202,7 +213,7 @@ async function listAllFunctions(projectId) {
 }
 exports.listAllFunctions = listAllFunctions;
 function endpointFromFunction(gcfFunction) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     const [, project, , region, , id] = gcfFunction.name.split("/");
     let trigger;
     let uri;
@@ -223,25 +234,29 @@ function endpointFromFunction(gcfFunction) {
             callableTrigger: {},
         };
     }
+    else if ((_e = gcfFunction.labels) === null || _e === void 0 ? void 0 : _e[exports.BLOCKING_LABEL]) {
+        trigger = {
+            blockingTrigger: {
+                eventType: BLOCKING_LABEL_KEY_TO_EVENT[gcfFunction.labels[exports.BLOCKING_LABEL]],
+            },
+        };
+    }
     else if (gcfFunction.httpsTrigger) {
         trigger = { httpsTrigger: {} };
-        uri = gcfFunction.httpsTrigger.url;
-        securityLevel = gcfFunction.httpsTrigger.securityLevel;
     }
     else {
         trigger = {
             eventTrigger: {
                 eventType: gcfFunction.eventTrigger.eventType,
-                eventFilters: [
-                    {
-                        attribute: "resource",
-                        value: gcfFunction.eventTrigger.resource,
-                    },
-                ],
-                retry: !!((_e = gcfFunction.eventTrigger.failurePolicy) === null || _e === void 0 ? void 0 : _e.retry),
+                eventFilters: { resource: gcfFunction.eventTrigger.resource },
+                retry: !!((_f = gcfFunction.eventTrigger.failurePolicy) === null || _f === void 0 ? void 0 : _f.retry),
             },
         };
     }
+    if (gcfFunction.httpsTrigger) {
+        uri = gcfFunction.httpsTrigger.url;
+        securityLevel = gcfFunction.httpsTrigger.securityLevel;
+    }
     if (!runtimes.isValidRuntime(gcfFunction.runtime)) {
         logger_1.logger.debug("GCFv1 function has a deprecated runtime:", JSON.stringify(gcfFunction, null, 2));
     }
@@ -254,11 +269,13 @@ function endpointFromFunction(gcfFunction) {
     if (securityLevel) {
         endpoint.securityLevel = securityLevel;
     }
-    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "timeout", "minInstances", "maxInstances", "ingressSettings", "labels", "environmentVariables", "secretEnvironmentVariables", "sourceUploadUrl");
+    proto.copyIfPresent(endpoint, gcfFunction, "serviceAccountEmail", "availableMemoryMb", "minInstances", "maxInstances", "ingressSettings", "labels", "environmentVariables", "secretEnvironmentVariables", "sourceUploadUrl");
+    proto.renameIfPresent(endpoint, gcfFunction, "timeoutSeconds", "timeout", proto.secondsFromDuration);
     if (gcfFunction.vpcConnector) {
         endpoint.vpc = { connector: gcfFunction.vpcConnector };
         proto.renameIfPresent(endpoint.vpc, gcfFunction, "egressSettings", "vpcConnectorEgressSettings");
     }
+    endpoint.codebase = ((_g = gcfFunction.labels) === null || _g === void 0 ? void 0 : _g[exports.CODEBASE_LABEL]) || projectConfig.DEFAULT_CODEBASE;
     return endpoint;
 }
 exports.endpointFromFunction = endpointFromFunction;
@@ -278,13 +295,9 @@ 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: resourceFilter.value,
+            resource: endpoint.eventTrigger.eventFilters.resource,
         };
         gcfFunction.eventTrigger.failurePolicy = endpoint.eventTrigger.retry
             ? { retry: {} }
@@ -302,6 +315,10 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
         gcfFunction.httpsTrigger = {};
         gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { "deployment-taskqueue": "true" });
     }
+    else if (backend.isBlockingTriggered(endpoint)) {
+        gcfFunction.httpsTrigger = {};
+        gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.BLOCKING_LABEL]: BLOCKING_EVENT_TO_LABEL_KEY[endpoint.blockingTrigger.eventType] });
+    }
     else {
         gcfFunction.httpsTrigger = {};
         if (backend.isCallableTriggered(endpoint)) {
@@ -311,11 +328,13 @@ function functionFromEndpoint(endpoint, sourceUploadUrl) {
             gcfFunction.httpsTrigger.securityLevel = endpoint.securityLevel;
         }
     }
-    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "timeout", "availableMemoryMb", "minInstances", "maxInstances", "ingressSettings", "environmentVariables", "secretEnvironmentVariables");
+    proto.copyIfPresent(gcfFunction, endpoint, "serviceAccountEmail", "availableMemoryMb", "minInstances", "maxInstances", "ingressSettings", "environmentVariables", "secretEnvironmentVariables");
+    proto.renameIfPresent(gcfFunction, endpoint, "timeout", "timeoutSeconds", proto.durationFromSeconds);
     if (endpoint.vpc) {
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnector", "connector");
         proto.renameIfPresent(gcfFunction, endpoint.vpc, "vpcConnectorEgressSettings", "egressSettings");
     }
+    gcfFunction.labels = Object.assign(Object.assign({}, gcfFunction.labels), { [exports.CODEBASE_LABEL]: endpoint.codebase || projectConfig.DEFAULT_CODEBASE });
     return gcfFunction;
 }
 exports.functionFromEndpoint = functionFromEndpoint;