firebase-functions 3.20.0 → 3.21.1

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

@@ -0,0 +1,116 @@
+import { CloudEvent, CloudFunction } from '../core';
+import * as options from '../options';
+/** Options that can be set on an Eventarc trigger. */
+export interface EventarcTriggerOptions extends options.EventHandlerOptions {
+    /**
+     * Type of the event to trigger on.
+     */
+    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>;
+    /**
+     * 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;
+}
+/** Handles an Eventarc event published on the default channel.
+ * @param eventType - Type of the event to trigger on.
+ * @param handler - A function to execute when triggered.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onCustomEventPublished<T = any>(eventType: string, handler: (event: CloudEvent<T>) => any | Promise<any>): CloudFunction<CloudEvent<T>>;
+/** Handles an Eventarc event.
+ * @param opts - Options to set on this function
+ * @param handler - A function to execute when triggered.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onCustomEventPublished<T = any>(opts: EventarcTriggerOptions, handler: (event: CloudEvent<T>) => any | Promise<any>): CloudFunction<CloudEvent<T>>;

package/lib/v2/providers/eventarc.js

@@ -0,0 +1,69 @@
+"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;
+/**
+ * Cloud functions to integrate directly with Eventarc.
+ * @packageDocumentation
+ */
+const encoding_1 = require("../../common/encoding");
+const options = require("../options");
+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,
+        },
+    };
+    (0, encoding_1.convertIfPresent)(endpoint.eventTrigger, opts, 'eventFilters', 'filters');
+    (0, encoding_1.copyIfPresent)(endpoint.eventTrigger, opts, 'retry');
+    func.__endpoint = endpoint;
+    return func;
+}
+exports.onCustomEventPublished = onCustomEventPublished;

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

@@ -1,20 +1,144 @@
 import * as express from 'express';
-import * as options from '../options';
 import { CallableRequest, FunctionsErrorCode, HttpsError, Request } from '../../common/providers/https';
 import { ManifestEndpoint } from '../../runtime/manifest';
+import * as options from '../options';
+import { GlobalOptions, SupportedRegion } from '../options';
 export { Request, CallableRequest, FunctionsErrorCode, HttpsError };
