firebase-functions 6.6.0 → 7.0.0-rc.1

package/lib/esm/bin/firebase-functions.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { loadStack } from "../runtime/loader.mjs";
+import { stackToWire } from "../runtime/manifest.mjs";
+import express from "express";
+import fs from "fs/promises";
+import * as path from "path";
+
+//#region src/bin/firebase-functions.ts
+function printUsageAndExit() {
+	console.error(`
+Usage: firebase-functions [functionsDir]
+
+Arguments:
+  - functionsDir: Directory containing source code for Firebase Functions.
+`);
+	process.exit(1);
+}
+let functionsDir = ".";
+const args = process.argv.slice(2);
+if (args.length > 1) {
+	if (args[0] === "-h" || args[0] === "--help") {
+		printUsageAndExit();
+	}
+	functionsDir = args[0];
+}
+function handleQuitquitquit(req, res, server) {
+	res.send("ok");
+	server.close();
+}
+if (process.env.FUNCTIONS_MANIFEST_OUTPUT_PATH) {
+	void (async () => {
+		const outputPath = process.env.FUNCTIONS_MANIFEST_OUTPUT_PATH;
+		try {
+			const dir = path.dirname(outputPath);
+			try {
+				await fs.access(dir, fs.constants.W_OK);
+			} catch (e) {
+				console.error(`Error: Cannot write to directory '${dir}': ${e instanceof Error ? e.message : String(e)}`);
+				console.error("Please ensure the directory exists and you have write permissions.");
+				process.exit(1);
+			}
+			const stack = await loadStack(functionsDir);
+			const wireFormat = stackToWire(stack);
+			await fs.writeFile(outputPath, JSON.stringify(wireFormat, null, 2));
+			process.exit(0);
+		} catch (e) {
+			if (e.code === "ENOENT") {
+				console.error(`Error: Directory '${path.dirname(outputPath)}' does not exist.`);
+				console.error("Please create the directory or specify a valid path.");
+			} else if (e.code === "EACCES") {
+				console.error(`Error: Permission denied writing to '${outputPath}'.`);
+				console.error("Please check file permissions or choose a different location.");
+			} else if (e.message?.includes("Failed to generate manifest")) {
+				console.error(e.message);
+			} else {
+				console.error(`Failed to generate manifest from function source: ${e instanceof Error ? e.message : String(e)}`);
+			}
+			if (e instanceof Error && e.stack) {
+				console.error(e.stack);
+			}
+			process.exit(1);
+		}
+	})();
+} else {
+	let server = undefined;
+	const app = express();
+	app.get("/__/quitquitquit", (req, res) => handleQuitquitquit(req, res, server));
+	app.post("/__/quitquitquit", (req, res) => handleQuitquitquit(req, res, server));
+	if (process.env.FUNCTIONS_CONTROL_API === "true") {
+		app.get("/__/functions.yaml", async (req, res) => {
+			try {
+				const stack = await loadStack(functionsDir);
+				res.setHeader("content-type", "text/yaml");
+				res.send(JSON.stringify(stackToWire(stack)));
+			} catch (e) {
+				console.error(e);
+				const errorMessage = e instanceof Error ? e.message : String(e);
+				res.status(400).send(`Failed to generate manifest from function source: ${errorMessage}`);
+			}
+		});
+	}
+	let port = 8080;
+	if (process.env.PORT) {
+		port = Number.parseInt(process.env.PORT);
+	}
+	console.log("Serving at port", port);
+	server = app.listen(port);
+}
+
+//#endregion
+export {  };

package/lib/esm/common/app.mjs

@@ -0,0 +1,39 @@
+import { firebaseConfig } from "./config.mjs";
+import { applicationDefault, deleteApp, getApp as getApp$1, initializeApp } from "firebase-admin/app";
+
+//#region src/common/app.ts
+const APP_NAME = "__FIREBASE_FUNCTIONS_SDK__";
+let cache;
+function getApp() {
+	if (typeof cache === "undefined") {
+		try {
+			cache = getApp$1();
+		} catch {
+			cache = initializeApp({
+				...firebaseConfig(),
+				credential: applicationDefault()
+			}, APP_NAME);
+		}
+	}
+	return cache;
+}
+/**
+* This function allows the Firebase Emulator Suite to override the FirebaseApp instance
+* used by the Firebase Functions SDK. Developers should never call this function for
+* other purposes.
+* N.B. For clarity for use in testing this name has no mention of emulation, but
+* it must be exported from index as app.setEmulatedAdminApp or we break the emulator.
+* We can remove this export when:
+* A) We complete the new emulator and no longer depend on monkeypatching
+* B) We tweak the CLI to look for different APIs to monkeypatch depending on versions.
+* @alpha
+*/
+function setApp(app) {
+	if (cache?.name === APP_NAME) {
+		void deleteApp(cache);
+	}
+	cache = app;
+}
+
+//#endregion
+export { getApp, setApp };

