firebase-functions 6.6.0 → 7.0.0-rc.0

package/lib/esm/v2/providers/https.mjs

@@ -0,0 +1,210 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { debug } from "../../logger/index.mjs";
+import { Expression } from "../../params/types.mjs";
+import "../../params/index.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { isDebugFeatureEnabled } from "../../common/debug.mjs";
+import { convertIfPresent, convertInvoker, copyIfPresent } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { HttpsError, onCallHandler, withErrorHandler } from "../../common/providers/https.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint, optionsToTriggerAnnotations } from "../options.mjs";
+import cors from "cors";
+
+//#region src/v2/providers/https.ts
+var https_exports = /* @__PURE__ */ __export({
+	HttpsError: () => HttpsError,
+	hasClaim: () => hasClaim,
+	isSignedIn: () => isSignedIn,
+	onCall: () => onCall,
+	onCallGenkit: () => onCallGenkit,
+	onRequest: () => onRequest
+});
+/**
+* @deprecated
+*
+* An auth policy that requires a user to be signed in.
+*/
+const isSignedIn = () => (auth) => !!auth;
+/**
+* @deprecated
+*
+* An auth policy that requires a user to be both signed in and have a specific claim (optionally with a specific value)
+*/
+const hasClaim = (claim, value) => (auth) => {
+	if (!auth) {
+		return false;
+	}
+	if (!(claim in auth.token)) {
+		return false;
+	}
+	return !value || auth.token[claim] === value;
+};
+function onRequest(optsOrHandler, handler) {
+	let opts;
+	if (arguments.length === 1) {
+		opts = {};
+		handler = optsOrHandler;
+	} else {
+		opts = optsOrHandler;
+	}
+	handler = withErrorHandler(handler);
+	if (isDebugFeatureEnabled("enableCors") || "cors" in opts) {
+		let origin = opts.cors instanceof Expression ? opts.cors.value() : opts.cors;
+		if (isDebugFeatureEnabled("enableCors")) {
+			origin = opts.cors === false ? false : true;
+		}
+		if (Array.isArray(origin) && origin.length === 1) {
+			origin = origin[0];
+		}
+		const middleware = cors({ origin });
+		const userProvidedHandler = handler;
+		handler = (req, res) => {
+			return new Promise((resolve) => {
+				res.on("finish", resolve);
+				middleware(req, res, () => {
+					resolve(userProvidedHandler(req, res));
+				});
+			});
+		};
+	}
+	handler = wrapTraceContext(withInit(handler));
+	Object.defineProperty(handler, "__trigger", { get: () => {
+		const baseOpts$1 = optionsToTriggerAnnotations(getGlobalOptions());
+		const specificOpts$1 = optionsToTriggerAnnotations(opts);
+		const trigger = {
+			platform: "gcfv2",
+			...baseOpts$1,
+			...specificOpts$1,
+			labels: {
+				...baseOpts$1?.labels,
+				...specificOpts$1?.labels
+			},
+			httpsTrigger: { allowInsecure: false }
+		};
+		convertIfPresent(trigger.httpsTrigger, getGlobalOptions(), "invoker", "invoker", convertInvoker);
+		convertIfPresent(trigger.httpsTrigger, opts, "invoker", "invoker", convertInvoker);
+		return trigger;
+	} });
+	const globalOpts = getGlobalOptions();
+	const baseOpts = optionsToEndpoint(globalOpts);
+	const specificOpts = optionsToEndpoint(opts);
+	const endpoint = {
+		...initV2Endpoint(globalOpts, opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		httpsTrigger: {}
+	};
+	convertIfPresent(endpoint.httpsTrigger, globalOpts, "invoker", "invoker", convertInvoker);
+	convertIfPresent(endpoint.httpsTrigger, opts, "invoker", "invoker", convertInvoker);
+	handler.__endpoint = endpoint;
+	return handler;
+}
+function onCall(optsOrHandler, handler) {
+	let opts;
+	if (arguments.length === 1) {
+		opts = {};
+		handler = optsOrHandler;
+	} else {
+		opts = optsOrHandler;
+	}
+	let cors$1;
+	if ("cors" in opts) {
+		if (opts.cors instanceof Expression) {
+			cors$1 = opts.cors.value();
+		} else {
+			cors$1 = opts.cors;
+		}
+	} else {
+		cors$1 = true;
+	}
+	let origin = isDebugFeatureEnabled("enableCors") ? true : cors$1;
+	if (Array.isArray(origin) && origin.length === 1) {
+		origin = origin[0];
+	}
+	const fixedLen = (req, resp) => handler(req, resp);
+	let func = onCallHandler({
+		cors: {
+			origin,
+			methods: "POST"
+		},
+		enforceAppCheck: opts.enforceAppCheck ?? getGlobalOptions().enforceAppCheck,
+		consumeAppCheckToken: opts.consumeAppCheckToken,
+		heartbeatSeconds: opts.heartbeatSeconds,
+		authPolicy: opts.authPolicy
+	}, fixedLen, "gcfv2");
+	func = wrapTraceContext(withInit(func));
+	Object.defineProperty(func, "__trigger", { get: () => {
+		const baseOpts$1 = optionsToTriggerAnnotations(getGlobalOptions());
+		const specificOpts$1 = optionsToTriggerAnnotations(opts);
+		return {
+			platform: "gcfv2",
+			...baseOpts$1,
+			...specificOpts$1,
+			labels: {
+				...baseOpts$1?.labels,
+				...specificOpts$1?.labels,
+				"deployment-callable": "true"
+			},
+			httpsTrigger: { allowInsecure: false }
+		};
+	} });
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	func.__endpoint = {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		callableTrigger: {}
+	};
+	func.run = withInit(handler);
+	func.stream = () => {
+		return {
+			stream: { next() {
+				return Promise.reject("Coming soon");
+			} },
+			output: Promise.reject("Coming soon")
+		};
+	};
+	return func;
+}
+function onCallGenkit(optsOrAction, action) {
+	let opts;
+	if (arguments.length === 2) {
+		opts = optsOrAction;
+	} else {
+		opts = {};
+		action = optsOrAction;
+	}
+	if (!opts.secrets?.length) {
+		debug(`Genkit function for ${action.__action.name} is not bound to any secret. This may mean that you are not storing API keys as a secret or that you are not binding your secret to this function. See https://firebase.google.com/docs/functions/config-env?gen=2nd#secret_parameters for more information.`);
+	}
+	const cloudFunction = onCall(opts, async (req, res) => {
+		const context = {};
+		copyIfPresent(context, req, "auth", "app", "instanceIdToken");
+		if (!req.acceptsStreaming) {
+			const { result } = await action.run(req.data, { context });
+			return result;
+		}
+		const { stream, output } = action.stream(req.data, { context });
+		for await (const chunk of stream) {
+			await res.sendChunk(chunk);
+		}
+		return output;
+	});
+	cloudFunction.__endpoint.callableTrigger.genkitAction = action.__action.name;
+	return cloudFunction;
+}
+
+//#endregion
+export { HttpsError, hasClaim, https_exports, isSignedIn, onCall, onCallGenkit, onRequest };

package/lib/esm/v2/providers/identity.mjs

@@ -0,0 +1,103 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { HttpsError } from "../../common/providers/https.mjs";
+import { wrapHandler } from "../../common/providers/identity.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+
+//#region src/v2/providers/identity.ts
+var identity_exports = /* @__PURE__ */ __export({
+	HttpsError: () => HttpsError,
+	beforeEmailSent: () => beforeEmailSent,
+	beforeOperation: () => beforeOperation,
+	beforeSmsSent: () => beforeSmsSent,
+	beforeUserCreated: () => beforeUserCreated,
+	beforeUserSignedIn: () => beforeUserSignedIn,
+	getOpts: () => getOpts
+});
+/**
+* Handles an event that is triggered before a user is created.
+* @param optsOrHandler - Either an object containing function options, or an event handler (run before user creation).
+* @param handler? - If defined, an event handler which is run every time before a user is created.
+*/
+function beforeUserCreated(optsOrHandler, handler) {
+	return beforeOperation("beforeCreate", optsOrHandler, handler);
+}
+/**
+* Handles an event that is triggered before a user is signed in.
+* @param optsOrHandler - Either an object containing function options, or an event handler (run before user signin).
+* @param handler - Event handler which is run every time before a user is signed in.
+*/
+function beforeUserSignedIn(optsOrHandler, handler) {
+	return beforeOperation("beforeSignIn", optsOrHandler, handler);
+}
+/**
+* Handles an event that is triggered before an email is sent to a user.
+* @param optsOrHandler- Either an object containing function options, or an event handler that is run before an email is sent to a user.
+* @param handler - Event handler that is run before an email is sent to a user.
+*/
+function beforeEmailSent(optsOrHandler, handler) {
+	return beforeOperation("beforeSendEmail", optsOrHandler, handler);
+}
+/**
+* Handles an event that is triggered before an SMS is sent to a user.
+* @param optsOrHandler - Either an object containing function options, or an event handler that is run before an SMS is sent to a user.
+* @param handler - Event handler that is run before an SMS is sent to a user.
+*/
+function beforeSmsSent(optsOrHandler, handler) {
+	return beforeOperation("beforeSendSms", optsOrHandler, handler);
+}
+/** @hidden */
+function beforeOperation(eventType, optsOrHandler, handler) {
+	if (!handler || typeof optsOrHandler === "function") {
+		handler = optsOrHandler;
+		optsOrHandler = {};
+	}
+	const { opts,...blockingOptions } = getOpts(optsOrHandler);
+	const annotatedHandler = Object.assign(handler, { platform: "gcfv2" });
+	const func = wrapTraceContext(withInit(wrapHandler(eventType, annotatedHandler)));
+	const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
+	/** Endpoint */
+	const baseOptsEndpoint = optionsToEndpoint(getGlobalOptions());
+	const specificOptsEndpoint = optionsToEndpoint(opts);
+	func.__endpoint = {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOptsEndpoint,
+		...specificOptsEndpoint,
+		labels: {
+			...baseOptsEndpoint?.labels,
+			...specificOptsEndpoint?.labels
+		},
+		blockingTrigger: {
+			eventType: legacyEventType,
+			options: { ...(eventType === "beforeCreate" || eventType === "beforeSignIn") && blockingOptions }
+		}
+	};
+	func.__requiredAPIs = [{
+		api: "identitytoolkit.googleapis.com",
+		reason: "Needed for auth blocking functions"
+	}];
+	func.run = handler;
+	return func;
+}
+/** @hidden */
+function getOpts(blockingOptions) {
+	const accessToken = blockingOptions.accessToken || false;
+	const idToken = blockingOptions.idToken || false;
+	const refreshToken = blockingOptions.refreshToken || false;
+	const opts = { ...blockingOptions };
+	delete opts.accessToken;
+	delete opts.idToken;
+	delete opts.refreshToken;
+	return {
+		opts,
+		accessToken,
+		idToken,
+		refreshToken
+	};
+}
+
+//#endregion
+export { HttpsError, beforeEmailSent, beforeOperation, beforeSmsSent, beforeUserCreated, beforeUserSignedIn, getOpts, identity_exports };

package/lib/esm/v2/providers/pubsub.mjs

@@ -0,0 +1,148 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { copyIfPresent } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint, optionsToTriggerAnnotations } from "../options.mjs";
+
+//#region src/v2/providers/pubsub.ts
+var pubsub_exports = /* @__PURE__ */ __export({
+	Message: () => Message,
+	onMessagePublished: () => onMessagePublished
+});
+/**
+* Google Cloud Pub/Sub is a globally distributed message bus that automatically scales as you need it.
+* You can create a function ({@link onMessagePublished}) that handles pub/sub events by using functions.pubsub.
+*
+* This function triggers whenever a new pub/sub message is sent to a specific topic.
+* You must specify the Pub/Sub topic name that you want to trigger your function, and set the event within the
+* onPublish() event handler.
+*
+* PubSub Topic:
+* <ul>
+*   <li>A resource that you can publish messages to and then consume those messages via subscriptions.
+*   <li>An isolated data stream for pub/sub messages.
+*   <li>Messages are published to a topic.
+*   <li>Messages are listened to via a subscription.
+*   <li>Each subscription listens to the messages published to exactly one topic.
+*
+* Subscriptions - Resource that listens to the messages published by exactly one topic.
+*
+* [More info here](https://firebase.google.com/docs/functions/pubsub-events)
+*/
+/**
+* Interface representing a Google Cloud Pub/Sub message.
+*
+* @param data - Payload of a Pub/Sub message.
+* @typeParam T - Type representing `Message.data`'s JSON format
+*/
+var Message = class {
+	/**
+	* @hidden
+	* @alpha
+	*/
+	constructor(data) {
+		this.messageId = data.messageId;
+		this.data = data.data;
+		this.attributes = data.attributes || {};
+		this.orderingKey = data.orderingKey || "";
+		this.publishTime = data.publishTime || new Date().toISOString();
+		this._json = data.json;
+	}
+	/**
+	* The JSON data payload of this message object, if any.
+	*/
+	get json() {
+		if (typeof this._json === "undefined") {
+			try {
+				this._json = JSON.parse(Buffer.from(this.data, "base64").toString("utf8"));
+			} catch (err) {
+				throw new Error(`Unable to parse Pub/Sub message data as JSON: ${err.message}`);
+			}
+		}
+		return this._json;
+	}
+	/**
+	* Returns a JSON-serializable representation of this object.
+	*
+	* @returns A JSON-serializable representation of this object.
+	*/
+	toJSON() {
+		const json = {
+			messageId: this.messageId,
+			data: this.data,
+			publishTime: this.publishTime
+		};
+		if (Object.keys(this.attributes).length) {
+			json.attributes = this.attributes;
+		}
+		if (this.orderingKey) {
+			json.orderingKey = this.orderingKey;
+		}
+		return json;
+	}
+};
+/**
+* Handle a message being published to a Pub/Sub topic.
+* @param topicOrOptions - A string representing the PubSub topic or an option (which contains the topic)
+* @param handler - runs every time a Cloud Pub/Sub message is published
+* @typeParam T - Type representing `Message.data`'s JSON format
+*/
+function onMessagePublished(topicOrOptions, handler) {
+	let topic;
+	let opts;
+	if (typeof topicOrOptions === "string") {
+		topic = topicOrOptions;
+		opts = {};
+	} else {
+		topic = topicOrOptions.topic;
+		opts = { ...topicOrOptions };
+		delete opts.topic;
+	}
+	const func = (raw) => {
+		const messagePublishedData = raw.data;
+		messagePublishedData.message = new Message(messagePublishedData.message);
+		return wrapTraceContext(withInit(handler))(raw);
+	};
+	func.run = handler;
+	Object.defineProperty(func, "__trigger", { get: () => {
+		const baseOpts$1 = optionsToTriggerAnnotations(getGlobalOptions());
+		const specificOpts$1 = optionsToTriggerAnnotations(opts);
+		return {
+			platform: "gcfv2",
+			...baseOpts$1,
+			...specificOpts$1,
+			labels: {
+				...baseOpts$1?.labels,
+				...specificOpts$1?.labels
+			},
+			eventTrigger: {
+				eventType: "google.cloud.pubsub.topic.v1.messagePublished",
+				resource: `projects/${process.env.GCLOUD_PROJECT}/topics/${topic}`
+			}
+		};
+	} });
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	const endpoint = {
+		...initV2Endpoint(getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType: "google.cloud.pubsub.topic.v1.messagePublished",
+			eventFilters: { topic },
+			retry: opts.retry ?? false
+		}
+	};
+	copyIfPresent(endpoint.eventTrigger, opts, "retry", "retry");
+	func.__endpoint = endpoint;
+	return func;
+}
+
+//#endregion
+export { Message, onMessagePublished, pubsub_exports };

