firebase-functions 6.6.0 → 7.0.0-rc.0

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

@@ -0,0 +1,131 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { Change } from "../../common/change.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+import { createBeforeSnapshotFromJson, createSnapshotFromJson } from "../../common/providers/firestore.mjs";
+import { posix } from "path";
+
+//#region src/v1/providers/firestore.ts
+var firestore_exports = /* @__PURE__ */ __export({
+	DatabaseBuilder: () => DatabaseBuilder,
+	DocumentBuilder: () => DocumentBuilder,
+	NamespaceBuilder: () => NamespaceBuilder,
+	_databaseWithOptions: () => _databaseWithOptions,
+	_documentWithOptions: () => _documentWithOptions,
+	_namespaceWithOptions: () => _namespaceWithOptions,
+	beforeSnapshotConstructor: () => beforeSnapshotConstructor,
+	database: () => database,
+	defaultDatabase: () => defaultDatabase,
+	document: () => document,
+	namespace: () => namespace,
+	provider: () => provider,
+	service: () => service,
+	snapshotConstructor: () => snapshotConstructor
+});
+/** @internal */
+const provider = "google.firestore";
+/** @internal */
+const service = "firestore.googleapis.com";
+/** @internal */
+const defaultDatabase = "(default)";
+/**
+* Select the Firestore document to listen to for events.
+* @param path Full database path to listen to. This includes the name of
+* the collection that the document is a part of. For example, if the
+* collection is named "users" and the document is named "Ada", then the
+* path is "/users/Ada".
+*/
+function document(path) {
+	return _documentWithOptions(path, {});
+}
+function namespace(namespace$1) {
+	return _namespaceWithOptions(namespace$1, {});
+}
+function database(database$1) {
+	return _databaseWithOptions(database$1, {});
+}
+/** @internal */
+function _databaseWithOptions(database$1 = defaultDatabase, options) {
+	return new DatabaseBuilder(database$1, options);
+}
+/** @internal */
+function _namespaceWithOptions(namespace$1, options) {
+	return _databaseWithOptions(defaultDatabase, options).namespace(namespace$1);
+}
+/** @internal */
+function _documentWithOptions(path, options) {
+	return _databaseWithOptions(defaultDatabase, options).document(path);
+}
+var DatabaseBuilder = class {
+	constructor(database$1, options) {
+		this.database = database$1;
+		this.options = options;
+	}
+	namespace(namespace$1) {
+		return new NamespaceBuilder(this.database, this.options, namespace$1);
+	}
+	document(path) {
+		return new NamespaceBuilder(this.database, this.options).document(path);
+	}
+};
+var NamespaceBuilder = class {
+	constructor(database$1, options, namespace$1) {
+		this.database = database$1;
+		this.options = options;
+		this.namespace = namespace$1;
+	}
+	document(path) {
+		return new DocumentBuilder(() => {
+			if (!process.env.GCLOUD_PROJECT) {
+				throw new Error("process.env.GCLOUD_PROJECT is not set.");
+			}
+			const database$1 = posix.join("projects", process.env.GCLOUD_PROJECT, "databases", this.database);
+			return posix.join(database$1, this.namespace ? `documents@${this.namespace}` : "documents", path);
+		}, this.options);
+	}
+};
+function snapshotConstructor(event) {
+	return createSnapshotFromJson(event.data, event.context.resource.name, event?.data?.value?.readTime, event?.data?.value?.updateTime);
+}
+function beforeSnapshotConstructor(event) {
+	return createBeforeSnapshotFromJson(event.data, event.context.resource.name, event?.data?.oldValue?.readTime, undefined);
+}
+function changeConstructor(raw) {
+	return Change.fromObjects(beforeSnapshotConstructor(raw), snapshotConstructor(raw));
+}
+var DocumentBuilder = class {
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/** Respond to all document writes (creates, updates, or deletes). */
+	onWrite(handler) {
+		return this.onOperation(handler, "document.write", changeConstructor);
+	}
+	/** Respond only to document updates. */
+	onUpdate(handler) {
+		return this.onOperation(handler, "document.update", changeConstructor);
+	}
+	/** Respond only to document creations. */
+	onCreate(handler) {
+		return this.onOperation(handler, "document.create", snapshotConstructor);
+	}
+	/** Respond only to document deletions. */
+	onDelete(handler) {
+		return this.onOperation(handler, "document.delete", beforeSnapshotConstructor);
+	}
+	onOperation(handler, eventType, dataConstructor) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			eventType,
+			service,
+			triggerResource: this.triggerResource,
+			legacyEventType: `providers/cloud.firestore/eventTypes/${eventType}`,
+			dataConstructor,
+			options: this.options
+		});
+	}
+};
+
+//#endregion
+export { DatabaseBuilder, DocumentBuilder, NamespaceBuilder, _databaseWithOptions, _documentWithOptions, _namespaceWithOptions, beforeSnapshotConstructor, database, defaultDatabase, document, firestore_exports, namespace, provider, service, snapshotConstructor };

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

