firebase-functions 3.21.1 → 3.23.0

package/lib/v2/providers/database.js

@@ -0,0 +1,204 @@
+"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.onOperation = exports.onChangedOperation = exports.makeEndpoint = exports.makeParams = exports.getOpts = exports.onValueDeleted = exports.onValueUpdated = exports.onValueCreated = exports.onValueWritten = exports.deletedEventType = exports.updatedEventType = exports.createdEventType = exports.writtenEventType = exports.DataSnapshot = void 0;
+const apps_1 = require("../../apps");
+const database_1 = require("../../common/providers/database");
+Object.defineProperty(exports, "DataSnapshot", { enumerable: true, get: function () { return database_1.DataSnapshot; } });
+const path_1 = require("../../utilities/path");
+const path_pattern_1 = require("../../utilities/path-pattern");
+const utils_1 = require("../../utils");
+const options = require("../options");
+/** @internal */
+exports.writtenEventType = 'google.firebase.database.ref.v1.written';
+/** @internal */
+exports.createdEventType = 'google.firebase.database.ref.v1.created';
+/** @internal */
+exports.updatedEventType = 'google.firebase.database.ref.v1.updated';
+/** @internal */
+exports.deletedEventType = 'google.firebase.database.ref.v1.deleted';
+/**
+ * Event handler which triggers when data is created, updated, or deleted in Realtime Database.
+ *
+ * @param referenceOrOpts - Options or a string reference.
+ * @param handler - Event handler which is run every time a Realtime Database create, update, or delete occurs.
+ */
+function onValueWritten(referenceOrOpts, handler) {
+    return onChangedOperation(exports.writtenEventType, referenceOrOpts, handler);
+}
+exports.onValueWritten = onValueWritten;
+/**
+ * Event handler which triggers when data is created in Realtime Database.
+ *
+ * @param referenceOrOpts - Options or a string reference.
+ * @param handler - Event handler which is run every time a Realtime Database create occurs.
+ */
+function onValueCreated(referenceOrOpts, handler) {
+    return onOperation(exports.createdEventType, referenceOrOpts, handler);
+}
+exports.onValueCreated = onValueCreated;
+/**
+ * Event handler which triggers when data is updated in Realtime Database.
+ *
+ * @param referenceOrOpts - Options or a string reference.
+ * @param handler - Event handler which is run every time a Realtime Database update occurs.
+ */
+function onValueUpdated(referenceOrOpts, handler) {
+    return onChangedOperation(exports.updatedEventType, referenceOrOpts, handler);
+}
+exports.onValueUpdated = onValueUpdated;
+/**
+ * Event handler which triggers when data is deleted in Realtime Database.
+ *
+ * @param referenceOrOpts - Options or a string reference.
+ * @param handler - Event handler which is run every time a Realtime Database deletion occurs.
+ */
+function onValueDeleted(referenceOrOpts, handler) {
+    // TODO - need to use event.data.delta
+    return onOperation(exports.deletedEventType, referenceOrOpts, handler);
+}
+exports.onValueDeleted = onValueDeleted;
+/** @internal */
+function getOpts(referenceOrOpts) {
+    let path, instance, opts;
+    if (typeof referenceOrOpts === 'string') {
+        path = (0, path_1.normalizePath)(referenceOrOpts);
+        instance = '*';
+        opts = {};
+    }
+    else {
+        path = (0, path_1.normalizePath)(referenceOrOpts.ref);
+        instance = referenceOrOpts.instance || '*';
+        opts = { ...referenceOrOpts };
+        delete opts.ref;
+        delete opts.instance;
+    }
+    return {
+        path,
+        instance,
+        opts,
+    };
+}
+exports.getOpts = getOpts;
+/** @internal */
+function makeParams(event, path, instance) {
+    return {
+        ...path.extractMatches(event.ref),
+        ...instance.extractMatches(event.instance),
+    };
+}
+exports.makeParams = makeParams;
+/** @hidden */
+function makeDatabaseEvent(event, data, instance, params) {
+    const snapshot = new database_1.DataSnapshot(data, event.ref, (0, apps_1.apps)().admin, instance);
+    const databaseEvent = {
+        ...event,
+        firebaseDatabaseHost: event.firebasedatabasehost,
+        data: snapshot,
+        params,
+    };
+    delete databaseEvent.firebasedatabasehost;
+    return databaseEvent;
+}
+/** @hidden */
+function makeChangedDatabaseEvent(event, instance, params) {
+    const before = new database_1.DataSnapshot(event.data.data, event.ref, (0, apps_1.apps)().admin, instance);
+    const after = new database_1.DataSnapshot((0, utils_1.applyChange)(event.data.data, event.data.delta), event.ref, (0, apps_1.apps)().admin, instance);
+    const databaseEvent = {
+        ...event,
+        firebaseDatabaseHost: event.firebasedatabasehost,
+        data: {
+            before,
+            after,
+        },
+        params,
+    };
+    delete databaseEvent.firebasedatabasehost;
+    return databaseEvent;
+}
+/** @internal */
+function makeEndpoint(eventType, opts, path, instance) {
+    const baseOpts = options.optionsToEndpoint(options.getGlobalOptions());
+    const specificOpts = options.optionsToEndpoint(opts);
+    const eventFilters = {};
+    const eventFilterPathPatterns = {
+        // Note: Eventarc always treats ref as a path pattern
+        ref: path.getValue(),
+    };
+    instance.hasWildcards()
+        ? (eventFilterPathPatterns.instance = instance.getValue())
+        : (eventFilters.instance = instance.getValue());
+    return {
+        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,
+            eventFilters,
+            eventFilterPathPatterns,
+            retry: false,
+        },
+    };
+}
+exports.makeEndpoint = makeEndpoint;
+/** @internal */
+function onChangedOperation(eventType, referenceOrOpts, handler) {
+    const { path, instance, opts } = getOpts(referenceOrOpts);
+    const pathPattern = new path_pattern_1.PathPattern(path);
+    const instancePattern = new path_pattern_1.PathPattern(instance);
+    // wrap the handler
+    const func = (raw) => {
+        const event = raw;
+        const instanceUrl = `https://${event.instance}.${event.firebasedatabasehost}`;
+        const params = makeParams(event, pathPattern, instancePattern);
+        const databaseEvent = makeChangedDatabaseEvent(event, instanceUrl, params);
+        return handler(databaseEvent);
+    };
+    func.run = handler;
+    func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+    return func;
+}
+exports.onChangedOperation = onChangedOperation;
+/** @internal */
+function onOperation(eventType, referenceOrOpts, handler) {
+    const { path, instance, opts } = getOpts(referenceOrOpts);
+    const pathPattern = new path_pattern_1.PathPattern(path);
+    const instancePattern = new path_pattern_1.PathPattern(instance);
+    // wrap the handler
+    const func = (raw) => {
+        const event = raw;
+        const instanceUrl = `https://${event.instance}.${event.firebasedatabasehost}`;
+        const params = makeParams(event, pathPattern, instancePattern);
+        const data = eventType === exports.deletedEventType ? event.data.data : event.data.delta;
+        const databaseEvent = makeDatabaseEvent(event, data, instanceUrl, params);
+        return handler(databaseEvent);
+    };
+    func.run = handler;
+    func.__endpoint = makeEndpoint(eventType, opts, pathPattern, instancePattern);
+    return func;
+}
+exports.onOperation = onOperation;

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

