firebase-functions 6.6.0 → 7.0.0-rc.0

package/lib/esm/common/utilities/path-pattern.mjs

@@ -0,0 +1,116 @@
+import { pathParts } from "./path.mjs";
+
+//#region src/common/utilities/path-pattern.ts
+/** https://cloud.google.com/eventarc/docs/path-patterns */
+/** @hidden */
+const WILDCARD_CAPTURE_REGEX = new RegExp("{[^/{}]+}", "g");
+/** @internal */
+function trimParam(param) {
+	const paramNoBraces = param.slice(1, -1);
+	if (paramNoBraces.includes("=")) {
+		return paramNoBraces.slice(0, paramNoBraces.indexOf("="));
+	}
+	return paramNoBraces;
+}
+/** @hidden */
+var Segment = class {
+	constructor(value) {
+		this.value = value;
+		this.name = "segment";
+		this.trimmed = value;
+	}
+	isSingleSegmentWildcard() {
+		return this.value.includes("*") && !this.isMultiSegmentWildcard();
+	}
+	isMultiSegmentWildcard() {
+		return this.value.includes("**");
+	}
+};
+/** @hidden */
+var SingleCaptureSegment = class {
+	constructor(value) {
+		this.value = value;
+		this.name = "single-capture";
+		this.trimmed = trimParam(value);
+	}
+	isSingleSegmentWildcard() {
+		return true;
+	}
+	isMultiSegmentWildcard() {
+		return false;
+	}
+};
+/** @hidden */
+var MultiCaptureSegment = class {
+	constructor(value) {
+		this.value = value;
+		this.name = "multi-capture";
+		this.trimmed = trimParam(value);
+	}
+	isSingleSegmentWildcard() {
+		return false;
+	}
+	isMultiSegmentWildcard() {
+		return true;
+	}
+};
+/**
+* Implements Eventarc's path pattern from the spec https://cloud.google.com/eventarc/docs/path-patterns
+* @internal
+*/
+var PathPattern = class {
+	/** @throws on validation error */
+	static compile(rawPath) {
+		return undefined;
+	}
+	constructor(raw) {
+		this.raw = raw;
+		this.segments = [];
+		this.initPathSegments(raw);
+	}
+	getValue() {
+		return this.raw;
+	}
+	hasWildcards() {
+		return this.segments.some((segment) => segment.isSingleSegmentWildcard() || segment.isMultiSegmentWildcard());
+	}
+	hasCaptures() {
+		return this.segments.some((segment) => segment.name === "single-capture" || segment.name === "multi-capture");
+	}
+	extractMatches(path) {
+		const matches = {};
+		if (!this.hasCaptures()) {
+			return matches;
+		}
+		const pathSegments = pathParts(path);
+		let pathNdx = 0;
+		for (let segmentNdx = 0; segmentNdx < this.segments.length && pathNdx < pathSegments.length; segmentNdx++) {
+			const segment = this.segments[segmentNdx];
+			const remainingSegments = this.segments.length - 1 - segmentNdx;
+			const nextPathNdx = pathSegments.length - remainingSegments;
+			if (segment.name === "single-capture") {
+				matches[segment.trimmed] = pathSegments[pathNdx];
+			} else if (segment.name === "multi-capture") {
+				matches[segment.trimmed] = pathSegments.slice(pathNdx, nextPathNdx).join("/");
+			}
+			pathNdx = segment.isMultiSegmentWildcard() ? nextPathNdx : pathNdx + 1;
+		}
+		return matches;
+	}
+	initPathSegments(raw) {
+		const parts = pathParts(raw);
+		for (const part of parts) {
+			let segment;
+			const capture = part.match(WILDCARD_CAPTURE_REGEX);
+			if (capture && capture.length === 1) {
+				segment = part.includes("**") ? new MultiCaptureSegment(part) : new SingleCaptureSegment(part);
+			} else {
+				segment = new Segment(part);
+			}
+			this.segments.push(segment);
+		}
+	}
+};
+
+//#endregion
+export { PathPattern, trimParam };

package/lib/esm/common/utilities/path.mjs

