firebase-functions 6.6.0 → 7.0.0-rc.1

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

@@ -0,0 +1,155 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initV2Endpoint } from "../../runtime/manifest.mjs";
+import { firebaseConfig } from "../../common/config.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/storage.ts
+var storage_exports = /* @__PURE__ */ __export({
+	archivedEvent: () => archivedEvent,
+	deletedEvent: () => deletedEvent,
+	finalizedEvent: () => finalizedEvent,
+	getOptsAndBucket: () => getOptsAndBucket,
+	metadataUpdatedEvent: () => metadataUpdatedEvent,
+	onObjectArchived: () => onObjectArchived,
+	onObjectDeleted: () => onObjectDeleted,
+	onObjectFinalized: () => onObjectFinalized,
+	onObjectMetadataUpdated: () => onObjectMetadataUpdated,
+	onOperation: () => onOperation
+});
+/** @internal */
+const archivedEvent = "google.cloud.storage.object.v1.archived";
+/** @internal */
+const finalizedEvent = "google.cloud.storage.object.v1.finalized";
+/** @internal */
+const deletedEvent = "google.cloud.storage.object.v1.deleted";
+/** @internal */
+const metadataUpdatedEvent = "google.cloud.storage.object.v1.metadataUpdated";
+/**
+* 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 bucketOrOptsOrHandler - Options or string that may (or may not) define the bucket to be used.
+* @param handler - Event handler which is run every time a Google Cloud Storage archival occurs.
+*/
+function onObjectArchived(bucketOrOptsOrHandler, handler) {
+	return onOperation(archivedEvent, bucketOrOptsOrHandler, handler);
+}
+/**
+* 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 bucketOrOptsOrHandler - Options or string that may (or may not) define the bucket to be used.
+* @param handler - Event handler which is run every time a Google Cloud Storage object creation occurs.
+*/
+function onObjectFinalized(bucketOrOptsOrHandler, handler) {
+	return onOperation(finalizedEvent, bucketOrOptsOrHandler, handler);
+}
+/**
+* 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 bucketOrOptsOrHandler - Options or string that may (or may not) define the bucket to be used.
+* @param handler - Event handler which is run every time a Google Cloud Storage object deletion occurs.
+*/
+function onObjectDeleted(bucketOrOptsOrHandler, handler) {
+	return onOperation(deletedEvent, bucketOrOptsOrHandler, handler);
+}
+/**
+* Event handler which fires every time the metadata of an existing object
+* changes.
+*
+* @param bucketOrOptsOrHandler - Options or string that may (or may not) define the bucket to be used.
+* @param handler - Event handler which is run every time a Google Cloud Storage object metadata update occurs.
+*/
+function onObjectMetadataUpdated(bucketOrOptsOrHandler, handler) {
+	return onOperation(metadataUpdatedEvent, bucketOrOptsOrHandler, handler);
+}
+/** @internal */
+function onOperation(eventType, bucketOrOptsOrHandler, handler) {
+	if (typeof bucketOrOptsOrHandler === "function") {
+		handler = bucketOrOptsOrHandler;
+		bucketOrOptsOrHandler = {};
+	}
+	const [opts, bucket] = getOptsAndBucket(bucketOrOptsOrHandler);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(handler))(raw);
+	};
+	func.run = handler;
+	Object.defineProperty(func, "__trigger", { get: () => {
+		const baseOpts = optionsToTriggerAnnotations(getGlobalOptions());
+		const specificOpts = optionsToTriggerAnnotations(opts);
+		return {
+			platform: "gcfv2",
+			...baseOpts,
+			...specificOpts,
+			labels: {
+				...baseOpts?.labels,
+				...specificOpts?.labels
+			},
+			eventTrigger: {
+				eventType,
+				resource: bucket
+			}
+		};
+	} });
+	func.__endpoint = {};
+	Object.defineProperty(func, "__endpoint", { get: () => {
+		const baseOpts = optionsToEndpoint(getGlobalOptions());
+		const specificOpts = optionsToEndpoint(opts);
+		const endpoint = {
+			platform: "gcfv2",
+			...initV2Endpoint(getGlobalOptions(), opts),
+			...baseOpts,
+			...specificOpts,
+			labels: {
+				...baseOpts?.labels,
+				...specificOpts?.labels
+			},
+			eventTrigger: {
+				eventType,
+				eventFilters: { bucket },
+				retry: opts.retry ?? false
+			}
+		};
+		copyIfPresent(endpoint.eventTrigger, opts, "retry", "retry");
+		return endpoint;
+	} });
+	return func;
+}
+/** @internal */
+function getOptsAndBucket(bucketOrOpts) {
+	let bucket;
+	let opts;
+	if (typeof bucketOrOpts === "string" || "value" in bucketOrOpts) {
+		bucket = bucketOrOpts;
+		opts = {};
+	} else {
+		bucket = bucketOrOpts.bucket || firebaseConfig()?.storageBucket;
+		opts = { ...bucketOrOpts };
+		delete opts.bucket;
+	}
+	if (!bucket) {
+		throw new Error("Missing bucket name. If you are unit testing, please provide a bucket name" + " by providing bucket name directly in the event handler or by setting process.env.FIREBASE_CONFIG.");
+	}
+	if (typeof bucket === "string" && !/^[a-z\d][a-z\d\\._-]{1,230}[a-z\d]$/.test(bucket)) {
+		throw new Error(`Invalid bucket name ${bucket}`);
+	}
+	return [opts, bucket];
+}
+
+//#endregion
+export { archivedEvent, deletedEvent, finalizedEvent, getOptsAndBucket, metadataUpdatedEvent, onObjectArchived, onObjectDeleted, onObjectFinalized, onObjectMetadataUpdated, onOperation, storage_exports };

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