package/lib/esm/v2/providers/remoteConfig.mjs

@@ -0,0 +1,52 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+
+//#region src/v2/providers/remoteConfig.ts
+var remoteConfig_exports = /* @__PURE__ */ __export({
+	eventType: () => eventType,
+	onConfigUpdated: () => onConfigUpdated
+});
+/** @internal */
+const eventType = "google.firebase.remoteconfig.remoteConfig.v1.updated";
+/**
+* Event handler which triggers when data is updated in a Remote Config.
+*
+* @param optsOrHandler - Options or an event handler.
+* @param handler - Event handler which is run every time a Remote Config update occurs.
+* @returns A function that you can export and deploy.
+*/
+function onConfigUpdated(optsOrHandler, handler) {
+	if (typeof optsOrHandler === "function") {
+		handler = optsOrHandler;
+		optsOrHandler = {};
+	}
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(optsOrHandler);
+	const func = wrapTraceContext(withInit((raw) => {
+		return handler(raw);
+	}));
+	func.run = handler;
+	const ep = {
+		...initV2Endpoint(getGlobalOptions(), optsOrHandler),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters: {},
+			retry: optsOrHandler.retry ?? false
+		}
+	};
+	func.__endpoint = ep;
+	return func;
+}
+
+//#endregion
+export { eventType, onConfigUpdated, remoteConfig_exports };

