firebase-functions 6.0.1 → 6.1.1

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

@@ -85,6 +85,14 @@ export interface CallableRequest<T = any> {
      */
     rawRequest: Request;
 }
+/**
+ * CallableProxyResponse exposes subset of express.Response object
+ * to allow writing partial, streaming responses back to the client.
+ */
+export interface CallableProxyResponse {
+    write: express.Response["write"];
+    acceptsStreaming: boolean;
+}
 /**
  * The set of Firebase Functions status codes. The codes are the same at the
  * ones exposed by {@link https://github.com/grpc/grpc/blob/master/doc/statuscodes.md | gRPC}.

package/lib/common/providers/https.js

@@ -385,8 +385,8 @@ async function checkAppCheckToken(req, ctx, options) {
     }
 }
 /** @internal */
-function onCallHandler(options, handler) {
-    const wrapped = wrapOnCallHandler(options, handler);
+function onCallHandler(options, handler, version) {
+    const wrapped = wrapOnCallHandler(options, handler, version);
     return (req, res) => {
         return new Promise((resolve) => {
             res.on("finish", resolve);
@@ -397,8 +397,11 @@ function onCallHandler(options, handler) {
     };
 }
 exports.onCallHandler = onCallHandler;
+function encodeSSE(data) {
+    return `data: ${JSON.stringify(data)}\n`;
+}
 /** @internal */
-function wrapOnCallHandler(options, handler) {
+function wrapOnCallHandler(options, handler, version) {
     return async (req, res) => {
         try {
             if (!isValidRequest(req)) {
@@ -413,7 +416,7 @@ function wrapOnCallHandler(options, handler) {
             // The original monkey-patched code lived in the functionsEmulatorRuntime
             // (link: https://github.com/firebase/firebase-tools/blob/accea7abda3cc9fa6bb91368e4895faf95281c60/src/emulator/functionsEmulatorRuntime.ts#L480)
             // and was not compatible with how monorepos separate out packages (see https://github.com/firebase/firebase-tools/issues/5210).
-            if ((0, debug_1.isDebugFeatureEnabled)("skipTokenVerification") && handler.length === 2) {
+            if ((0, debug_1.isDebugFeatureEnabled)("skipTokenVerification") && version === "gcfv1") {
                 const authContext = context.rawRequest.header(exports.CALLABLE_AUTH_HEADER);
                 if (authContext) {
                     logger.debug("Callable functions auth override", {
@@ -452,9 +455,14 @@ function wrapOnCallHandler(options, handler) {
                 // pushes with FCM. In that case, the FCM APIs will validate the token.
                 context.instanceIdToken = req.header("Firebase-Instance-ID-Token");
             }
+            const acceptsStreaming = req.header("accept") === "text/event-stream";
+            if (acceptsStreaming && version === "gcfv1") {
+                // streaming responses are not supported in v1 callable
+                throw new HttpsError("invalid-argument", "Unsupported Accept header 'text/event-stream'");
+            }
             const data = decode(req.body.data);
             let result;
-            if (handler.length === 2) {
+            if (version === "gcfv1") {
                 result = await handler(data, context);
             }
             else {
@@ -462,15 +470,36 @@ function wrapOnCallHandler(options, handler) {
                     ...context,
                     data,
                 };
+                // TODO: set up optional heartbeat
+                const responseProxy = {
+                    write(chunk) {
+                        if (acceptsStreaming) {
+                            const formattedData = encodeSSE({ message: chunk });
+                            return res.write(formattedData);
+                        }
+                        // if client doesn't accept sse-protocol, response.write() is no-op.
+                    },
+                    acceptsStreaming,
+                };
+                if (acceptsStreaming) {
+                    // SSE always responds with 200
+                    res.status(200);
+                }
                 // For some reason the type system isn't picking up that the handler
                 // is a one argument function.
-                result = await handler(arg);
+                result = await handler(arg, responseProxy);
             }
             // Encode the result as JSON to preserve types like Dates.
             result = encode(result);
             // If there was some result, encode it in the body.
             const responseBody = { result };
-            res.status(200).send(responseBody);
+            if (acceptsStreaming) {
+                res.write(encodeSSE(responseBody));
+                res.end();
+            }
+            else {
+                res.status(200).send(responseBody);
+            }
         }
         catch (err) {
             let httpErr = err;
@@ -481,7 +510,12 @@ function wrapOnCallHandler(options, handler) {
             }
             const { status } = httpErr.httpErrorCode;
             const body = { error: httpErr.toJSON() };
-            res.status(status).send(body);
+            if (version === "gcfv2" && req.header("accept") === "text/event-stream") {
+                res.send(encodeSSE(body));
+            }
+            else {
+                res.status(status).send(body);
+            }
         }
     };
 }

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

@@ -7,7 +7,7 @@ export { HttpsError };
  * @hidden
  * @alpha
  */
-export type AuthBlockingEventType = "beforeCreate" | "beforeSignIn";
+export type AuthBlockingEventType = "beforeCreate" | "beforeSignIn" | "beforeSendEmail" | "beforeSendSms";
 /**
  * The `UserRecord` passed to Cloud Functions is the same
  * {@link https://firebase.google.com/docs/reference/admin/node/firebase-admin.auth.userrecord | UserRecord}
@@ -179,11 +179,13 @@ export interface AuthUserRecord {
 }
 /** The additional user info component of the auth event context */
 export interface AdditionalUserInfo {
-    providerId: string;
+    providerId?: string;
     profile?: any;
     username?: string;
     isNewUser: boolean;
     recaptchaScore?: number;
+    email?: string;
+    phoneNumber?: string;
 }
 /** The credential component of the auth event context */
 export interface Credential {
@@ -198,6 +200,19 @@ export interface Credential {
     providerId: string;
     signInMethod: string;
 }
+/**
+ * Possible types of emails as described by the GCIP backend, which can be:
+ * - A sign-in email
+ * - A password reset email
+ */
+export type EmailType = "EMAIL_SIGN_IN" | "PASSWORD_RESET";
+/**
+ * The type of SMS message, which can be:
+ * - A sign-in or sign up SMS message
+ * - A multi-factor sign-in SMS message
+ * - A multi-factor enrollment SMS message
+ */
+export type SmsType = "SIGN_IN_OR_SIGN_UP" | "MULTI_FACTOR_SIGN_IN" | "MULTI_FACTOR_ENROLLMENT";
 /** Defines the auth event context for blocking events */
 export interface AuthEventContext extends EventContext {
     locale?: string;
@@ -205,15 +220,23 @@ export interface AuthEventContext extends EventContext {
     userAgent: string;
     additionalUserInfo?: AdditionalUserInfo;
     credential?: Credential;
+    emailType?: EmailType;
+    smsType?: SmsType;
 }
 /** Defines the auth event for 2nd gen blocking events */
 export interface AuthBlockingEvent extends AuthEventContext {
-    data: AuthUserRecord;
+    data?: AuthUserRecord;
 }
-/**
- * The reCAPTCHA action options.
- */
+/** The reCAPTCHA action options. */
 export type RecaptchaActionOptions = "ALLOW" | "BLOCK";
+/** The handler response type for `beforeEmailSent` blocking events */
+export interface BeforeEmailResponse {
+    recaptchaActionOverride?: RecaptchaActionOptions;
+}
+/** The handler response type for `beforeSmsSent` blocking events */
+export interface BeforeSmsResponse {
+    recaptchaActionOverride?: RecaptchaActionOptions;
+}
 /** The handler response type for `beforeCreate` blocking events */
 export interface BeforeCreateResponse {
     displayName?: string;
@@ -227,3 +250,9 @@ export interface BeforeCreateResponse {
 export interface BeforeSignInResponse extends BeforeCreateResponse {
     sessionClaims?: object;
 }
+export type MaybeAsync<T> = T | Promise<T>;
+export type HandlerV1 = (userOrContext: AuthUserRecord | AuthEventContext, context?: AuthEventContext) => MaybeAsync<BeforeCreateResponse | BeforeSignInResponse | BeforeEmailResponse | BeforeSmsResponse | void>;
+export type HandlerV2 = (event: AuthBlockingEvent) => MaybeAsync<BeforeCreateResponse | BeforeSignInResponse | BeforeEmailResponse | BeforeSmsResponse | void>;
+export type AuthBlockingEventHandler = (HandlerV1 | HandlerV2) & {
+    platform: "gcfv1" | "gcfv2";
+};

package/lib/common/providers/identity.js

@@ -49,6 +49,8 @@ const CLAIMS_MAX_PAYLOAD_SIZE = 1000;
 const EVENT_MAPPING = {
     beforeCreate: "providers/cloud.auth/eventTypes/user.beforeCreate",
     beforeSignIn: "providers/cloud.auth/eventTypes/user.beforeSignIn",
+    beforeSendEmail: "providers/cloud.auth/eventTypes/user.beforeSendEmail",
+    beforeSendSms: "providers/cloud.auth/eventTypes/user.beforeSendSms",
 };
 /**
  * Helper class to create the user metadata in a `UserRecord` object.
@@ -302,6 +304,8 @@ function parseAdditionalUserInfo(decodedJWT) {
         username,
         isNewUser: decodedJWT.event_type === "beforeCreate" ? true : false,
         recaptchaScore: decodedJWT.recaptcha_score,
+        email: decodedJWT.email,
+        phoneNumber: decodedJWT.phone_number,
     };
 }
 /**
@@ -372,6 +376,8 @@ function parseAuthEventContext(decodedJWT, projectId, time = new Date().getTime(
         timestamp: new Date(decodedJWT.iat * 1000).toUTCString(),
         additionalUserInfo: parseAdditionalUserInfo(decodedJWT),
         credential: parseAuthCredential(decodedJWT, time),
+        emailType: decodedJWT.email_type,
+        smsType: decodedJWT.sms_type,
         params: {},
     };
 }
@@ -443,15 +449,20 @@ function wrapHandler(eventType, handler) {
             }
             const decodedPayload = (0, debug_1.isDebugFeatureEnabled)("skipTokenVerification")
                 ? unsafeDecodeAuthBlockingToken(req.body.data.jwt)
-                : handler.length === 2
+                : handler.platform === "gcfv1"
                     ? await auth.getAuth((0, app_1.getApp)())._verifyAuthBlockingToken(req.body.data.jwt)
                     : await auth.getAuth((0, app_1.getApp)())._verifyAuthBlockingToken(req.body.data.jwt, "run.app");
-            const authUserRecord = parseAuthUserRecord(decodedPayload.user_record);
+            let authUserRecord;
+            if (decodedPayload.event_type === "beforeCreate" ||
+                decodedPayload.event_type === "beforeSignIn") {
+                authUserRecord = parseAuthUserRecord(decodedPayload.user_record);
+            }
             const authEventContext = parseAuthEventContext(decodedPayload, projectId);
             let authResponse;
-            if (handler.length === 2) {
-                authResponse =
-                    (await handler(authUserRecord, authEventContext)) || undefined;
+            if (handler.platform === "gcfv1") {
+                authResponse = authUserRecord
+                    ? (await handler(authUserRecord, authEventContext)) || undefined
+                    : (await handler(authEventContext)) || undefined;
             }
             else {
                 authResponse =

package/lib/v1/providers/auth.d.ts

@@ -1,4 +1,4 @@
-import { AuthEventContext, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, HttpsError, UserInfo, UserRecord, userRecordConstructor, UserRecordMetadata } from "../../common/providers/identity";
+import { AuthEventContext, AuthUserRecord, BeforeCreateResponse, BeforeEmailResponse, BeforeSignInResponse, BeforeSmsResponse, HttpsError, MaybeAsync, UserInfo, UserRecord, userRecordConstructor, UserRecordMetadata } from "../../common/providers/identity";
 import { BlockingFunction, CloudFunction, EventContext } from "../cloud-functions";
 export { UserRecord, UserInfo, UserRecordMetadata, userRecordConstructor };
 export { HttpsError };
@@ -57,7 +57,7 @@ export declare class UserBuilder {
      *
      * @public
      */
-    beforeCreate(handler: (user: AuthUserRecord, context: AuthEventContext) => BeforeCreateResponse | void | Promise<BeforeCreateResponse> | Promise<void>): BlockingFunction;
+    beforeCreate(handler: (user: AuthUserRecord, context: AuthEventContext) => MaybeAsync<BeforeCreateResponse | void>): BlockingFunction;
     /**
      * Blocks request to sign-in a Firebase Auth user.
      *
@@ -65,7 +65,9 @@ export declare class UserBuilder {
      *
      * @public
      */
-    beforeSignIn(handler: (user: AuthUserRecord, context: AuthEventContext) => BeforeSignInResponse | void | Promise<BeforeSignInResponse> | Promise<void>): BlockingFunction;
+    beforeSignIn(handler: (user: AuthUserRecord, context: AuthEventContext) => MaybeAsync<BeforeSignInResponse | void>): BlockingFunction;
+    beforeEmail(handler: (context: AuthEventContext) => MaybeAsync<BeforeEmailResponse | void>): BlockingFunction;
+    beforeSms(handler: (context: AuthEventContext) => MaybeAsync<BeforeSmsResponse | void>): BlockingFunction;
     private onOperation;
     private beforeOperation;
 }

package/lib/v1/providers/auth.js

@@ -108,6 +108,12 @@ class UserBuilder {
     beforeSignIn(handler) {
         return this.beforeOperation(handler, "beforeSignIn");
     }
+    beforeEmail(handler) {
+        return this.beforeOperation(handler, "beforeSendEmail");
+    }
+    beforeSms(handler) {
+        return this.beforeOperation(handler, "beforeSendSms");
+    }
     onOperation(handler, eventType) {
         return (0, cloud_functions_1.makeCloudFunction)({
             handler,
@@ -126,10 +132,8 @@ class UserBuilder {
         const accessToken = ((_b = (_a = this.userOptions) === null || _a === void 0 ? void 0 : _a.blockingOptions) === null || _b === void 0 ? void 0 : _b.accessToken) || false;
         const idToken = ((_d = (_c = this.userOptions) === null || _c === void 0 ? void 0 : _c.blockingOptions) === null || _d === void 0 ? void 0 : _d.idToken) || false;
         const refreshToken = ((_f = (_e = this.userOptions) === null || _e === void 0 ? void 0 : _e.blockingOptions) === null || _f === void 0 ? void 0 : _f.refreshToken) || false;
-        // Create our own function that just calls the provided function so we know for sure that
-        // handler takes two arguments. This is something common/providers/identity depends on.
-        const wrappedHandler = (user, context) => handler(user, context);
-        const func = (0, identity_1.wrapHandler)(eventType, wrappedHandler);
+        const annotatedHandler = Object.assign(handler, { platform: "gcfv1" });
+        const func = (0, identity_1.wrapHandler)(eventType, annotatedHandler);
         const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
         func.__trigger = {
             labels: {},

package/lib/v1/providers/https.js

@@ -70,9 +70,8 @@ function _onRequestWithOptions(handler, options) {
 exports._onRequestWithOptions = _onRequestWithOptions;
 /** @internal */
 function _onCallWithOptions(handler, options) {
-    // onCallHandler 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
+    // fix the length of handler to make the call to handler consistent
+    // in the onCallHandler
     const fixedLen = (data, context) => {
         return (0, onInit_1.withInit)(handler)(data, context);
     };
@@ -80,7 +79,7 @@ function _onCallWithOptions(handler, options) {
         enforceAppCheck: options.enforceAppCheck,
         consumeAppCheckToken: options.consumeAppCheckToken,
         cors: { origin: true, methods: "POST" },
-    }, fixedLen));
+    }, fixedLen, "gcfv1"));
     func.__trigger = {
         labels: {},
         ...(0, cloud_functions_1.optionsToTrigger)(options),

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

@@ -1,6 +1,6 @@
 import * as express from "express";
 import { ResetValue } from "../../common/options";
-import { CallableRequest, FunctionsErrorCode, HttpsError, Request } from "../../common/providers/https";
+import { CallableRequest, CallableProxyResponse, FunctionsErrorCode, HttpsError, Request } from "../../common/providers/https";
 import { ManifestEndpoint } from "../../runtime/manifest";
 import { GlobalOptions, SupportedRegion } from "../options";
 import { Expression } from "../../params";
@@ -175,10 +175,10 @@ export declare function onRequest(handler: (request: Request, response: express.
  * @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: CallableOptions, handler: (request: CallableRequest<T>) => Return): CallableFunction<T, Return extends Promise<unknown> ? Return : Promise<Return>>;
+export declare function onCall<T = any, Return = any | Promise<any>>(opts: CallableOptions, handler: (request: CallableRequest<T>, response?: CallableProxyResponse) => Return): CallableFunction<T, Return extends Promise<unknown> ? Return : Promise<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 extends Promise<unknown> ? Return : Promise<Return>>;
+export declare function onCall<T = any, Return = any | Promise<any>>(handler: (request: CallableRequest<T>, response?: CallableProxyResponse) => Return): CallableFunction<T, Return extends Promise<unknown> ? Return : Promise<Return>>;

package/lib/v2/providers/https.js

@@ -130,15 +130,14 @@ function onCall(optsOrHandler, handler) {
     if (Array.isArray(origin) && origin.length === 1) {
         origin = origin[0];
     }
-    // onCallHandler sniffs the function length to determine which API to present.
-    // fix the length to prevent api versions from being mismatched.
-    const fixedLen = (req) => (0, onInit_1.withInit)(handler)(req);
+    // fix the length of handler to make the call to handler consistent
+    const fixedLen = (req, resp) => (0, onInit_1.withInit)(handler)(req, resp);
     let func = (0, https_1.onCallHandler)({
         cors: { origin, methods: "POST" },
         enforceAppCheck: (_a = opts.enforceAppCheck) !== null && _a !== void 0 ? _a : options.getGlobalOptions().enforceAppCheck,
         consumeAppCheckToken: opts.consumeAppCheckToken,
-    }, fixedLen);
-    func = (0, trace_1.wrapTraceContext)(func);
+    }, fixedLen, "gcfv2");
+    func = (0, trace_1.wrapTraceContext)((0, onInit_1.withInit)(func));
     Object.defineProperty(func, "__trigger", {
         get: () => {
             const baseOpts = options.optionsToTriggerAnnotations(options.getGlobalOptions());

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

@@ -3,7 +3,7 @@
  * @packageDocumentation
  */
 import { ResetValue } from "../../common/options";
-import { AuthBlockingEvent, AuthBlockingEventType, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, HttpsError } from "../../common/providers/identity";
+import { AuthBlockingEvent, AuthBlockingEventType, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, BeforeEmailResponse, BeforeSmsResponse, HandlerV2, HttpsError, MaybeAsync } from "../../common/providers/identity";
 import { BlockingFunction } from "../../v1/cloud-functions";
 import { Expression } from "../../params";
 import * as options from "../options";
@@ -107,27 +107,49 @@ export interface BlockingOptions {
 }
 /**
  * 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
+ * @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;
+export declare function beforeUserCreated(handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeCreateResponse | 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
+ * @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;
+export declare function beforeUserCreated(opts: BlockingOptions, handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeCreateResponse | 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
+ * @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;
+export declare function beforeUserSignedIn(handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeSignInResponse | 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
+ * @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;
+export declare function beforeUserSignedIn(opts: BlockingOptions, handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeSignInResponse | void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before an email is sent to a user.
+ * @param handler - Event handler that is run before an email is sent to a user.
+ */
+export declare function beforeEmailSent(handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeEmailResponse | void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before an email is sent to a user.
+ * @param opts - Object containing function options.
+ * @param handler - Event handler that is run before an email is sent to a user.
+ */
+export declare function beforeEmailSent(opts: Omit<BlockingOptions, "idToken" | "accessToken" | "refreshToken">, handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeEmailResponse | void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before an SMS is sent to a user.
+ * @param handler - Event handler that is run before an SMS is sent to a user.
+ */
+export declare function beforeSmsSent(handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeSmsResponse | void>): BlockingFunction;
+/**
+ * Handles an event that is triggered before an SMS is sent to a user.
+ * @param opts - Object containing function options.
+ * @param handler - Event handler that is run before an SMS is sent to a user.
+ */
+export declare function beforeSmsSent(opts: Omit<BlockingOptions, "idToken" | "accessToken" | "refreshToken">, handler: (event: AuthBlockingEvent) => MaybeAsync<BeforeSmsResponse | 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;
+export declare function beforeOperation(eventType: AuthBlockingEventType, optsOrHandler: BlockingOptions | ((event: AuthBlockingEvent) => MaybeAsync<BeforeCreateResponse | BeforeSignInResponse | BeforeEmailResponse | BeforeSmsResponse | void>), handler: HandlerV2): BlockingFunction;
 /** @hidden */
 export declare function getOpts(blockingOptions: BlockingOptions): InternalOptions;

package/lib/v2/providers/identity.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.getOpts = exports.beforeOperation = exports.beforeUserSignedIn = exports.beforeUserCreated = exports.HttpsError = void 0;
+exports.getOpts = exports.beforeOperation = exports.beforeSmsSent = exports.beforeEmailSent = 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 trace_1 = require("../trace");
@@ -29,9 +29,9 @@ const manifest_1 = require("../../runtime/manifest");
 const options = require("../options");
 const onInit_1 = require("../../common/onInit");
 /**
- * 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
+ * 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);
@@ -39,24 +39,42 @@ function beforeUserCreated(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
+ * @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;
+/**
+ * Handles an event that is triggered before an email is sent to a user.
+ * @param optsOrHandler- Either an object containing function options, or an event handler that is run before an email is sent to a user.
+ * @param handler - Event handler that is run before an email is sent to a user.
+ */
+function beforeEmailSent(optsOrHandler, handler) {
+    return beforeOperation("beforeSendEmail", optsOrHandler, handler);
+}
+exports.beforeEmailSent = beforeEmailSent;
+/**
+ * Handles an event that is triggered before an SMS is sent to a user.
+ * @param optsOrHandler - Either an object containing function options, or an event handler that is run before an SMS is sent to a user.
+ * @param handler - Event handler that is run before an SMS is sent to a user.
+ */
+function beforeSmsSent(optsOrHandler, handler) {
+    return beforeOperation("beforeSendSms", optsOrHandler, handler);
+}
+exports.beforeSmsSent = beforeSmsSent;
 /** @hidden */
 function beforeOperation(eventType, optsOrHandler, handler) {
     if (!handler || typeof optsOrHandler === "function") {
         handler = optsOrHandler;
         optsOrHandler = {};
     }
-    const { opts, accessToken, idToken, refreshToken } = getOpts(optsOrHandler);
+    const { opts, ...blockingOptions } = 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, trace_1.wrapTraceContext)((0, onInit_1.withInit)((0, identity_1.wrapHandler)(eventType, wrappedHandler)));
+    const annotatedHandler = Object.assign(handler, { platform: "gcfv2" });
+    const func = (0, trace_1.wrapTraceContext)((0, onInit_1.withInit)((0, identity_1.wrapHandler)(eventType, annotatedHandler)));
     const legacyEventType = `providers/cloud.auth/eventTypes/user.${eventType}`;
     /** Endpoint */
     const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions());
@@ -73,9 +91,7 @@ function beforeOperation(eventType, optsOrHandler, handler) {
         blockingTrigger: {
             eventType: legacyEventType,
             options: {
-                accessToken,
-                idToken,
-                refreshToken,
+                ...((eventType === "beforeCreate" || eventType === "beforeSignIn") && blockingOptions),
             },
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-functions",
-  "version": "6.0.1",
+  "version": "6.1.1",
   "description": "Firebase SDK for Cloud Functions",
   "keywords": [
     "firebase",
@@ -270,9 +270,9 @@
   },
   "dependencies": {
     "@types/cors": "^2.8.5",
-    "@types/express": "4.17.3",
+    "@types/express": "^4.17.21",
     "cors": "^2.8.5",
-    "express": "^4.17.1",
+    "express": "^4.21.0",
     "protobufjs": "^7.2.2"
   },
   "devDependencies": {
@@ -299,7 +299,7 @@
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-jsdoc": "^39.2.9",
     "eslint-plugin-prettier": "^4.0.0",
-    "firebase-admin": "^12.1.0",
+    "firebase-admin": "^13.0.0",
     "js-yaml": "^3.13.1",
     "jsdom": "^16.2.1",
     "jsonwebtoken": "^9.0.0",
@@ -319,7 +319,7 @@
     "yargs": "^15.3.1"
   },
   "peerDependencies": {
-    "firebase-admin": "^11.10.0 || ^12.0.0"
+    "firebase-admin": "^11.10.0 || ^12.0.0 || ^13.0.0"
   },
   "engines": {
     "node": ">=14.10.0"