@@ -0,0 +1,82 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV1Endpoint } from "../../runtime/manifest.mjs";
+import { convertIfPresent, convertInvoker } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { optionsToEndpoint, optionsToTrigger } from "../cloud-functions.mjs";
+import { HttpsError, onCallHandler, withErrorHandler } from "../../common/providers/https.mjs";
+import { wrapTraceContext } from "../../v2/trace.mjs";
+
+//#region src/v1/providers/https.ts
+var https_exports = /* @__PURE__ */ __export({
+	HttpsError: () => HttpsError,
+	_onCallWithOptions: () => _onCallWithOptions,
+	_onRequestWithOptions: () => _onRequestWithOptions,
+	onCall: () => onCall,
+	onRequest: () => onRequest
+});
+/**
+* Handle HTTP requests.
+* @param handler A function that takes a request and response object,
+* same signature as an Express app.
+*/
+function onRequest(handler) {
+	return _onRequestWithOptions(handler, {});
+}
+/**
+* Declares a callable method for clients to call using a Firebase SDK.
+* @param handler A method that takes a data and context and returns a value.
+*/
+function onCall(handler) {
+	return _onCallWithOptions(handler, {});
+}
+/** @internal */
+function _onRequestWithOptions(handler, options) {
+	const cloudFunction = (req, res) => {
+		return wrapTraceContext(withInit(withErrorHandler(handler)))(req, res);
+	};
+	cloudFunction.__trigger = {
+		...optionsToTrigger(options),
+		httpsTrigger: {}
+	};
+	convertIfPresent(cloudFunction.__trigger.httpsTrigger, options, "invoker", "invoker", convertInvoker);
+	cloudFunction.__endpoint = {
+		platform: "gcfv1",
+		...initV1Endpoint(options),
+		...optionsToEndpoint(options),
+		httpsTrigger: {}
+	};
+	convertIfPresent(cloudFunction.__endpoint.httpsTrigger, options, "invoker", "invoker", convertInvoker);
+	return cloudFunction;
+}
+/** @internal */
+function _onCallWithOptions(handler, options) {
+	const fixedLen = (data, context) => {
+		return withInit(handler)(data, context);
+	};
+	const func = wrapTraceContext(onCallHandler({
+		enforceAppCheck: options.enforceAppCheck,
+		consumeAppCheckToken: options.consumeAppCheckToken,
+		cors: {
+			origin: true,
+			methods: "POST"
+		}
+	}, fixedLen, "gcfv1"));
+	func.__trigger = {
+		labels: {},
+		...optionsToTrigger(options),
+		httpsTrigger: {}
+	};
+	func.__trigger.labels["deployment-callable"] = "true";
+	func.__endpoint = {
+		platform: "gcfv1",
+		labels: {},
+		...initV1Endpoint(options),
+		...optionsToEndpoint(options),
+		callableTrigger: {}
+	};
+	func.run = fixedLen;
+	return func;
+}
+
+//#endregion
+export { HttpsError, _onCallWithOptions, _onRequestWithOptions, https_exports, onCall, onRequest };

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

