firebase-functions 6.6.0 → 7.0.0-rc.0

package/lib/v2/providers/database.js

@@ -1,219 +1,216 @@
-"use strict";
-// The MIT License (MIT)
-//
-// Copyright (c) 2022 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.onOperation = exports.onChangedOperation = exports.makeEndpoint = exports.makeParams = exports.getOpts = exports.onValueDeleted = exports.onValueUpdated = exports.onValueCreated = exports.onValueWritten = exports.deletedEventType = exports.updatedEventType = exports.createdEventType = exports.writtenEventType = exports.DataSnapshot = void 0;
-const app_1 = require("../../common/app");
-const database_1 = require("../../common/providers/database");
-Object.defineProperty(exports, "DataSnapshot", { enumerable: true, get: function () { return database_1.DataSnapshot; } });
-const path_1 = require("../../common/utilities/path");
-const path_pattern_1 = require("../../common/utilities/path-pattern");
-const utils_1 = require("../../common/utilities/utils");
-const manifest_1 = require("../../runtime/manifest");
-const trace_1 = require("../trace");
-const options = require("../options");
-const onInit_1 = require("../../common/onInit");
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require_runtime_manifest = require('../../runtime/manifest.js');
+const require_common_app = require('../../common/app.js');
+const require_common_onInit = require('../../common/onInit.js');
+const require_common_utilities_path = require('../../common/utilities/path.js');
+const require_common_providers_database = require('../../common/providers/database.js');
+const require_common_utilities_utils = require('../../common/utilities/utils.js');
+const require_v2_trace = require('../trace.js');
+const require_v2_options = require('../options.js');
+const require_common_utilities_path_pattern = require('../../common/utilities/path-pattern.js');
+
+//#region src/v2/providers/database.ts
+var database_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	DataSnapshot: () => require_common_providers_database.DataSnapshot,
+	createdEventType: () => createdEventType,
+	deletedEventType: () => deletedEventType,
+	getOpts: () => getOpts,
+	makeEndpoint: () => makeEndpoint,
+	makeParams: () => makeParams,
+	onChangedOperation: () => onChangedOperation,
+	onOperation: () => onOperation,
+	onValueCreated: () => onValueCreated,
+	onValueDeleted: () => onValueDeleted,
+	onValueUpdated: () => onValueUpdated,
+	onValueWritten: () => onValueWritten,
+	updatedEventType: () => updatedEventType,
+	writtenEventType: () => writtenEventType
+});
 /** @internal */
-exports.writtenEventType = "google.firebase.database.ref.v1.written";
+const writtenEventType = "google.firebase.database.ref.v1.written";
 /** @internal */
-exports.createdEventType = "google.firebase.database.ref.v1.created";
+const createdEventType = "google.firebase.database.ref.v1.created";
 /** @internal */
-exports.updatedEventType = "google.firebase.database.ref.v1.updated";
+const updatedEventType = "google.firebase.database.ref.v1.updated";
 /** @internal */
-exports.deletedEventType = "google.firebase.database.ref.v1.deleted";
+const deletedEventType = "google.firebase.database.ref.v1.deleted";
 /**
- * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
- *
- * @param referenceOrOpts - Options or a string reference.
- * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
- */
+* Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+*/
 function onValueWritten(referenceOrOpts, handler) {
-    return onChangedOperation(exports.writtenEventType, referenceOrOpts, handler);
+	return onChangedOperation(writtenEventType, referenceOrOpts, handler);
 }
-exports.onValueWritten = onValueWritten;
 /**
- * Event handler which triggers when data is created in Realtime Database.
- *
- * @param referenceOrOpts - Options or a string reference.
- * @param handler - Event handler which is run every time a Realtime Database create occurs.
- */
+* Event handler which triggers when data is created in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database create occurs.
+*/
 function onValueCreated(referenceOrOpts, handler) {
-    return onOperation(exports.createdEventType, referenceOrOpts, handler);
+	return onOperation(createdEventType, referenceOrOpts, handler);
 }
