firebase-functions 3.21.2 → 3.22.0

package/lib/utilities/path-pattern.js

@@ -0,0 +1,142 @@
+"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.PathPattern = exports.trimParam = void 0;
+const path_1 = require("./path");
+/** https://cloud.google.com/eventarc/docs/path-patterns */
+/** @hidden */
+const WILDCARD_CAPTURE_REGEX = new RegExp('{[^/{}]+}', 'g');
+/** @internal */
+function trimParam(param) {
+    const paramNoBraces = param.slice(1, -1);
+    if (paramNoBraces.includes('=')) {
+        return paramNoBraces.slice(0, paramNoBraces.indexOf('='));
+    }
+    return paramNoBraces;
+}
+exports.trimParam = trimParam;
+/** @hidden */
+class Segment {
+    constructor(value) {
+        this.value = value;
+        this.name = 'segment';
+        this.trimmed = value;
+    }
+    isSingleSegmentWildcard() {
+        return this.value.includes('*') && !this.isMultiSegmentWildcard();
+    }
+    isMultiSegmentWildcard() {
+        return this.value.includes('**');
+    }
+}
+/** @hidden */
+class SingleCaptureSegment {
+    constructor(value) {
+        this.value = value;
+        this.name = 'single-capture';
+        this.trimmed = trimParam(value);
+    }
+    isSingleSegmentWildcard() {
+        return true;
+    }
+    isMultiSegmentWildcard() {
+        return false;
+    }
+}
+/** @hidden */
+class MultiCaptureSegment {
+    constructor(value) {
+        this.value = value;
+        this.name = 'multi-capture';
+        this.trimmed = trimParam(value);
+    }
+    isSingleSegmentWildcard() {
+        return false;
+    }
+    isMultiSegmentWildcard() {
+        return true;
+    }
+}
+/**
+ * Implements Eventarc's path pattern from the spec https://cloud.google.com/eventarc/docs/path-patterns
+ * @internal
+ */
+class PathPattern {
+    constructor(raw) {
+        this.raw = raw;
+        this.segments = [];
+        this.initPathSegments(raw);
+    }
+    /** @throws on validation error */
+    static compile(rawPath) { }
+    getValue() {
+        return this.raw;
+    }
+    // If false, we don't need to use pathPattern as our eventarc match type.
+    hasWildcards() {
+        return this.segments.some((segment) => segment.isSingleSegmentWildcard() || segment.isMultiSegmentWildcard());
+    }
+    hasCaptures() {
+        return this.segments.some((segment) => segment.name == 'single-capture' || segment.name === 'multi-capture');
+    }
+    extractMatches(path) {
+        const matches = {};
+        if (!this.hasCaptures()) {
+            return matches;
+        }
+        const pathSegments = (0, path_1.pathParts)(path);
+        let pathNdx = 0;
+        for (let segmentNdx = 0; segmentNdx < this.segments.length && pathNdx < pathSegments.length; segmentNdx++) {
+            const segment = this.segments[segmentNdx];
+            const remainingSegments = this.segments.length - 1 - segmentNdx;
+            const nextPathNdx = pathSegments.length - remainingSegments;
+            if (segment.name === 'single-capture') {
+                matches[segment.trimmed] = pathSegments[pathNdx];
+            }
+            else if (segment.name === 'multi-capture') {
+                matches[segment.trimmed] = pathSegments
+                    .slice(pathNdx, nextPathNdx)
+                    .join('/');
+            }
+            pathNdx = segment.isMultiSegmentWildcard() ? nextPathNdx : pathNdx + 1;
+        }
+        return matches;
+    }
+    initPathSegments(raw) {
+        const parts = (0, path_1.pathParts)(raw);
+        for (const part of parts) {
+            let segment;
+            const capture = part.match(WILDCARD_CAPTURE_REGEX);
+            if (capture && capture.length === 1) {
+                segment = part.includes('**')
+                    ? new MultiCaptureSegment(part)
+                    : new SingleCaptureSegment(part);
+            }
+            else {
+                segment = new Segment(part);
+            }
+            this.segments.push(segment);
+        }
+    }
+}
+exports.PathPattern = PathPattern;

package/lib/v2/core.d.ts

@@ -2,7 +2,9 @@
  * Core functionality of the Firebase Functions v2 SDK.
  * @packageDocumentation
  */