@@ -0,0 +1,35 @@
+//#region src/common/utilities/path.ts
+/** @hidden
+* Removes leading and trailing slashes from a path.
+*
+* @param path A path to normalize, in POSIX format.
+*/
+function normalizePath(path) {
+	if (!path) {
+		return "";
+	}
+	return path.replace(/^\//, "").replace(/\/$/, "");
+}
+/**
+* Normalizes a given path and splits it into an array of segments.
+*
+* @param path A path to split, in POSIX format.
+*/
+function pathParts(path) {
+	if (!path || path === "" || path === "/") {
+		return [];
+	}
+	return normalizePath(path).split("/");
+}
+/**
+* Normalizes given paths and joins these together using a POSIX separator.
+*
+* @param base A first path segment, in POSIX format.
+* @param child A second path segment, in POSIX format.
+*/
+function joinPath(base, child) {
+	return pathParts(base).concat(pathParts(child)).join("/");
+}
+
+//#endregion
+export { joinPath, normalizePath, pathParts };

package/lib/esm/common/utilities/utils.mjs

@@ -0,0 +1,29 @@
+//#region src/common/utilities/utils.ts
+function isObject(obj) {
+	return typeof obj === "object" && !!obj;
+}
+/** @hidden */
+function applyChange(src, dest) {
+	if (!isObject(dest) || !isObject(src)) {
+		return dest;
+	}
+	return merge(src, dest);
+}
+function merge(src, dest) {
+	const res = {};
+	const keys = new Set([...Object.keys(src), ...Object.keys(dest)]);
+	for (const key of keys.values()) {
+		if (key in dest) {
+			if (dest[key] === null) {
+				continue;
+			}
+			res[key] = applyChange(src[key], dest[key]);
+		} else if (src[key] !== null) {
+			res[key] = src[key];
+		}
+	}
+	return res;
+}
+
+//#endregion
+export { applyChange };

package/lib/esm/function-configuration.mjs

@@ -0,0 +1 @@
+export {  };

package/lib/esm/logger/common.mjs

@@ -0,0 +1,23 @@
+//#region src/logger/common.ts
+/** @hidden */
+const CONSOLE_SEVERITY = {
+	DEBUG: "debug",
+	INFO: "info",
+	NOTICE: "info",
+	WARNING: "warn",
+	ERROR: "error",
+	CRITICAL: "error",
+	ALERT: "error",
+	EMERGENCY: "error"
+};
+/** @hidden */
+const UNPATCHED_CONSOLE = {
+	debug: console.debug,
+	info: console.info,
+	log: console.log,
+	warn: console.warn,
+	error: console.error
+};
+
+//#endregion
+export { CONSOLE_SEVERITY, UNPATCHED_CONSOLE };

package/lib/esm/logger/compat.mjs

@@ -0,0 +1,25 @@
+import { CONSOLE_SEVERITY, UNPATCHED_CONSOLE } from "./common.mjs";
+import { format } from "util";
+
+//#region src/logger/compat.ts
+/** @hidden */
+function patchedConsole(severity) {
+	return function(data, ...args) {
+		let message = format(data, ...args);
+		if (severity === "ERROR") {
+			message = new Error(message).stack || message;
+		}
+		UNPATCHED_CONSOLE[CONSOLE_SEVERITY[severity]](JSON.stringify({
+			severity,
+			message
+		}));
+	};
+}
+console.debug = patchedConsole("DEBUG");
+console.info = patchedConsole("INFO");
+console.log = patchedConsole("INFO");
+console.warn = patchedConsole("WARNING");
+console.error = patchedConsole("ERROR");
+
+//#endregion
+export {  };

package/lib/esm/logger/index.mjs

@@ -0,0 +1,131 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+import { traceContext } from "../common/trace.mjs";
+import { CONSOLE_SEVERITY, UNPATCHED_CONSOLE } from "./common.mjs";
+import { format } from "util";
+
+//#region src/logger/index.ts
+var logger_exports = /* @__PURE__ */ __export({
+	debug: () => debug,
+	error: () => error,
+	info: () => info,
+	log: () => log,
+	warn: () => warn,
+	write: () => write
+});
+/** @internal */
+function removeCircular(obj, refs = new Set()) {
+	if (typeof obj !== "object" || !obj) {
+		return obj;
+	}
+	if (obj.toJSON && typeof obj.toJSON === "function") {
+		return obj.toJSON();
+	}
+	if (refs.has(obj)) {
+		return "[Circular]";
+	} else {
+		refs.add(obj);
+	}
+	let returnObj;
+	if (Array.isArray(obj)) {
+		returnObj = new Array(obj.length);
+	} else {
+		returnObj = {};
+	}
+	for (const k in obj) {
+		if (obj.hasOwnProperty(k)) {
+			try {
+				if (refs.has(obj[k])) {
+					returnObj[k] = "[Circular]";
+				} else {
+					returnObj[k] = removeCircular(obj[k], refs);
+				}
+			} catch {
+				returnObj[k] = "[Error - cannot serialize]";
+			}
+		} else {
+			returnObj[k] = "[Error - defined in the prototype but missing in the object]";
+		}
+	}
+	refs.delete(obj);
+	return returnObj;
+}
+/**
+* Writes a `LogEntry` to `stdout`/`stderr` (depending on severity).
+* @param entry - The `LogEntry` including severity, message, and any additional structured metadata.
+* @public
+*/
+function write(entry) {
+	const ctx = traceContext.getStore();
+	if (ctx?.traceId) {
+		entry["logging.googleapis.com/trace"] = `projects/${process.env.GCLOUD_PROJECT}/traces/${ctx.traceId}`;
+	}
+	UNPATCHED_CONSOLE[CONSOLE_SEVERITY[entry.severity]](JSON.stringify(removeCircular(entry)));
+}
+/**
+* Writes a `DEBUG` severity log. If the last argument provided is a plain object,
+* it is added to the `jsonPayload` in the Cloud Logging entry.
+* @param args - Arguments, concatenated into the log message with space separators.
+* @public
+*/
+function debug(...args) {
+	write(entryFromArgs("DEBUG", args));
+}
+/**
+* Writes an `INFO` severity log. If the last argument provided is a plain object,
+* it is added to the `jsonPayload` in the Cloud Logging entry.
+* @param args - Arguments, concatenated into the log message with space separators.
+* @public
+*/
+function log(...args) {
+	write(entryFromArgs("INFO", args));
+}
+/**
+* Writes an `INFO` severity log. If the last argument provided is a plain object,
+* it is added to the `jsonPayload` in the Cloud Logging entry.
+* @param args - Arguments, concatenated into the log message with space separators.
+* @public
+*/
+function info(...args) {
+	write(entryFromArgs("INFO", args));
+}
+/**
+* Writes a `WARNING` severity log. If the last argument provided is a plain object,
+* it is added to the `jsonPayload` in the Cloud Logging entry.
+* @param args - Arguments, concatenated into the log message with space separators.
+* @public
+*/
+function warn(...args) {
+	write(entryFromArgs("WARNING", args));
+}
+/**
+* Writes an `ERROR` severity log. If the last argument provided is a plain object,
+* it is added to the `jsonPayload` in the Cloud Logging entry.
+* @param args - Arguments, concatenated into the log message with space separators.
+* @public
+*/
+function error(...args) {
+	write(entryFromArgs("ERROR", args));
+}
+/** @hidden */
+function entryFromArgs(severity, args) {
+	let entry = {};
+	const lastArg = args[args.length - 1];
+	if (lastArg && typeof lastArg === "object" && lastArg.constructor === Object) {
+		entry = args.pop();
+	}
+	let message = format(...args);
+	if (severity === "ERROR" && !args.find((arg) => arg instanceof Error)) {
+		message = new Error(message).stack || message;
+	}
+	const out = {
+		...entry,
+		severity
+	};
+	if (message) {
+		out.message = message;
+	}
+	return out;
+}
+
+//#endregion
+export { debug, error, info, log, logger_exports, warn, write };

package/lib/esm/params/index.mjs

@@ -0,0 +1,160 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+import { BUCKET_PICKER, BooleanParam, Expression, FloatParam, IntParam, InternalExpression, JsonSecretParam, ListParam, SecretParam, StringParam, multiSelect, select } from "./types.mjs";
+
+//#region src/params/index.ts
+var params_exports = /* @__PURE__ */ __export({
+	BUCKET_PICKER: () => BUCKET_PICKER,
+	Expression: () => Expression,
+	clearParams: () => clearParams,
+	databaseURL: () => databaseURL,
+	declaredParams: () => declaredParams,
+	defineBoolean: () => defineBoolean,
+	defineFloat: () => defineFloat,
+	defineInt: () => defineInt,
+	defineJsonSecret: () => defineJsonSecret,
+	defineList: () => defineList,
+	defineSecret: () => defineSecret,
+	defineString: () => defineString,
+	gcloudProject: () => gcloudProject,
+	multiSelect: () => multiSelect,
+	projectID: () => projectID,
+	select: () => select,
+	storageBucket: () => storageBucket
+});
+const declaredParams = [];
+/**
+* Use a helper to manage the list such that parameters are uniquely
+* registered once only but order is preserved.
+* @internal
+*/
+function registerParam(param) {
+	for (let i = 0; i < declaredParams.length; i++) {
+		if (declaredParams[i].name === param.name) {
+			declaredParams.splice(i, 1);
+		}
+	}
+	declaredParams.push(param);
+}
+/**
+* For testing.
+* @internal
+*/
+function clearParams() {
+	declaredParams.splice(0, declaredParams.length);
+}
+/**
+* A built-in parameter that resolves to the default RTDB database URL associated
+* with the project, without prompting the deployer. Empty string if none exists.
+*/
+const databaseURL = new InternalExpression("DATABASE_URL", (env) => JSON.parse(env.FIREBASE_CONFIG)?.databaseURL || "");
+/**
+* A built-in parameter that resolves to the Cloud project ID associated with
+* the project, without prompting the deployer.
+*/
+const projectID = new InternalExpression("PROJECT_ID", (env) => JSON.parse(env.FIREBASE_CONFIG)?.projectId || "");
+/**
+* A built-in parameter that resolves to the Cloud project ID, without prompting
+* the deployer.
+*/
+const gcloudProject = new InternalExpression("GCLOUD_PROJECT", (env) => JSON.parse(env.FIREBASE_CONFIG)?.projectId || "");
+/**
+* A builtin parameter that resolves to the Cloud storage bucket associated
+* with the function, without prompting the deployer. Empty string if not
+* defined.
+*/
+const storageBucket = new InternalExpression("STORAGE_BUCKET", (env) => JSON.parse(env.FIREBASE_CONFIG)?.storageBucket || "");
+/**
+* Declares a secret param, that will persist values only in Cloud Secret Manager.
+* Secrets are stored internally as bytestrings. Use `ParamOptions.as` to provide type
+* hinting during parameter resolution.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @returns A parameter with a `string` return type for `.value`.
+*/
+function defineSecret(name) {
+	const param = new SecretParam(name);
+	registerParam(param);
+	return param;
+}
+/**
+* Declares a secret parameter that retrieves a structured JSON object in Cloud Secret Manager.
+* This is useful for managing groups of related configuration values, such as all settings
+* for a third-party API, as a single unit.
+*
+* The secret value must be a valid JSON string. At runtime, the value will be automatically parsed
+* and returned as a JavaScript object. If the value is not set or is not valid JSON, an error will be thrown.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @returns A parameter whose `.value()` method returns the parsed JSON object.
+* ```
+*/
+function defineJsonSecret(name) {
+	const param = new JsonSecretParam(name);
+	registerParam(param);
+	return param;
+}
+/**
+* Declare a string parameter.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @param options Configuration options for the parameter.
+* @returns A parameter with a `string` return type for `.value`.
+*/
+function defineString(name, options = {}) {
+	const param = new StringParam(name, options);
+	registerParam(param);
+	return param;
+}
+/**
+* Declare a boolean parameter.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @param options Configuration options for the parameter.
+* @returns A parameter with a `boolean` return type for `.value`.
+*/
+function defineBoolean(name, options = {}) {
+	const param = new BooleanParam(name, options);
+	registerParam(param);
+	return param;
+}
+/**
+* Declare an integer parameter.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @param options Configuration options for the parameter.
+* @returns A parameter with a `number` return type for `.value`.
+*/
+function defineInt(name, options = {}) {
+	const param = new IntParam(name, options);
+	registerParam(param);
+	return param;
+}
+/**
+* Declare a float parameter.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @param options Configuration options for the parameter.
+* @returns A parameter with a `number` return type for `.value`.
+*
+* @internal
+*/
+function defineFloat(name, options = {}) {
+	const param = new FloatParam(name, options);
+	registerParam(param);
+	return param;
+}
+/**
+* Declare a list parameter.
+*
+* @param name The name of the environment variable to use to load the parameter.
+* @param options Configuration options for the parameter.
+* @returns A parameter with a `string[]` return type for `.value`.
+*/
+function defineList(name, options = {}) {
+	const param = new ListParam(name, options);
+	registerParam(param);
+	return param;
+}
+
+//#endregion
+export { BUCKET_PICKER, Expression, clearParams, databaseURL, declaredParams, defineBoolean, defineFloat, defineInt, defineJsonSecret, defineList, defineSecret, defineString, gcloudProject, multiSelect, params_exports, projectID, select, storageBucket };