firebase-functions 3.18.1 → 3.20.1

package/lib/providers/tasks.d.ts

@@ -0,0 +1,46 @@
+import * as express from 'express';
+import { Request } from '../common/providers/https';
+import { ManifestEndpoint, ManifestRequiredAPI } from '../runtime/manifest';
+import { TaskContext, RateLimits, RetryConfig } from '../common/providers/tasks';
+export { 
+/** @hidden */
+RetryConfig as RetryPolicy, 
+/** @hidden */
+RateLimits, 
+/** @hidden */
+TaskContext, };
+/**
+ * Configurations for Task Queue Functions.
+ * @hidden
+ */
+export interface TaskQueueOptions {
+    retryConfig?: RetryConfig;
+    rateLimits?: RateLimits;
+    /**
+     * Who can enqueue tasks for this function.
+     * If left unspecified, only service accounts which have
+     * roles/cloudtasks.enqueuer and roles/cloudfunctions.invoker
+     * will have permissions.
+     */
+    invoker?: 'private' | string | string[];
+}
+/** @hidden */
+export interface TaskQueueFunction {
+    (req: Request, res: express.Response): Promise<void>;
+    __trigger: unknown;
+    __endpoint: ManifestEndpoint;
+    __requiredAPIs?: ManifestRequiredAPI[];
+    run(data: any, context: TaskContext): void | Promise<void>;
+}
+/** @hidden */
+export declare class TaskQueueBuilder {
+    private readonly tqOpts?;
+    private readonly depOpts?;
+    onDispatch(handler: (data: any, context: TaskContext) => void | Promise<void>): TaskQueueFunction;
+}
+/**
+ * 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.
+ * @hidden
+ */
+export declare function taskQueue(options?: TaskQueueOptions): TaskQueueBuilder;

package/lib/providers/tasks.js

@@ -0,0 +1,75 @@
+"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.taskQueue = exports.TaskQueueBuilder = void 0;
+const cloud_functions_1 = require("../cloud-functions");
+const encoding_1 = require("../common/encoding");
+const tasks_1 = require("../common/providers/tasks");
+/** @hidden */
+class TaskQueueBuilder {
+    /** @internal */
+    constructor(tqOpts, depOpts) {
+        this.tqOpts = tqOpts;
+        this.depOpts = depOpts;
+    }
+    onDispatch(handler) {
+        // onEnqueueHandler sniffs the function length of the passed-in callback
+        // and the user could have only tried to listen to data. Wrap their handler
+        // in another handler to avoid accidentally triggering the v2 API
+        const fixedLen = (data, context) => handler(data, context);
+        const func = tasks_1.onDispatchHandler(fixedLen);
+        func.__trigger = {
+            ...cloud_functions_1.optionsToTrigger(this.depOpts || {}),
+            taskQueueTrigger: {},
+        };
+        encoding_1.copyIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, 'retryConfig');
+        encoding_1.copyIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, 'rateLimits');
+        encoding_1.convertIfPresent(func.__trigger.taskQueueTrigger, this.tqOpts, 'invoker', 'invoker', encoding_1.convertInvoker);
+        func.__endpoint = {
+            platform: 'gcfv1',
+            ...cloud_functions_1.optionsToEndpoint(this.depOpts),
+            taskQueueTrigger: {},
+        };
+        encoding_1.copyIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, 'retryConfig');
+        encoding_1.copyIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, 'rateLimits');
+        encoding_1.convertIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, 'invoker', 'invoker', encoding_1.convertInvoker);
+        func.__requiredAPIs = [
+            {
+                api: 'cloudtasks.googleapis.com',
+                reason: 'Needed for task queue functions',
+            },
+        ];
+        func.run = handler;
+        return func;
+    }
+}
+exports.TaskQueueBuilder = TaskQueueBuilder;
+/**
+ * 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.
+ * @hidden
+ */
+function taskQueue(options) {
+    return new TaskQueueBuilder(options);
+}
+exports.taskQueue = taskQueue;

package/lib/providers/testLab.js

