firebase-functions 3.24.0 → 4.0.0-rc.0

package/lib/runtime/manifest.js

@@ -21,13 +21,15 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stackToWire = void 0;
-const params_1 = require("../v2/params");
+exports.initV2ScheduleTrigger = exports.initV1ScheduleTrigger = exports.initTaskQueueTrigger = exports.initV2Endpoint = exports.initV1Endpoint = exports.stackToWire = void 0;
+const options_1 = require("../common/options");
+const params_1 = require("../params");
 /**
  * Returns the JSON representation of a ManifestStack, which has CEL
  * expressions in its options as object types, with its expressions
  * transformed into the actual CEL strings.
- * @internal
+ *
+ * @alpha
  */
 function stackToWire(stack) {
     const wireStack = stack;
@@ -36,7 +38,11 @@ function stackToWire(stack) {
             if (val instanceof params_1.Expression) {
                 obj[key] = val.toCEL();
             }
-            else if (typeof val === 'object') {
+            else if (val instanceof options_1.ResetValue) {
+                obj[key] = val.toJSON();
+            }
+            else if (typeof val === "object" && val !== null) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 traverse(val);
             }
         }
@@ -45,3 +51,107 @@ function stackToWire(stack) {
     return wireStack;
 }
 exports.stackToWire = stackToWire;
+const RESETTABLE_OPTIONS = {
+    availableMemoryMb: null,
+    timeoutSeconds: null,
+    minInstances: null,
+    maxInstances: null,
+    ingressSettings: null,
+    concurrency: null,
+    serviceAccountEmail: null,
+    vpc: null,
+};
+function initEndpoint(resetOptions, ...opts) {
+    const endpoint = {};
+    if (opts.every((opt) => !(opt === null || opt === void 0 ? void 0 : opt.preserveExternalChanges))) {
+        for (const key of Object.keys(resetOptions)) {
+            endpoint[key] = options_1.RESET_VALUE;
+        }
+    }
+    return endpoint;
+}
+/**
+ * @internal
+ */
+function initV1Endpoint(...opts) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { concurrency, ...resetOpts } = RESETTABLE_OPTIONS;
+    return initEndpoint({ ...resetOpts }, ...opts);
+}
+exports.initV1Endpoint = initV1Endpoint;
+/**
+ * @internal
+ */
+function initV2Endpoint(...opts) {
+    return initEndpoint(RESETTABLE_OPTIONS, ...opts);
+}
+exports.initV2Endpoint = initV2Endpoint;
+const RESETTABLE_RETRY_CONFIG_OPTIONS = {
+    maxAttempts: null,
+    maxDoublings: null,
+    maxBackoffSeconds: null,
+    maxRetrySeconds: null,
+    minBackoffSeconds: null,
+};
+const RESETTABLE_RATE_LIMITS_OPTIONS = {
+    maxConcurrentDispatches: null,
+    maxDispatchesPerSecond: null,
+};
+/**
+ * @internal
+ */
+function initTaskQueueTrigger(...opts) {
+    let taskQueueTrigger = {};
+    if (opts.every((opt) => !(opt === null || opt === void 0 ? void 0 : opt.preserveExternalChanges))) {
+        const retryConfig = {};
+        for (const key of Object.keys(RESETTABLE_RETRY_CONFIG_OPTIONS)) {
+            retryConfig[key] = options_1.RESET_VALUE;
+        }
+        const rateLimits = {};
+        for (const key of Object.keys(RESETTABLE_RATE_LIMITS_OPTIONS)) {
+            rateLimits[key] = options_1.RESET_VALUE;
+        }
+        taskQueueTrigger = { retryConfig, rateLimits };
+    }
+    return taskQueueTrigger;
+}
+exports.initTaskQueueTrigger = initTaskQueueTrigger;
+const RESETTABLE_V1_SCHEDULE_OPTIONS = {
+    retryCount: null,
+    maxDoublings: null,
+    maxRetryDuration: null,
+    maxBackoffDuration: null,
+    minBackoffDuration: null,
+};
+const RESETTABLE_V2_SCHEDULE_OPTIONS = {
+    retryCount: null,
+    maxDoublings: null,
+    maxRetrySeconds: null,
+    minBackoffSeconds: null,
+    maxBackoffSeconds: null,
+};
+function initScheduleTrigger(resetOptions, schedule, ...opts) {
+    let scheduleTrigger = { schedule };
+    if (opts.every((opt) => !(opt === null || opt === void 0 ? void 0 : opt.preserveExternalChanges))) {
+        const retryConfig = {};
+        for (const key of Object.keys(resetOptions)) {
+            retryConfig[key] = options_1.RESET_VALUE;
+        }
+        scheduleTrigger = { ...scheduleTrigger, timeZone: options_1.RESET_VALUE, retryConfig };
+    }
+    return scheduleTrigger;
+}
+/**
+ * @internal
+ */
+function initV1ScheduleTrigger(schedule, ...opts) {
+    return initScheduleTrigger(RESETTABLE_V1_SCHEDULE_OPTIONS, schedule, ...opts);
+}
+exports.initV1ScheduleTrigger = initV1ScheduleTrigger;
+/**
+ * @internal
+ */
+function initV2ScheduleTrigger(schedule, ...opts) {
+    return initScheduleTrigger(RESETTABLE_V2_SCHEDULE_OPTIONS, schedule, ...opts);
+}
+exports.initV2ScheduleTrigger = initV2ScheduleTrigger;

