firebase-tools 13.15.4 → 13.17.0

package/lib/emulator/taskQueue.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskQueue = exports.TaskStatus = exports.Queue = void 0;
+const abort_controller_1 = require("abort-controller");
+const emulatorLogger_1 = require("./emulatorLogger");
+const types_1 = require("./types");
+const node_fetch_1 = require("node-fetch");
+class Node {
+    constructor(data) {
+        this.data = data;
+        this.next = null;
+        this.prev = null;
+    }
+}
+class Queue {
+    constructor(capacity = 10000) {
+        this.nodeMap = {};
+        this.count = 0;
+        this.first = null;
+        this.last = null;
+        this.capacity = capacity;
+    }
+    enqueue(id, item) {
+        if (this.count >= this.capacity) {
+            throw new Error("Queue has reached capacity");
+        }
+        const newNode = new Node(item);
+        if (this.nodeMap[id] !== undefined) {
+            throw new Error("Queue IDs must be unique");
+        }
+        this.nodeMap[id] = newNode;
+        if (!this.first) {
+            this.first = newNode;
+        }
+        if (this.last) {
+            this.last.next = newNode;
+        }
+        newNode.prev = this.last;
+        this.last = newNode;
+        this.count++;
+    }
+    peek() {
+        if (this.first) {
+            return this.first.data;
+        }
+        else {
+            throw new Error("Trying to peek into an empty queue");
+        }
+    }
+    dequeue() {
+        if (this.first) {
+            const currentFirst = this.first;
+            this.first = this.first.next;
+            if (this.last === currentFirst) {
+                this.last = null;
+            }
+            this.count--;
+            return currentFirst.data;
+        }
+        else {
+            throw new Error("Trying to dequeue from an empty queue");
+        }
+    }
+    remove(id) {
+        if (this.nodeMap[id] === undefined) {
+            throw new Error("Trying to remove a task that doesn't exist");
+        }
+        const toRemove = this.nodeMap[id];
+        if (toRemove.next === null && toRemove.prev === null) {
+            this.first = null;
+            this.last = null;
+        }
+        else if (toRemove.next === null) {
+            this.last = toRemove.prev;
+            toRemove.prev.next = null;
+        }
+        else if (toRemove.prev === null) {
+            this.first = toRemove.next;
+            toRemove.next.prev = null;
+        }
+        else {
+            const prev = toRemove.prev;
+            const next = toRemove.next;
+            prev.next = next;
+            next.prev = prev;
+        }
+        delete this.nodeMap[id];
+        this.count--;
+    }
+    getAll() {
+        const all = [];
+        let curr = this.first;
+        while (curr) {
+            all.push(curr.data);
+            curr = curr.next;
+        }
+        return all;
+    }
+    isEmpty() {
+        return this.first === null;
+    }
+    size() {
+        return this.count;
+    }
+}
+exports.Queue = Queue;
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus[TaskStatus["NOT_STARTED"] = 0] = "NOT_STARTED";
+    TaskStatus[TaskStatus["RUNNING"] = 1] = "RUNNING";
+    TaskStatus[TaskStatus["RETRY"] = 2] = "RETRY";
+    TaskStatus[TaskStatus["FAILED"] = 3] = "FAILED";
+    TaskStatus[TaskStatus["FINISHED"] = 4] = "FINISHED";
+})(TaskStatus = exports.TaskStatus || (exports.TaskStatus = {}));
+class TaskQueue {
+    constructor(key, config) {
+        this.key = key;
+        this.config = config;
+        this.queue = new Queue();
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.TASKS);
+        this.tokens = 0;
+        this.addedTimes = [];
+        this.completedTimes = [];
+        this.failedTimes = [];
+        this.maxTokens = Math.max(this.config.rateLimits.maxDispatchesPerSecond, 1.1);
+        this.lastTokenUpdate = Date.now();
+        this.queuedIds = new Set();
+        this.dispatches = new Array(this.config.rateLimits.maxConcurrentDispatches).fill(null);
+        this.openDispatches = Array.from(this.dispatches.keys());
+    }
+    dispatchTasks() {
+        while (!this.queue.isEmpty() && this.openDispatches.length > 0 && this.tokens >= 1) {
+            const dispatchLocation = this.openDispatches.pop();
+            if (dispatchLocation !== undefined) {
+                const dispatch = this.queue.dequeue();
+                dispatch.metadata.lastRunTime = null;
+                dispatch.metadata.currentAttempt = 1;
+                dispatch.metadata.status = TaskStatus.NOT_STARTED;
+                dispatch.metadata.startTime = Date.now();
+                this.dispatches[dispatchLocation] = dispatch;
+                this.tokens--;
+            }
+        }
+    }
+    setDispatch(dispatches) {
+        this.dispatches = dispatches;
+        const open = [];
+        for (let i = 0; i < this.dispatches.length; i++) {
+            if (dispatches[i] === null) {
+                open.push(i);
+            }
+        }
+        this.openDispatches = open;
+    }
+    getDispatch() {
+        return this.dispatches;
+    }
+    processDispatch() {
+        var _a;
+        for (let i = 0; i < this.dispatches.length; i++) {
+            if (this.dispatches[i] !== null) {
+                switch ((_a = this.dispatches[i]) === null || _a === void 0 ? void 0 : _a.metadata.status) {
+                    case TaskStatus.FAILED:
+                        this.dispatches[i] = null;
+                        this.openDispatches.push(i);
+                        this.completedTimes.push(Date.now());
+                        this.failedTimes.push(Date.now());
+                        break;
+                    case TaskStatus.NOT_STARTED:
+                        void this.runTask(i);
+                        break;
+                    case TaskStatus.RETRY:
+                        this.handleRetry(i);
+                        break;
+                    case TaskStatus.FINISHED:
+                        this.dispatches[i] = null;
+                        this.openDispatches.push(i);
+                        this.completedTimes.push(Date.now());
+                        break;
+                }
+            }
+        }
+    }
+    async runTask(dispatchIndex) {
+        if (this.dispatches[dispatchIndex] === null) {
+            throw new Error("Trying to dispatch a nonexistent task");
+        }
+        const emulatedTask = this.dispatches[dispatchIndex];
+        if (emulatedTask.metadata.lastRunTime !== null &&
+            Date.now() - emulatedTask.metadata.lastRunTime < emulatedTask.metadata.currentBackoff * 1000) {
+            return;
+        }
+        emulatedTask.metadata.status = TaskStatus.RUNNING;
+        try {
+            const headers = Object.assign({ "Content-Type": "application/json", "X-CloudTasks-QueueName": this.key, "X-CloudTasks-TaskName": emulatedTask.task.name.split("/").pop(), "X-CloudTasks-TaskRetryCount": `${emulatedTask.metadata.currentAttempt - 1}`, "X-CloudTasks-TaskExecutionCount": `${emulatedTask.metadata.executionCount}`, "X-CloudTasks-TaskETA": `${emulatedTask.task.scheduleTime || Date.now()}` }, emulatedTask.task.httpRequest.headers);
+            if (emulatedTask.metadata.previousResponse) {
+                headers["X-CloudTasks-TaskPreviousResponse"] = `${emulatedTask.metadata.previousResponse}`;
+            }
+            const controller = new abort_controller_1.default();
+            const signal = controller.signal;
+            const request = (0, node_fetch_1.default)(emulatedTask.task.httpRequest.url, {
+                method: "POST",
+                headers: headers,
+                body: JSON.stringify(emulatedTask.task.httpRequest.body),
+                signal: signal,
+            });
+            const dispatchDeadline = emulatedTask.task.dispatchDeadline;
+            const dispatchDeadlineSeconds = dispatchDeadline
+                ? parseInt(dispatchDeadline.substring(0, dispatchDeadline.length - 1))
+                : 60;
+            const abortId = setTimeout(() => {
+                controller.abort();
+            }, dispatchDeadlineSeconds * 1000);
+            const response = await request;
+            clearTimeout(abortId);
+            if (response.ok) {
+                emulatedTask.metadata.status = TaskStatus.FINISHED;
+                return;
+            }
+            else {
+                if (!(response.status >= 500 && response.status <= 599)) {
+                    emulatedTask.metadata.executionCount++;
+                }
+                emulatedTask.metadata.previousResponse = response.status;
+                emulatedTask.metadata.status = TaskStatus.RETRY;
+                emulatedTask.metadata.lastRunTime = Date.now();
+            }
+        }
+        catch (e) {
+            this.logger.logLabeled("WARN", `${e}`);
+            emulatedTask.metadata.status = TaskStatus.RETRY;
+            emulatedTask.metadata.lastRunTime = Date.now();
+        }
+    }
+    handleRetry(dispatchIndex) {
+        if (this.dispatches[dispatchIndex] === null) {
+            throw new Error("Trying to retry a nonexistent task");
+        }
+        const { metadata } = this.dispatches[dispatchIndex];
+        const { retryConfig } = this.config;
+        if (this.shouldStopRetrying(metadata, retryConfig)) {
+            metadata.status = TaskStatus.FAILED;
+            return;
+        }
+        this.updateMetadata(metadata, retryConfig);
+        metadata.status = TaskStatus.NOT_STARTED;
+    }
+    shouldStopRetrying(metadata, retryOptions) {
+        if (metadata.currentAttempt > retryOptions.maxAttempts) {
+            if (retryOptions.maxRetrySeconds === null || retryOptions.maxRetrySeconds === 0) {
+                return true;
+            }
+            if (Date.now() - metadata.startTime > retryOptions.maxRetrySeconds * 1000) {
+                return true;
+            }
+        }
+        return false;
+    }
+    updateMetadata(metadata, retryOptions) {
+        const timeMultplier = Math.pow(2, Math.min(metadata.currentAttempt - 1, retryOptions.maxDoublings)) +
+            Math.max(0, metadata.currentAttempt - retryOptions.maxDoublings - 1) *
+                Math.pow(2, retryOptions.maxDoublings);
+        metadata.currentBackoff = Math.min(retryOptions.maxBackoffSeconds, timeMultplier * retryOptions.minBackoffSeconds);
+        metadata.currentAttempt++;
+    }
+    isActive() {
+        return !this.queue.isEmpty() || this.dispatches.some((e) => e !== null);
+    }
+    refillTokens() {
+        const tokensToAdd = ((Date.now() - this.lastTokenUpdate) / 1000) * this.config.rateLimits.maxDispatchesPerSecond;
+        this.addTokens(tokensToAdd);
+        this.lastTokenUpdate = Date.now();
+    }
+    addTokens(t) {
+        this.tokens += t;
+        this.tokens = Math.min(this.tokens, this.maxTokens);
+    }
+    setTokens(t) {
+        this.tokens = t;
+    }
+    getTokens() {
+        return this.tokens;
+    }
+    enqueue(task) {
+        if (this.queuedIds.has(task.name)) {
+            throw new Error(`A task has already been queued with id ${task.name}`);
+        }
+        const emulatedTask = {
+            task: task,
+            metadata: {
+                currentAttempt: 0,
+                currentBackoff: 0,
+                startTime: 0,
+                status: TaskStatus.NOT_STARTED,
+                lastRunTime: null,
+                previousResponse: null,
+                executionCount: 0,
+            },
+        };
+        emulatedTask.task.httpRequest.url =
+            emulatedTask.task.httpRequest.url === ""
+                ? this.config.defaultUri
+                : emulatedTask.task.httpRequest.url;
+        this.queue.enqueue(emulatedTask.task.name, emulatedTask);
+        this.queuedIds.add(task.name);
+        this.addedTimes.push(Date.now());
+    }
+    delete(taskId) {
+        this.queue.remove(taskId);
+    }
+    getDebugInfo() {
+        return `
+    Task Queue (${this.key}): 
+    - Active: ${this.isActive().toString()}
+    - Tokens: ${this.tokens}
+    - In Queue: ${this.queue.size()}
+    - Dispatch: [
+      ${this.dispatches.map((t) => (t === null ? "empty" : t.task.name)).join(",\n")}
+    ]
+    - Open Locations: [${this.openDispatches.join(", ")}]
+    `;
+    }
+    getStatistics() {
+        const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
+        const oneMinuteAgo = Date.now() - 60 * 1000;
+        this.addedTimes = this.addedTimes.filter((t) => t > fiveMinutesAgo);
+        this.failedTimes = this.failedTimes.filter((t) => t > fiveMinutesAgo);
+        this.completedTimes = this.completedTimes.filter((t) => t > oneMinuteAgo);
+        return {
+            numberOfTasks: this.queue.size(),
+            tasksAdded: this.addedTimes.length / 5,
+            completedLastMin: this.completedTimes.length,
+            failedTasks: this.failedTimes.length / 5,
+            runningTasks: this.dispatches.length,
+            maxRate: this.config.rateLimits.maxDispatchesPerSecond,
+            maxConcurrent: this.config.rateLimits.maxConcurrentDispatches,
+        };
+    }
+}
+exports.TaskQueue = TaskQueue;
+TaskQueue.TASK_QUEUE_INTERVAL = 1000;