@@ -0,0 +1,65 @@
+import { __export } from "../../_virtual/rolldown_runtime.mjs";
+import { initTaskQueueTrigger, initV2Endpoint } from "../../runtime/manifest.mjs";
+import { convertIfPresent, convertInvoker, copyIfPresent } from "../../common/encoding.mjs";
+import { withInit } from "../../common/onInit.mjs";
+import { wrapTraceContext } from "../trace.mjs";
+import { onDispatchHandler } from "../../common/providers/tasks.mjs";
+import { getGlobalOptions, optionsToEndpoint, optionsToTriggerAnnotations } from "../options.mjs";
+
+//#region src/v2/providers/tasks.ts
+var tasks_exports = /* @__PURE__ */ __export({ onTaskDispatched: () => onTaskDispatched });
+function onTaskDispatched(optsOrHandler, handler) {
+	let opts;
+	if (arguments.length === 1) {
+		opts = {};
+		handler = optsOrHandler;
+	} else {
+		opts = optsOrHandler;
+	}
+	const fixedLen = (req) => handler(req);
+	const func = wrapTraceContext(withInit(onDispatchHandler(fixedLen)));
+	Object.defineProperty(func, "__trigger", { get: () => {
+		const baseOpts$1 = optionsToTriggerAnnotations(getGlobalOptions());
+		const specificOpts$1 = optionsToTriggerAnnotations(opts);
+		const taskQueueTrigger = {};
+		copyIfPresent(taskQueueTrigger, opts, "retryConfig", "rateLimits");
+		convertIfPresent(taskQueueTrigger, getGlobalOptions(), "invoker", "invoker", convertInvoker);
+		convertIfPresent(taskQueueTrigger, opts, "invoker", "invoker", convertInvoker);
+		return {
+			platform: "gcfv2",
+			...baseOpts$1,
+			...specificOpts$1,
+			labels: {
+				...baseOpts$1?.labels,
+				...specificOpts$1?.labels
+			},
+			taskQueueTrigger
+		};
+	} });
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(opts);
+	func.__endpoint = {
+		platform: "gcfv2",
+		...initV2Endpoint(getGlobalOptions(), opts),
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		taskQueueTrigger: initTaskQueueTrigger(getGlobalOptions(), opts)
+	};
+	copyIfPresent(func.__endpoint.taskQueueTrigger.retryConfig, opts.retryConfig, "maxAttempts", "maxBackoffSeconds", "maxDoublings", "maxRetrySeconds", "minBackoffSeconds");
+	copyIfPresent(func.__endpoint.taskQueueTrigger.rateLimits, opts.rateLimits, "maxConcurrentDispatches", "maxDispatchesPerSecond");
+	convertIfPresent(func.__endpoint.taskQueueTrigger, getGlobalOptions(), "invoker", "invoker", convertInvoker);
+	convertIfPresent(func.__endpoint.taskQueueTrigger, opts, "invoker", "invoker", convertInvoker);
+	func.__requiredAPIs = [{
+		api: "cloudtasks.googleapis.com",
+		reason: "Needed for task queue functions"
+	}];
+	func.run = handler;
+	return func;
+}
+
+//#endregion
+export { onTaskDispatched, tasks_exports };

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

