firebase-functions 4.6.0 → 4.8.0

package/lib/common/onInit.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Registers a callback that should be run when in a production environment
+ * before executing any functions code.
+ * Calling this function more than once leads to undefined behavior.
+ * @param callback initialization callback to be run before any function executes.
+ */
+export declare function onInit(callback: () => unknown): void;

package/lib/common/onInit.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withInit = exports.onInit = void 0;
+const logger = require("../logger");
+let initCallback = null;
+let didInit = false;
+/**
+ * Registers a callback that should be run when in a production environment
+ * before executing any functions code.
+ * Calling this function more than once leads to undefined behavior.
+ * @param callback initialization callback to be run before any function executes.
+ */
+function onInit(callback) {
+    if (initCallback) {
+        logger.warn("Setting onInit callback more than once. Only the most recent callback will be called");
+    }
+    initCallback = callback;
+    didInit = false;
+}
+exports.onInit = onInit;
+/** @internal */
+function withInit(func) {
+    return async (...args) => {
+        if (!didInit) {
+            if (initCallback) {
+                await initCallback();
+            }
+            didInit = true;
+        }
+        // Note: This cast is actually inaccurate because it may be a promise, but
+        // it doesn't actually matter because the async function will promisify
+        // non-promises and forward promises.
+        return func(...args);
+    };
+}
+exports.withInit = withInit;

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

@@ -1,5 +1,12 @@
 import { App } from "firebase-admin/app";
 import * as database from "firebase-admin/database";
+/**
+ * Pulled from @firebase/database-types, make sure the interface is updated on dependencies upgrades.
+ * Represents a child snapshot of a `Reference` that is being iterated over. The key will never be undefined.
+ */
+interface IteratedDataSnapshot extends DataSnapshot {
+    key: string;
+}
 /**
  * Interface representing a Firebase Realtime database data snapshot.
  */
@@ -97,7 +104,7 @@ export declare class DataSnapshot implements database.DataSnapshot {
      * @return `true` if enumeration was canceled due to your callback
      *   returning `true`.
      */
-    forEach(action: (a: DataSnapshot) => boolean | void): boolean;
+    forEach(action: (a: IteratedDataSnapshot) => boolean | void): boolean;
     /**
      * Returns `true` if the specified child path has (non-`null`) data.
      *
@@ -141,3 +148,4 @@ export declare class DataSnapshot implements database.DataSnapshot {
     /** @hidden */
     private _fullPath;
 }
+export {};

package/lib/common/providers/database.js

@@ -101,6 +101,9 @@ class DataSnapshot {
         let source = this._data;
         if (parts.length) {
             for (const part of parts) {
+                if (source[part] === undefined) {
+                    return null;
+                }
                 source = source[part];
             }
         }

package/lib/params/index.d.ts

@@ -3,69 +3,70 @@
  * @alpha
  */
 import { BooleanParam, Expression, IntParam, Param, ParamOptions, SecretParam, StringParam, ListParam } from "./types";
+export { BUCKET_PICKER, TextInput, SelectInput, SelectOptions, MultiSelectInput, select, multiSelect, } from "./types";
 export { ParamOptions, Expression };
 type SecretOrExpr = Param<any> | SecretParam;
 export declare const declaredParams: SecretOrExpr[];
 /**
- * A builtin param that resolves to the default RTDB database URL associated
+ * A built-in parameter that resolves to the default RTDB database URL associated
  * with the project, without prompting the deployer. Empty string if none exists.
  */
 export declare const databaseURL: Param<string>;
 /**
- * A builtin param that resolves to the Cloud project ID associated with
+ * A built-in parameter that resolves to the Cloud project ID associated with
  * the project, without prompting the deployer.
  */
 export declare const projectID: Param<string>;
 /**
- * A builtin param that resolves to the Cloud project ID, without prompting
+ * A built-in parameter that resolves to the Cloud project ID, without prompting
  * the deployer.
  */
 export declare const gcloudProject: Param<string>;
 /**
- * A builtin param that resolves to the Cloud storage bucket associated
+ * A builtin parameter that resolves to the Cloud storage bucket associated
  * with the function, without prompting the deployer. Empty string if not
  * defined.
  */
 export declare const storageBucket: Param<string>;
 /**
  * Declares a secret param, that will persist values only in Cloud Secret Manager.
- * Secrets are stored interally as bytestrings. Use ParamOptions.`as` to provide type
+ * Secrets are stored interally as bytestrings. Use `ParamOptions.as` to provide type
  * hinting during parameter resolution.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string` return type for `.value`.
  */
 export declare function defineSecret(name: string): SecretParam;
 /**
- * Declare a string param.
+ * Declare a string parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string` return type for `.value`.
  */
 export declare function defineString(name: string, options?: ParamOptions<string>): StringParam;
 /**
- * Declare a boolean param.
+ * Declare a boolean parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `boolean` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `boolean` return type for `.value`.
  */
 export declare function defineBoolean(name: string, options?: ParamOptions<boolean>): BooleanParam;
 /**
- * Declare an integer param.
+ * Declare an integer parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `number` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `number` return type for `.value`.
  */
 export declare function defineInt(name: string, options?: ParamOptions<number>): IntParam;
 /**
- * Declare a list param.
+ * Declare a list parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string[]` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string[]` return type for `.value`.
  */
 export declare function defineList(name: string, options?: ParamOptions<string[]>): ListParam;

package/lib/params/index.js

@@ -21,16 +21,20 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineList = exports.defineFloat = exports.defineInt = exports.defineBoolean = exports.defineString = exports.defineSecret = exports.storageBucket = exports.gcloudProject = exports.projectID = exports.databaseURL = exports.clearParams = exports.declaredParams = exports.Expression = void 0;
+exports.defineList = exports.defineFloat = exports.defineInt = exports.defineBoolean = exports.defineString = exports.defineSecret = exports.storageBucket = exports.gcloudProject = exports.projectID = exports.databaseURL = exports.clearParams = exports.declaredParams = exports.Expression = exports.multiSelect = exports.select = exports.BUCKET_PICKER = void 0;
 /**
  * @hidden
  * @alpha
  */
 const types_1 = require("./types");
 Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return types_1.Expression; } });