@@ -0,0 +1,175 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+
+//#region src/v1/providers/pubsub.ts
+var pubsub_exports = /* @__PURE__ */ __export({
+	Message: () => Message,
+	ScheduleBuilder: () => ScheduleBuilder,
+	TopicBuilder: () => TopicBuilder,
+	_scheduleWithOptions: () => _scheduleWithOptions,
+	_topicWithOptions: () => _topicWithOptions,
+	provider: () => provider,
+	schedule: () => schedule,
+	service: () => service,
+	topic: () => topic
+});
+/** @internal */
+const provider = "google.pubsub";
+/** @internal */
+const service = "pubsub.googleapis.com";
+/**
+* Registers a Cloud Function triggered when a Google Cloud Pub/Sub message
+* is sent to a specified topic.
+*
+* @param topic - The Pub/Sub topic to watch for message events.
+* @returns Pub/Sub topic builder interface.
+*/
+function topic(topic$1) {
+	return _topicWithOptions(topic$1, {});
+}
+/** @internal */
+function _topicWithOptions(topic$1, options) {
+	if (topic$1.indexOf("/") !== -1) {
+		throw new Error("Topic name may not have a /");
+	}
+	return new TopicBuilder(() => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return `projects/${process.env.GCLOUD_PROJECT}/topics/${topic$1}`;
+	}, options);
+}
+/**
+* The Google Cloud Pub/Sub topic builder.
+*
+* Access via `functions.pubsub.topic()`.
+*/
+var TopicBuilder = class {
+	/** @hidden */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/**
+	* Event handler that fires every time a Cloud Pub/Sub message is
+	* published.
+	*
+	* @param handler - Event handler that runs every time a Cloud Pub/Sub message
+	*   is published.
+	* @returns A function that you can export and deploy.
+	*/
+	onPublish(handler) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			service,
+			triggerResource: this.triggerResource,
+			eventType: "topic.publish",
+			dataConstructor: (raw) => new Message(raw.data),
+			options: this.options
+		});
+	}
+};
+/**
+* Registers a Cloud Function to run at specified times.
+*
+* @param schedule - The schedule, in Unix Crontab or AppEngine syntax.
+* @returns ScheduleBuilder interface.
+*/
+function schedule(schedule$1) {
+	return _scheduleWithOptions(schedule$1, {});
+}
+/** @internal */
+function _scheduleWithOptions(schedule$1, options) {
+	const triggerResource = () => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return `projects/${process.env.GCLOUD_PROJECT}/topics`;
+	};
+	return new ScheduleBuilder(triggerResource, {
+		...options,
+		schedule: { schedule: schedule$1 }
+	});
+}
+/**
+* The builder for scheduled functions, which are powered by
+* Google Pub/Sub and Cloud Scheduler. Describes the Cloud Scheduler
+* job that is deployed to trigger a scheduled function at the provided
+* frequency. For more information, see
+* [Schedule functions](/docs/functions/schedule-functions).
+*
+* Access via `functions.pubsub.schedule()`.
+*/
+var ScheduleBuilder = class {
+	/** @hidden */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	retryConfig(config) {
+		this.options.schedule.retryConfig = config;
+		return this;
+	}
+	timeZone(timeZone) {
+		this.options.schedule.timeZone = timeZone;
+		return this;
+	}
+	/**
+	* Event handler for scheduled functions. Triggered whenever the associated
+	* scheduler job sends a Pub/Sub message.
+	*
+	* @param handler - Handler that fires whenever the associated
+	*   scheduler job sends a Pub/Sub message.
+	* @returns A function that you can export and deploy.
+	*/
+	onRun(handler) {
+		const cloudFunction = makeCloudFunction({
+			contextOnlyHandler: handler,
+			provider,
+			service,
+			triggerResource: this.triggerResource,
+			eventType: "topic.publish",
+			options: this.options,
+			labels: { "deployment-scheduled": "true" }
+		});
+		return cloudFunction;
+	}
+};
+/**
+* Interface representing a Google Cloud Pub/Sub message.
+*
+* @param data - Payload of a Pub/Sub message.
+*/
+var Message = class {
+	constructor(data) {
+		[this.data, this.attributes, this._json] = [
+			data.data,
+			data.attributes || {},
+			data.json
+		];
+	}
+	/**
+	* The JSON data payload of this message object, if any.
+	*/
+	get json() {
+		if (typeof this._json === "undefined") {
+			this._json = JSON.parse(Buffer.from(this.data, "base64").toString("utf8"));
+		}
+		return this._json;
+	}
+	/**
+	* Returns a JSON-serializable representation of this object.
+	*
+	* @returns A JSON-serializable representation of this object.
+	*/
+	toJSON() {
+		return {
+			data: this.data,
+			attributes: this.attributes
+		};
+	}
+};
+
+//#endregion
+export { Message, ScheduleBuilder, TopicBuilder, _scheduleWithOptions, _topicWithOptions, provider, pubsub_exports, schedule, service, topic };

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