package/lib/esm/common/change.mjs

@@ -0,0 +1,57 @@
+//#region src/common/change.ts
+/** @internal */
+function applyFieldMask(sparseBefore, after, fieldMask) {
+	const before = { ...after };
+	const masks = fieldMask.split(",");
+	for (const mask of masks) {
+		const parts = mask.split(".");
+		const head = parts[0];
+		const tail = parts.slice(1).join(".");
+		if (parts.length > 1) {
+			before[head] = applyFieldMask(sparseBefore?.[head], after[head], tail);
+			continue;
+		}
+		const val = sparseBefore?.[head];
+		if (typeof val === "undefined") {
+			delete before[mask];
+		} else {
+			before[mask] = val;
+		}
+	}
+	return before;
+}
+/**
+* The Cloud Functions interface for events that change state, such as
+* Realtime Database or Cloud Firestore `onWrite` and `onUpdate` events.
+*
+* For more information about the format used to construct `Change` objects, see
+* {@link ChangeJson} below.
+*
+*/
+var Change = class Change {
+	/**
+	* Factory method for creating a `Change` from a `before` object and an `after`
+	* object.
+	*/
+	static fromObjects(before, after) {
+		return new Change(before, after);
+	}
+	/**
+	* Factory method for creating a `Change` from JSON and an optional customizer
+	* function to be applied to both the `before` and the `after` fields.
+	*/
+	static fromJSON(json, customizer = (x) => x) {
+		let before = { ...json.before };
+		if (json.fieldMask) {
+			before = applyFieldMask(before, json.after, json.fieldMask);
+		}
+		return Change.fromObjects(customizer(before || {}), customizer(json.after || {}));
+	}
+	constructor(before, after) {
+		this.before = before;
+		this.after = after;
+	}
+};
+
+//#endregion
+export { Change, applyFieldMask };

package/lib/esm/common/config.mjs

@@ -0,0 +1,45 @@
+import { warn } from "../logger/index.mjs";
+import * as path from "path";
+import fs from "fs";
+
+//#region src/common/config.ts
+let cache = null;
+/**
+* @internal
+* @alpha
+*/
+function resetCache(newCache = null) {
+	cache = newCache;
+}
+/**
+* Get the fields you need to initialize a Firebase app
+* @alpha
+*/
+function firebaseConfig() {
+	if (cache) {
+		return cache;
+	}
+	let env = process.env.FIREBASE_CONFIG;
+	if (env) {
+		if (!env.startsWith("{")) {
+			env = fs.readFileSync(path.join(process.env.PWD, env)).toString("utf8");
+		}
+		cache = JSON.parse(env);
+		return cache;
+	}
+	if (process.env.GCLOUD_PROJECT) {
+		warn("Warning, estimating Firebase Config based on GCLOUD_PROJECT. Initializing firebase-admin may fail");
+		cache = {
+			databaseURL: process.env.DATABASE_URL || `https://${process.env.GCLOUD_PROJECT}.firebaseio.com`,
+			storageBucket: process.env.STORAGE_BUCKET_URL || `${process.env.GCLOUD_PROJECT}.appspot.com`,
+			projectId: process.env.GCLOUD_PROJECT
+		};
+		return cache;
+	} else {
+		warn("Warning, FIREBASE_CONFIG and GCLOUD_PROJECT environment variables are missing. Initializing firebase-admin will fail");
+	}
+	return null;
+}
+
+//#endregion
+export { firebaseConfig, resetCache };

package/lib/esm/common/debug.mjs

@@ -0,0 +1,28 @@
+//#region src/common/debug.ts
+const debugMode = process.env.FIREBASE_DEBUG_MODE === "true";
+function loadDebugFeatures() {
+	if (!debugMode) {
+		return {};
+	}
+	try {
+		const obj = JSON.parse(process.env.FIREBASE_DEBUG_FEATURES);
+		if (typeof obj !== "object") {
+			return {};
+		}
+		return obj;
+	} catch (_e) {
+		return {};
+	}
+}
+function debugFeatureValue(feat) {
+	if (!debugMode) {
+		return;
+	}
+	return loadDebugFeatures()[feat];
+}
+function isDebugFeatureEnabled(feat) {
+	return debugMode && !!debugFeatureValue(feat);
+}
+
+//#endregion
+export { debugFeatureValue, isDebugFeatureEnabled };