+var types_2 = require("./types");
+Object.defineProperty(exports, "BUCKET_PICKER", { enumerable: true, get: function () { return types_2.BUCKET_PICKER; } });
+Object.defineProperty(exports, "select", { enumerable: true, get: function () { return types_2.select; } });
+Object.defineProperty(exports, "multiSelect", { enumerable: true, get: function () { return types_2.multiSelect; } });
 exports.declaredParams = [];
 /**
- * Use a helper to manage the list such that params are uniquely
+ * Use a helper to manage the list such that parameters are uniquely
  * registered once only but order is preserved.
  * @internal
  */
@@ -51,34 +55,34 @@ function clearParams() {
 }
 exports.clearParams = clearParams;
 /**
- * A builtin param that resolves to the default RTDB database URL associated
+ * A built-in parameter that resolves to the default RTDB database URL associated
  * with the project, without prompting the deployer. Empty string if none exists.
  */
 exports.databaseURL = new types_1.InternalExpression("DATABASE_URL", (env) => { var _a; return ((_a = JSON.parse(env.FIREBASE_CONFIG)) === null || _a === void 0 ? void 0 : _a.databaseURL) || ""; });
 /**
- * A builtin param that resolves to the Cloud project ID associated with
+ * A built-in parameter that resolves to the Cloud project ID associated with
  * the project, without prompting the deployer.
  */
 exports.projectID = new types_1.InternalExpression("PROJECT_ID", (env) => { var _a; return ((_a = JSON.parse(env.FIREBASE_CONFIG)) === null || _a === void 0 ? void 0 : _a.projectId) || ""; });
 /**
- * A builtin param that resolves to the Cloud project ID, without prompting
+ * A built-in parameter that resolves to the Cloud project ID, without prompting
  * the deployer.
  */
 exports.gcloudProject = new types_1.InternalExpression("GCLOUD_PROJECT", (env) => { var _a; return ((_a = JSON.parse(env.FIREBASE_CONFIG)) === null || _a === void 0 ? void 0 : _a.projectId) || ""; });
 /**
- * A builtin param that resolves to the Cloud storage bucket associated
+ * A builtin parameter that resolves to the Cloud storage bucket associated
  * with the function, without prompting the deployer. Empty string if not
  * defined.
  */
 exports.storageBucket = new types_1.InternalExpression("STORAGE_BUCKET", (env) => { var _a; return ((_a = JSON.parse(env.FIREBASE_CONFIG)) === null || _a === void 0 ? void 0 : _a.storageBucket) || ""; });
 /**
  * Declares a secret param, that will persist values only in Cloud Secret Manager.
- * Secrets are stored interally as bytestrings. Use ParamOptions.`as` to provide type
+ * Secrets are stored interally as bytestrings. Use `ParamOptions.as` to provide type
  * hinting during parameter resolution.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string` return type for `.value`.
  */
 function defineSecret(name) {
     const param = new types_1.SecretParam(name);
@@ -87,11 +91,11 @@ function defineSecret(name) {
 }
 exports.defineSecret = defineSecret;
 /**
- * Declare a string param.
+ * Declare a string parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string` return type for `.value`.
  */
 function defineString(name, options = {}) {
     const param = new types_1.StringParam(name, options);
@@ -100,11 +104,11 @@ function defineString(name, options = {}) {
 }
 exports.defineString = defineString;
 /**
- * Declare a boolean param.
+ * Declare a boolean parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `boolean` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `boolean` return type for `.value`.
  */
 function defineBoolean(name, options = {}) {
     const param = new types_1.BooleanParam(name, options);
@@ -113,11 +117,11 @@ function defineBoolean(name, options = {}) {
 }
 exports.defineBoolean = defineBoolean;
 /**
- * Declare an integer param.
+ * Declare an integer parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `number` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `number` return type for `.value`.
  */
 function defineInt(name, options = {}) {
     const param = new types_1.IntParam(name, options);
@@ -126,11 +130,11 @@ function defineInt(name, options = {}) {
 }
 exports.defineInt = defineInt;
 /**
- * Declare a float param.
+ * Declare a float parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `number` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `number` return type for `.value`.
  *
  * @internal
  */
@@ -141,11 +145,11 @@ function defineFloat(name, options = {}) {
 }
 exports.defineFloat = defineFloat;
 /**
- * Declare a list param.
+ * Declare a list parameter.
  *
- * @param name The name of the environment variable to use to load the param.
- * @param options Configuration options for the param.
- * @returns A Param with a `string[]` return type for `.value`.
+ * @param name The name of the environment variable to use to load the parameter.
+ * @param options Configuration options for the parameter.
+ * @returns A parameter with a `string[]` return type for `.value`.
  */
 function defineList(name, options = {}) {
     const param = new types_1.ListParam(name, options);

package/lib/params/types.d.ts

@@ -1,8 +1,9 @@
 export declare abstract class Expression<T extends string | number | boolean | string[]> {
-    /** Returns the Expression's runtime value, based on the CLI's resolution of params. */
+    /** Returns the expression's runtime value, based on the CLI's resolution of parameters. */
     value(): T;
-    /** Returns the Expression's representation as a braced CEL expression. */
+    /** Returns the expression's representation as a braced CEL expression. */
     toCEL(): string;
+    /** Returns the expression's representation as JSON. */
     toJSON(): string;
 }
 /**
@@ -25,83 +26,93 @@ export declare class CompareExpression<T extends string | number | boolean | str
     rhs: T | Expression<T>;
     constructor(cmp: "==" | "!=" | ">" | ">=" | "<" | "<=", lhs: Expression<T>, rhs: T | Expression<T>);
     toString(): string;
-    /** Returns a TernaryExpression which can resolve to one of two values, based on the resolution of this comparison. */
+    /** Returns a `TernaryExpression` which can resolve to one of two values, based on the resolution of this comparison. */
     thenElse<retT extends string | number | boolean | string[]>(ifTrue: retT | Expression<retT>, ifFalse: retT | Expression<retT>): TernaryExpression<retT>;
 }
 /** @hidden */
 type ParamValueType = "string" | "list" | "boolean" | "int" | "float" | "secret";
-type ParamInput<T> = {
-    text: TextInput<T>;
-} | {
-    select: SelectInput<T>;
-} | {
-    multiSelect: MultiSelectInput;
-} | {
-    resource: ResourceInput;
-};
+/** Create a select input from a series of values. */
+export declare function select<T>(options: T[]): SelectInput<T>;
+/** Create a select input from a map of labels to vaues. */
+export declare function select<T>(optionsWithLabels: Record<string, T>): SelectInput<T>;
+/** Create a multi-select input from a series of values. */
+export declare function multiSelect(options: string[]): MultiSelectInput;
+/** Create a multi-select input from map of labels to values. */
+export declare function multiSelect(options: Record<string, string>): MultiSelectInput;
+type ParamInput<T> = TextInput<T> | SelectInput<T> | (T extends string[] ? MultiSelectInput : never) | (T extends string ? ResourceInput : never);
 /**
- * Specifies that a Param's value should be determined by prompting the user
- * to type it in interactively at deploy-time. Input that does not match the
+ * Specifies that a parameter's value should be determined by prompting the user
+ * to type it in interactively at deploy time. Input that does not match the
  * provided validationRegex, if present, will be retried.
  */
 export interface TextInput<T = unknown> {
-    example?: string;
-    /**
-     * A regular expression (or an escaped string to compile into a regular
-     * expression) which the prompted text must satisfy; the prompt will retry
-     * until input matching the regex is provided.
-     */
-    validationRegex?: string | RegExp;
-    /**
-     * A custom error message to display when retrying the prompt based on input
-     * failing to conform to the validationRegex,
-     */
-    validationErrorMessage?: string;
+    text: {
+        example?: string;
+        /**
+         * A regular expression (or an escaped string to compile into a regular
+         * expression) which the prompted text must satisfy; the prompt will retry
+         * until input matching the regex is provided.
+         */
+        validationRegex?: string | RegExp;
+        /**
+         * A custom error message to display when retrying the prompt based on input
+         * failing to conform to the validationRegex,
+         */
+        validationErrorMessage?: string;
+    };
 }
 /**
- * Specifies that a Param's value should be determined by having the user
+ * Specifies that a parameter's value should be determined by having the user
  * select from a list containing all the project's resources of a certain
  * type. Currently, only type:"storage.googleapis.com/Bucket" is supported.
  */
 export interface ResourceInput {
     resource: {
-        type: string;
+        type: "storage.googleapis.com/Bucket";
     };
 }
 /**
- * Specifies that a Param's value should be determined by having the user select
- * from a list of pre-canned options interactively at deploy-time.
+ * Autogenerate a list of buckets in a project that a user can select from.
+ */
+export declare const BUCKET_PICKER: ResourceInput;
+/**
+ * Specifies that a parameter's value should be determined by having the user select
+ * from a list of pre-canned options interactively at deploy time.
  */
 export interface SelectInput<T = unknown> {
-    options: Array<SelectOptions<T>>;
+    select: {
+        options: Array<SelectOptions<T>>;
+    };
 }
 /**
- * Specifies that a Param's value should be determined by having the user select
- * a subset from a list of pre-canned options interactively at deploy-time.
- * Will result in errors if used on Params of type other than string[].
+ * Specifies that a parameter's value should be determined by having the user select
+ * a subset from a list of pre-canned options interactively at deploy time.
+ * Will result in errors if used on parameters of type other than `string[]`.
  */
 export interface MultiSelectInput {
-    options: Array<SelectOptions<string>>;
+    multiSelect: {
+        options: Array<SelectOptions<string>>;
+    };
 }
 /**
- * One of the options provided to a SelectInput, containing a value and
+ * One of the options provided to a `SelectInput`, containing a value and
  * optionally a human-readable label to display in the selection interface.
  */
 export interface SelectOptions<T = unknown> {
     label?: string;
     value: T;
 }
-/** The wire representation of a Param when it's sent to the CLI. A superset of ParamOptions. */
+/** The wire representation of a parameter when it's sent to the CLI. A superset of `ParamOptions`. */
 export type ParamSpec<T extends string | number | boolean | string[]> = {
     /** The name of the parameter which will be stored in .env files. Use UPPERCASE. */
     name: string;
     /** An optional default value to be used while prompting for input. Can be a literal or another parametrized expression. */
     default?: T | Expression<T>;
-    /** An optional human-readable string to be used as a replacement for the Param's name when prompting. */
+    /** An optional human-readable string to be used as a replacement for the parameter's name when prompting. */
     label?: string;
-    /** An optional long-form description of the Param to be displayed while prompting. */
+    /** An optional long-form description of the parameter to be displayed while prompting. */
     description?: string;
-    /** The way in which the Firebase CLI will prompt for the value of this Param. Defaults to a TextInput. */
+    /** The way in which the Firebase CLI will prompt for the value of this parameter. Defaults to a TextInput. */
     input?: ParamInput<T>;
 };
 /**
@@ -120,7 +131,7 @@ export type WireParamSpec<T extends string | number | boolean | string[]> = {
     type: ParamValueType;
     input?: ParamInput<T>;
 };
-/** Configuration options which can be used to customize the prompting behavior of a Param. */
+/** Configuration options which can be used to customize the prompting behavior of a parameter. */
 export type ParamOptions<T extends string | number | boolean | string[]> = Omit<ParamSpec<T>, "name" | "type">;
 /**
  * Represents a parametrized value that will be read from .env files if present,
@@ -132,22 +143,22 @@ export declare abstract class Param<T extends string | number | boolean | string
     readonly options: ParamOptions<T>;
     static type: ParamValueType;
     constructor(name: string, options?: ParamOptions<T>);
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     cmp(cmp: "==" | "!=" | ">" | ">=" | "<" | "<=", rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     equals(rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     notEquals(rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     greaterThan(rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     greaterThanOrEqualTo(rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     lessThan(rhs: T | Expression<T>): CompareExpression<T>;
-    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression. */
     lessThanOrEqualTo(rhs: T | Expression<T>): CompareExpression<T>;
     /**
-     * Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression.
+     * Returns a parametrized expression of Boolean type, based on comparing the value of this parameter to a literal or a different expression.
      * @deprecated A typo. Use lessThanOrEqualTo instead.
      */
     lessThanorEqualTo(rhs: T | Expression<T>): CompareExpression<T>;