package/lib/v1/cloud-functions.d.ts

@@ -0,0 +1,232 @@
+import { Request, Response } from "express";
+export { Request, Response };
+import { ManifestEndpoint, ManifestRequiredAPI } from "../runtime/manifest";
+export { Change } from "../common/change";
+/**
+ * Wire format for an event.
+ */
+export interface Event {
+    /**
+     * Wire format for an event context.
+     */
+    context: {
+        eventId: string;
+        timestamp: string;
+        eventType: string;
+        resource: Resource;
+        domain?: string;
+        auth?: {
+            variable?: {
+                uid?: string;
+                token?: string;
+            };
+            admin: boolean;
+        };
+    };
+    /**
+     * Event data over wire.
+     */
+    data: any;
+}
+/**
+ * The context in which an event occurred.
+ *
+ * @remarks
+ * An EventContext describes:
+ * - The time an event occurred.
+ * - A unique identifier of the event.
+ * - The resource on which the event occurred, if applicable.
+ * - Authorization of the request that triggered the event, if applicable and
+ *   available.
+ */
+export interface EventContext<Params = Record<string, string>> {
+    /**
+     * Authentication information for the user that triggered the function.
+     *
+     * @remarks
+     * This object contains `uid` and `token` properties for authenticated users.
+     * For more detail including token keys, see the
+     * {@link https://firebase.google.com/docs/reference/rules/rules#properties | security rules reference}.
+     *
+     * This field is only populated for Realtime Database triggers and Callable
+     * functions. For an unauthenticated user, this field is null. For Firebase
+     * admin users and event types that do not provide user information, this field
+     * does not exist.
+     */
+    auth?: {
+        token: object;
+        uid: string;
+    };
+    /**
+     * The level of permissions for a user.
+     *
+     * @remarks
+     * Valid values are:
+     *
+     * - `ADMIN`: Developer user or user authenticated via a service account.
+     *
+     * - `USER`: Known user.
+     *
+     * - `UNAUTHENTICATED`: Unauthenticated action
+     *
+     * - `null`: For event types that do not provide user information (all except
+     *   Realtime Database).
+     */
+    authType?: "ADMIN" | "USER" | "UNAUTHENTICATED";
+    /**
+     * The event’s unique identifier.
+     */
+    eventId: string;
+    /**
+     * Type of event.
+     *
+     * @remarks
+     * Possible values are:
+     *
+     * - `google.analytics.event.log`
+     *
+     * - `google.firebase.auth.user.create`
+     *
+     * - `google.firebase.auth.user.delete`
+     *
+     * - `google.firebase.database.ref.write`
+     *
+     * - `google.firebase.database.ref.create`
+     *
+     * - `google.firebase.database.ref.update`
+     *
+     * - `google.firebase.database.ref.delete`
+     *
+     * - `google.firestore.document.write`
+     *
+     * - `google.firestore.document.create`
+     *
+     * - `google.firestore.document.update`
+     *
+     * - `google.firestore.document.delete`
+     *
+     * - `google.pubsub.topic.publish`
+     *
+     * - `google.firebase.remoteconfig.update`
+     *
+     * - `google.storage.object.finalize`
+     *
+     * - `google.storage.object.archive`
+     *
+     * - `google.storage.object.delete`
+     *
+     * - `google.storage.object.metadataUpdate`
+     *
+     * - `google.testing.testMatrix.complete`
+     */
+    eventType: string;
+    /**
+     * An object containing the values of the wildcards in the `path` parameter
+     * provided to the {@link fireabase-functions.v1.database#ref | `ref()`} method for a Realtime Database trigger.
+     */
+    params: Params;
+    /**
+     * The resource that emitted the event.
+     *
+     * @remarks
+     * Valid values are:
+     *
+     * Analytics: `projects/<projectId>/events/<analyticsEventType>`
+     *
+     * Realtime Database: `projects/_/instances/<databaseInstance>/refs/<databasePath>`
+     *
+     * Storage: `projects/_/buckets/<bucketName>/objects/<fileName>#<generation>`
+     *
+     * Authentication: `projects/<projectId>`
+     *
+     * Pub/Sub: `projects/<projectId>/topics/<topicName>`
+     *
+     * Because Realtime Database instances and Cloud Storage buckets are globally
+     * unique and not tied to the project, their resources start with `projects/_`.
+     * Underscore is not a valid project name.
+     */
+    resource: Resource;
+    /**
+     * Timestamp for the event as an {@link https://www.ietf.org/rfc/rfc3339.txt | RFC 3339} string.
+     */
+    timestamp: string;
+}
+/**
+ * Resource is a standard format for defining a resource
+ * (google.rpc.context.AttributeContext.Resource). In Cloud Functions, it is the
+ * resource that triggered the function - such as a storage bucket.
+ */
+export interface Resource {
+    /** The name of the service that this resource belongs to. */
+    service: string;
+    /**
+     * The stable identifier (name) of a resource on the service.
+     * A resource can be logically identified as "//{resource.service}/{resource.name}"
+     */
+    name: string;
+    /**
+     * The type of the resource. The syntax is platform-specific because different platforms define their resources differently.
+     * For Google APIs, the type format must be "{service}/{kind}"
+     */
+    type?: string;
+    /** Map of Resource's labels. */
+    labels?: {
+        [tag: string]: string;
+    };
+}
+/**
+ * A Runnable has a `run` method which directly invokes the user-defined
+ * function - useful for unit testing.
+ */
+export interface Runnable<T> {
+    /** Directly invoke the user defined function. */
+    run: (data: T, context: any) => PromiseLike<any> | any;
+}
+/**
+ * The function type for HTTPS triggers. This should be exported from your
+ * JavaScript file to define a Cloud Function.
+ *
+ * @remarks
+ * This type is a special JavaScript function which takes Express
+ * {@link https://expressjs.com/en/api.html#req | `Request` } and
+ * {@link https://expressjs.com/en/api.html#res | `Response` } objects as its only
+ * arguments.
+ */
+export interface HttpsFunction {
+    (req: Request, resp: Response): void | Promise<void>;
+    /** @alpha */
+    __endpoint: ManifestEndpoint;
+    /** @alpha */
+    __requiredAPIs?: ManifestRequiredAPI[];
+}
+/**
+ * The function type for Auth Blocking triggers.
+ *
+ * @remarks
+ * This type is a special JavaScript function for Auth Blocking triggers which takes Express
+ * {@link https://expressjs.com/en/api.html#req | `Request` } and
+ * {@link https://expressjs.com/en/api.html#res | `Response` } objects as its only
+ * arguments.
+ */
+export interface BlockingFunction {
+    /** @public */
+    (req: Request, resp: Response): void | Promise<void>;
+    /** @alpha */
+    __endpoint: ManifestEndpoint;
+    /** @alpha */
+    __requiredAPIs?: ManifestRequiredAPI[];
+}
+/**
+ * The function type for all non-HTTPS triggers. This should be exported
+ * from your JavaScript file to define a Cloud Function.
+ *
+ * This type is a special JavaScript function which takes a templated
+ * `Event` object as its only argument.
+ */
+export interface CloudFunction<T> extends Runnable<T> {
+    (input: any, context?: any): PromiseLike<any> | any;
+    /** @alpha */
+    __endpoint: ManifestEndpoint;
+    /** @alpha */
+    __requiredAPIs?: ManifestRequiredAPI[];
+}