package/lib/esm/v2/providers/scheduler.mjs

@@ -0,0 +1,84 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { error } from "../../logger/index.mjs";
+import { initV2Endpoint, initV2ScheduleTrigger } from "../../runtime/manifest.mjs";
+import { copyIfPresent } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
+
+//#region src/v2/providers/scheduler.ts
+var scheduler_exports = /* @__PURE__ */ __export({
+	getOpts: () => getOpts,
+	onSchedule: () => onSchedule
+});
+/** @internal */
+function getOpts(args) {
+	if (typeof args === "string") {
+		return {
+			schedule: args,
+			opts: {}
+		};
+	}
+	return {
+		schedule: args.schedule,
+		timeZone: args.timeZone,
+		retryConfig: {
+			retryCount: args.retryCount,
+			maxRetrySeconds: args.maxRetrySeconds,
+			minBackoffSeconds: args.minBackoffSeconds,
+			maxBackoffSeconds: args.maxBackoffSeconds,
+			maxDoublings: args.maxDoublings
+		},
+		opts: args
+	};
+}
+/**
+* Handler for scheduled functions. Triggered whenever the associated
+* scheduler job sends a http request.
+* @param args - Either a schedule or an object containing function options.
+* @param handler - A function to execute when triggered.
+* @returns A function that you can export and deploy.
+*/
+function onSchedule(args, handler) {
+	const separatedOpts = getOpts(args);
+	const httpFunc = async (req, res) => {
+		const event = {
+			jobName: req.header("X-CloudScheduler-JobName") || undefined,
+			scheduleTime: req.header("X-CloudScheduler-ScheduleTime") || new Date().toISOString()
+		};
+		try {
+			await handler(event);
+			res.status(200).send();
+		} catch (err) {
+			error(err.message);
+			res.status(500).send();
+		}
+	};
+	const func = wrapTraceContext(withInit(httpFunc));
+	func.run = handler;
+	const globalOpts = getGlobalOptions();
+	const baseOptsEndpoint = optionsToEndpoint(globalOpts);
+	const specificOptsEndpoint = optionsToEndpoint(separatedOpts.opts);
+	const ep = {
+		...initV2Endpoint(globalOpts, separatedOpts.opts),
+		platform: "gcfv2",
+		...baseOptsEndpoint,
+		...specificOptsEndpoint,
+		labels: {
+			...baseOptsEndpoint?.labels,
+			...specificOptsEndpoint?.labels
+		},
+		scheduleTrigger: initV2ScheduleTrigger(separatedOpts.schedule, globalOpts, separatedOpts.opts)
+	};
+	copyIfPresent(ep.scheduleTrigger, separatedOpts, "timeZone");
+	copyIfPresent(ep.scheduleTrigger.retryConfig, separatedOpts.retryConfig, "retryCount", "maxRetrySeconds", "minBackoffSeconds", "maxBackoffSeconds", "maxDoublings");
+	func.__endpoint = ep;
+	func.__requiredAPIs = [{
+		api: "cloudscheduler.googleapis.com",
+		reason: "Needed for scheduled functions."
+	}];
+	return func;
+}
+
+//#endregion
+export { getOpts, onSchedule, scheduler_exports };