package/lib/esm/common/encoding.mjs

@@ -0,0 +1,69 @@
+import { Expression } from "../params/types.mjs";
+import "../params/index.mjs";
+
+//#region src/common/encoding.ts
+/** Get a google.protobuf.Duration for a number of seconds. */
+function durationFromSeconds(s) {
+	return `${s}s`;
+}
+/**
+* Utility function to help copy fields from type A to B.
+* As a safety net, catches typos or fields that aren't named the same
+* in A and B, but cannot verify that both Src and Dest have the same type for the same field.
+*/
+function copyIfPresent(dest, src, ...fields) {
+	if (!src) {
+		return;
+	}
+	for (const field of fields) {
+		if (!Object.prototype.hasOwnProperty.call(src, field)) {
+			continue;
+		}
+		dest[field] = src[field];
+	}
+}
+function convertIfPresent(dest, src, destField, srcField, converter = (from) => {
+	return from;
+}) {
+	if (!src) {
+		return;
+	}
+	if (!Object.prototype.hasOwnProperty.call(src, srcField)) {
+		return;
+	}
+	dest[destField] = converter(src[srcField]);
+}
+function serviceAccountFromShorthand(serviceAccount) {
+	if (serviceAccount === "default") {
+		return null;
+	} else if (serviceAccount instanceof Expression) {
+		return serviceAccount;
+	} else if (serviceAccount.endsWith("@")) {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error(`Unable to determine email for service account '${serviceAccount}' because process.env.GCLOUD_PROJECT is not set.`);
+		}
+		return `${serviceAccount}${process.env.GCLOUD_PROJECT}.iam.gserviceaccount.com`;
+	} else if (serviceAccount.includes("@")) {
+		return serviceAccount;
+	} else {
+		throw new Error(`Invalid option for serviceAccount: '${serviceAccount}'. Valid options are 'default', a service account email, or '{serviceAccountName}@'`);
+	}
+}
+function convertInvoker(invoker) {
+	if (typeof invoker === "string") {
+		invoker = [invoker];
+	}
+	if (invoker.length === 0) {
+		throw new Error("Invalid option for invoker: Must be a non-empty array.");
+	}
+	if (invoker.find((inv) => inv.length === 0)) {
+		throw new Error("Invalid option for invoker: Must be a non-empty string.");
+	}
+	if (invoker.length > 1 && invoker.find((inv) => inv === "public" || inv === "private")) {
+		throw new Error("Invalid option for invoker: Cannot have 'public' or 'private' in an array of service accounts.");
+	}
+	return invoker;
+}
+
+//#endregion
+export { convertIfPresent, convertInvoker, copyIfPresent, durationFromSeconds, serviceAccountFromShorthand };

package/lib/esm/common/onInit.mjs

@@ -0,0 +1,33 @@
+import { warn } from "../logger/index.mjs";
+
+//#region src/common/onInit.ts
+let initCallback = null;
+let didInit = false;
+/**
+* Registers a callback that should be run when in a production environment
+* before executing any functions code.
+* Calling this function more than once leads to undefined behavior.
+* @param callback initialization callback to be run before any function executes.
+*/
+function onInit(callback) {
+	if (initCallback) {
+		warn("Setting onInit callback more than once. Only the most recent callback will be called");
+	}
+	initCallback = callback;
+	didInit = false;
+}
+/** @internal */
+function withInit(func) {
+	return async (...args) => {
+		if (!didInit) {
+			if (initCallback) {
+				await initCallback();
+			}
+			didInit = true;
+		}
+		return func(...args);
+	};
+}
+
+//#endregion
+export { onInit, withInit };

package/lib/esm/common/options.mjs

@@ -0,0 +1,22 @@
+//#region src/common/options.ts
+/**
+* Special configuration type to reset configuration to platform default.
+*
+* @alpha
+*/
+var ResetValue = class ResetValue {
+	toJSON() {
+		return null;
+	}
+	constructor() {}
+	static getInstance() {
+		return new ResetValue();
+	}
+};
+/**
+* Special configuration value to reset configuration to platform default.
+*/
+const RESET_VALUE = ResetValue.getInstance();
+
+//#endregion
+export { RESET_VALUE, ResetValue };