+import { Change } from '../common/change';
 import { ManifestEndpoint } from '../runtime/manifest';
+export { Change };
 /**
  * A CloudEventBase is the base of a cross-platform format for encoding a serverless event.
  * More information can be found in https://github.com/cloudevents/spec

package/lib/v2/core.js

@@ -21,3 +21,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Change = void 0;
+/**
+ * Core functionality of the Firebase Functions v2 SDK.
+ * @packageDocumentation
+ */
+const change_1 = require("../common/change");
+Object.defineProperty(exports, "Change", { enumerable: true, get: function () { return change_1.Change; } });

package/lib/v2/index.d.ts

@@ -7,12 +7,14 @@
  */
 import * as logger from '../logger';
 import * as alerts from './providers/alerts';
+import * as database from './providers/database';
 import * as eventarc from './providers/eventarc';
 import * as https from './providers/https';
 import * as identity from './providers/identity';
 import * as pubsub from './providers/pubsub';
 import * as storage from './providers/storage';
 import * as tasks from './providers/tasks';
-export { alerts, storage, https, identity, pubsub, logger, tasks, eventarc };
+export { alerts, database, storage, https, identity, pubsub, logger, tasks, eventarc, };
 export { setGlobalOptions, GlobalOptions, SupportedRegion, MemoryOption, VpcEgressSetting, IngressSetting, EventHandlerOptions, } from './options';
+export { Change } from '../common/change';
 export { CloudFunction, CloudEvent } from './core';

package/lib/v2/index.js