package/lib/emulator/tasksEmulator.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksEmulator = exports.TaskQueueController = void 0;
+const express = require("express");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const utils_1 = require("../utils");
+const emulatorLogger_1 = require("./emulatorLogger");
+const taskQueue_1 = require("./taskQueue");
+const cors = require("cors");
+const RETRY_CONFIG_DEFAULTS = {
+    maxAttempts: 3,
+    maxRetrySeconds: null,
+    maxBackoffSeconds: 60 * 60,
+    maxDoublings: 16,
+    minBackoffSeconds: 0.1,
+};
+const RATE_LIMITS_DEFAULT = {
+    maxConcurrentDispatches: 1000,
+    maxDispatchesPerSecond: 500,
+};
+class TaskQueueController {
+    constructor() {
+        this.queues = {};
+        this.tokenRefillIds = [];
+        this.running = false;
+        this.listenId = null;
+    }
+    enqueue(key, task) {
+        if (!this.queues[key]) {
+            throw new Error("Queue does not exist");
+        }
+        this.queues[key].enqueue(task);
+    }
+    delete(key, taskId) {
+        if (!this.queues[key]) {
+            throw new Error("Queue does not exist");
+        }
+        this.queues[key].delete(taskId);
+    }
+    createQueue(key, config) {
+        const newQueue = new taskQueue_1.TaskQueue(key, config);
+        const intervalID = setInterval(() => newQueue.refillTokens(), TaskQueueController.TOKEN_REFRESH_INTERVAL);
+        this.tokenRefillIds.push(intervalID);
+        this.queues[key] = newQueue;
+    }
+    listen() {
+        let shouldUpdate = false;
+        for (const [_key, queue] of Object.entries(this.queues)) {
+            shouldUpdate = shouldUpdate || queue.isActive();
+        }
+        if (shouldUpdate) {
+            this.updateQueues();
+            this.listenId = setTimeout(() => this.listen(), TaskQueueController.UPDATE_TIMEOUT);
+        }
+        else {
+            this.listenId = setTimeout(() => this.listen(), TaskQueueController.LISTEN_TIMEOUT);
+        }
+    }
+    updateQueues() {
+        for (const [_key, queue] of Object.entries(this.queues)) {
+            if (queue.isActive()) {
+                queue.dispatchTasks();
+                queue.processDispatch();
+            }
+        }
+    }
+    start() {
+        this.running = true;
+        this.listen();
+    }
+    stop() {
+        if (this.listenId) {
+            clearTimeout(this.listenId);
+        }
+        this.tokenRefillIds.forEach(clearInterval);
+        this.running = false;
+    }
+    isRunning() {
+        return this.running;
+    }
+    getStatistics() {
+        const stats = {};
+        for (const [key, queue] of Object.entries(this.queues)) {
+            stats[key] = queue.getStatistics();
+        }
+        return stats;
+    }
+}
+exports.TaskQueueController = TaskQueueController;
+TaskQueueController.UPDATE_TIMEOUT = 0;
+TaskQueueController.LISTEN_TIMEOUT = 1000;
+TaskQueueController.TOKEN_REFRESH_INTERVAL = 1000;
+class TasksEmulator {
+    constructor(args) {
+        this.args = args;
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.TASKS);
+        this.controller = new TaskQueueController();
+    }
+    validateQueueId(queueId) {
+        if (typeof queueId !== "string") {
+            return false;
+        }
+        if (queueId.length > 100) {
+            return false;
+        }
+        const regex = /^[A-Za-z0-9-]+$/;
+        return regex.test(queueId);
+    }
+    createHubServer() {
+        const hub = express();
+        const createTaskQueueRoute = `/projects/:project_id/locations/:location_id/queues/:queue_name`;
+        const createTaskQueueHandler = (req, res) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+            const projectId = req.params.project_id;
+            const locationId = req.params.location_id;
+            const queueName = req.params.queue_name;
+            if (!this.validateQueueId(queueName)) {
+                res.status(400).send("Invalid Queue ID");
+                return;
+            }
+            const key = `queue:${projectId}-${locationId}-${queueName}`;
+            this.logger.logLabeled("SUCCESS", "tasks", `Created queue with key: ${key}`);
+            const body = req.body;
+            const taskQueueConfig = {
+                retryConfig: {
+                    maxAttempts: (_b = (_a = body.retryConfig) === null || _a === void 0 ? void 0 : _a.maxAttempts) !== null && _b !== void 0 ? _b : RETRY_CONFIG_DEFAULTS.maxAttempts,
+                    maxRetrySeconds: (_d = (_c = body.retryConfig) === null || _c === void 0 ? void 0 : _c.maxRetrySeconds) !== null && _d !== void 0 ? _d : RETRY_CONFIG_DEFAULTS.maxRetrySeconds,
+                    maxBackoffSeconds: (_f = (_e = body.retryConfig) === null || _e === void 0 ? void 0 : _e.maxBackoffSeconds) !== null && _f !== void 0 ? _f : RETRY_CONFIG_DEFAULTS.maxBackoffSeconds,
+                    maxDoublings: (_h = (_g = body.retryConfig) === null || _g === void 0 ? void 0 : _g.maxDoublings) !== null && _h !== void 0 ? _h : RETRY_CONFIG_DEFAULTS.maxDoublings,
+                    minBackoffSeconds: (_k = (_j = body.retryConfig) === null || _j === void 0 ? void 0 : _j.minBackoffSeconds) !== null && _k !== void 0 ? _k : RETRY_CONFIG_DEFAULTS.minBackoffSeconds,
+                },
+                rateLimits: {
+                    maxConcurrentDispatches: (_m = (_l = body.rateLimits) === null || _l === void 0 ? void 0 : _l.maxConcurrentDispatches) !== null && _m !== void 0 ? _m : RATE_LIMITS_DEFAULT.maxConcurrentDispatches,
+                    maxDispatchesPerSecond: (_p = (_o = body.rateLimits) === null || _o === void 0 ? void 0 : _o.maxDispatchesPerSecond) !== null && _p !== void 0 ? _p : RATE_LIMITS_DEFAULT.maxDispatchesPerSecond,
+                },
+                timeoutSeconds: (_q = body.timeoutSeconds) !== null && _q !== void 0 ? _q : 10,
+                retry: (_r = body.retry) !== null && _r !== void 0 ? _r : false,
+                defaultUri: body.defaultUri,
+            };
+            if (taskQueueConfig.rateLimits.maxConcurrentDispatches > 5000) {
+                res.status(400).send("cannot set maxConcurrentDispatches to a value over 5000");
+                return;
+            }
+            this.controller.createQueue(key, taskQueueConfig);
+            this.logger.log("DEBUG", `Created task queue ${key} with configuration: ${JSON.stringify(taskQueueConfig)}`);
+            res.status(200).send({ taskQueueConfig });
+        };
+        const enqueueTasksRoute = `/projects/:project_id/locations/:location_id/queues/:queue_name/tasks`;
+        const enqueueTasksHandler = (req, res) => {
+            var _a;
+            if (!this.controller.isRunning()) {
+                this.controller.start();
+            }
+            const projectId = req.params.project_id;
+            const locationId = req.params.location_id;
+            const queueName = req.params.queue_name;
+            const queueKey = `queue:${projectId}-${locationId}-${queueName}`;
+            if (!this.controller.queues[queueKey]) {
+                this.logger.log("WARN", "Tried to queue a task into a non-existent queue");
+                res.status(404).send("Tried to queue a task from a non-existent queue");
+                return;
+            }
+            req.body.task.name =
+                (_a = req.body.task.name) !== null && _a !== void 0 ? _a : `/projects/${projectId}/locations/${locationId}/queues/${queueName}/tasks/${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}`;
+            req.body.task.httpRequest.body = JSON.parse(atob(req.body.task.httpRequest.body));
+            const task = req.body.task;
+            try {
+                this.controller.enqueue(queueKey, task);
+                this.logger.log("DEBUG", `Enqueueing task ${task.name} onto ${queueKey}`);
+                res.status(200).send({ task: task });
+            }
+            catch (e) {
+                res.status(409).send("A task with the same name already exists");
+            }
+        };
+        const deleteTasksRoute = `/projects/:project_id/locations/:location_id/queues/:queue_name/tasks/:task_id`;
+        const deleteTasksHandler = (req, res) => {
+            const projectId = req.params.project_id;
+            const locationId = req.params.location_id;
+            const queueName = req.params.queue_name;
+            const taskId = req.params.task_id;
+            const queueKey = `queue:${projectId}-${locationId}-${queueName}`;
+            if (!this.controller.queues[queueKey]) {
+                this.logger.log("WARN", "Tried to remove a task from a non-existent queue");
+                res.status(404).send("Tried to remove a task from a non-existent queue");
+                return;
+            }
+            try {
+                const taskName = `projects/${projectId}/locations/${locationId}/queues/${queueName}/tasks/${taskId}`;
+                this.logger.log("DEBUG", `removing: ${taskName}`);
+                this.controller.delete(queueKey, taskName);
+                res.status(200).send({ res: "OK" });
+            }
+            catch (e) {
+                this.logger.log("WARN", "Tried to remove a task that doesn't exist");
+                res.status(404).send("Tried to remove a task that doesn't exist");
+            }
+        };
+        const getStatsRoute = `/queueStats`;
+        const getStatsHandler = (req, res) => {
+            res.json(this.controller.getStatistics());
+        };
+        hub.get([getStatsRoute], cors({ origin: true }), getStatsHandler);
+        hub.post([createTaskQueueRoute], express.json(), createTaskQueueHandler);
+        hub.post([enqueueTasksRoute], express.json(), enqueueTasksHandler);
+        hub.delete([deleteTasksRoute], express.json(), deleteTasksHandler);
+        return hub;
+    }
+    async start() {
+        const { host, port } = this.getInfo();
+        const server = this.createHubServer().listen(port, host);
+        this.destroyServer = (0, utils_1.createDestroyer)(server);
+        return Promise.resolve();
+    }
+    async connect() {
+        return Promise.resolve();
+    }
+    async stop() {
+        if (this.destroyServer) {
+            await this.destroyServer();
+        }
+        this.controller.stop();
+    }
+    getInfo() {
+        const host = this.args.host || constants_1.Constants.getDefaultHost();
+        const port = this.args.port || constants_1.Constants.getDefaultPort(types_1.Emulators.TASKS);
+        return {
+            name: this.getName(),
+            host,
+            port,
+        };
+    }
+    getName() {
+        return types_1.Emulators.TASKS;
+    }
+}
+exports.TasksEmulator = TasksEmulator;