@@ -0,0 +1,53 @@
+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/testLab.ts
+var testLab_exports = /* @__PURE__ */ __export({
+	eventType: () => eventType,
+	onTestMatrixCompleted: () => onTestMatrixCompleted
+});
+/** @internal */
+const eventType = "google.firebase.testlab.testMatrix.v1.completed";
+/**
+* Event handler which triggers when a Firebase test matrix completes.
+*
+* @param optsOrHandler - Options or an event handler.
+* @param handler - Event handler which is run every time a Firebase test matrix completes.
+* @returns A Cloud Function that you can export and deploy.
+* @alpha
+*/
+function onTestMatrixCompleted(optsOrHandler, handler) {
+	if (typeof optsOrHandler === "function") {
+		handler = optsOrHandler;
+		optsOrHandler = {};
+	}
+	const baseOpts = optionsToEndpoint(getGlobalOptions());
+	const specificOpts = optionsToEndpoint(optsOrHandler);
+	const func = (raw) => {
+		return wrapTraceContext(withInit(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, onTestMatrixCompleted, testLab_exports };

package/lib/esm/v2/trace.mjs

@@ -0,0 +1,20 @@
+import { extractTraceContext, traceContext } from "../common/trace.mjs";
+
+//#region src/v2/trace.ts
+function wrapTraceContext(handler) {
+	return (...args) => {
+		let traceParent;
+		if (args.length === 1) {
+			traceParent = extractTraceContext(args[0]);
+		} else {
+			traceParent = extractTraceContext(args[0].headers);
+		}
+		if (!traceParent) {
+			return handler.apply(null, args);
+		}
+		return traceContext.run(traceParent, handler, ...args);
+	};
+}
+
+//#endregion
+export { wrapTraceContext };

package/lib/logger/common.js

@@ -1,45 +1,25 @@
-"use strict";
-// The MIT License (MIT)
-//
-// Copyright (c) 2017 Firebase
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNPATCHED_CONSOLE = exports.CONSOLE_SEVERITY = void 0;
-// Map LogSeverity types to their equivalent `console.*` method.
+
+//#region src/logger/common.ts
 /** @hidden */
-exports.CONSOLE_SEVERITY = {
-    DEBUG: "debug",
-    INFO: "info",
-    NOTICE: "info",
-    WARNING: "warn",
-    ERROR: "error",
-    CRITICAL: "error",
-    ALERT: "error",
-    EMERGENCY: "error",
+const CONSOLE_SEVERITY = {
+	DEBUG: "debug",
+	INFO: "info",
+	NOTICE: "info",
+	WARNING: "warn",
+	ERROR: "error",
+	CRITICAL: "error",
+	ALERT: "error",
+	EMERGENCY: "error"
 };
-// safely preserve unpatched console.* methods in case of compat require
 /** @hidden */
-exports.UNPATCHED_CONSOLE = {
-    debug: console.debug,
-    info: console.info,
-    log: console.log,
-    warn: console.warn,
-    error: console.error,
+const UNPATCHED_CONSOLE = {
+	debug: console.debug,
+	info: console.info,
+	log: console.log,
+	warn: console.warn,
+	error: console.error
 };
+
+//#endregion
+exports.CONSOLE_SEVERITY = CONSOLE_SEVERITY;
+exports.UNPATCHED_CONSOLE = UNPATCHED_CONSOLE;

package/lib/logger/compat.js

@@ -1,41 +1,26 @@
-"use strict";
-// The MIT License (MIT)
-//
-// Copyright (c) 2017 Firebase
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
-const common_1 = require("./common");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_logger_common = require('./common.js');
+let util = require("util");
+util = require_rolldown_runtime.__toESM(util);
+
+//#region src/logger/compat.ts
 /** @hidden */
 function patchedConsole(severity) {
-    return function (data, ...args) {
-        let message = (0, util_1.format)(data, ...args);
-        if (severity === "ERROR") {
-            message = new Error(message).stack || message;
-        }
-        common_1.UNPATCHED_CONSOLE[common_1.CONSOLE_SEVERITY[severity]](JSON.stringify({ severity, message }));
-    };
+	return function(data, ...args) {
+		let message = (0, util.format)(data, ...args);
+		if (severity === "ERROR") {
+			message = new Error(message).stack || message;
+		}
+		require_logger_common.UNPATCHED_CONSOLE[require_logger_common.CONSOLE_SEVERITY[severity]](JSON.stringify({
+			severity,
+			message
+		}));
+	};
 }
-// IMPORTANT -- "../logger" must be imported before monkeypatching!
 console.debug = patchedConsole("DEBUG");
 console.info = patchedConsole("INFO");
 console.log = patchedConsole("INFO");
 console.warn = patchedConsole("WARNING");
 console.error = patchedConsole("ERROR");
+
+//#endregion