@@ -0,0 +1,64 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+
+//#region src/v1/providers/remoteConfig.ts
+var remoteConfig_exports = /* @__PURE__ */ __export({
+	UpdateBuilder: () => UpdateBuilder,
+	_onUpdateWithOptions: () => _onUpdateWithOptions,
+	onUpdate: () => onUpdate,
+	provider: () => provider,
+	service: () => service
+});
+/** @internal */
+const provider = "google.firebase.remoteconfig";
+/** @internal */
+const service = "firebaseremoteconfig.googleapis.com";
+/**
+* Registers a function that triggers on Firebase Remote Config template
+* update events.
+*
+* @param handler A function that takes the updated Remote Config
+*   template version metadata as an argument.
+*
+* @returns A function that you can export and deploy.
+*/
+function onUpdate(handler) {
+	return _onUpdateWithOptions(handler, {});
+}
+/** @internal */
+function _onUpdateWithOptions(handler, options) {
+	const triggerResource = () => {
+		if (!process.env.GCLOUD_PROJECT) {
+			throw new Error("process.env.GCLOUD_PROJECT is not set.");
+		}
+		return `projects/${process.env.GCLOUD_PROJECT}`;
+	};
+	return new UpdateBuilder(triggerResource, options).onUpdate(handler);
+}
+/** Builder used to create Cloud Functions for Remote Config. */
+var UpdateBuilder = class {
+	/** @internal */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/**
+	* Handle all updates (including rollbacks) that affect a Remote Config
+	* project.
+	* @param handler A function that takes the updated Remote Config template
+	* version metadata as an argument.
+	*/
+	onUpdate(handler) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			service,
+			triggerResource: this.triggerResource,
+			eventType: "update",
+			options: this.options
+		});
+	}
+};
+
+//#endregion
+export { UpdateBuilder, _onUpdateWithOptions, onUpdate, provider, remoteConfig_exports, service };

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

