firebase-functions 6.6.0 → 7.0.0-rc.0

package/lib/esm/v1/providers/analytics.mjs

@@ -0,0 +1,212 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+
+//#region src/v1/providers/analytics.ts
+var analytics_exports = /* @__PURE__ */ __export({
+	AnalyticsEvent: () => AnalyticsEvent,
+	AnalyticsEventBuilder: () => AnalyticsEventBuilder,
+	ExportBundleInfo: () => ExportBundleInfo,
+	UserDimensions: () => UserDimensions,
+	UserPropertyValue: () => UserPropertyValue,
+	_eventWithOptions: () => _eventWithOptions,
+	event: () => event,
+	provider: () => provider,
+	service: () => service
+});
+/** @internal */
+const provider = "google.analytics";
+/** @internal */
+const service = "app-measurement.com";
+/**
+* Registers a function to handle analytics events.
+*
+* @param analyticsEventType Name of the analytics event type to which
+*   this Cloud Function is scoped.
+*
+* @returns Analytics event builder interface.
+*/
+function event(analyticsEventType) {
+	return _eventWithOptions(analyticsEventType, {});
+}
+/** @internal */
+function _eventWithOptions(analyticsEventType, options) {
+	return new AnalyticsEventBuilder(() => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return "projects/" + process.env.GCLOUD_PROJECT + "/events/" + analyticsEventType;
+	}, options);
+}
+/**
+* The Firebase Analytics event builder interface.
+*
+* Access via `functions.analytics.event()`.
+*/
+var AnalyticsEventBuilder = class {
+	/** @hidden */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/**
+	* Event handler that fires every time a Firebase Analytics event occurs.
+	*
+	* @param handler Event handler that fires every time a Firebase Analytics event
+	*   occurs.
+	*
+	* @returns A function that you can export and deploy.
+	*/
+	onLog(handler) {
+		const dataConstructor = (raw) => {
+			return new AnalyticsEvent(raw.data);
+		};
+		return makeCloudFunction({
+			handler,
+			provider,
+			eventType: "event.log",
+			service,
+			legacyEventType: `providers/google.firebase.analytics/eventTypes/event.log`,
+			triggerResource: this.triggerResource,
+			dataConstructor,
+			options: this.options
+		});
+	}
+};
+/** Interface representing a Firebase Analytics event that was logged for a specific user. */
+var AnalyticsEvent = class {
+	/** @hidden */
+	constructor(wireFormat) {
+		this.params = {};
+		if (wireFormat.eventDim && wireFormat.eventDim.length > 0) {
+			const eventDim = wireFormat.eventDim[0];
+			copyField(eventDim, this, "name");
+			copyField(eventDim, this, "params", (p) => mapKeys(p, unwrapValue));
+			copyFieldTo(eventDim, this, "valueInUsd", "valueInUSD");
+			copyFieldTo(eventDim, this, "date", "reportingDate");
+			copyTimestampToString(eventDim, this, "timestampMicros", "logTime");
+			copyTimestampToString(eventDim, this, "previousTimestampMicros", "previousLogTime");
+		}
+		copyFieldTo(wireFormat, this, "userDim", "user", (dim) => new UserDimensions(dim));
+	}
+};
+function isValidUserProperty(property) {
+	if (property == null || typeof property !== "object" || !("value" in property)) {
+		return false;
+	}
+	const { value } = property;
+	if (value == null) {
+		return false;
+	}
+	if (typeof value === "object" && Object.keys(value).length === 0) {
+		return false;
+	}
+	return true;
+}
+/**
+* Interface representing the user who triggered the events.
+*/
+var UserDimensions = class {
+	/** @hidden */
+	constructor(wireFormat) {
+		copyFields(wireFormat, this, [
+			"userId",
+			"deviceInfo",
+			"geoInfo",
+			"appInfo"
+		]);
+		copyTimestampToString(wireFormat, this, "firstOpenTimestampMicros", "firstOpenTime");
+		this.userProperties = {};
+		copyField(wireFormat, this, "userProperties", (r) => {
+			const entries = Object.entries(r).filter(([, v]) => isValidUserProperty(v)).map(([k, v]) => [k, new UserPropertyValue(v)]);
+			return Object.fromEntries(entries);
+		});
+		copyField(wireFormat, this, "bundleInfo", (r) => new ExportBundleInfo(r));
+		if (!this.userId && this.userProperties["user_id"]) {
+			this.userId = this.userProperties["user_id"].value;
+		}
+	}
+};
+/** Predefined or custom properties stored on the client side. */
+var UserPropertyValue = class {
+	/** @hidden */
+	constructor(wireFormat) {
+		copyField(wireFormat, this, "value", unwrapValueAsString);
+		copyTimestampToString(wireFormat, this, "setTimestampUsec", "setTime");
+	}
+};
+/** Interface representing the bundle these events were uploaded to. */
+var ExportBundleInfo = class {
+	/** @hidden */
+	constructor(wireFormat) {
+		copyField(wireFormat, this, "bundleSequenceId");
+		copyTimestampToMillis(wireFormat, this, "serverTimestampOffsetMicros", "serverTimestampOffset");
+	}
+};
+/** @hidden */
+function copyFieldTo(from, to, fromField, toField, transform) {
+	if (typeof from[fromField] === "undefined") {
+		return;
+	}
+	if (transform) {
+		to[toField] = transform(from[fromField]);
+		return;
+	}
+	to[toField] = from[fromField];
+}
+/** @hidden */
+function copyField(from, to, field, transform = (from$1) => from$1) {
+	copyFieldTo(from, to, field, field, transform);
+}
+/** @hidden */
+function copyFields(from, to, fields) {
+	for (const field of fields) {
+		copyField(from, to, field);
+	}
+}
+function mapKeys(obj, transform) {
+	const entries = Object.entries(obj).map(([k, v]) => [k, transform(v)]);
+	return Object.fromEntries(entries);
+}
+/** @hidden */
+function unwrapValueAsString(wrapped) {
+	if (!wrapped || typeof wrapped !== "object") {
+		return "";
+	}
+	const keys = Object.keys(wrapped);
+	if (keys.length === 0) {
+		return "";
+	}
+	const key = keys[0];
+	const value = wrapped[key];
+	if (value === null || value === undefined) {
+		return "";
+	}
+	return value.toString();
+}
+/** @hidden */
+const xValueNumberFields = [
+	"intValue",
+	"floatValue",
+	"doubleValue"
+];
+/** @hidden */
+function unwrapValue(wrapped) {
+	const key = Object.keys(wrapped)[0];
+	const value = unwrapValueAsString(wrapped);
+	return xValueNumberFields.includes(key) ? Number(value) : value;
+}
+/** @hidden */
+function copyTimestampToMillis(from, to, fromName, toName) {
+	if (from[fromName] !== undefined) {
+		to[toName] = Math.round(from[fromName] / 1e3);
+	}
+}
+/** @hidden */
+function copyTimestampToString(from, to, fromName, toName) {
+	if (from[fromName] !== undefined) {
+		to[toName] = new Date(from[fromName] / 1e3).toISOString();
+	}
+}
+
+//#endregion
+export { AnalyticsEvent, AnalyticsEventBuilder, ExportBundleInfo, UserDimensions, UserPropertyValue, _eventWithOptions, analytics_exports, event, provider, service };