-export interface HttpsOptions extends Omit<options.GlobalOptions, 'region'> {
-    region?: options.SupportedRegion | string | Array<options.SupportedRegion | string>;
+/**
+ * Options that can be set on an individual HTTPS function.
+ */
+export interface HttpsOptions extends Omit<GlobalOptions, 'region'> {
+    /** HTTP functions can override global options and can specify multiple regions to deploy to. */
+    region?: SupportedRegion | string | Array<SupportedRegion | string>;
+    /** If true, allows CORS on requests to this function.
+     * If this is a `string` or `RegExp`, allows requests from domains that match the provided value.
+     * If this is an `Array`, allows requests from domains matching at least one entry of the array.
+     * Defaults to true for {@link https.CallableFunction} and false otherwise.
+     */
     cors?: string | boolean | RegExp | Array<string | RegExp>;
+    /**
+     * 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>;
+    /**
+     * Invoker to set access control on https functions.
+     */
+    invoker?: 'public' | 'private' | string | string[];
+    secrets?: string[];
+    /** Whether failed executions should be delivered again. */
+    retry?: boolean;
 }
-export declare type HttpsFunction = ((req: Request, res: express.Response) => void | Promise<void>) & {
+/**
+ * Handles HTTPS requests.
+ */
+export declare type HttpsFunction = ((
+/** An Express request object representing the HTTPS call to the function. */
+req: Request, 
+/** An Express response object, for this function to respond to callers. */
+res: express.Response) => void | Promise<void>) & {
+    /** @alpha */
     __trigger?: unknown;
+    /** @alpha */
     __endpoint: ManifestEndpoint;
 };
+/**
+ * Creates a callable method for clients to call using a Firebase SDK.
+ */
 export interface CallableFunction<T, Return> extends HttpsFunction {
+    /** Executes the handler function with the provided data as input. Used for unit testing.
+     * @param data - An input for the handler function.
+     * @returns The output of the handler function.
+     */
     run(data: CallableRequest<T>): Return;
 }
+/**
+ * Handles HTTPS requests.
+ * @param opts - Options to set on this function
+ * @param handler - A function that takes a {@link https.Request} and response object, same signature as an Express app.
+ * @returns A function that you can export and deploy.
+ */
 export declare function onRequest(opts: HttpsOptions, handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
+/**
+ * Handles HTTPS requests.
+ * @param handler - A function that takes a {@link https.Request} and response object, same signature as an Express app.
+ * @returns A function that you can export and deploy.
+ */
 export declare function onRequest(handler: (request: Request, response: express.Response) => void | Promise<void>): HttpsFunction;
+/**
+ * Declares a callable method for clients to call using a Firebase SDK.
+ * @param opts - Options to set on this function.
+ * @param handler - A function that takes a {@link https.CallableRequest}.
+ * @returns A function that you can export and deploy.
+ */
 export declare function onCall<T = any, Return = any | Promise<any>>(opts: HttpsOptions, handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;
+/**
+ * Declares a callable method for clients to call using a Firebase SDK.
+ * @param handler - A function that takes a {@link https.CallableRequest}.
+ * @returns A function that you can export and deploy.
+ */
 export declare function onCall<T = any, Return = any | Promise<any>>(handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return>;

package/lib/v2/providers/https.js

@@ -22,11 +22,16 @@
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onCall = exports.onRequest = exports.HttpsError = void 0;
+/**
+ * Cloud functions to handle HTTPS request or callable RPCs.
+ * @packageDocumentation
+ */
 const cors = require("cors");
 const encoding_1 = require("../../common/encoding");
-const options = require("../options");
+const debug_1 = require("../../common/debug");
 const https_1 = require("../../common/providers/https");
 Object.defineProperty(exports, "HttpsError", { enumerable: true, get: function () { return https_1.HttpsError; } });
+const options = require("../options");
 function onRequest(optsOrHandler, handler) {
     let opts;
     if (arguments.length === 1) {
@@ -36,12 +41,13 @@ function onRequest(optsOrHandler, handler) {
     else {
         opts = optsOrHandler;
     }
-    if ('cors' in opts) {
+    if ((0, debug_1.isDebugFeatureEnabled)('enableCors') || 'cors' in opts) {
+        const origin = (0, debug_1.isDebugFeatureEnabled)('enableCors') ? true : opts.cors;
         const userProvidedHandler = handler;
         handler = (req, res) => {
             return new Promise((resolve) => {
                 res.on('finish', resolve);
-                cors({ origin: opts.cors })(req, res, () => {
+                cors({ origin })(req, res, () => {
                     resolve(userProvidedHandler(req, res));
                 });
             });
@@ -54,9 +60,6 @@ function onRequest(optsOrHandler, handler) {
             // but optionsToTriggerAnnotations handles both cases.
             const specificOpts = options.optionsToTriggerAnnotations(opts);
             const trigger = {
-                // TODO(inlined): Remove "apiVersion" once the latest version of the CLI
-                // has migrated to "platform".
-                apiVersion: 2,
                 platform: 'gcfv2',
                 ...baseOpts,
                 ...specificOpts,
@@ -68,7 +71,7 @@ function onRequest(optsOrHandler, handler) {
                     allowInsecure: false,
                 },
             };
-            encoding_1.convertIfPresent(trigger.httpsTrigger, opts, 'invoker', 'invoker', encoding_1.convertInvoker);
+            (0, encoding_1.convertIfPresent)(trigger.httpsTrigger, opts, 'invoker', 'invoker', encoding_1.convertInvoker);
             return trigger;
         },
     });
@@ -86,7 +89,7 @@ function onRequest(optsOrHandler, handler) {
         },
         httpsTrigger: {},
     };
-    encoding_1.convertIfPresent(endpoint.httpsTrigger, opts, 'invoker', 'invoker', encoding_1.convertInvoker);
+    (0, encoding_1.convertIfPresent)(endpoint.httpsTrigger, opts, 'invoker', 'invoker', encoding_1.convertInvoker);
     handler.__endpoint = endpoint;
     return handler;
 }
@@ -100,11 +103,15 @@ function onCall(optsOrHandler, handler) {
     else {
         opts = optsOrHandler;
     }
-    const origin = 'cors' in opts ? opts.cors : true;
+    const origin = (0, debug_1.isDebugFeatureEnabled)('enableCors')
+        ? true
+        : 'cors' in opts
+            ? opts.cors
+            : true;
     // onCallHandler sniffs the function length to determine which API to present.
     // fix the length to prevent api versions from being mismatched.
     const fixedLen = (req) => handler(req);
-    const func = https_1.onCallHandler({ cors: { origin, methods: 'POST' } }, fixedLen);
+    const func = (0, https_1.onCallHandler)({ cors: { origin, methods: 'POST' } }, fixedLen);
     Object.defineProperty(func, '__trigger', {
         get: () => {
             const baseOpts = options.optionsToTriggerAnnotations(options.getGlobalOptions());
@@ -112,9 +119,6 @@ function onCall(optsOrHandler, handler) {
             // but optionsToTriggerAnnotations handles both cases.
             const specificOpts = options.optionsToTriggerAnnotations(opts);
             return {
-                // TODO(inlined): Remove "apiVersion" once the latest version of the CLI
-                // has migrated to "platform".
-                apiVersion: 2,
                 platform: 'gcfv2',
                 ...baseOpts,
                 ...specificOpts,
@@ -131,7 +135,7 @@ function onCall(optsOrHandler, handler) {
     });
     const baseOpts = options.optionsToEndpoint(options.getGlobalOptions());
     // global options calls region a scalar and https allows it to be an array,
-    // but optionsToManifestEndpoint handles both cases.
+    // but optionsToEndpoint handles both cases.
     const specificOpts = options.optionsToEndpoint(opts);
     func.__endpoint = {
         platform: 'gcfv2',

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

@@ -0,0 +1,126 @@
+/**
+ * Cloud functions to handle events from Google Cloud Identity Platform.
+ * @packageDocumentation
+ */
+import { BlockingFunction } from '../../cloud-functions';
+import { AuthBlockingEvent, AuthBlockingEventType, BeforeCreateResponse, BeforeSignInResponse, HttpsError } from '../../common/providers/identity';
+import * as options from '../options';
+export { HttpsError };
+/** @hidden Internally used when parsing the options. */
+interface InternalOptions {
+    opts: options.GlobalOptions;
+    idToken: boolean;
+    accessToken: boolean;
+    refreshToken: boolean;
+}
+/**
+ * All function options plus idToken, accessToken, and refreshToken.
+ */
+export interface BlockingOptions {
+    /** Pass the ID Token credential to the function. */
+    idToken?: boolean;
+    /** Pass the Access Token credential to the function. */
+    accessToken?: boolean;
+    /** Pass the Refresh Token credential to the function. */
+    refreshToken?: boolean;
+    /**
+     * 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[];
+}
+/**
+ * Handles an event that is triggered before a user is created.
+ * @param handler - Event handler which is run every time before a user is created
+ */
+export declare function beforeUserCreated(handler: (event: AuthBlockingEvent) => BeforeCreateResponse | Promise<BeforeCreateResponse> | void | Promise<void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before a user is created.
+ * @param opts - Object containing function options
+ * @param handler - Event handler which is run every time before a user is created
+ */
+export declare function beforeUserCreated(opts: BlockingOptions, handler: (event: AuthBlockingEvent) => BeforeCreateResponse | Promise<BeforeCreateResponse> | void | Promise<void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before a user is signed in.
+ * @param handler - Event handler which is run every time before a user is signed in
+ */
+export declare function beforeUserSignedIn(handler: (event: AuthBlockingEvent) => BeforeSignInResponse | Promise<BeforeSignInResponse> | void | Promise<void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before a user is signed in.
+ * @param opts - Object containing function options
+ * @param handler - Event handler which is run every time before a user is signed in
+ */
+export declare function beforeUserSignedIn(opts: BlockingOptions, handler: (event: AuthBlockingEvent) => BeforeSignInResponse | Promise<BeforeSignInResponse> | void | Promise<void>): BlockingFunction;
+/** @hidden */
+export declare function beforeOperation(eventType: AuthBlockingEventType, optsOrHandler: BlockingOptions | ((event: AuthBlockingEvent) => BeforeCreateResponse | BeforeSignInResponse | void | Promise<BeforeCreateResponse> | Promise<BeforeSignInResponse> | Promise<void>), handler: (event: AuthBlockingEvent) => BeforeCreateResponse | BeforeSignInResponse | void | Promise<BeforeCreateResponse> | Promise<BeforeSignInResponse> | Promise<void>): BlockingFunction;
+/** @hidden */
+export declare function getOpts(blockingOptions: BlockingOptions): InternalOptions;

package/lib/v2/providers/identity.js

@@ -0,0 +1,104 @@
+"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.getOpts = exports.beforeOperation = exports.beforeUserSignedIn = exports.beforeUserCreated = exports.HttpsError = void 0;
+const identity_1 = require("../../common/providers/identity");
+Object.defineProperty(exports, "HttpsError", { enumerable: true, get: function () { return identity_1.HttpsError; } });
+const options = require("../options");
+/**
+ * Handles an event that is triggered before a user is created
+ * @param optsOrHandler - Either an object containing function options, or an event handler (run before user creation)
+ * @param handler? - If defined, an event handler which is run every time before a user is created
+ */
+function beforeUserCreated(optsOrHandler, handler) {
+    return beforeOperation('beforeCreate', optsOrHandler, handler);
+}
+exports.beforeUserCreated = beforeUserCreated;
+/**
+ * Handles an event that is triggered before a user is signed in.
+ * @param optsOrHandler - Either an object containing function options, or an event handler (run before user signin)
+ * @param handler - Event handler which is run every time before a user is signed in
+ */
+function beforeUserSignedIn(optsOrHandler, handler) {
+    return beforeOperation('beforeSignIn', optsOrHandler, handler);
+}
+exports.beforeUserSignedIn = beforeUserSignedIn;
+/** @hidden */
+function beforeOperation(eventType, optsOrHandler, handler) {
+    if (!handler || typeof optsOrHandler === 'function') {
+        handler = optsOrHandler;
+        optsOrHandler = {};
+    }
+    const { opts, accessToken, idToken, refreshToken } = getOpts(optsOrHandler);
+    // Create our own function that just calls the provided function so we know for sure that
+    // handler takes one argument. This is something common/providers/identity depends on.
+    const wrappedHandler = (event) => handler(event);
+    const func = (0, identity_1.wrapHandler)(eventType, wrappedHandler);
+    const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
+    /** Endpoint */
+    const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions());
+    const specificOptsEndpoint = options.optionsToEndpoint(opts);
+    func.__endpoint = {
+        platform: 'gcfv2',
+        ...baseOptsEndpoint,
+        ...specificOptsEndpoint,
+        labels: {
+            ...baseOptsEndpoint === null || baseOptsEndpoint === void 0 ? void 0 : baseOptsEndpoint.labels,
+            ...specificOptsEndpoint === null || specificOptsEndpoint === void 0 ? void 0 : specificOptsEndpoint.labels,
+        },
+        blockingTrigger: {
+            eventType: legacyEventType,
+            options: {
+                accessToken,
+                idToken,
+                refreshToken,
+            },
+        },
+    };
+    func.__requiredAPIs = [
+        {
+            api: 'identitytoolkit.googleapis.com',
+            reason: 'Needed for auth blocking functions',
+        },
+    ];
+    func.run = handler;
+    return func;
+}
+exports.beforeOperation = beforeOperation;
+/** @hidden */
+function getOpts(blockingOptions) {
+    const accessToken = blockingOptions.accessToken || false;
+    const idToken = blockingOptions.idToken || false;
+    const refreshToken = blockingOptions.refreshToken || false;
+    const opts = { ...blockingOptions };
+    delete opts.accessToken;
+    delete opts.idToken;
+    delete opts.refreshToken;
+    return {
+        opts,
+        accessToken,
+        idToken,
+        refreshToken,
+    };
+}
+exports.getOpts = getOpts;