@@ -0,0 +1,163 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { firebaseConfig } from "../../common/config.mjs";
+import { makeCloudFunction } from "../cloud-functions.mjs";
+
+//#region src/v1/providers/storage.ts
+var storage_exports = /* @__PURE__ */ __export({
+	BucketBuilder: () => BucketBuilder,
+	ObjectBuilder: () => ObjectBuilder,
+	_bucketWithOptions: () => _bucketWithOptions,
+	_objectWithOptions: () => _objectWithOptions,
+	bucket: () => bucket,
+	object: () => object,
+	provider: () => provider,
+	service: () => service
+});
+/** @internal */
+const provider = "google.storage";
+/** @internal */
+const service = "storage.googleapis.com";
+/**
+* Registers a Cloud Function scoped to a specific storage bucket.
+*
+* @param bucket Name of the bucket to which this Cloud Function is
+*   scoped.
+*
+* @returns Storage bucket builder interface.
+*/
+function bucket(bucket$1) {
+	return _bucketWithOptions({}, bucket$1);
+}
+/**
+* Registers a Cloud Function scoped to the default storage bucket for the
+* project.
+*
+* @returns Storage object builder interface.
+*/
+function object() {
+	return _objectWithOptions({});
+}
+/** @internal */
+function _bucketWithOptions(options, bucket$1) {
+	const resourceGetter = () => {
+		bucket$1 = bucket$1 || firebaseConfig().storageBucket;
+		if (!bucket$1) {
+			throw new Error("Missing bucket name. If you are unit testing, please provide a bucket name" + " through `functions.storage.bucket(bucketName)`, or set process.env.FIREBASE_CONFIG.");
+		}
+		if (!/^[a-z\d][a-z\d\\._-]{1,230}[a-z\d]$/.test(bucket$1)) {
+			throw new Error(`Invalid bucket name ${bucket$1}`);
+		}
+		return `projects/_/buckets/${bucket$1}`;
+	};
+	return new BucketBuilder(resourceGetter, options);
+}
+/** @internal */
+function _objectWithOptions(options) {
+	return _bucketWithOptions(options).object();
+}
+/**
+* The Google Cloud Storage bucket builder interface.
+*
+* Access via `functions.storage.bucket()`.
+*/
+var BucketBuilder = class {
+	/** @internal */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/**
+	* Event handler which fires every time a Google Cloud Storage change occurs.
+	*
+	* @returns Storage object builder interface scoped to the specified storage
+	*   bucket.
+	*/
+	object() {
+		return new ObjectBuilder(this.triggerResource, this.options);
+	}
+};
+/**
+* The Google Cloud Storage object builder interface.
+*
+* Access via `functions.storage.object()`.
+*/
+var ObjectBuilder = class {
+	/** @internal */
+	constructor(triggerResource, options) {
+		this.triggerResource = triggerResource;
+		this.options = options;
+	}
+	/**
+	* Event handler sent only when a bucket has enabled object versioning.
+	* This event indicates that the live version of an object has become an
+	* archived version, either because it was archived or because it was
+	* overwritten by the upload of an object of the same name.
+	*
+	* @param handler Event handler which is run every time a Google Cloud Storage
+	*   archival occurs.
+	*
+	* @returns A function which you can export and deploy.
+	*/
+	onArchive(handler) {
+		return this.onOperation(handler, "object.archive");
+	}
+	/**
+	* Event handler which fires every time a Google Cloud Storage deletion occurs.
+	*
+	* Sent when an object has been permanently deleted. This includes objects
+	* that are overwritten or are deleted as part of the bucket's lifecycle
+	* configuration. For buckets with object versioning enabled, this is not
+	* sent when an object is archived, even if archival occurs
+	* via the `storage.objects.delete` method.
+	*
+	* @param handler Event handler which is run every time a Google Cloud Storage
+	*   deletion occurs.
+	*
+	* @returns A function which you can export and deploy.
+	*/
+	onDelete(handler) {
+		return this.onOperation(handler, "object.delete");
+	}
+	/**
+	* Event handler which fires every time a Google Cloud Storage object
+	* creation occurs.
+	*
+	* Sent when a new object (or a new generation of an existing object)
+	* is successfully created in the bucket. This includes copying or rewriting
+	* an existing object. A failed upload does not trigger this event.
+	*
+	* @param handler Event handler which is run every time a Google Cloud Storage
+	*   object creation occurs.
+	*
+	* @returns A function which you can export and deploy.
+	*/
+	onFinalize(handler) {
+		return this.onOperation(handler, "object.finalize");
+	}
+	/**
+	* Event handler which fires every time the metadata of an existing object
+	* changes.
+	*
+	* @param handler Event handler which is run every time a Google Cloud Storage
+	*   metadata update occurs.
+	*
+	* @returns A function which you can export and deploy.
+	*/
+	onMetadataUpdate(handler) {
+		return this.onOperation(handler, "object.metadataUpdate");
+	}
+	/** @hidden */
+	onOperation(handler, eventType) {
+		return makeCloudFunction({
+			handler,
+			provider,
+			service,
+			eventType,
+			triggerResource: this.triggerResource,
+			options: this.options
+		});
+	}
+};
+
+//#endregion
+export { BucketBuilder, ObjectBuilder, _bucketWithOptions, _objectWithOptions, bucket, object, provider, service, storage_exports };

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