package/lib/esm/v1/providers/auth.mjs

@@ -0,0 +1,156 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV1Endpoint } from "../../runtime/manifest.mjs";
+import { makeCloudFunction, optionsToEndpoint, optionsToTrigger } from "../cloud-functions.mjs";
+import { HttpsError } from "../../common/providers/https.mjs";
+import { UserRecordMetadata, userRecordConstructor, wrapHandler } from "../../common/providers/identity.mjs";
+
+//#region src/v1/providers/auth.ts
+var auth_exports = /* @__PURE__ */ __export({
+	HttpsError: () => HttpsError,
+	UserBuilder: () => UserBuilder,
+	UserRecordMetadata: () => UserRecordMetadata,
+	_userWithOptions: () => _userWithOptions,
+	provider: () => provider,
+	service: () => service,
+	user: () => user,
+	userRecordConstructor: () => userRecordConstructor
+});
+/** @internal */
+const provider = "google.firebase.auth";
+/** @internal */
+const service = "firebaseauth.googleapis.com";
+/**
+* Handles events related to Firebase Auth users events.
+*
+* @param userOptions - Resource level options
+* @returns UserBuilder - Builder used to create functions for Firebase Auth user lifecycle events
+*
+* @public
+*/
+function user(userOptions) {
+	return _userWithOptions({}, userOptions || {});
+}
+/** @internal */
+function _userWithOptions(options, userOptions) {
+	return new UserBuilder(() => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return "projects/" + process.env.GCLOUD_PROJECT;
+	}, options, userOptions);
+}
+/**
+* Builder used to create functions for Firebase Auth user lifecycle events.
+* @public
+*/
+var UserBuilder = class UserBuilder {
+	static dataConstructor(raw) {
+		return userRecordConstructor(raw.data);
+	}
+	constructor(triggerResource, options, userOptions) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+		this.userOptions = userOptions;
+	}
+	/**
+	* Responds to the creation of a Firebase Auth user.
+	*
+	* @param handler Event handler that responds to the creation of a Firebase Auth user.
+	*
+	* @public
+	*/
+	onCreate(handler) {
+		return this.onOperation(handler, "user.create");
+	}
+	/**
+	* Responds to the deletion of a Firebase Auth user.
+	*
+	* @param handler Event handler that responds to the deletion of a Firebase Auth user.
+	*
+	* @public
+	*/
+	onDelete(handler) {
+		return this.onOperation(handler, "user.delete");
+	}
+	/**
+	* Blocks request to create a Firebase Auth user.
+	*
+	* @param handler Event handler that blocks creation of a Firebase Auth user.
+	*
+	* @public
+	*/
+	beforeCreate(handler) {
+		return this.beforeOperation(handler, "beforeCreate");
+	}
+	/**
+	* Blocks request to sign-in a Firebase Auth user.
+	*
+	* @param handler Event handler that blocks sign-in of a Firebase Auth user.
+	*
+	* @public
+	*/
+	beforeSignIn(handler) {
+		return this.beforeOperation(handler, "beforeSignIn");
+	}
+	beforeEmail(handler) {
+		return this.beforeOperation(handler, "beforeSendEmail");
+	}
+	beforeSms(handler) {
+		return this.beforeOperation(handler, "beforeSendSms");
+	}
+	onOperation(handler, eventType) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			eventType,
+			service,
+			triggerResource: this.triggerResource,
+			dataConstructor: UserBuilder.dataConstructor,
+			legacyEventType: `providers/firebase.auth/eventTypes/${eventType}`,
+			options: this.options
+		});
+	}
+	beforeOperation(handler, eventType) {
+		const accessToken = this.userOptions?.blockingOptions?.accessToken || false;
+		const idToken = this.userOptions?.blockingOptions?.idToken || false;
+		const refreshToken = this.userOptions?.blockingOptions?.refreshToken || false;
+		const annotatedHandler = Object.assign(handler, { platform: "gcfv1" });
+		const func = wrapHandler(eventType, annotatedHandler);
+		const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
+		func.__trigger = {
+			labels: {},
+			...optionsToTrigger(this.options),
+			blockingTrigger: {
+				eventType: legacyEventType,
+				options: {
+					accessToken,
+					idToken,
+					refreshToken
+				}
+			}
+		};
+		func.__endpoint = {
+			platform: "gcfv1",
+			labels: {},
+			...initV1Endpoint(this.options),
+			...optionsToEndpoint(this.options),
+			blockingTrigger: {
+				eventType: legacyEventType,
+				options: {
+					accessToken,
+					idToken,
+					refreshToken
+				}
+			}
+		};
+		func.__requiredAPIs = [{
+			api: "identitytoolkit.googleapis.com",
+			reason: "Needed for auth blocking functions"
+		}];
+		func.run = handler;
+		return func;
+	}
+};
+
+//#endregion
+export { HttpsError, UserBuilder, UserRecordMetadata, _userWithOptions, auth_exports, provider, service, user, userRecordConstructor };

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