@@ -1,5 +1,6 @@
 import { CloudEvent, CloudFunction } from '../core';
 import * as options from '../options';
+import { Expression } from '../params';
 /** Options that can be set on an Eventarc trigger. */
 export interface EventarcTriggerOptions extends options.EventHandlerOptions {
     /**
@@ -33,7 +34,7 @@ export interface EventarcTriggerOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -44,19 +45,19 @@ export interface EventarcTriggerOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -64,7 +65,7 @@ export interface EventarcTriggerOptions extends options.EventHandlerOptions {
      * 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;
+    concurrency?: number | Expression<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.

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

@@ -3,6 +3,7 @@ import { CallableRequest, FunctionsErrorCode, HttpsError, Request } from '../../
 import { ManifestEndpoint } from '../../runtime/manifest';
 import * as options from '../options';
 import { GlobalOptions, SupportedRegion } from '../options';
+import { Expression } from '../params';
 export { Request, CallableRequest, FunctionsErrorCode, HttpsError };
 /**
  * Options that can be set on an individual HTTPS function.
@@ -20,7 +21,7 @@ export interface HttpsOptions extends Omit<GlobalOptions, 'region'> {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -31,19 +32,19 @@ export interface HttpsOptions extends Omit<GlobalOptions, 'region'> {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -51,7 +52,7 @@ export interface HttpsOptions extends Omit<GlobalOptions, 'region'> {
      * 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;
+    concurrency?: number | Expression<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.

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

@@ -3,9 +3,10 @@
  * @packageDocumentation
  */
 import { BlockingFunction } from '../../cloud-functions';
-import { AuthBlockingEvent, AuthBlockingEventType, BeforeCreateResponse, BeforeSignInResponse, HttpsError } from '../../common/providers/identity';
+import { AuthBlockingEvent, AuthBlockingEventType, AuthUserRecord, BeforeCreateResponse, BeforeSignInResponse, HttpsError } from '../../common/providers/identity';
 import * as options from '../options';
-export { HttpsError };
+import { Expression } from '../params';
+export { AuthUserRecord, AuthBlockingEvent, HttpsError };
 /** @hidden Internally used when parsing the options. */
 interface InternalOptions {
     opts: options.GlobalOptions;
@@ -31,7 +32,7 @@ export interface BlockingOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -42,19 +43,19 @@ export interface BlockingOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -62,7 +63,7 @@ export interface BlockingOptions {
      * 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;
+    concurrency?: number | Expression<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.

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

@@ -1,5 +1,6 @@
 import { CloudEvent, CloudFunction } from '../core';
 import * as options from '../options';
+import { Expression } from '../params';
 /**
  * Google Cloud Pub/Sub is a globally distributed message bus that automatically scales as you need it.
  * You can create a function ({@link onMessagePublished}) that handles pub/sub events by using functions.pubsub.
@@ -89,7 +90,7 @@ export interface PubSubOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -100,19 +101,19 @@ export interface PubSubOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -120,7 +121,7 @@ export interface PubSubOptions extends options.EventHandlerOptions {
      * 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;
+    concurrency?: number | Expression<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.

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

@@ -0,0 +1,63 @@
+import { timezone } from '../../common/timezone';
+import { ManifestRequiredAPI } from '../../runtime/manifest';
+import * as options from '../options';
+import { HttpsFunction } from './https';
+/**
+ * Interface representing a ScheduleEvent that is passed to the function handler.
+ */
+export interface ScheduledEvent {
+    /**
+     * The Cloud Scheduler job name.
+     * Populated via the X-CloudScheduler-JobName header.
+     *
+     * If invoked manually, this field is undefined.
+     */
+    jobName?: string;
+    /**
+     * For Cloud Scheduler jobs specified in the unix-cron format,
+     * this is the job schedule time in RFC3339 UTC "Zulu" format.
+     * Populated via the X-CloudScheduler-ScheduleTime header.
+     *
+     * If the schedule is manually triggered, this field will be
+     * the function execution time.
+     */
+    scheduleTime: string;
+}
+/** The Cloud Function type for Schedule triggers. */
+export interface ScheduleFunction extends HttpsFunction {
+    __requiredAPIs?: ManifestRequiredAPI[];
+    run(data: ScheduledEvent): void | Promise<void>;
+}
+/** Options that can be set on a Schedule trigger. */
+export interface ScheduleOptions extends options.GlobalOptions {
+    /** The schedule, in Unix Crontab or AppEngine syntax. */
+    schedule: string;
+    /** The timezone that the schedule executes in. */
+    timeZone?: timezone;
+    /** The number of retry attempts for a failed run. */
+    retryCount?: number;
+    /** The time limit for retrying. */
+    maxRetrySeconds?: number;
+    /** The minimum time to wait before retying. */
+    minBackoffSeconds?: number;
+    /** The maximum time to wait before retrying. */
+    maxBackoffSeconds?: number;
+    /** The time between will double max doublings times. */
+    maxDoublings?: number;
+}
+/**
+ * Handler for scheduled functions. Triggered whenever the associated
+ * scheduler job sends a http request.
+ * @param schedule - The schedule, in Unix Crontab or AppEngine syntax.
+ * @param handler - A function to execute when triggered.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onSchedule(schedule: string, handler: (req: ScheduledEvent) => void | Promise<void>): ScheduleFunction;
+/**
+ * Handler for scheduled functions. Triggered whenever the associated
+ * scheduler job sends a http request.
+ * @param options - Options to set on scheduled functions.
+ * @param handler - A function to execute when triggered.
+ * @returns A function that you can export and deploy.
+ */
+export declare function onSchedule(options: ScheduleOptions, handler: (req: ScheduledEvent) => void | Promise<void>): ScheduleFunction;

package/lib/v2/providers/scheduler.js

@@ -0,0 +1,98 @@
+"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.onSchedule = exports.getOpts = void 0;
+const encoding_1 = require("../../common/encoding");
+const logger = require("../../logger");
+const options = require("../options");
+/** @internal */
+function getOpts(args) {
+    if (typeof args === 'string') {
+        return {
+            schedule: args,
+            opts: {},
+        };
+    }
+    return {
+        schedule: args.schedule,
+        timeZone: args.timeZone,
+        retryCount: args.retryCount,
+        maxRetrySeconds: args.maxRetrySeconds,
+        minBackoffSeconds: args.minBackoffSeconds,
+        maxBackoffSeconds: args.maxBackoffSeconds,
+        maxDoublings: args.maxDoublings,
+        opts: args,
+    };
+}
+exports.getOpts = getOpts;
+/**
+ * Handler for scheduled functions. Triggered whenever the associated
+ * scheduler job sends a http request.
+ * @param args - Either a schedule or an object containing function options.
+ * @param handler - A function to execute when triggered.
+ * @returns A function that you can export and deploy.
+ */
+function onSchedule(args, handler) {
+    const separatedOpts = getOpts(args);
+    const func = async (req, res) => {
+        const event = {
+            jobName: req.header('X-CloudScheduler-JobName') || undefined,
+            scheduleTime: req.header('X-CloudScheduler-ScheduleTime') || new Date().toISOString(),
+        };
+        try {
+            await handler(event);
+            res.status(200).send();
+        }
+        catch (err) {
+            logger.error(err.message);
+            res.status(500).send();
+        }
+    };
+    func.run = handler;
+    const baseOptsEndpoint = options.optionsToEndpoint(options.getGlobalOptions());
+    const specificOptsEndpoint = options.optionsToEndpoint(separatedOpts.opts);
+    const ep = {
+        platform: 'gcfv2',
+        ...baseOptsEndpoint,
+        ...specificOptsEndpoint,
+        labels: {
+            ...baseOptsEndpoint === null || baseOptsEndpoint === void 0 ? void 0 : baseOptsEndpoint.labels,
+            ...specificOptsEndpoint === null || specificOptsEndpoint === void 0 ? void 0 : specificOptsEndpoint.labels,
+        },
+        scheduleTrigger: {
+            schedule: separatedOpts.schedule,
+            retryConfig: {},
+        },
+    };
+    (0, encoding_1.copyIfPresent)(ep.scheduleTrigger, separatedOpts, 'timeZone');
+    (0, encoding_1.copyIfPresent)(ep.scheduleTrigger.retryConfig, separatedOpts, 'retryCount', 'maxRetrySeconds', 'minBackoffSeconds', 'maxBackoffSeconds', 'maxDoublings');
+    func.__endpoint = ep;
+    func.__requiredAPIs = [
+        {
+            api: 'cloudscheduler.googleapis.com',
+            reason: 'Needed for scheduled functions.',
+        },
+    ];
+    return func;
+}
+exports.onSchedule = onSchedule;

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

@@ -1,5 +1,6 @@
 import { CloudEvent, CloudFunction } from '../core';
 import * as options from '../options';
+import { Expression } from '../params';
 /**
  * An object within Google Cloud Storage.
  * Ref: https://github.com/googleapis/google-cloudevents-nodejs/blob/main/cloud/storage/v1/StorageObjectData.ts
@@ -165,7 +166,7 @@ export interface StorageOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -176,19 +177,19 @@ export interface StorageOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -196,7 +197,7 @@ export interface StorageOptions extends options.EventHandlerOptions {
      * 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;
+    concurrency?: number | Expression<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.

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

@@ -1,7 +1,8 @@
 import { AuthData, RateLimits, Request, RetryConfig } from '../../common/providers/tasks';
 import * as options from '../options';
 import { HttpsFunction } from './https';
-export { AuthData, RateLimits, Request, RetryConfig };
+import { Expression } from '../params';
+export { AuthData, Request };
 export interface TaskQueueOptions extends options.EventHandlerOptions {
     /** How a task should be retried in the event of a non-2xx return. */
     retryConfig?: RetryConfig;
@@ -22,7 +23,7 @@ export interface TaskQueueOptions extends options.EventHandlerOptions {
      * Amount of memory to allocate to a function.
      * A value of null restores the defaults of 256MB.
      */
-    memory?: options.MemoryOption | null;
+    memory?: options.MemoryOption | Expression<number> | null;
     /**
      * Timeout for the function in sections, possible values are 0 to 540.
      * HTTPS functions can specify a higher timeout.
@@ -33,19 +34,19 @@ export interface TaskQueueOptions extends options.EventHandlerOptions {
      * maximum timeout of 36,00s (1 hour). Task queue functions have a maximum
      * timeout of 1,800s (30 minutes)
      */
-    timeoutSeconds?: number | null;
+    timeoutSeconds?: number | Expression<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;
+    minInstances?: number | Expression<number> | null;
     /**
      * Max number of instances to be running in parallel.
      * A value of null restores the default max instances.
      */
-    maxInstances?: number | null;
+    maxInstances?: number | Expression<number> | null;
     /**
      * Number of requests a function can serve at once.
      * Can only be applied to functions running on Cloud Functions v2.
@@ -53,7 +54,7 @@ export interface TaskQueueOptions extends options.EventHandlerOptions {
      * 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;
+    concurrency?: number | Expression<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.