@@ -0,0 +1,63 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initTaskQueueTrigger, initV1Endpoint } from "../../runtime/manifest.mjs";
+import { convertIfPresent, convertInvoker, copyIfPresent } from "../../common/encoding.mjs";
+import { optionsToEndpoint, optionsToTrigger } from "../cloud-functions.mjs";
+import { onDispatchHandler } from "../../common/providers/tasks.mjs";
+
+//#region src/v1/providers/tasks.ts
+var tasks_exports = /* @__PURE__ */ __export({
+	TaskQueueBuilder: () => TaskQueueBuilder,
+	taskQueue: () => taskQueue
+});
+/**
+* Builder for creating a `TaskQueueFunction`.
+*/
+var TaskQueueBuilder = class {
+	/** @internal */
+	constructor(tqOpts, depOpts) {
+		this.tqOpts = tqOpts;
+		this.depOpts = depOpts;
+	}
+	/**
+	* Creates a handler for tasks sent to a Google Cloud Tasks queue.
+	* @param handler - A callback to handle task requests.
+	* @returns A function you can export and deploy.
+	*/
+	onDispatch(handler) {
+		const fixedLen = (data, context) => handler(data, context);
+		const func = onDispatchHandler(fixedLen);
+		func.__trigger = {
+			...optionsToTrigger(this.depOpts || {}),
+			taskQueueTrigger: {}
+		};
+		copyIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, "retryConfig");
+		copyIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, "rateLimits");
+		convertIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, "invoker", "invoker", convertInvoker);
+		func.__endpoint = {
+			platform: "gcfv1",
+			...initV1Endpoint(this.depOpts),
+			...optionsToEndpoint(this.depOpts),
+			taskQueueTrigger: initTaskQueueTrigger(this.depOpts)
+		};
+		copyIfPresent(func.__endpoint.taskQueueTrigger.retryConfig, this.tqOpts?.retryConfig || {}, "maxAttempts", "maxBackoffSeconds", "maxDoublings", "maxRetrySeconds", "minBackoffSeconds");
+		copyIfPresent(func.__endpoint.taskQueueTrigger.rateLimits, this.tqOpts?.rateLimits || {}, "maxConcurrentDispatches", "maxDispatchesPerSecond");
+		convertIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, "invoker", "invoker", convertInvoker);
+		func.__requiredAPIs = [{
+			api: "cloudtasks.googleapis.com",
+			reason: "Needed for task queue functions"
+		}];
+		func.run = handler;
+		return func;
+	}
+};
+/**
+* Declares a function that can handle tasks enqueued using the Firebase Admin SDK.
+* @param options - Configuration for the Task Queue that feeds into this function.
+*        Omitting options will configure a Task Queue with default settings.
+*/
+function taskQueue(options) {
+	return new TaskQueueBuilder(options);
+}
+
+//#endregion
+export { TaskQueueBuilder, taskQueue, tasks_exports };