-exports.onValueCreated = onValueCreated;
 /**
- * Event handler which triggers when data is updated in Realtime Database.
- *
- * @param referenceOrOpts - Options or a string reference.
- * @param handler - Event handler which is run every time a Realtime Database update occurs.
- */
+* Event handler which triggers when data is updated in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database update occurs.
+*/
 function onValueUpdated(referenceOrOpts, handler) {
-    return onChangedOperation(exports.updatedEventType, referenceOrOpts, handler);
+	return onChangedOperation(updatedEventType, referenceOrOpts, handler);
 }
-exports.onValueUpdated = onValueUpdated;
 /**
- * Event handler which triggers when data is deleted in Realtime Database.
- *
- * @param referenceOrOpts - Options or a string reference.
- * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
- */
+* Event handler which triggers when data is deleted in Realtime Database.
+*
+* @param referenceOrOpts - Options or a string reference.
+* @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+*/
 function onValueDeleted(referenceOrOpts, handler) {
-    // TODO - need to use event.data.delta
-    return onOperation(exports.deletedEventType, referenceOrOpts, handler);
+	return onOperation(deletedEventType, referenceOrOpts, handler);
 }
-exports.onValueDeleted = onValueDeleted;
 /** @internal */
 function getOpts(referenceOrOpts) {
-    let path;
-    let instance;
-    let opts;
-    if (typeof referenceOrOpts === "string") {
-        path = (0, path_1.normalizePath)(referenceOrOpts);
-        instance = "*";
-        opts = {};
-    }
-    else {
-        path = (0, path_1.normalizePath)(referenceOrOpts.ref);
-        instance = referenceOrOpts.instance || "*";
-        opts = { ...referenceOrOpts };
-        delete opts.ref;
-        delete opts.instance;
-    }
-    return {
-        path,
-        instance,
-        opts,
-    };
+	let path;
+	let instance;
+	let opts;
+	if (typeof referenceOrOpts === "string") {
+		path = require_common_utilities_path.normalizePath(referenceOrOpts);
+		instance = "*";
+		opts = {};
+	} else {
+		path = require_common_utilities_path.normalizePath(referenceOrOpts.ref);
+		instance = referenceOrOpts.instance || "*";
+		opts = { ...referenceOrOpts };
+		delete opts.ref;
+		delete opts.instance;
+	}
+	return {
+		path,
+		instance,
+		opts
+	};
 }
-exports.getOpts = getOpts;
 /** @internal */
 function makeParams(event, path, instance) {
-    return {
-        ...path.extractMatches(event.ref),
-        ...instance.extractMatches(event.instance),
-    };
+	return {
+		...path.extractMatches(event.ref),
+		...instance.extractMatches(event.instance)
+	};
 }