@@ -57,7 +57,7 @@ class TestMatrixBuilder {
         const dataConstructor = (raw) => {
             return new TestMatrix(raw.data);
         };
-        return (0, cloud_functions_1.makeCloudFunction)({
+        return cloud_functions_1.makeCloudFunction({
             provider: exports.PROVIDER,
             eventType: exports.TEST_MATRIX_COMPLETE_EVENT_TYPE,
             triggerResource: this.triggerResource,

package/lib/runtime/manifest.d.ts

@@ -18,16 +18,18 @@ export interface ManifestEndpoint {
     labels?: Record<string, string>;
     ingressSettings?: string;
     environmentVariables?: Record<string, string>;
-    secretEnvironmentVariables?: {
+    secretEnvironmentVariables?: Array<{
         key: string;
         secret?: string;
-    }[];
+    }>;
     httpsTrigger?: {
         invoker?: string[];
     };
     callableTrigger?: {};
     eventTrigger?: {
         eventFilters: Record<string, string>;
+        eventFilterPathPatterns?: Record<string, string>;
+        channel?: string;
         eventType: string;
         retry: boolean;
         region?: string;
@@ -51,7 +53,7 @@ export interface ManifestRequiredAPI {
 }
 /**
  * An definition of a function deployment as appears in the Manifest.
- **/
+ */
 export interface ManifestStack {
     specVersion: 'v1alpha1';
     requiredAPIs: ManifestRequiredAPI[];

package/lib/runtime/manifest.js

@@ -1,2 +1,23 @@
 "use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2021 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 });

package/lib/setup.js

@@ -31,7 +31,7 @@ function setup() {
     // Until the Cloud Functions builder can publish FIREBASE_CONFIG, automatically provide it on import based on what
     // we can deduce.
     if (!process.env.FIREBASE_CONFIG) {
-        const cfg = (0, config_1.firebaseConfig)();
+        const cfg = config_1.firebaseConfig();
         if (cfg) {
             process.env.FIREBASE_CONFIG = JSON.stringify(cfg);
         }
@@ -43,7 +43,7 @@ function setup() {
     // If FIREBASE_CONFIG is still not found, try using GCLOUD_PROJECT to estimate
     if (!process.env.FIREBASE_CONFIG) {
         if (process.env.GCLOUD_PROJECT) {
-            (0, logger_1.warn)('Warning, estimating Firebase Config based on GCLOUD_PROJECT. Initializing firebase-admin may fail');
+            logger_1.warn('Warning, estimating Firebase Config based on GCLOUD_PROJECT. Initializing firebase-admin may fail');
             process.env.FIREBASE_CONFIG = JSON.stringify({
                 databaseURL: process.env.DATABASE_URL ||
                     `https://${process.env.GCLOUD_PROJECT}.firebaseio.com`,
@@ -53,7 +53,7 @@ function setup() {
             });
         }
         else {
-            (0, logger_1.warn)('Warning, FIREBASE_CONFIG and GCLOUD_PROJECT environment variables are missing. Initializing firebase-admin will fail');
+            logger_1.warn('Warning, FIREBASE_CONFIG and GCLOUD_PROJECT environment variables are missing. Initializing firebase-admin will fail');
         }
     }
 }

package/lib/v2/index.d.ts

@@ -4,6 +4,8 @@ import * as alerts from './providers/alerts';
 import * as https from './providers/https';
 import * as pubsub from './providers/pubsub';
 import * as storage from './providers/storage';
-export { https, pubsub, storage, logger, params, alerts };
+import * as tasks from './providers/tasks';
+import * as eventarc from './providers/eventarc';
+export { alerts, https, pubsub, storage, logger, params, tasks, eventarc };
 export { setGlobalOptions, GlobalOptions } from './options';
 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.alerts = exports.params = exports.logger = exports.storage = exports.pubsub = exports.https = void 0;
+exports.setGlobalOptions = exports.eventarc = exports.tasks = exports.params = exports.logger = exports.storage = exports.pubsub = exports.https = exports.alerts = void 0;
 const logger = require("../logger");
 exports.logger = logger;
 const params = require("./params");
@@ -34,5 +34,9 @@ const pubsub = require("./providers/pubsub");
 exports.pubsub = pubsub;
 const storage = require("./providers/storage");
 exports.storage = storage;
+const tasks = require("./providers/tasks");
+exports.tasks = tasks;
+const eventarc = require("./providers/eventarc");
+exports.eventarc = eventarc;
 var options_1 = require("./options");
 Object.defineProperty(exports, "setGlobalOptions", { enumerable: true, get: function () { return options_1.setGlobalOptions; } });

package/lib/v2/options.d.ts

@@ -2,7 +2,7 @@ import { ParamSpec } from './params/types';
 /**
  * List of all regions supported by Cloud Functions v2
  */
-export declare const SUPPORTED_REGIONS: readonly ["us-west1", "us-central1", "europe-west4", "asia-northeast1"];
+export declare const SUPPORTED_REGIONS: readonly ["asia-northeast1", "europe-north1", "europe-west1", "europe-west4", "us-central1", "us-east1", "us-west1"];
 /**
  * A region known to be supported by CloudFunctions v2
  */
@@ -26,7 +26,7 @@ export declare const MAX_CONCURRENCY = 1000;
 /**
  * List of available memory options supported by Cloud Functions.
  */
-export declare const SUPPORTED_MEMORY_OPTIONS: readonly ["256MB", "512MB", "1GB", "2GB", "4GB", "8GB"];
+export declare const SUPPORTED_MEMORY_OPTIONS: readonly ["128MB", "256MB", "512MB", "1GB", "2GB", "4GB", "8GB", "16GB", "32GB"];
 /**
  * A supported memory option.
  */

package/lib/v2/options.js

@@ -29,10 +29,13 @@ const params_1 = require("./params");
  * List of all regions supported by Cloud Functions v2
  */
 exports.SUPPORTED_REGIONS = [
-    'us-west1',
-    'us-central1',
-    'europe-west4',
     'asia-northeast1',
+    'europe-north1',
+    'europe-west1',
+    'europe-west4',
+    'us-central1',
+    'us-east1',
+    'us-west1',
 ];
 /**
  * Cloud Functions v2 min timeout value.
@@ -54,20 +57,26 @@ exports.MAX_CONCURRENCY = 1000;
  * List of available memory options supported by Cloud Functions.
  */
 exports.SUPPORTED_MEMORY_OPTIONS = [
+    '128MB',
     '256MB',
     '512MB',
     '1GB',
     '2GB',
     '4GB',
     '8GB',
+    '16GB',
+    '32GB',
 ];
 const MemoryOptionToMB = {
+    '128MB': 128,
     '256MB': 256,
     '512MB': 512,
     '1GB': 1024,
     '2GB': 2048,
     '4GB': 4096,
     '8GB': 8192,
+    '16GB': 16384,
+    '32GB': 32768,
 };
 /**
  * List of available options for VpcConnectorEgressSettings.
@@ -111,19 +120,19 @@ exports.getGlobalOptions = getGlobalOptions;
  */
 function optionsToTriggerAnnotations(opts) {
     const annotation = {};
-    (0, encoding_1.copyIfPresent)(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings');
-    (0, encoding_1.convertIfPresent)(annotation, opts, 'availableMemoryMb', 'memory', (mem) => {
+    encoding_1.copyIfPresent(annotation, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'vpcConnector', 'vpcConnectorEgressSettings');
+    encoding_1.convertIfPresent(annotation, opts, 'availableMemoryMb', 'memory', (mem) => {
         return MemoryOptionToMB[mem];
     });
-    (0, encoding_1.convertIfPresent)(annotation, opts, 'regions', 'region', (region) => {
+    encoding_1.convertIfPresent(annotation, opts, 'regions', 'region', (region) => {
         if (typeof region === 'string') {
             return [region];
         }
         return region;
     });
-    (0, encoding_1.convertIfPresent)(annotation, opts, 'serviceAccountEmail', 'serviceAccount', encoding_1.serviceAccountFromShorthand);
-    (0, encoding_1.convertIfPresent)(annotation, opts, 'timeout', 'timeoutSeconds', encoding_1.durationFromSeconds);
-    (0, encoding_1.convertIfPresent)(annotation, opts, 'failurePolicy', 'retry', (retry) => {
+    encoding_1.convertIfPresent(annotation, opts, 'serviceAccountEmail', 'serviceAccount', encoding_1.serviceAccountFromShorthand);
+    encoding_1.convertIfPresent(annotation, opts, 'timeout', 'timeoutSeconds', encoding_1.durationFromSeconds);
+    encoding_1.convertIfPresent(annotation, opts, 'failurePolicy', 'retry', (retry) => {
         return retry ? { retry: true } : null;
     });
     return annotation;
@@ -135,14 +144,14 @@ exports.optionsToTriggerAnnotations = optionsToTriggerAnnotations;
  */
 function optionsToEndpoint(opts) {
     const endpoint = {};
-    (0, encoding_1.copyIfPresent)(endpoint, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'timeoutSeconds');
-    (0, encoding_1.convertIfPresent)(endpoint, opts, 'serviceAccountEmail', 'serviceAccount');
+    encoding_1.copyIfPresent(endpoint, opts, 'concurrency', 'minInstances', 'maxInstances', 'ingressSettings', 'labels', 'timeoutSeconds');
+    encoding_1.convertIfPresent(endpoint, opts, 'serviceAccountEmail', 'serviceAccount');
     if (opts.vpcConnector) {
         const vpc = { connector: opts.vpcConnector };
-        (0, encoding_1.convertIfPresent)(vpc, opts, 'egressSettings', 'vpcConnectorEgressSettings');
+        encoding_1.convertIfPresent(vpc, opts, 'egressSettings', 'vpcConnectorEgressSettings');
         endpoint.vpc = vpc;
     }
-    (0, encoding_1.convertIfPresent)(endpoint, opts, 'availableMemoryMb', 'memory', (mem) => {
+    encoding_1.convertIfPresent(endpoint, opts, 'availableMemoryMb', 'memory', (mem) => {
         const memoryLookup = {
             '128MB': 128,
             '256MB': 256,
@@ -154,7 +163,7 @@ function optionsToEndpoint(opts) {
         };
         return memoryLookup[mem];
     });
-    (0, encoding_1.convertIfPresent)(endpoint, opts, 'region', 'region', (region) => {
+    encoding_1.convertIfPresent(endpoint, opts, 'region', 'region', (region) => {
         if (typeof region === 'string') {
             return [region];
         }

package/lib/v2/providers/alerts/alerts.js

@@ -37,13 +37,13 @@ function getEndpointAnnotation(opts, alertType, appId) {
         eventTrigger: {
             eventType: exports.eventType,
             eventFilters: {
-                alertType,
+                alerttype: alertType,
             },
             retry: !!opts.retry,
         },
     };
     if (appId) {
-        endpoint.eventTrigger.eventFilters.appId = appId;
+        endpoint.eventTrigger.eventFilters.appid = appId;
     }
     return endpoint;
 }

package/lib/v2/providers/alerts/appDistribution.js

@@ -14,7 +14,7 @@ function onNewTesterIosDevicePublished(appIdOrOptsOrHandler, handler) {
         return handler(raw);
     };
     func.run = handler;
-    func.__endpoint = (0, alerts_1.getEndpointAnnotation)(opts, exports.newTesterIosDeviceAlert, appId);
+    func.__endpoint = alerts_1.getEndpointAnnotation(opts, exports.newTesterIosDeviceAlert, appId);
     return func;
 }
 exports.onNewTesterIosDevicePublished = onNewTesterIosDevicePublished;

package/lib/v2/providers/alerts/billing.d.ts

@@ -33,6 +33,6 @@ export declare function onPlanUpdatePublished(opts: options.EventHandlerOptions,
 /**
  * Declares a function that can handle an automated billing plan update event.
  */
-export declare function onAutomatedPlanUpdatePublished(handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
-export declare function onAutomatedPlanUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
+export declare function onPlanAutomatedUpdatePublished(handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
+export declare function onPlanAutomatedUpdatePublished(opts: options.EventHandlerOptions, handler: (event: BillingEvent<PlanAutomatedUpdatePayload>) => any | Promise<any>): CloudFunction<FirebaseAlertData<PlanAutomatedUpdatePayload>>;
 export {};

package/lib/v2/providers/alerts/billing.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onOperation = exports.onAutomatedPlanUpdatePublished = exports.onPlanUpdatePublished = exports.automatedPlanUpdateAlert = exports.planUpdateAlert = void 0;
+exports.onOperation = exports.onPlanAutomatedUpdatePublished = exports.onPlanUpdatePublished = exports.planAutomatedUpdateAlert = exports.planUpdateAlert = void 0;
 const _1 = require(".");
 /** @internal */
 exports.planUpdateAlert = 'billing.planUpdate';
 /** @internal */
-exports.automatedPlanUpdateAlert = 'billing.automatedPlanUpdate';
+exports.planAutomatedUpdateAlert = 'billing.planAutomatedUpdate';
 function onPlanUpdatePublished(optsOrHandler, handler) {
     return onOperation(exports.planUpdateAlert, optsOrHandler, handler);
 }
 exports.onPlanUpdatePublished = onPlanUpdatePublished;
-function onAutomatedPlanUpdatePublished(optsOrHandler, handler) {
-    return onOperation(exports.automatedPlanUpdateAlert, optsOrHandler, handler);
+function onPlanAutomatedUpdatePublished(optsOrHandler, handler) {
+    return onOperation(exports.planAutomatedUpdateAlert, optsOrHandler, handler);
 }
-exports.onAutomatedPlanUpdatePublished = onAutomatedPlanUpdatePublished;
+exports.onPlanAutomatedUpdatePublished = onPlanAutomatedUpdatePublished;
 /** @internal */
 function onOperation(alertType, optsOrHandler, handler) {
     if (typeof optsOrHandler === 'function') {
@@ -24,7 +24,7 @@ function onOperation(alertType, optsOrHandler, handler) {
         return handler(raw);
     };
     func.run = handler;
-    func.__endpoint = (0, _1.getEndpointAnnotation)(optsOrHandler, alertType);
+    func.__endpoint = _1.getEndpointAnnotation(optsOrHandler, alertType);
     return func;
 }
 exports.onOperation = onOperation;

package/lib/v2/providers/alerts/crashlytics.js

@@ -49,7 +49,7 @@ function onOperation(alertType, appIdOrOptsOrHandler, handler) {
         return handler(raw);
     };
     func.run = handler;
-    func.__endpoint = (0, _1.getEndpointAnnotation)(opts, alertType, appId);
+    func.__endpoint = _1.getEndpointAnnotation(opts, alertType, appId);
     return func;
 }
 exports.onOperation = onOperation;

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

@@ -0,0 +1,32 @@
+import * as options from '../options';
+import { CloudEvent, CloudFunction } from '../core';
+/** Options that can be set on an Eventarc trigger. */
+export interface EventarcTriggerOptions extends options.EventHandlerOptions {
+    /**
+     * Type of the event.
+     */
+    eventType: string;
+    /**
+     * ID of the channel. Can be either:
+     *   * fully qualified channel resource name:
+     *     `projects/{project}/locations/{location}/channels/{channel-id}`
+     *   * partial resource name with location and channel ID, in which case
+     *     the runtime project ID of the function will be used:
+     *     `locations/{location}/channels/{channel-id}`
+     *   * partial channel ID, in which case the runtime project ID of the
+     *     function and `us-central1` as location will be used:
+     *     `{channel-id}`
+     *
+     * If not specified, the default Firebase channel will be used:
+     * `projects/{project}/locations/us-central1/channels/firebase`
+     */
+    channel?: string;
+    /**
+     * Eventarc event exact match filter.
+     */
+    filters?: Record<string, string>;
+}
+export declare type CloudEventHandler = (event: CloudEvent<any>) => any | Promise<any>;
+/** Handle an Eventarc event published on the default channel. */
+export declare function onCustomEventPublished<T = any>(eventType: string, handler: CloudEventHandler): CloudFunction<CloudEvent<T>>;
+export declare function onCustomEventPublished<T = any>(opts: EventarcTriggerOptions, handler: CloudEventHandler): CloudFunction<CloudEvent<T>>;

package/lib/v2/providers/eventarc.js

@@ -0,0 +1,65 @@
+"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.onCustomEventPublished = void 0;
+const options = require("../options");
+const encoding_1 = require("../../common/encoding");
+function onCustomEventPublished(eventTypeOrOpts, handler) {
+    var _a;
+    let opts;
+    if (typeof eventTypeOrOpts === 'string') {
+        opts = {
+            eventType: eventTypeOrOpts,
+        };
+    }
+    else if (typeof eventTypeOrOpts === 'object') {
+        opts = eventTypeOrOpts;
+    }
+    const func = (raw) => {
+        return handler(raw);
+    };
+    func.run = handler;
+    const channel = (_a = opts.channel) !== null && _a !== void 0 ? _a : 'locations/us-central1/channels/firebase';
+    const baseOpts = options.optionsToEndpoint(options.getGlobalOptions());
+    const specificOpts = options.optionsToEndpoint(opts);
+    const endpoint = {
+        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: opts.eventType,
+            eventFilters: {},
+            retry: false,
+            channel,
+        },
+    };
+    encoding_1.convertIfPresent(endpoint.eventTrigger, opts, 'eventFilters', 'filters');
+    encoding_1.copyIfPresent(endpoint.eventTrigger, opts, 'retry');
+    func.__endpoint = endpoint;
+    return func;
+}
+exports.onCustomEventPublished = onCustomEventPublished;

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

@@ -1,23 +1,12 @@
 import * as express from 'express';
 import * as options from '../options';
-import { CallableRequest, FunctionsErrorCode, HttpsError, Request, TaskRateLimits, TaskRequest, TaskRetryConfig } from '../../common/providers/https';
+import { CallableRequest, FunctionsErrorCode, HttpsError, Request } from '../../common/providers/https';
 import { ManifestEndpoint } from '../../runtime/manifest';
-export { Request, CallableRequest, FunctionsErrorCode, HttpsError, TaskRateLimits, TaskRequest, TaskRetryConfig as TaskRetryPolicy, };
+export { Request, CallableRequest, FunctionsErrorCode, HttpsError };
 export interface HttpsOptions extends Omit<options.GlobalOptions, 'region'> {
     region?: options.SupportedRegion | string | Array<options.SupportedRegion | string>;
     cors?: string | boolean | RegExp | Array<string | RegExp>;
 }
-export interface TaskQueueOptions extends options.GlobalOptions {
-    retryConfig?: TaskRetryConfig;
-    rateLimits?: TaskRateLimits;
-    /**
-     * Who can enqueue tasks for this function.
-     * If left unspecified, only service accounts which have
-     * roles/cloudtasks.enqueuer and roles/cloudfunctions.invoker
-     * will have permissions.
-     */
-    invoker?: 'private' | string | string[];
-}
 export declare type HttpsFunction = ((req: Request, res: express.Response) => void | Promise<void>) & {
     __trigger?: unknown;
     __endpoint: ManifestEndpoint;
@@ -25,14 +14,7 @@ export declare type HttpsFunction = ((req: Request, res: express.Response) => vo
 export interface CallableFunction<T, Return> extends HttpsFunction {
     run(data: CallableRequest<T>): Return;
 }
-export interface TaskQueueFunction<T = any> extends HttpsFunction {
-    run(data: TaskRequest<T>): void | Promise<void>;
-}
 export declare function onRequest(opts: HttpsOptions, handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
 export declare function onRequest(handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
 export declare function onCall<T = any, Return = any | Promise<any>>(opts: HttpsOptions, handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;
 export declare function onCall<T = any, Return = any | Promise<any>>(handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;
-/** Handle a request sent to a Cloud Tasks queue. */
-export declare function onTaskDispatched<Args = any>(handler: (request: TaskRequest<Args>) => void | Promise<void>): TaskQueueFunction<Args>;
-/** Handle a request sent to a Cloud Tasks queue. */
-export declare function onTaskDispatched<Args = any>(options: TaskQueueOptions, handler: (request: TaskRequest<Args>) => void | Promise<void>): TaskQueueFunction<Args>;