package/lib/esm/common/params.mjs

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

package/lib/esm/common/providers/database.mjs

@@ -0,0 +1,269 @@
+import { firebaseConfig } from "../config.mjs";
+import { joinPath, pathParts } from "../utilities/path.mjs";
+import * as database from "firebase-admin/database";
+
+//#region src/common/providers/database.ts
+/**
+* Interface representing a Firebase Realtime database data snapshot.
+*/
+var DataSnapshot = class DataSnapshot {
+	constructor(data, path, app, instance) {
+		this.app = app;
+		const config = firebaseConfig();
+		if (instance) {
+			this.instance = instance;
+		} else if (app) {
+			this.instance = app.options.databaseURL;
+		} else if (config.databaseURL) {
+			this.instance = config.databaseURL;
+		} else if (process.env.GCLOUD_PROJECT) {
+			this.instance = "https://" + process.env.GCLOUD_PROJECT + "-default-rtdb.firebaseio.com";
+		}
+		this._path = path;
+		this._data = data;
+	}
+	/**
+	* Returns a [`Reference`](/docs/reference/admin/node/admin.database.Reference)
+	* to the database location where the triggering write occurred. Has
+	* full read and write access.
+	*/
+	get ref() {
+		if (!this.app) {
+			throw new Error("Please supply a Firebase app in the constructor for DataSnapshot" + " in order to use the .ref method.");
+		}
+		if (!this._ref) {
+			let db;
+			if (this.instance) {
+				db = database.getDatabaseWithUrl(this.instance, this.app);
+			} else {
+				db = database.getDatabase(this.app);
+			}
+			this._ref = db.ref(this._fullPath());
+		}
+		return this._ref;
+	}
+	/**
+	* The key (last part of the path) of the location of this `DataSnapshot`.
+	*
+	* The last token in a database location is considered its key. For example,
+	* "ada" is the key for the `/users/ada/` node. Accessing the key on any
+	* `DataSnapshot` returns the key for the location that generated it.
+	* However, accessing the key on the root URL of a database returns `null`.
+	*/
+	get key() {
+		const segments = pathParts(this._fullPath());
+		const last = segments[segments.length - 1];
+		return !last || last === "" ? null : last;
+	}
+	/**
+	* Extracts a JavaScript value from a `DataSnapshot`.
+	*
+	* Depending on the data in a `DataSnapshot`, the `val()` method may return a
+	* scalar type (string, number, or boolean), an array, or an object. It may also
+	* return `null`, indicating that the `DataSnapshot` is empty (contains no
+	* data).
+	*
+	* @return The snapshot's contents as a JavaScript value (Object,
+	*   Array, string, number, boolean, or `null`).
+	*/
+	val() {
+		const parts = pathParts(this._childPath);
+		let source = this._data;
+		if (source === null) {
+			return null;
+		}
+		if (parts.length) {
+			for (const part of parts) {
+				if (typeof source === "undefined" || source === null) {
+					return null;
+				}
+				source = source[part];
+			}
+		}
+		const node = source ?? null;
+		return this._checkAndConvertToArray(node);
+	}
+	/**
+	* Exports the entire contents of the `DataSnapshot` as a JavaScript object.
+	*
+	* @return The contents of the `DataSnapshot` as a JavaScript value
+	*   (Object, Array, string, number, boolean, or `null`).
+	*/
+	exportVal() {
+		return this.val();
+	}
+	/**
+	* Gets the priority value of the data in this `DataSnapshot`.
+	*
+	* As an alternative to using priority, applications can order collections by
+	* ordinary properties. See [Sorting and filtering
+	* data](/docs/database/web/lists-of-data#sorting_and_filtering_data).
+	*
+	* @return The priority value of the data.
+	*/
+	getPriority() {
+		return 0;
+	}
+	/**
+	* Returns `true` if this `DataSnapshot` contains any data. It is slightly more
+	* efficient than using `snapshot.val() !== null`.
+	*
+	* @return `true` if this `DataSnapshot` contains any data; otherwise, `false`.
+	*/
+	exists() {
+		const val = this.val();
+		if (typeof val === "undefined" || val === null) {
+			return false;
+		}
+		if (typeof val === "object" && Object.keys(val).length === 0) {
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Gets a `DataSnapshot` for the location at the specified relative path.
+	*
+	* The relative path can either be a simple child name (for example, "ada") or
+	* a deeper slash-separated path (for example, "ada/name/first").
+	*
+	* @param path A relative path from this location to the desired child
+	*   location.
+	* @return The specified child location.
+	*/
+	child(childPath) {
+		if (!childPath) {
+			return this;
+		}
+		return this._dup(childPath);
+	}
+	/**
+	* Enumerates the `DataSnapshot`s of the children items.
+	*
+	* Because of the way JavaScript objects work, the ordering of data in the
+	* JavaScript object returned by `val()` is not guaranteed to match the ordering
+	* on the server nor the ordering of `child_added` events. That is where
+	* `forEach()` comes in handy. It guarantees the children of a `DataSnapshot`
+	* can be iterated in their query order.
+	*
+	* If no explicit `orderBy*()` method is used, results are returned
+	* ordered by key (unless priorities are used, in which case, results are
+	* returned by priority).
+	*
+	* @param action A function that is called for each child `DataSnapshot`.
+	*   The callback can return `true` to cancel further enumeration.
+	*
+	* @return `true` if enumeration was canceled due to your callback
+	*   returning `true`.
+	*/
+	forEach(action) {
+		const val = this.val() || {};
+		if (typeof val === "object") {
+			return Object.keys(val).some((key) => action(this.child(key)) === true);
+		}
+		return false;
+	}
+	/**
+	* Returns `true` if the specified child path has (non-`null`) data.
+	*
+	* @param path A relative path to the location of a potential child.
+	* @return `true` if data exists at the specified child path; otherwise,
+	*   `false`.
+	*/
+	hasChild(childPath) {
+		return this.child(childPath).exists();
+	}
+	/**
+	* Returns whether or not the `DataSnapshot` has any non-`null` child
+	* properties.
+	*
+	* You can use `hasChildren()` to determine if a `DataSnapshot` has any
+	* children. If it does, you can enumerate them using `forEach()`. If it
+	* doesn't, then either this snapshot contains a primitive value (which can be
+	* retrieved with `val()`) or it is empty (in which case, `val()` returns
+	* `null`).
+	*
+	* @return `true` if this snapshot has any children; else `false`.
+	*/
+	hasChildren() {
+		const val = this.val();
+		return val !== null && typeof val === "object" && Object.keys(val).length > 0;
+	}
+	/**
+	* Returns the number of child properties of this `DataSnapshot`.
+	*
+	* @return Number of child properties of this `DataSnapshot`.
+	*/
+	numChildren() {
+		const val = this.val();
+		return val !== null && typeof val === "object" ? Object.keys(val).length : 0;
+	}
+	/**
+	* Returns a JSON-serializable representation of this object.
+	*
+	* @return A JSON-serializable representation of this object.
+	*/
+	toJSON() {
+		return this.val();
+	}
+	/** Recursive function to check if keys are numeric & convert node object to array if they are
+	*
+	* @hidden
+	*/
+	_checkAndConvertToArray(node) {
+		if (node === null || typeof node === "undefined") {
+			return null;
+		}
+		if (typeof node !== "object") {
+			return node;
+		}
+		const obj = {};
+		let numKeys = 0;
+		let maxKey = 0;
+		let allIntegerKeys = true;
+		for (const key in node) {
+			if (!node.hasOwnProperty(key)) {
+				continue;
+			}
+			const childNode = node[key];
+			const v = this._checkAndConvertToArray(childNode);
+			if (v === null) {
+				continue;
+			}
+			obj[key] = v;
+			numKeys++;
+			const integerRegExp = /^(0|[1-9]\d*)$/;
+			if (allIntegerKeys && integerRegExp.test(key)) {
+				maxKey = Math.max(maxKey, Number(key));
+			} else {
+				allIntegerKeys = false;
+			}
+		}
+		if (numKeys === 0) {
+			return null;
+		}
+		if (allIntegerKeys && maxKey < 2 * numKeys) {
+			const array = [];
+			for (const key of Object.keys(obj)) {
+				array[key] = obj[key];
+			}
+			return array;
+		}
+		return obj;
+	}
+	/** @hidden */
+	_dup(childPath) {
+		const dup = new DataSnapshot(this._data, undefined, this.app, this.instance);
+		[dup._path, dup._childPath] = [this._path, this._childPath];
+		if (childPath) {
+			dup._childPath = joinPath(dup._childPath, childPath);
+		}
+		return dup;
+	}
+	/** @hidden */
+	_fullPath() {
+		return (this._path || "") + "/" + (this._childPath || "");
+	}
+};
+
+//#endregion
+export { DataSnapshot };