-exports.makeParams = makeParams;
 /** @hidden */
 function makeDatabaseEvent(event, data, instance, params) {
-    const snapshot = new database_1.DataSnapshot(data, event.ref, (0, app_1.getApp)(), instance);
-    const databaseEvent = {
-        ...event,
-        firebaseDatabaseHost: event.firebasedatabasehost,
-        data: snapshot,
-        params,
-    };
-    delete databaseEvent.firebasedatabasehost;
-    return databaseEvent;
+	const snapshot = new require_common_providers_database.DataSnapshot(data, event.ref, require_common_app.getApp(), instance);
+	const databaseEvent = {
+		...event,
+		firebaseDatabaseHost: event.firebasedatabasehost,
+		data: snapshot,
+		params
+	};
+	delete databaseEvent.firebasedatabasehost;
+	return databaseEvent;
 }
 /** @hidden */
 function makeChangedDatabaseEvent(event, instance, params) {
-    const before = new database_1.DataSnapshot(event.data.data, event.ref, (0, app_1.getApp)(), instance);
-    const after = new database_1.DataSnapshot((0, utils_1.applyChange)(event.data.data, event.data.delta), event.ref, (0, app_1.getApp)(), instance);
-    const databaseEvent = {
-        ...event,
-        firebaseDatabaseHost: event.firebasedatabasehost,
-        data: {
-            before,
-            after,
-        },
-        params,
-    };
-    delete databaseEvent.firebasedatabasehost;
-    return databaseEvent;
+	const before = new require_common_providers_database.DataSnapshot(event.data.data, event.ref, require_common_app.getApp(), instance);
+	const after = new require_common_providers_database.DataSnapshot(require_common_utilities_utils.applyChange(event.data.data, event.data.delta), event.ref, require_common_app.getApp(), instance);
+	const databaseEvent = {
+		...event,
+		firebaseDatabaseHost: event.firebasedatabasehost,
+		data: {
+			before,
+			after
+		},
+		params
+	};
+	delete databaseEvent.firebasedatabasehost;
+	return databaseEvent;
 }
 /** @internal */
 function makeEndpoint(eventType, opts, path, instance) {
-    var _a;
-    const baseOpts = options.optionsToEndpoint(options.getGlobalOptions());
-    const specificOpts = options.optionsToEndpoint(opts);
-    const eventFilters = {};
-    const eventFilterPathPatterns = {
-        // Note: Eventarc always treats ref as a path pattern
-        ref: path.getValue(),
-    };
-    instance.hasWildcards()
-        ? (eventFilterPathPatterns.instance = instance.getValue())
-        : (eventFilters.instance = instance.getValue());
-    return {
-        ...(0, manifest_1.initV2Endpoint)(options.getGlobalOptions(), opts),
-        platform: "gcfv2",
-        ...baseOpts,
-        ...specificOpts,
-        labels: {
-            ...baseOpts === null || baseOpts === void 0 ? void 0 : baseOpts.labels,
-            ...specificOpts === null || specificOpts === void 0 ? void 0 : specificOpts.labels,
-        },
-        eventTrigger: {
-            eventType,
-            eventFilters,
-            eventFilterPathPatterns,
-            retry: (_a = opts.retry) !== null && _a !== void 0 ? _a : false,
-        },
-    };
+	const baseOpts = require_v2_options.optionsToEndpoint(require_v2_options.getGlobalOptions());
+	const specificOpts = require_v2_options.optionsToEndpoint(opts);
+	const eventFilters = {};
+	const eventFilterPathPatterns = { ref: path.getValue() };
+	if (instance.hasWildcards()) {
+		eventFilterPathPatterns.instance = instance.getValue();
+	} else {
+		eventFilters.instance = instance.getValue();
+	}
+	return {
+		...require_runtime_manifest.initV2Endpoint(require_v2_options.getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters,
+			eventFilterPathPatterns,
+			retry: opts.retry ?? false
+		}
+	};
 }
