firebase-functions 7.2.2 → 7.2.3

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

@@ -2,6 +2,7 @@ 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 { addV1Compat } from "../compat.mjs";
 import { getGlobalOptions, optionsToEndpoint } from "../options.mjs";
 
 //#region src/v2/providers/remoteConfig.ts
@@ -26,7 +27,23 @@ function onConfigUpdated(optsOrHandler, handler) {
 	const baseOpts = optionsToEndpoint(getGlobalOptions());
 	const specificOpts = optionsToEndpoint(optsOrHandler);
 	const func = wrapTraceContext(withInit((raw) => {
-		return handler(raw);
+		const event = raw;
+		const patchedEvent = addV1Compat(event, {
+			context: () => {
+				return {
+					eventId: event.id,
+					timestamp: event.time,
+					eventType: "google.firebase.remoteconfig.update",
+					resource: {
+						service: "firebaseremoteconfig.googleapis.com",
+						name: event.subject || ""
+					},
+					params: {}
+				};
+			},
+			version: () => event.data
+		});
+		return handler(patchedEvent);
 	}));
 	func.run = handler;
 	const ep = {

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

@@ -46,6 +46,18 @@ function onSchedule(args, handler) {
 			jobName: req.header("X-CloudScheduler-JobName") || undefined,
 			scheduleTime: req.header("X-CloudScheduler-ScheduleTime") || new Date().toISOString()
 		};
+		const jobName = event.jobName || "unknown-job";
+		const v1Context = {
+			eventId: jobName,
+			timestamp: event.scheduleTime,
+			eventType: "google.pubsub.topic.publish",
+			resource: {
+				service: "pubsub.googleapis.com",
+				name: `projects/${process.env.GCLOUD_PROJECT}/topics/${jobName}`
+			},
+			params: {}
+		};
+		Object.defineProperty(event, "context", { get: () => v1Context });
 		try {
 			await handler(event);
 			res.status(200).send();

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

@@ -4,6 +4,7 @@ import { firebaseConfig } from "../../common/config.mjs";
 import { copyIfPresent } from "../../common/encoding.mjs";
 import { withInit } from "../../common/onInit.mjs";
 import { wrapTraceContext } from "../trace.mjs";
+import { addV1Compat } from "../compat.mjs";
 import { getGlobalOptions, optionsToEndpoint, optionsToTriggerAnnotations } from "../options.mjs";
 
 //#region src/v2/providers/storage.ts
@@ -86,7 +87,29 @@ function onOperation(eventType, bucketOrOptsOrHandler, handler) {
 	}
 	const [opts, bucket] = getOptsAndBucket(bucketOrOptsOrHandler);
 	const func = (raw) => {
-		return wrapTraceContext(withInit(handler))(raw);
+		const storageEvent = raw;
+		const event = addV1Compat(storageEvent, {
+			context: () => {
+				const bucketName = storageEvent.bucket;
+				return {
+					eventId: storageEvent.id,
+					timestamp: storageEvent.time,
+					eventType: {
+						[archivedEvent]: "google.storage.object.archive",
+						[finalizedEvent]: "google.storage.object.finalize",
+						[deletedEvent]: "google.storage.object.delete",
+						[metadataUpdatedEvent]: "google.storage.object.metadataUpdate"
+					}[eventType] || eventType,
+					resource: {
+						service: "storage.googleapis.com",
+						name: `projects/_/buckets/${bucketName}/objects/${storageEvent.data.name}#${storageEvent.data.generation}`
+					},
+					params: {}
+				};
+			},
+			object: () => storageEvent.data
+		});
+		return wrapTraceContext(withInit(handler))(event);
 	};
 	func.run = handler;
 	Object.defineProperty(func, "__trigger", { get: () => {

package/lib/v2/compat.d.ts

@@ -1,15 +1,17 @@
 import { CloudEvent } from "./core";
-import { MessagePublishedData, V1PubSubMessage } from "./providers/pubsub";
 import { EventContext as V1EventContext } from "../v1";
-export interface V1Context extends Omit<V1EventContext, "resource"> {
-    resource: {
-        service: string;
-        name: string;
-    };
-}
-export type PubSubCloudEvent<T> = CloudEvent<MessagePublishedData<T>> & {
-    context: V1Context;
-    message: V1PubSubMessage<T>;
+export type V1Compat<DataName extends string, DataType, ContextType = V1EventContext> = {
+    [K in DataName]: DataType;
+} & {
+    context: ContextType;
+};
+/**
+ * Patches a CloudEvent with V1 compatibility properties via getters.
+ * This function ensures idempotency by using a Symbol to mark already patched events.
+ * @param event The CloudEvent to patch.
+ * @param getters A map of getters to attach to the event object.
+ * @returns The patched CloudEvent with V1 compatibility properties.
+ */
+export declare function addV1Compat<T extends CloudEvent<unknown>, U extends Record<string, () => any>>(event: T, getters: U): T & {
+    [K in keyof U]: ReturnType<U[K]>;
 };
-export declare function patchV1Compat<T>(event: CloudEvent<MessagePublishedData<T>>): PubSubCloudEvent<T>;
-export declare function patchV1Compat<T>(event: CloudEvent<T>): CloudEvent<T>;

package/lib/v2/compat.js

@@ -1,14 +1,14 @@
-const require_v2_providers_pubsub = require('./providers/pubsub.js');
 
 //#region src/v2/compat.ts
 const V1_COMPAT_PATCHED = Symbol.for("firebase.functions.v2.compat");
 /**
-* Patches a CloudEvent with V1 compatibility properties (context and message) if it's a supported type (e.g., Pub/Sub).
+* Patches a CloudEvent with V1 compatibility properties via getters.
 * This function ensures idempotency by using a Symbol to mark already patched events.
-* @param event The CloudEvent to potentially patch.
-* @returns The patched CloudEvent with V1 compatibility properties, or the original event if not a supported event type or already patched.
+* @param event The CloudEvent to patch.
+* @param getters A map of getters to attach to the event object.
+* @returns The patched CloudEvent with V1 compatibility properties.
 */
-function patchV1Compat(event) {
+function addV1Compat(event, getters) {
 	if (event[V1_COMPAT_PATCHED]) {
 		return event;
 	}
@@ -18,60 +18,21 @@ function patchV1Compat(event) {
 		writable: false,
 		configurable: false
 	});
-	switch (event.type) {
-		case "google.cloud.pubsub.topic.v1.messagePublished": {
-			const pubsubEvent = event;
-			const pubsubData = pubsubEvent.data;
-			if (!pubsubData || !pubsubData.message) {
-				throw new Error("Malformed Pub/Sub event: missing 'message' property.");
-			}
-			if (!(pubsubData.message instanceof require_v2_providers_pubsub.Message)) {
-				pubsubData.message = new require_v2_providers_pubsub.Message(pubsubData.message);
-			}
-			const v2Message = pubsubData.message;
-			Object.defineProperty(pubsubEvent, "context", {
-				get: () => {
-					const service = "pubsub.googleapis.com";
-					const sourcePrefix = `//${service}/`;
-					return {
-						eventId: v2Message.messageId,
-						timestamp: v2Message.publishTime,
-						eventType: "google.pubsub.topic.publish",
-						resource: {
-							service,
-							name: event.source?.startsWith(sourcePrefix) ? event.source.substring(sourcePrefix.length) : event.source || ""
-						},
-						params: {}
-					};
-				},
-				configurable: true,
-				enumerable: true
-			});
-			Object.defineProperty(pubsubEvent, "message", {
-				get: () => {
-					const baseV1Message = {
-						data: v2Message.data,
-						messageId: v2Message.messageId,
-						publishTime: v2Message.publishTime,
-						attributes: v2Message.attributes,
-						...v2Message.orderingKey && { orderingKey: v2Message.orderingKey }
-					};
-					return {
-						...baseV1Message,
-						get json() {
-							return v2Message.json;
-						},
-						toJSON: () => baseV1Message
-					};
-				},
-				configurable: true,
-				enumerable: true
-			});
-			return pubsubEvent;
-		}
-		default: return event;
+	const memo = {};
+	for (const [key, getter] of Object.entries(getters)) {
+		Object.defineProperty(event, key, {
+			get: () => {
+				if (!Object.prototype.hasOwnProperty.call(memo, key)) {
+					memo[key] = getter();
+				}
+				return memo[key];
+			},
+			configurable: true,
+			enumerable: true
+		});
 	}
+	return event;
 }
 
 //#endregion
-exports.patchV1Compat = patchV1Compat;
+exports.addV1Compat = addV1Compat;

package/lib/v2/index.d.ts

@@ -26,7 +26,6 @@ export { onInit } from "./core";
 export type { CloudFunction, CloudEvent, ParamsOf } from "./core";
 export { Change } from "../common/change";
 export { traceContext } from "../common/trace";
-export type { PubSubCloudEvent } from "./compat";
 import * as params from "../params";
 export { params };
 export { config } from "../v1/config";

package/lib/v2/index.doc.js

@@ -5,13 +5,13 @@ const require_common_change = require('../common/change.js');
 const require_common_onInit = require('../common/onInit.js');
 const require_v1_config = require('../v1/config.js');
 const require_v2_options = require('./options.js');
-const require_v2_providers_pubsub = require('./providers/pubsub.js');
 const require_v2_dataconnect_doc = require('./dataconnect.doc.js');
 const require_v2_providers_alerts_index = require('./providers/alerts/index.js');
 const require_v2_providers_database = require('./providers/database.js');
 const require_v2_providers_eventarc = require('./providers/eventarc.js');
 const require_v2_providers_https = require('./providers/https.js');
 const require_v2_providers_identity = require('./providers/identity.js');
+const require_v2_providers_pubsub = require('./providers/pubsub.js');
 const require_v2_providers_scheduler = require('./providers/scheduler.js');
 const require_v2_providers_storage = require('./providers/storage.js');
 const require_v2_providers_tasks = require('./providers/tasks.js');

package/lib/v2/index.js

@@ -5,15 +5,15 @@ const require_common_app = require('../common/app.js');
 const require_common_change = require('../common/change.js');
 const require_common_onInit = require('../common/onInit.js');
 const require_v1_config = require('../v1/config.js');
-const require_v2_options = require('./options.js');
-const require_v2_providers_pubsub = require('./providers/pubsub.js');
 require('./core.js');
+const require_v2_options = require('./options.js');
 const require_v2_providers_dataconnect_index = require('./providers/dataconnect/index.js');
 const require_v2_providers_alerts_index = require('./providers/alerts/index.js');
 const require_v2_providers_database = require('./providers/database.js');
 const require_v2_providers_eventarc = require('./providers/eventarc.js');
 const require_v2_providers_https = require('./providers/https.js');
 const require_v2_providers_identity = require('./providers/identity.js');
+const require_v2_providers_pubsub = require('./providers/pubsub.js');
 const require_v2_providers_scheduler = require('./providers/scheduler.js');
 const require_v2_providers_storage = require('./providers/storage.js');
 const require_v2_providers_tasks = require('./providers/tasks.js');

package/lib/v2/providers/ai/index.d.ts

@@ -0,0 +1,53 @@
+import { CloudEvent } from "../../core";
+import { HttpsFunction, HttpsError, FunctionsErrorCode } from "../https";
+import { EventHandlerOptions } from "../../options";
+import { Expression } from "../../../params";
+import { ResetValue } from "../../../common/options";
+export { HttpsError };
+export declare const rpcCodeMap: Record<FunctionsErrorCode, number>;
+import { GenerateContentRequest as VertexV1Beta1GenerateContentRequest, GenerateContentResponse as VertexV1Beta1GenerateContentResponse } from "./types/vertex/v1beta1";
+import { GenerateContentRequest as GeminiV1BetaGenerateContentRequest, GenerateContentResponse as GeminiV1BetaGenerateContentResponse } from "./types/gemini/v1beta";
+export { VertexV1Beta1GenerateContentRequest, VertexV1Beta1GenerateContentResponse, GeminiV1BetaGenerateContentRequest, GeminiV1BetaGenerateContentResponse, };
+type MultipleLocationsIf<Allowed extends boolean> = Allowed extends true ? string[] : never;
+export interface WebhookOptions<Regional extends boolean = false> extends Omit<EventHandlerOptions, "location"> {
+    location?: string | Expression<string> | MultipleLocationsIf<Regional> | ResetValue;
+    regionalWebhook?: Regional;
+}
+export interface PromptTemplateInfo {
+    templateName?: string;
+}
+export type AuthType = "app_user" | "unauthenticated" | "unknown";
+export declare const beforeGenerateEventType = "google.firebase.ailogic.v1.beforeGenerate";
+export declare const afterGenerateEventType = "google.firebase.ailogic.v1.afterGenerate";
+export type AnyValidAIRequest = GeminiV1BetaGenerateContentRequest | VertexV1Beta1GenerateContentRequest;
+export type AnyValidAIResponse = GeminiV1BetaGenerateContentResponse | VertexV1Beta1GenerateContentResponse;
+export declare const geminiV1Beta = "google.ai.generativelanguage.v1beta";
+export declare const vertexV1Beta1 = "google.cloud.aiplatform.v1beta1";
+export type SupportedAPI = typeof geminiV1Beta | typeof vertexV1Beta1;
+export type AIRequest<API> = string extends API ? AnyValidAIRequest : API extends typeof geminiV1Beta ? GeminiV1BetaGenerateContentRequest : API extends typeof vertexV1Beta1 ? VertexV1Beta1GenerateContentRequest : never;
+export type AIResponse<API> = string extends API ? AnyValidAIResponse : API extends typeof geminiV1Beta ? GeminiV1BetaGenerateContentResponse : API extends typeof vertexV1Beta1 ? VertexV1Beta1GenerateContentResponse : never;
+export interface BeforeGenerateContentData<API extends string = string> {
+    model: string;
+    template?: PromptTemplateInfo;
+    api: SupportedAPI;
+    request: AIRequest<API>;
+}
+export interface AfterGenerateContentData<API extends string = string> extends BeforeGenerateContentData<API> {
+    response: AIResponse<API>;
+}
+export interface AIBlockingEvent<T = any> extends CloudEvent<T> {
+    authType: AuthType;
+    authId?: string;
+    authClaims?: any;
+    resourceName?: string;
+    appId?: string;
+    displayName?: string;
+    androidPackageName?: string;
+    iosBundleId?: string;
+}
+type MaybeAsync<T> = T | Promise<T>;
+export type BlockingFunction = HttpsFunction;
+export declare function beforeGenerateContent(callback: (event: AIBlockingEvent<BeforeGenerateContentData>) => MaybeAsync<void | Partial<AnyValidAIRequest>>): BlockingFunction;
+export declare function beforeGenerateContent<Regional extends boolean = false>(options: WebhookOptions<Regional>, callback: (event: AIBlockingEvent<BeforeGenerateContentData>) => MaybeAsync<void | Partial<AnyValidAIRequest>>): BlockingFunction;
+export declare function afterGenerateContent(callback: (event: AIBlockingEvent<AfterGenerateContentData>) => MaybeAsync<void | Partial<AnyValidAIResponse>>): BlockingFunction;
+export declare function afterGenerateContent<Regional extends boolean = false>(options: WebhookOptions<Regional>, callback: (event: AIBlockingEvent<AfterGenerateContentData>) => MaybeAsync<void | Partial<AnyValidAIResponse>>): BlockingFunction;

package/lib/v2/providers/ai/index.js

@@ -0,0 +1,198 @@
+const require_logger_index = require('../../../logger/index.js');
+const require_runtime_manifest = require('../../../runtime/manifest.js');
+const require_common_onInit = require('../../../common/onInit.js');
+const require_common_providers_https = require('../../../common/providers/https.js');
+const require_v2_trace = require('../../trace.js');
+const require_v2_options = require('../../options.js');
+require('../https.js');
+const require_v2_providers_ai_types_vertex_v1beta1_index = require('./types/vertex/v1beta1/index.js');
+const require_v2_providers_ai_types_gemini_v1beta_index = require('./types/gemini/v1beta/index.js');
+
+//#region src/v2/providers/ai/index.ts
+const rpcCodeMap = {
+	ok: 0,
+	cancelled: 1,
+	unknown: 2,
+	"invalid-argument": 3,
+	"deadline-exceeded": 4,
+	"not-found": 5,
+	"already-exists": 6,
+	"permission-denied": 7,
+	unauthenticated: 16,
+	"resource-exhausted": 8,
+	"failed-precondition": 9,
+	aborted: 10,
+	"out-of-range": 11,
+	unimplemented: 12,
+	internal: 13,
+	unavailable: 14,
+	"data-loss": 15
+};
+const beforeGenerateEventType = "google.firebase.ailogic.v1.beforeGenerate";
+const afterGenerateEventType = "google.firebase.ailogic.v1.afterGenerate";
+const geminiV1Beta = "google.ai.generativelanguage.v1beta";
+const vertexV1Beta1 = "google.cloud.aiplatform.v1beta1";
+function beforeGenerateContent(optsOrCb, cb) {
+	let opts;
+	let handler;
+	if (arguments.length === 1) {
+		opts = {};
+		handler = optsOrCb;
+	} else {
+		opts = optsOrCb;
+		handler = cb;
+	}
+	let func = async (req, res) => {
+		try {
+			let event = req.body;
+			if (Buffer.isBuffer(event)) {
+				try {
+					event = JSON.parse(event.toString("utf-8"));
+				} catch (e) {
+					require_logger_index.error("Invalid JSON body (Buffer):", e);
+					throw new require_common_providers_https.HttpsError("invalid-argument", "Invalid JSON body", e);
+				}
+			} else if (typeof event === "string") {
+				try {
+					event = JSON.parse(event);
+				} catch (e) {
+					require_logger_index.error("Invalid JSON body (String):", e);
+					throw new require_common_providers_https.HttpsError("invalid-argument", "Invalid JSON body", e);
+				}
+			}
+			const parsedEvent = event;
+			const result = await handler(parsedEvent);
+			const responseBody = result || {};
+			if (typeof responseBody === "object") {
+				const api = parsedEvent.data?.api;
+				if (api === geminiV1Beta) {
+					responseBody["@type"] = require_v2_providers_ai_types_gemini_v1beta_index.requestTypeName;
+				} else if (api === vertexV1Beta1) {
+					responseBody["@type"] = require_v2_providers_ai_types_vertex_v1beta1_index.requestTypeName;
+				}
+			}
+			res.status(200).send(responseBody);
+		} catch (err) {
+			require_logger_index.error("Unhandled error:", err);
+			if (err instanceof require_common_providers_https.HttpsError) {
+				res.status(500).send({
+					code: rpcCodeMap[err.code] || 13,
+					message: err.message
+				});
+			} else {
+				res.status(500).send({
+					code: 13,
+					message: "Internal error."
+				});
+			}
+		}
+	};
+	func.run = handler;
+	func = require_v2_trace.wrapTraceContext(require_common_onInit.withInit(func));
+	const baseOpts = require_v2_options.optionsToEndpoint(require_v2_options.getGlobalOptions());
+	const specificOpts = require_v2_options.optionsToEndpoint(opts);
+	func.__endpoint = {
+		...require_runtime_manifest.initV2Endpoint(require_v2_options.getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		blockingTrigger: {
+			eventType: beforeGenerateEventType,
+			options: { regionalWebhook: opts.regionalWebhook }
+		}
+	};
+	return func;
+}
+function afterGenerateContent(optsOrCb, cb) {
+	let opts;
+	let handler;
+	if (arguments.length === 1) {
+		opts = {};
+		handler = optsOrCb;
+	} else {
+		opts = optsOrCb;
+		handler = cb;
+	}
+	let func = async (req, res) => {
+		try {
+			let event = req.body;
+			if (Buffer.isBuffer(event)) {
+				try {
+					event = JSON.parse(event.toString("utf-8"));
+				} catch (e) {
+					require_logger_index.error("Invalid JSON body (Buffer):", e);
+					throw new require_common_providers_https.HttpsError("invalid-argument", "Invalid JSON body", e);
+				}
+			} else if (typeof event === "string") {
+				try {
+					event = JSON.parse(event);
+				} catch (e) {
+					require_logger_index.error("Invalid JSON body (String):", e);
+					throw new require_common_providers_https.HttpsError("invalid-argument", "Invalid JSON body", e);
+				}
+			}
+			const parsedEvent = event;
+			const result = await handler(parsedEvent);
+			const responseBody = result || {};
+			if (typeof responseBody === "object") {
+				const api = parsedEvent.data?.api;
+				if (api === geminiV1Beta) {
+					responseBody["@type"] = require_v2_providers_ai_types_gemini_v1beta_index.responseTypeName;
+				} else if (api === vertexV1Beta1) {
+					responseBody["@type"] = require_v2_providers_ai_types_vertex_v1beta1_index.responseTypeName;
+				}
+			}
+			res.status(200).send(responseBody);
+		} catch (err) {
+			require_logger_index.error("Unhandled error:", err);
+			if (err instanceof require_common_providers_https.HttpsError) {
+				res.status(500).send({
+					code: rpcCodeMap[err.code] || 13,
+					message: err.message
+				});
+			} else {
+				res.status(500).send({
+					code: 13,
+					message: "Internal error."
+				});
+			}
+		}
+	};
+	func.run = handler;
+	func = require_v2_trace.wrapTraceContext(require_common_onInit.withInit(func));
+	const baseOpts = require_v2_options.optionsToEndpoint(require_v2_options.getGlobalOptions());
+	const specificOpts = require_v2_options.optionsToEndpoint(opts);
+	func.__endpoint = {
+		...require_runtime_manifest.initV2Endpoint(require_v2_options.getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		blockingTrigger: {
+			eventType: afterGenerateEventType,
+			options: { regionalWebhook: opts.regionalWebhook }
+		}
+	};
+	return func;
+}
+
+//#endregion
+exports.GeminiV1BetaGenerateContentRequest = GeminiV1BetaGenerateContentRequest;
+exports.GeminiV1BetaGenerateContentResponse = GeminiV1BetaGenerateContentResponse;
+exports.HttpsError = require_common_providers_https.HttpsError;
+exports.VertexV1Beta1GenerateContentRequest = VertexV1Beta1GenerateContentRequest;
+exports.VertexV1Beta1GenerateContentResponse = VertexV1Beta1GenerateContentResponse;
+exports.afterGenerateContent = afterGenerateContent;
+exports.afterGenerateEventType = afterGenerateEventType;
+exports.beforeGenerateContent = beforeGenerateContent;
+exports.beforeGenerateEventType = beforeGenerateEventType;
+exports.geminiV1Beta = geminiV1Beta;
+exports.rpcCodeMap = rpcCodeMap;
+exports.vertexV1Beta1 = vertexV1Beta1;