@@ -21,7 +21,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setGlobalOptions = exports.eventarc = exports.tasks = exports.logger = exports.pubsub = exports.identity = exports.https = exports.storage = exports.alerts = void 0;
+exports.Change = exports.setGlobalOptions = exports.eventarc = exports.tasks = exports.logger = exports.pubsub = exports.identity = exports.https = exports.storage = exports.database = exports.alerts = void 0;
 /**
  * The V2 API for Cloud Functions for Firebase.
  * This SDK also supports deep imports. For example, the namespace
@@ -33,6 +33,8 @@ const logger = require("../logger");
 exports.logger = logger;
 const alerts = require("./providers/alerts");
 exports.alerts = alerts;
+const database = require("./providers/database");
+exports.database = database;
 const eventarc = require("./providers/eventarc");
 exports.eventarc = eventarc;
 const https = require("./providers/https");
@@ -47,3 +49,5 @@ const tasks = require("./providers/tasks");
 exports.tasks = tasks;
 var options_1 = require("./options");
 Object.defineProperty(exports, "setGlobalOptions", { enumerable: true, get: function () { return options_1.setGlobalOptions; } });
+var change_1 = require("../common/change");
+Object.defineProperty(exports, "Change", { enumerable: true, get: function () { return change_1.Change; } });

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

@@ -0,0 +1,182 @@
+import { Change } from '../../common/change';
+import { DataSnapshot } from '../../common/providers/database';
+import { CloudEvent, CloudFunction } from '../core';
+import * as options from '../options';
+export { DataSnapshot };
+/** @hidden */
+export interface RawRTDBCloudEventData {
+    ['@type']: 'type.googleapis.com/google.events.firebase.database.v1.ReferenceEventData';
+    data: any;
+    delta: any;
+}
+/** @hidden */
+export interface RawRTDBCloudEvent extends CloudEvent<RawRTDBCloudEventData> {
+    firebasedatabasehost: string;
+    instance: string;
+    ref: string;
+    location: string;
+}
+/** A CloudEvent that contains a DataSnapshot or a Change<DataSnapshot> */
+export interface DatabaseEvent<T> extends CloudEvent<T> {
+    /** The domain of the database instance */
+    firebaseDatabaseHost: string;
+    /** The instance ID portion of the fully qualified resource name */
+    instance: string;
+    /** The database reference path */
+    ref: string;
+    /** The location of the database */
+    location: string;
+    /**
+     * An object containing the values of the path patterns.
+     * Only named capture groups will be populated - {key}, {key=*}, {key=**}
+     */
+    params: Record<string, string>;
+}
+/** ReferenceOptions extend EventHandlerOptions with provided ref and optional instance  */
+export interface ReferenceOptions extends options.EventHandlerOptions {
+    /**
+     * Specify the handler to trigger on a database reference(s).
+     * This value can either be a single reference or a pattern.
+     * Examples: '/foo/bar', '/foo/{bar}'
+     */
+    ref: string;
+    /**
+     * Specify the handler to trigger on a database instance(s).
+     * If present, this value can either be a single instance or a pattern.
+     * Examples: 'my-instance-1', 'my-instance-*'
+     * Note: The capture syntax cannot be used for 'instance'.
+     */
+    instance?: string;
+    /**
+     * Region where functions should be deployed.
+     */
+    region?: options.SupportedRegion | string;
+    /**
+     * Amount of memory to allocate to a function.
+     * A value of null restores the defaults of 256MB.
+     */
+    memory?: options.MemoryOption | null;
+    /**
+     * Timeout for the function in sections, possible values are 0 to 540.
+     * HTTPS functions can specify a higher timeout.
+     * A value of null restores the default of 60s
+     * The minimum timeout for a gen 2 function is 1s. The maximum timeout for a
+     * function depends on the type of function: Event handling functions have a
+     * maximum timeout of 540s (9 minutes). HTTPS and callable functions have a
+     * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
+     * timeout of 1,800s (30 minutes)
+     */
+    timeoutSeconds?: number | null;
+    /**
+     * Min number of actual instances to be running at a given time.
+     * Instances will be billed for memory allocation and 10% of CPU allocation
+     * while idle.
+     * A value of null restores the default min instances.
+     */
+    minInstances?: number | null;
+    /**
+     * Max number of instances to be running in parallel.
+     * A value of null restores the default max instances.
+     */
+    maxInstances?: number | null;
+    /**
+     * Number of requests a function can serve at once.
+     * Can only be applied to functions running on Cloud Functions v2.
+     * A value of null restores the default concurrency (80 when CPU >= 1, 1 otherwise).
+     * Concurrency cannot be set to any value other than 1 if `cpu` is less than 1.
+     * The maximum value for concurrency is 1,000.
+     */
+    concurrency?: number | null;
+    /**
+     * Fractional number of CPUs to allocate to a function.
+     * Defaults to 1 for functions with <= 2GB RAM and increases for larger memory sizes.
+     * This is different from the defaults when using the gcloud utility and is different from
+     * the fixed amount assigned in Google Cloud Functions generation 1.
+     * To revert to the CPU amounts used in gcloud or in Cloud Functions generation 1, set this
+     * to the value "gcf_gen1"
+     */
+    cpu?: number | 'gcf_gen1';
+    /**
+     * Connect cloud function to specified VPC connector.
+     * A value of null removes the VPC connector
+     */
+    vpcConnector?: string | null;
+    /**
+     * Egress settings for VPC connector.
+     * A value of null turns off VPC connector egress settings
+     */
+    vpcConnectorEgressSettings?: options.VpcEgressSetting | null;
+    /**
+     * Specific service account for the function to run as.
+     * A value of null restores the default service account.
+     */
+    serviceAccount?: string | null;
+    /**
+     * Ingress settings which control where this function can be called from.
+     * A value of null turns off ingress settings.
+     */
+    ingressSettings?: options.IngressSetting | null;
+    /**
+     * User labels to set on the function.
+     */
+    labels?: Record<string, string>;
+    secrets?: string[];
+    /** Whether failed executions should be delivered again. */
+    retry?: boolean;
+}
+/**
+ * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+ */
+export declare function onValueWritten(reference: string, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+ */
+export declare function onValueWritten(opts: ReferenceOptions, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is created in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database create occurs.
+ */
+export declare function onValueCreated(reference: string, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is created in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database create occurs.
+ */
+export declare function onValueCreated(opts: ReferenceOptions, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is updated in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database update occurs.
+ */
+export declare function onValueUpdated(reference: string, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is updated in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database update occurs.
+ */
+export declare function onValueUpdated(opts: ReferenceOptions, handler: (event: DatabaseEvent<Change<DataSnapshot>>) => any | Promise<any>): CloudFunction<DatabaseEvent<Change<DataSnapshot>>>;
+/**
+ * Event handler which triggers when data is deleted in Realtime Database.
+ *
+ * @param reference - The database reference path to trigger on.
+ * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+ */
+export declare function onValueDeleted(reference: string, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;
+/**
+ * Event handler which triggers when data is deleted in Realtime Database.
+ *
+ * @param opts - Options that can be set on an individual event-handling function.
+ * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+ */
+export declare function onValueDeleted(opts: ReferenceOptions, handler: (event: DatabaseEvent<DataSnapshot>) => any | Promise<any>): CloudFunction<DatabaseEvent<DataSnapshot>>;

package/lib/v2/providers/database.js

@@ -0,0 +1,204 @@
+"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 apps_1 = require("../../apps");
+const database_1 = require("../../common/providers/database");
+Object.defineProperty(exports, "DataSnapshot", { enumerable: true, get: function () { return database_1.DataSnapshot; } });
+const path_1 = require("../../utilities/path");
+const path_pattern_1 = require("../../utilities/path-pattern");
+const utils_1 = require("../../utils");
+const options = require("../options");
+/** @internal */
+exports.writtenEventType = 'google.firebase.database.ref.v1.written';
+/** @internal */
+exports.createdEventType = 'google.firebase.database.ref.v1.created';
+/** @internal */
+exports.updatedEventType = 'google.firebase.database.ref.v1.updated';
+/** @internal */
+exports.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.
+ */
+function onValueWritten(referenceOrOpts, handler) {
+    return onChangedOperation(exports.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.
+ */
+function onValueCreated(referenceOrOpts, handler) {
+    return onOperation(exports.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.
+ */
+function onValueUpdated(referenceOrOpts, handler) {
+    return onChangedOperation(exports.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.
+ */
+function onValueDeleted(referenceOrOpts, handler) {
+    // TODO - need to use event.data.delta
+    return onOperation(exports.deletedEventType, referenceOrOpts, handler);
+}
+exports.onValueDeleted = onValueDeleted;
+/** @internal */
+function getOpts(referenceOrOpts) {
+    let path, instance, 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,
+    };
+}
+exports.getOpts = getOpts;
+/** @internal */
+function makeParams(event, path, 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, apps_1.apps)().admin, 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, apps_1.apps)().admin, instance);
+    const after = new database_1.DataSnapshot((0, utils_1.applyChange)(event.data.data, event.data.delta), event.ref, (0, apps_1.apps)().admin, instance);
+    const databaseEvent = {
+        ...event,
+        firebaseDatabaseHost: event.firebasedatabasehost,
+        data: {
+            before,
+            after,
+        },
+        params,
+    };
+    delete databaseEvent.firebasedatabasehost;
+    return databaseEvent;
+}
+/** @internal */
+function makeEndpoint(eventType, opts, path, instance) {
+    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 {
+        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: 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 = `https://${event.instance}.${event.firebasedatabasehost}`;
+        const params = makeParams(event, pathPattern, instancePattern);
+        const databaseEvent = makeChangedDatabaseEvent(event, instanceUrl, params);
+        return 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 = `https://${event.instance}.${event.firebasedatabasehost}`;
+        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 handler(databaseEvent);
+    };
+    func.run = handler;
+    func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+    return func;
+}
+exports.onOperation = onOperation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-functions",
-  "version": "3.21.2",
+  "version": "3.22.0",
   "description": "Firebase SDK for Cloud Functions",
   "keywords": [
     "firebase",
@@ -65,7 +65,8 @@
     "./v2/alerts/billing": "./lib/v2/providers/alerts/billing.js",
     "./v2/alerts/crashlytics": "./lib/v2/providers/alerts/crashlytics.js",
     "./v2/eventarc": "./lib/v2/providers/eventarc.js",
-    "./v2/identity": "./lib/v2/providers/identity.js"
+    "./v2/identity": "./lib/v2/providers/identity.js",
+    "./v2/database": "./lib/v2/providers/database.js"
   },
   "typesVersions": {
     "*": {
@@ -126,6 +127,9 @@
       "v2/base": [
         "lib/v2/base"
       ],
+      "v2/database": [
+        "lib/v2/providers/database"
+      ],
       "v2/eventarc": [
         "lib/v2/providers/eventarc"
       ],
@@ -225,7 +229,7 @@
     "yargs": "^15.3.1"
   },
   "peerDependencies": {
-    "firebase-admin": "^8.0.0 || ^9.0.0 || ^10.0.0"
+    "firebase-admin": "^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0"
   },
   "engines": {
     "node": "^8.13.0 || >=10.10.0"