package/lib/v1/cloud-functions.js

@@ -0,0 +1,205 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 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.optionsToEndpoint = exports.makeCloudFunction = exports.Change = void 0;
+const logger_1 = require("../logger");
+const function_configuration_1 = require("./function-configuration");
+const encoding_1 = require("../common/encoding");
+const manifest_1 = require("../runtime/manifest");
+const options_1 = require("../common/options");
+const types_1 = require("../params/types");
+var change_1 = require("../common/change");
+Object.defineProperty(exports, "Change", { enumerable: true, get: function () { return change_1.Change; } });
+/** @internal */
+const WILDCARD_REGEX = new RegExp("{[^/{}]*}", "g");
+/** @internal */
+function makeCloudFunction({ contextOnlyHandler, dataConstructor = (raw) => raw.data, eventType, handler, labels = {}, legacyEventType, options = {}, provider, service, triggerResource, }) {
+    const cloudFunction = (data, context) => {
+        if (legacyEventType && context.eventType === legacyEventType) {
+            /*
+             * v1beta1 event flow has different format for context, transform them to
+             * new format.
+             */
+            context.eventType = provider + "." + eventType;
+            context.resource = {
+                service,
+                name: context.resource,
+            };
+        }
+        const event = {
+            data,
+            context,
+        };
+        if (provider === "google.firebase.database") {
+            context.authType = _detectAuthType(event);
+            if (context.authType !== "ADMIN") {
+                context.auth = _makeAuth(event, context.authType);
+            }
+            else {
+                delete context.auth;
+            }
+        }
+        if (triggerResource() == null) {
+            Object.defineProperty(context, "params", {
+                get: () => {
+                    throw new Error("context.params is not available when using the handler namespace.");
+                },
+            });
+        }
+        else {
+            context.params = context.params || _makeParams(context, triggerResource);
+        }
+        let promise;
+        if (labels && labels["deployment-scheduled"]) {
+            // Scheduled function do not have meaningful data, so exclude it
+            promise = contextOnlyHandler(context);
+        }
+        else {
+            const dataOrChange = dataConstructor(event);
+            promise = handler(dataOrChange, context);
+        }
+        if (typeof promise === "undefined") {
+            (0, logger_1.warn)("Function returned undefined, expected Promise or value");
+        }
+        return Promise.resolve(promise);
+    };
+    Object.defineProperty(cloudFunction, "__endpoint", {
+        get: () => {
+            if (triggerResource() == null) {
+                return undefined;
+            }
+            const endpoint = {
+                platform: "gcfv1",
+                ...(0, manifest_1.initV1Endpoint)(options),
+                ...optionsToEndpoint(options),
+            };
+            if (options.schedule) {
+                endpoint.scheduleTrigger = (0, manifest_1.initV1ScheduleTrigger)(options.schedule.schedule, options);
+                (0, encoding_1.copyIfPresent)(endpoint.scheduleTrigger, options.schedule, "timeZone");
+                (0, encoding_1.copyIfPresent)(endpoint.scheduleTrigger.retryConfig, options.schedule.retryConfig, "retryCount", "maxDoublings", "maxBackoffDuration", "maxRetryDuration", "minBackoffDuration");
+            }
+            else {
+                endpoint.eventTrigger = {
+                    eventType: legacyEventType || provider + "." + eventType,
+                    eventFilters: {
+                        resource: triggerResource(),
+                    },
+                    retry: !!options.failurePolicy,
+                };
+            }
+            // Note: We intentionally don't make use of labels args here.
+            // labels is used to pass SDK-defined labels to the trigger, which isn't
+            // something we will do in the container contract world.
+            endpoint.labels = { ...endpoint.labels };
+            return endpoint;
+        },
+    });
+    if (options.schedule) {
+        cloudFunction.__requiredAPIs = [
+            {
+                api: "cloudscheduler.googleapis.com",
+                reason: "Needed for scheduled functions.",
+            },
+        ];
+    }
+    cloudFunction.run = handler || contextOnlyHandler;
+    return cloudFunction;
+}
+exports.makeCloudFunction = makeCloudFunction;
+function _makeParams(context, triggerResourceGetter) {
+    var _a, _b, _c;
+    if (context.params) {
+        // In unit testing, user may directly provide `context.params`.
+        return context.params;
+    }
+    if (!context.resource) {
+        // In unit testing, `resource` may be unpopulated for a test event.
+        return {};
+    }
+    const triggerResource = triggerResourceGetter();
+    const wildcards = triggerResource.match(WILDCARD_REGEX);
+    const params = {};
+    // Note: some tests don't set context.resource.name
+    const eventResourceParts = (_c = (_b = (_a = context === null || context === void 0 ? void 0 : context.resource) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.split) === null || _c === void 0 ? void 0 : _c.call(_b, "/");
+    if (wildcards && eventResourceParts) {
+        const triggerResourceParts = triggerResource.split("/");
+        for (const wildcard of wildcards) {
+            const wildcardNoBraces = wildcard.slice(1, -1);
+            const position = triggerResourceParts.indexOf(wildcard);
+            params[wildcardNoBraces] = eventResourceParts[position];
+        }
+    }
+    return params;
+}
+function _makeAuth(event, authType) {
+    var _a, _b, _c, _d, _e, _f;
+    if (authType === "UNAUTHENTICATED") {
+        return null;
+    }
+    return {
+        uid: (_c = (_b = (_a = event.context) === null || _a === void 0 ? void 0 : _a.auth) === null || _b === void 0 ? void 0 : _b.variable) === null || _c === void 0 ? void 0 : _c.uid,
+        token: (_f = (_e = (_d = event.context) === null || _d === void 0 ? void 0 : _d.auth) === null || _e === void 0 ? void 0 : _e.variable) === null || _f === void 0 ? void 0 : _f.token,
+    };
+}
+function _detectAuthType(event) {
+    var _a, _b, _c, _d;
+    if ((_b = (_a = event.context) === null || _a === void 0 ? void 0 : _a.auth) === null || _b === void 0 ? void 0 : _b.admin) {
+        return "ADMIN";
+    }
+    if ((_d = (_c = event.context) === null || _c === void 0 ? void 0 : _c.auth) === null || _d === void 0 ? void 0 : _d.variable) {
+        return "USER";
+    }
+    return "UNAUTHENTICATED";
+}
+/** @internal */
+function optionsToEndpoint(options) {
+    const endpoint = {};
+    (0, encoding_1.copyIfPresent)(endpoint, options, "minInstances", "maxInstances", "ingressSettings", "labels", "timeoutSeconds");
+    (0, encoding_1.convertIfPresent)(endpoint, options, "region", "regions");
+    (0, encoding_1.convertIfPresent)(endpoint, options, "serviceAccountEmail", "serviceAccount", (sa) => sa);
+    (0, encoding_1.convertIfPresent)(endpoint, options, "secretEnvironmentVariables", "secrets", (secrets) => secrets.map((secret) => ({ key: secret instanceof types_1.SecretParam ? secret.name : secret })));
+    if ((options === null || options === void 0 ? void 0 : options.vpcConnector) !== undefined) {
+        if (options.vpcConnector === null || options.vpcConnector instanceof options_1.ResetValue) {
+            endpoint.vpc = function_configuration_1.RESET_VALUE;
+        }
+        else {
+            const vpc = { connector: options.vpcConnector };
+            (0, encoding_1.convertIfPresent)(vpc, options, "egressSettings", "vpcConnectorEgressSettings");
+            endpoint.vpc = vpc;
+        }
+    }
+    (0, encoding_1.convertIfPresent)(endpoint, options, "availableMemoryMb", "memory", (mem) => {
+        const memoryLookup = {
+            "128MB": 128,
+            "256MB": 256,
+            "512MB": 512,
+            "1GB": 1024,
+            "2GB": 2048,
+            "4GB": 4096,
+            "8GB": 8192,
+        };
+        return typeof mem === "object" ? mem : memoryLookup[mem];
+    });
+    return endpoint;
+}
+exports.optionsToEndpoint = optionsToEndpoint;

package/lib/v1/config.d.ts

@@ -0,0 +1,8 @@
+export { firebaseConfig } from "../common/config";
+/**
+ * Store and retrieve project configuration data such as third-party API
+ * keys or other settings. You can set configuration values using the
+ * Firebase CLI as described in
+ * [Environment Configuration](/docs/functions/config-env).
+ */
+export declare function config(): Record<string, any>;

package/lib/v1/config.js

@@ -0,0 +1,75 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 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.config = exports.resetCache = exports.singleton = exports.firebaseConfig = void 0;
+const fs = require("fs");
+const path = require("path");
+var config_1 = require("../common/config");
+Object.defineProperty(exports, "firebaseConfig", { enumerable: true, get: function () { return config_1.firebaseConfig; } });
+/** @internal */
+function resetCache() {
+    exports.singleton = undefined;
+}
+exports.resetCache = resetCache;
+/**
+ * Store and retrieve project configuration data such as third-party API
+ * keys or other settings. You can set configuration values using the
+ * Firebase CLI as described in
+ * [Environment Configuration](/docs/functions/config-env).
+ */
+function config() {
+    // K_CONFIGURATION is only set in GCFv2
+    if (process.env.K_CONFIGURATION) {
+        throw new Error("functions.config() is no longer available in Cloud Functions for " +
+            "Firebase v2. Please see the latest documentation for information " +
+            "on how to transition to using environment variables");
+    }
+    if (typeof exports.singleton === "undefined") {
+        init();
+    }
+    return exports.singleton;
+}
+exports.config = config;
+function init() {
+    try {
+        const parsed = JSON.parse(process.env.CLOUD_RUNTIME_CONFIG);
+        delete parsed.firebase;
+        exports.singleton = parsed;
+        return;
+    }
+    catch (e) {
+        // Do nothing
+    }
+    try {
+        const configPath = process.env.CLOUD_RUNTIME_CONFIG || path.join(process.cwd(), ".runtimeconfig.json");
+        const contents = fs.readFileSync(configPath);
+        const parsed = JSON.parse(contents.toString("utf8"));
+        delete parsed.firebase;
+        exports.singleton = parsed;
+        return;
+    }
+    catch (e) {
+        // Do nothing
+    }
+    exports.singleton = {};
+}