package/lib/emulator/types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Severity = exports.EmulatorLog = exports.FunctionsExecutionMode = exports.isEmulator = exports.isDownloadableEmulator = exports.ALL_EMULATORS = exports.EMULATORS_SUPPORTED_BY_USE_EMULATOR = exports.EMULATORS_SUPPORTED_BY_UI = exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = exports.ALL_SERVICE_EMULATORS = exports.IMPORT_EXPORT_EMULATORS = exports.DOWNLOADABLE_EMULATORS = exports.Emulators = void 0;
+const experiments = require("../experiments");
 var Emulators;
 (function (Emulators) {
     Emulators["AUTH"] = "auth";
@@ -9,6 +10,7 @@ var Emulators;
     Emulators["FIRESTORE"] = "firestore";
     Emulators["DATABASE"] = "database";
     Emulators["HOSTING"] = "hosting";
+    Emulators["APPHOSTING"] = "apphosting";
     Emulators["PUBSUB"] = "pubsub";
     Emulators["UI"] = "ui";
     Emulators["LOGGING"] = "logging";
@@ -16,6 +18,7 @@ var Emulators;
     Emulators["EXTENSIONS"] = "extensions";
     Emulators["EVENTARC"] = "eventarc";
     Emulators["DATACONNECT"] = "dataconnect";
+    Emulators["TASKS"] = "tasks";
 })(Emulators = exports.Emulators || (exports.Emulators = {}));
 exports.DOWNLOADABLE_EMULATORS = [
     Emulators.FIRESTORE,
@@ -37,10 +40,12 @@ exports.ALL_SERVICE_EMULATORS = [
     Emulators.FIRESTORE,
     Emulators.DATABASE,
     Emulators.HOSTING,
+    ...(experiments.isEnabled("emulatorapphosting") ? [Emulators.APPHOSTING] : []),
     Emulators.PUBSUB,
     Emulators.STORAGE,
     Emulators.EVENTARC,
     Emulators.DATACONNECT,
+    Emulators.TASKS,
 ].filter((v) => v);
 exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = [
     Emulators.FIRESTORE,
@@ -48,6 +53,7 @@ exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = [
     Emulators.PUBSUB,
     Emulators.STORAGE,
     Emulators.EVENTARC,
+    Emulators.TASKS,
 ];
 exports.EMULATORS_SUPPORTED_BY_UI = [
     Emulators.AUTH,

package/lib/experiments.js

@@ -56,6 +56,10 @@ exports.ALL_EXPERIMENTS = experiments({
     emulatoruisnapshot: {
         shortDescription: "Load pre-release versions of the emulator UI",
     },
+    emulatorapphosting: {
+        shortDescription: "App Hosting emulator",
+        public: false,
+    },
     webframeworks: {
         shortDescription: "Native support for popular web frameworks",
         fullDescription: "Adds support for popular web frameworks such as Next.js " +

package/lib/firestore/api.js

@@ -459,11 +459,12 @@ class FirestoreApi {
         }
         return database;
     }
-    async restoreDatabase(project, databaseId, backupName) {
+    async restoreDatabase(project, databaseId, backupName, encryptionConfig) {
         const url = `/projects/${project}/databases:restore`;
         const payload = {
             databaseId,
             backup: backupName,
+            encryptionConfig: encryptionConfig,
         };
         const options = { queryParams: { databaseId: databaseId } };
         const res = await this.apiClient.post(url, payload, options);

package/lib/firestore/options.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionType = void 0;
+var EncryptionType;
+(function (EncryptionType) {
+    EncryptionType["CUSTOMER_MANAGED_ENCRYPTION"] = "CUSTOMER_MANAGED_ENCRYPTION";
+    EncryptionType["USE_SOURCE_ENCRYPTION"] = "USE_SOURCE_ENCRYPTION";
+    EncryptionType["GOOGLE_DEFAULT_ENCRYPTION"] = "GOOGLE_DEFAULT_ENCRYPTION";
+})(EncryptionType = exports.EncryptionType || (exports.EncryptionType = {}));