-exports.makeEndpoint = makeEndpoint;
 /** @internal */
 function onChangedOperation(eventType, referenceOrOpts, handler) {
-    const { path, instance, opts } = getOpts(referenceOrOpts);
-    const pathPattern = new path_pattern_1.PathPattern(path);
-    const instancePattern = new path_pattern_1.PathPattern(instance);
-    // wrap the handler
-    const func = (raw) => {
-        const event = raw;
-        const instanceUrl = getInstance(event);
-        const params = makeParams(event, pathPattern, instancePattern);
-        const databaseEvent = makeChangedDatabaseEvent(event, instanceUrl, params);
-        // Intentionally put init in the context of traces in case there is something
-        // expensive to observe.
-        return (0, trace_1.wrapTraceContext)((0, onInit_1.withInit)(handler))(databaseEvent);
-    };
-    func.run = handler;
-    func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
-    return func;
+	const { path, instance, opts } = getOpts(referenceOrOpts);
+	const pathPattern = new require_common_utilities_path_pattern.PathPattern(path);
+	const instancePattern = new require_common_utilities_path_pattern.PathPattern(instance);
+	const func = (raw) => {
+		const event = raw;
+		const instanceUrl = getInstance(event);
+		const params = makeParams(event, pathPattern, instancePattern);
+		const databaseEvent = makeChangedDatabaseEvent(event, instanceUrl, params);
+		return require_v2_trace.wrapTraceContext(require_common_onInit.withInit(handler))(databaseEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+	return func;
 }
-exports.onChangedOperation = onChangedOperation;
 /** @internal */
 function onOperation(eventType, referenceOrOpts, handler) {
-    const { path, instance, opts } = getOpts(referenceOrOpts);
-    const pathPattern = new path_pattern_1.PathPattern(path);
-    const instancePattern = new path_pattern_1.PathPattern(instance);
-    // wrap the handler
-    const func = (raw) => {
-        const event = raw;
-        const instanceUrl = getInstance(event);
-        const params = makeParams(event, pathPattern, instancePattern);
-        const data = eventType === exports.deletedEventType ? event.data.data : event.data.delta;
-        const databaseEvent = makeDatabaseEvent(event, data, instanceUrl, params);
-        return (0, trace_1.wrapTraceContext)((0, onInit_1.withInit)(handler))(databaseEvent);
-    };
-    func.run = handler;
-    func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
-    return func;
+	const { path, instance, opts } = getOpts(referenceOrOpts);
+	const pathPattern = new require_common_utilities_path_pattern.PathPattern(path);
+	const instancePattern = new require_common_utilities_path_pattern.PathPattern(instance);
+	const func = (raw) => {
+		const event = raw;
+		const instanceUrl = getInstance(event);
+		const params = makeParams(event, pathPattern, instancePattern);
+		const data = eventType === deletedEventType ? event.data.data : event.data.delta;
+		const databaseEvent = makeDatabaseEvent(event, data, instanceUrl, params);
+		return require_v2_trace.wrapTraceContext(require_common_onInit.withInit(handler))(databaseEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+	return func;
 }
-exports.onOperation = onOperation;
 function getInstance(event) {
-    const emuHost = process.env.FIREBASE_DATABASE_EMULATOR_HOST;
-    return emuHost
-        ? `http://${emuHost}/?ns=${event.instance}`
-        : `https://${event.instance}.${event.firebasedatabasehost}`;
+	const emuHost = process.env.FIREBASE_DATABASE_EMULATOR_HOST;
+	return emuHost ? `http://${emuHost}/?ns=${event.instance}` : `https://${event.instance}.${event.firebasedatabasehost}`;
 }
+
+//#endregion
+exports.DataSnapshot = require_common_providers_database.DataSnapshot;
+exports.createdEventType = createdEventType;
+Object.defineProperty(exports, 'database_exports', {
+  enumerable: true,
+  get: function () {
+    return database_exports;
+  }
+});
+exports.deletedEventType = deletedEventType;
+exports.getOpts = getOpts;
+exports.makeEndpoint = makeEndpoint;
+exports.makeParams = makeParams;
+exports.onChangedOperation = onChangedOperation;
+exports.onOperation = onOperation;
+exports.onValueCreated = onValueCreated;
+exports.onValueDeleted = onValueDeleted;
+exports.onValueUpdated = onValueUpdated;
+exports.onValueWritten = onValueWritten;
+exports.updatedEventType = updatedEventType;
+exports.writtenEventType = writtenEventType;

package/lib/v2/providers/dataconnect.d.ts

@@ -0,0 +1,95 @@
+import { CloudEvent, CloudFunction } from "../core";
+import { ParamsOf, VarName } from "../../common/params";
+import { EventHandlerOptions, SupportedRegion } from "../options";
+import { Expression } from "../../params";
+import { ResetValue } from "../../common/options";
+/** @hidden */
+export interface SourceLocation {
+    line: number;
+    column: number;
+}
+/** @hidden */
+export interface GraphqlErrorExtensions {
+    file: string;
+    code: string;
+    debugDetails: string;
+}
+/** @hidden */
+export interface GraphqlError {
+    message: string;
+    locations: Array<SourceLocation>;
+    path: Array<string>;
+    extensions: GraphqlErrorExtensions;
+}
+/** @hidden */
+export interface RawMutation<V, R> {
+    data: R;
+    variables: V;
+    errors: Array<GraphqlError>;
+}
+/** @hidden */
+export interface MutationEventData<V, R> {
+    ["@type"]: "type.googleapis.com/google.events.firebase.dataconnect.v1.MutationEventData";
+    payload: RawMutation<V, R>;
+}
+/** @hidden */
+export interface RawDataConnectEvent<T> extends CloudEvent<T> {
+    project: string;
+    location: string;
+    service: string;
+    schema: string;
+    connector: string;
+    operation: string;
+    authtype: AuthType;
+    authid?: string;
+}
+/**
+ * AuthType defines the possible values for the authType field in a Firebase Data Connect event.
+ * - app_user: an end user of an application..
+ * - admin: an admin user of an application. In the context of impersonate endpoints used by the admin SDK, the impersonator.
+ * - unknown: a general type to capture all other principals not captured in the other auth types.
+ */
+export type AuthType = "app_user" | "admin" | "unknown";
+/** OperationOptions extend EventHandlerOptions with a provided service, connector, and operation. */
+export interface OperationOptions<Service extends string = string, Connector extends string = string, Operation extends string = string> extends EventHandlerOptions {
+    /** Firebase Data Connect service ID */
+    service?: Service;
+    /** Firebase Data Connect connector ID */
+    connector?: Connector;
+    /** Name of the operation */
+    operation?: Operation;
+    /**
+     * Region where functions should be deployed. Defaults to us-central1.
+     */
+    region?: SupportedRegion | string | Expression<string> | ResetValue;
+}
+export type DataConnectParams<PathPatternOrOptions extends string | OperationOptions> = PathPatternOrOptions extends string ? ParamsOf<PathPatternOrOptions> : PathPatternOrOptions extends OperationOptions<infer Service extends string, infer Connector extends string, infer Operation extends string> ? Record<VarName<Service> | VarName<Connector> | VarName<Operation>, string> : never;
+export interface DataConnectEvent<T, Params extends Record<never, string>> extends CloudEvent<T> {
+    /** The location of the Firebase Data Connect instance */
+    location: string;
+    /** The project identifier */
+    project: string;
+    /**
+     * An object containing the values of the path patterns.
+     * Only named capture groups will be populated - {key}, {key=*}, {key=**}.
+     */
+    params: Params;
+    /** The type of principal that triggered the event */
+    authType: AuthType;
+    /** The unique identifier for the principal */
+    authId?: string;
+}
+/**
+ * Event handler that triggers when a mutation is executed in Firebase Data Connect.
+ *
+ * @param mutation - The mutation path to trigger on.
+ * @param handler - Event handler which is run every time a mutation is executed.
+ */
+export declare function onMutationExecuted<Mutation extends string, Variables = unknown, ResponseData = unknown>(mutation: Mutation, handler: (event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Mutation>>) => unknown | Promise<unknown>): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Mutation>>>;
+/**
+ * Event handler that triggers when a mutation is executed in Firebase Data Connect.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a mutation is executed.
+ */
+export declare function onMutationExecuted<Options extends OperationOptions, Variables = unknown, ResponseData = unknown>(opts: Options, handler: (event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Options>>) => unknown | Promise<unknown>): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Options>>>;

package/lib/v2/providers/dataconnect.js

@@ -0,0 +1,137 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.js');
+const require_runtime_manifest = require('../../runtime/manifest.js');
+const require_common_onInit = require('../../common/onInit.js');
+const require_common_utilities_path = require('../../common/utilities/path.js');
+const require_v2_trace = require('../trace.js');
+const require_v2_options = require('../options.js');
+const require_common_utilities_path_pattern = require('../../common/utilities/path-pattern.js');
+
+//#region src/v2/providers/dataconnect.ts
+var dataconnect_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	mutationExecutedEventType: () => mutationExecutedEventType,
+	onMutationExecuted: () => onMutationExecuted
+});
+/** @internal */
+const mutationExecutedEventType = "google.firebase.dataconnect.connector.v1.mutationExecuted";
+/**
+* Event handler that triggers when a mutation is executed in Firebase Data Connect.
+*
+* @param mutationOrOpts - Options or string mutation path.
+* @param handler - Event handler which is run every time a mutation is executed.
+*/
+function onMutationExecuted(mutationOrOpts, handler) {
+	return onOperation(mutationExecutedEventType, mutationOrOpts, handler);
+}
+function getOpts(mutationOrOpts) {
+	const operationRegex = new RegExp("services/([^/]+)/connectors/([^/]*)/operations/([^/]+)");
+	let service;
+	let connector;
+	let operation;
+	let opts;
+	if (typeof mutationOrOpts === "string") {
+		const path = require_common_utilities_path.normalizePath(mutationOrOpts);
+		const match = path.match(operationRegex);
+		if (!match) {
+			throw new Error(`Invalid operation path: ${path}`);
+		}
+		service = match[1];
+		connector = match[2];
+		operation = match[3];
+		opts = {};
+	} else {
+		service = mutationOrOpts.service;
+		connector = mutationOrOpts.connector;
+		operation = mutationOrOpts.operation;
+		opts = { ...mutationOrOpts };
+		delete opts.service;
+		delete opts.connector;
+		delete opts.operation;
+	}
+	return {
+		service,
+		connector,
+		operation,
+		opts
+	};
+}
+function makeEndpoint(eventType, opts, service, connector, operation) {
+	const baseOpts = require_v2_options.optionsToEndpoint(require_v2_options.getGlobalOptions());
+	const specificOpts = require_v2_options.optionsToEndpoint(opts);
+	const eventFilters = {};
+	const eventFilterPathPatterns = {};
+	if (service) {
+		if (service.hasWildcards()) {
+			eventFilterPathPatterns.service = service.getValue();
+		} else {
+			eventFilters.service = service.getValue();
+		}
+	}
+	if (connector) {
+		if (connector.hasWildcards()) {
+			eventFilterPathPatterns.connector = connector.getValue();
+		} else {
+			eventFilters.connector = connector.getValue();
+		}
+	}
+	if (operation) {
+		if (operation.hasWildcards()) {
+			eventFilterPathPatterns.operation = operation.getValue();
+		} else {
+			eventFilters.operation = operation.getValue();
+		}
+	}
+	return {
+		...require_runtime_manifest.initV2Endpoint(require_v2_options.getGlobalOptions(), opts),
+		platform: "gcfv2",
+		...baseOpts,
+		...specificOpts,
+		labels: {
+			...baseOpts?.labels,
+			...specificOpts?.labels
+		},
+		eventTrigger: {
+			eventType,
+			eventFilters,
+			eventFilterPathPatterns,
+			retry: opts.retry ?? false
+		}
+	};
+}
+function makeParams(event, service, connector, operation) {
+	return {
+		...service?.extractMatches(event.service),
+		...connector?.extractMatches(event.connector),
+		...operation?.extractMatches(event.operation)
+	};
+}
+function onOperation(eventType, mutationOrOpts, handler) {
+	const { service, connector, operation, opts } = getOpts(mutationOrOpts);
+	const servicePattern = service ? new require_common_utilities_path_pattern.PathPattern(service) : undefined;
+	const connectorPattern = connector ? new require_common_utilities_path_pattern.PathPattern(connector) : undefined;
+	const operationPattern = operation ? new require_common_utilities_path_pattern.PathPattern(operation) : undefined;
+	const func = (raw) => {
+		const event = raw;
+		const params = makeParams(event, servicePattern, connectorPattern, operationPattern);
+		const { authtype, authid, service: service$1, connector: connector$1, operation: operation$1,...rest } = event;
+		const dataConnectEvent = {
+			...rest,
+			authType: authtype,
+			authId: authid,
+			params
+		};
+		return require_v2_trace.wrapTraceContext(require_common_onInit.withInit(handler))(dataConnectEvent);
+	};
+	func.run = handler;
+	func.__endpoint = makeEndpoint(eventType, opts, servicePattern, connectorPattern, operationPattern);
+	return func;
+}
+
+//#endregion
+Object.defineProperty(exports, 'dataconnect_exports', {
+  enumerable: true,
+  get: function () {
+    return dataconnect_exports;
+  }
+});
+exports.mutationExecutedEventType = mutationExecutedEventType;
+exports.onMutationExecuted = onMutationExecuted;