@@ -0,0 +1,243 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { firebaseConfig } from "../../common/config.mjs";
+import { getApp } from "../../common/app.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+import { normalizePath } from "../../common/utilities/path.mjs";
+import { DataSnapshot } from "../../common/providers/database.mjs";
+import { applyChange } from "../../common/utilities/utils.mjs";
+
+//#region src/v1/providers/database.ts
+var database_exports = /* @__PURE__ */ __export({
+	DataSnapshot: () => DataSnapshot,
+	InstanceBuilder: () => InstanceBuilder,
+	RefBuilder: () => RefBuilder,
+	_instanceWithOptions: () => _instanceWithOptions,
+	_refWithOptions: () => _refWithOptions,
+	extractInstanceAndPath: () => extractInstanceAndPath,
+	instance: () => instance,
+	provider: () => provider,
+	ref: () => ref,
+	service: () => service
+});
+/** @internal */
+const provider = "google.firebase.database";
+/** @internal */
+const service = "firebaseio.com";
+const databaseURLRegex = new RegExp("^https://([^.]+).");
+const emulatorDatabaseURLRegex = new RegExp("^http://.*ns=([^&]+)");
+/**
+* Registers a function that triggers on events from a specific
+* Firebase Realtime Database instance.
+*
+* @remarks
+* Use this method together with `ref` to specify the instance on which to
+* watch for database events. For example: `firebase.database.instance('my-app-db-2').ref('/foo/bar')`
+*
+* Note that `functions.database.ref` used without `instance` watches the
+* *default* instance for events.
+*
+* @param instance The instance name of the database instance
+*   to watch for write events.
+* @returns Firebase Realtime Database instance builder interface.
+*/
+function instance(instance$1) {
+	return _instanceWithOptions(instance$1, {});
+}
+/**
+* Registers a function that triggers on Firebase Realtime Database write
+* events.
+*
+* @remarks
+* This method behaves very similarly to the method of the same name in the
+* client and Admin Firebase SDKs. Any change to the Database that affects the
+* data at or below the provided `path` will fire an event in Cloud Functions.
+*
+* There are three important differences between listening to a Realtime
+* Database event in Cloud Functions and using the Realtime Database in the
+* client and Admin SDKs:
+*
+* 1. Cloud Functions allows wildcards in the `path` name. Any `path` component
+*    in curly brackets (`{}`) is a wildcard that matches all strings. The value
+*    that matched a certain invocation of a Cloud Function is returned as part
+*    of the [`EventContext.params`](cloud_functions_eventcontext.html#params object. For
+*    example, `ref("messages/{messageId}")` matches changes at
+*    `/messages/message1` or `/messages/message2`, resulting in
+*    `event.params.messageId` being set to `"message1"` or `"message2"`,
+*    respectively.
+*
+* 2. Cloud Functions do not fire an event for data that already existed before
+*    the Cloud Function was deployed.
+*
+* 3. Cloud Function events have access to more information, including a
+*    snapshot of the previous event data and information about the user who
+*    triggered the Cloud Function.
+*
+* @param path The path within the Database to watch for write events.
+* @returns Firebase Realtime Database builder interface.
+*/
+function ref(path) {
+	return _refWithOptions(path, {});
+}
+/** @internal */
+function _instanceWithOptions(instance$1, options) {
+	return new InstanceBuilder(instance$1, options);
+}
+/**
+* The Firebase Realtime Database instance builder interface.
+*
+* Access via [`database.instance()`](providers_database_.html#instance).
+*/
+var InstanceBuilder = class {
+	constructor(instance$1, options) {
+		this.instance = instance$1;
+		this.options = options;
+	}
+	/**
+	* @returns Firebase Realtime Database reference builder interface.
+	*/
+	ref(path) {
+		const normalized = normalizePath(path);
+		return new RefBuilder(() => `projects/_/instances/${this.instance}/refs/${normalized}`, this.options);
+	}
+};
+/** @internal */
+function _refWithOptions(path, options) {
+	const resourceGetter = () => {
+		const normalized = normalizePath(path);
+		const databaseURL = firebaseConfig().databaseURL;
+		if (!databaseURL) {
+			throw new Error("Missing expected firebase config value databaseURL, " + "config is actually" + JSON.stringify(firebaseConfig()) + "\n If you are unit testing, please set process.env.FIREBASE_CONFIG");
+		}
+		let instance$1;
+		const prodMatch = databaseURL.match(databaseURLRegex);
+		if (prodMatch) {
+			instance$1 = prodMatch[1];
+		} else {
+			const emulatorMatch = databaseURL.match(emulatorDatabaseURLRegex);
+			if (emulatorMatch) {
+				instance$1 = emulatorMatch[1];
+			}
+		}
+		if (!instance$1) {
+			throw new Error("Invalid value for config firebase.databaseURL: " + databaseURL);
+		}
+		return `projects/_/instances/${instance$1}/refs/${normalized}`;
+	};
+	return new RefBuilder(resourceGetter, options);
+}
+/**
+* The Firebase Realtime Database reference builder interface.
+*
+* Access via [`functions.database.ref()`](functions.database#.ref).
+*/
+var RefBuilder = class {
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+		this.changeConstructor = (raw) => {
+			const [dbInstance, path] = extractInstanceAndPath(raw.context.resource.name, raw.context.domain);
+			const before = new DataSnapshot(raw.data.data, path, getApp(), dbInstance);
+			const after = new DataSnapshot(applyChange(raw.data.data, raw.data.delta), path, getApp(), dbInstance);
+			return {
+				before,
+				after
+			};
+		};
+	}
+	/**
+	* Event handler that fires every time a Firebase Realtime Database write
+	* of any kind (creation, update, or delete) occurs.
+	*
+	* @param handler Event handler that runs every time a Firebase Realtime Database
+	*   write occurs.
+	* @returns A function that you can export and deploy.
+	*/
+	onWrite(handler) {
+		return this.onOperation(handler, "ref.write", this.changeConstructor);
+	}
+	/**
+	* Event handler that fires every time data is updated in
+	* Firebase Realtime Database.
+	*
+	* @param handler Event handler which is run every time a Firebase Realtime Database
+	*   write occurs.
+	* @returns A function which you can export and deploy.
+	*/
+	onUpdate(handler) {
+		return this.onOperation(handler, "ref.update", this.changeConstructor);
+	}
+	/**
+	* Event handler that fires every time new data is created in
+	* Firebase Realtime Database.
+	*
+	* @param handler Event handler that runs every time new data is created in
+	*   Firebase Realtime Database.
+	* @returns A function that you can export and deploy.
+	*/
+	onCreate(handler) {
+		const dataConstructor = (raw) => {
+			const [dbInstance, path] = extractInstanceAndPath(raw.context.resource.name, raw.context.domain);
+			return new DataSnapshot(raw.data.delta, path, getApp(), dbInstance);
+		};
+		return this.onOperation(handler, "ref.create", dataConstructor);
+	}
+	/**
+	* Event handler that fires every time data is deleted from
+	* Firebase Realtime Database.
+	*
+	* @param handler Event handler that runs every time data is deleted from
+	*   Firebase Realtime Database.
+	* @returns A function that you can export and deploy.
+	*/
+	onDelete(handler) {
+		const dataConstructor = (raw) => {
+			const [dbInstance, path] = extractInstanceAndPath(raw.context.resource.name, raw.context.domain);
+			return new DataSnapshot(raw.data.data, path, getApp(), dbInstance);
+		};
+		return this.onOperation(handler, "ref.delete", dataConstructor);
+	}
+	onOperation(handler, eventType, dataConstructor) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			service,
+			eventType,
+			legacyEventType: `providers/${provider}/eventTypes/${eventType}`,
+			triggerResource: this.triggerResource,
+			dataConstructor,
+			options: this.options
+		});
+	}
+};
+const resourceRegex = /^projects\/([^/]+)\/instances\/([a-zA-Z0-9-]+)\/refs(\/.+)?/;
+/**
+* Utility function to extract database reference from resource string
+*
+* @param optional database domain override for the original of the source database.
+*    It defaults to `firebaseio.com`.
+*    Multi-region RTDB will be served from different domains.
+*    Since region is not part of the resource name, it is provided through context.
+*
+* @internal
+*/
+function extractInstanceAndPath(resource, domain = "firebaseio.com") {
+	const match = resource.match(new RegExp(resourceRegex));
+	if (!match) {
+		throw new Error(`Unexpected resource string for Firebase Realtime Database event: ${resource}. ` + "Expected string in the format of \"projects/_/instances/{firebaseioSubdomain}/refs/{ref=**}\"");
+	}
+	const [, project, dbInstanceName, path] = match;
+	if (project !== "_") {
+		throw new Error(`Expect project to be '_' in a Firebase Realtime Database event`);
+	}
+	const emuHost = process.env.FIREBASE_DATABASE_EMULATOR_HOST;
+	if (emuHost) {
+		const dbInstance = `http://${emuHost}/?ns=${dbInstanceName}`;
+		return [dbInstance, path];
+	} else {
+		const dbInstance = "https://" + dbInstanceName + "." + domain;
+		return [dbInstance, path];
+	}
+}
+
+//#endregion
+export { DataSnapshot, InstanceBuilder, RefBuilder, _instanceWithOptions, _refWithOptions, database_exports, extractInstanceAndPath, instance, provider, ref, service };