firebase-tools 13.15.4 → 13.16.0

package/lib/dataconnect/client.js

@@ -123,13 +123,14 @@ async function deleteConnector(name) {
     return;
 }
 exports.deleteConnector = deleteConnector;
-async function listConnectors(serviceName) {
+async function listConnectors(serviceName, fields = []) {
     const connectors = [];
     const getNextPage = async (pageToken = "") => {
         const res = await dataconnectClient().get(`${serviceName}/connectors`, {
             queryParams: {
                 pageSize: PAGE_SIZE_MAX,
                 pageToken,
+                fields: fields.join(","),
             },
         });
         connectors.push(...(res.body.connectors || []));

package/lib/deploy/functions/prepare.js

@@ -27,7 +27,6 @@ const serviceusage_1 = require("../../gcp/serviceusage");
 const applyHash_1 = require("./cache/applyHash");
 const backend_1 = require("./backend");
 const functional_1 = require("../../functional");
-const prepare_1 = require("../extensions/prepare");
 exports.EVENTARC_SOURCE_ENV = "EVENTARC_CLOUD_EVENT_SOURCE";
 async function prepare(context, options, payload) {
     var _a, _b;
@@ -56,13 +55,6 @@ async function prepare(context, options, payload) {
     }
     context.codebaseDeployEvents = {};
     const wantBuilds = await loadCodebases(context.config, options, firebaseConfig, runtimeConfig, context.filters);
-    if (Object.values(wantBuilds).some((b) => b.extensions)) {
-        const extContext = {};
-        const extPayload = {};
-        await (0, prepare_1.prepareDynamicExtensions)(extContext, options, extPayload, wantBuilds);
-        context.extensions = extContext;
-        payload.extensions = extPayload;
-    }
     const codebaseUsesEnvs = [];
     const wantBackends = {};
     for (const [codebase, wantBuild] of Object.entries(wantBuilds)) {

package/lib/emulator/constants.js

@@ -15,6 +15,7 @@ exports.DEFAULT_PORTS = {
     storage: 9199,
     eventarc: 9299,
     dataconnect: 9399,
+    tasks: 9499,
 };
 exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     ui: true,
@@ -30,6 +31,7 @@ exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     extensions: false,
     eventarc: true,
     dataconnect: true,
+    tasks: true,
 };
 exports.EMULATOR_DESCRIPTION = {
     ui: "Emulator UI",
@@ -45,6 +47,7 @@ exports.EMULATOR_DESCRIPTION = {
     extensions: "Extensions Emulator",
     eventarc: "Eventarc Emulator",
     dataconnect: "Data Connect Emulator",
+    tasks: "Cloud Tasks Emulator",
 };
 exports.DEFAULT_HOST = "localhost";
 class Constants {
@@ -70,6 +73,8 @@ class Constants {
                 return "test lab";
             case this.SERVICE_EVENTARC:
                 return "eventarc";
+            case this.SERVICE_CLOUD_TASKS:
+                return "tasks";
             default:
                 return service;
         }
@@ -100,12 +105,14 @@ Constants.FIREBASE_STORAGE_EMULATOR_HOST = "FIREBASE_STORAGE_EMULATOR_HOST";
 Constants.CLOUD_STORAGE_EMULATOR_HOST = "STORAGE_EMULATOR_HOST";
 Constants.PUBSUB_EMULATOR_HOST = "PUBSUB_EMULATOR_HOST";
 Constants.CLOUD_EVENTARC_EMULATOR_HOST = "CLOUD_EVENTARC_EMULATOR_HOST";
+Constants.CLOUD_TASKS_EMULATOR_HOST = "CLOUD_TASKS_EMULATOR_HOST";
 Constants.FIREBASE_EMULATOR_HUB = "FIREBASE_EMULATOR_HUB";
 Constants.FIREBASE_GA_SESSION = "FIREBASE_GA_SESSION";
 Constants.SERVICE_FIRESTORE = "firestore.googleapis.com";
 Constants.SERVICE_REALTIME_DATABASE = "firebaseio.com";
 Constants.SERVICE_PUBSUB = "pubsub.googleapis.com";
 Constants.SERVICE_EVENTARC = "eventarc.googleapis.com";
+Constants.SERVICE_CLOUD_TASKS = "cloudtasks.googleapis.com";
 Constants.SERVICE_FIREALERTS = "firebasealerts.googleapis.com";
 Constants.SERVICE_ANALYTICS = "app-measurement.com";
 Constants.SERVICE_AUTH = "firebaseauth.googleapis.com";

package/lib/emulator/controller.js

@@ -44,6 +44,7 @@ const hostingEmulator_1 = require("./hostingEmulator");
 const pubsubEmulator_1 = require("./pubsubEmulator");
 const storage_1 = require("./storage");
 const fileUtils_1 = require("../dataconnect/fileUtils");
+const tasksEmulator_1 = require("./tasksEmulator");
 const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
 async function exportOnExit(options) {
     const exportOnExitDir = options.exportOnExit;
@@ -159,7 +160,7 @@ function findExportMetadata(importPath) {
     }
 }
 async function startAll(options, showUI = true, runningTestScript = false) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const targets = filterEmulatorTargets(options);
     options.targets = targets;
     const singleProjectModeEnabled = ((_a = options.config.src.emulators) === null || _a === void 0 ? void 0 : _a.singleProjectMode) === undefined ||
@@ -224,10 +225,12 @@ async function startAll(options, showUI = true, runningTestScript = false) {
     if (emulatableBackends.length) {
         listenConfig[types_1.Emulators.FUNCTIONS] = getListenConfig(options, types_1.Emulators.FUNCTIONS);
         listenConfig[types_1.Emulators.EVENTARC] = getListenConfig(options, types_1.Emulators.EVENTARC);
+        listenConfig[types_1.Emulators.TASKS] = getListenConfig(options, types_1.Emulators.TASKS);
     }
     for (const emulator of types_1.ALL_EMULATORS) {
         if (emulator === types_1.Emulators.FUNCTIONS ||
             emulator === types_1.Emulators.EVENTARC ||
+            emulator === types_1.Emulators.TASKS ||
             emulator === types_1.Emulators.EXTENSIONS ||
             (emulator === types_1.Emulators.UI && !showUI)) {
             continue;
@@ -330,8 +333,8 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {
-        if (!listenForEmulator.functions || !listenForEmulator.eventarc) {
-            listenForEmulator = await (0, portUtils_1.resolveHostAndAssignPorts)(Object.assign(Object.assign({}, listenForEmulator), { functions: (_f = listenForEmulator.functions) !== null && _f !== void 0 ? _f : getListenConfig(options, types_1.Emulators.FUNCTIONS), eventarc: (_g = listenForEmulator.eventarc) !== null && _g !== void 0 ? _g : getListenConfig(options, types_1.Emulators.EVENTARC) }));
+        if (!listenForEmulator.functions || !listenForEmulator.eventarc || !listenForEmulator.tasks) {
+            listenForEmulator = await (0, portUtils_1.resolveHostAndAssignPorts)(Object.assign(Object.assign({}, listenForEmulator), { functions: (_f = listenForEmulator.functions) !== null && _f !== void 0 ? _f : getListenConfig(options, types_1.Emulators.FUNCTIONS), eventarc: (_g = listenForEmulator.eventarc) !== null && _g !== void 0 ? _g : getListenConfig(options, types_1.Emulators.EVENTARC), tasks: (_h = listenForEmulator.eventarc) !== null && _h !== void 0 ? _h : getListenConfig(options, types_1.Emulators.TASKS) }));
             hubLogger.log("DEBUG", "late-assigned ports for functions and eventarc emulators", {
                 user: listenForEmulator,
             });
@@ -368,6 +371,12 @@ async function startAll(options, showUI = true, runningTestScript = false) {
             port: eventarcAddr.port,
         });
         await startEmulator(eventarcEmulator);
+        const tasksAddr = legacyGetFirstAddr(types_1.Emulators.TASKS);
+        const tasksEmulator = new tasksEmulator_1.TasksEmulator({
+            host: tasksAddr.host,
+            port: tasksAddr.port,
+        });
+        await startEmulator(tasksEmulator);
     }
     if (listenForEmulator.firestore) {
         const firestoreLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FIRESTORE);

package/lib/emulator/downloadableEmulators.js

@@ -23,9 +23,9 @@ const EMULATOR_UPDATE_DETAILS = {
         expectedChecksum: "2fd771101c0e1f7898c04c9204f2ce63",
     },
     firestore: {
-        version: "1.19.7",
-        expectedSize: 66438992,
-        expectedChecksum: "aec233bea95c5cfab03881574ec16d6c",
+        version: "1.19.8",
+        expectedSize: 63634791,
+        expectedChecksum: "9b43a6daa590678de9b7df6d68260395",
     },
     storage: {
         version: "1.1.3",

package/lib/emulator/env.js

@@ -31,6 +31,9 @@ function setEnvVarsForEmulators(env, emulators) {
             case types_1.Emulators.EVENTARC:
                 env[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${host}`;
                 break;
+            case types_1.Emulators.TASKS:
+                env[constants_1.Constants.CLOUD_TASKS_EMULATOR_HOST] = host;
+                break;
         }
     }
 }

package/lib/emulator/functionsEmulator.js

@@ -386,6 +386,9 @@ class FunctionsEmulator {
             if (definition.httpsTrigger) {
                 added = true;
                 url = FunctionsEmulator.getHttpFunctionUrl(this.args.projectId, definition.name, definition.region);
+                if (definition.taskQueueTrigger) {
+                    added = await this.addTaskQueueTrigger(this.args.projectId, definition.region, definition.name, url, definition.taskQueueTrigger);
+                }
             }
             else if (definition.eventTrigger) {
                 const service = (0, functionsEmulatorShared_1.getFunctionService)(definition);
@@ -753,6 +756,22 @@ class FunctionsEmulator {
         };
         return true;
     }
+    async addTaskQueueTrigger(projectId, location, entryPoint, defaultUri, taskQueueTrigger) {
+        logger_1.logger.debug(`addTaskQueueTrigger`, JSON.stringify(taskQueueTrigger));
+        if (!registry_1.EmulatorRegistry.isRunning(types_1.Emulators.TASKS)) {
+            logger_1.logger.debug(`addTaskQueueTrigger`, "TQ not running");
+            return Promise.resolve(false);
+        }
+        const bundle = Object.assign(Object.assign({}, taskQueueTrigger), { defaultUri });
+        try {
+            await registry_1.EmulatorRegistry.client(types_1.Emulators.TASKS).post(`/projects/${projectId}/locations/${location}/queues/${entryPoint}`, bundle);
+            return true;
+        }
+        catch (err) {
+            this.logger.log("WARN", "Error adding Task Queue function: " + err);
+            return false;
+        }
+    }
     getProjectId() {
         return this.args.projectId;
     }

package/lib/emulator/functionsEmulatorShared.js

@@ -61,6 +61,7 @@ function prepareEndpoints(endpoints) {
 }
 exports.prepareEndpoints = prepareEndpoints;
 function emulatedFunctionsFromEndpoints(endpoints) {
+    var _a, _b, _c, _d, _e, _f, _g;
     const regionDefinitions = [];
     for (const endpoint of endpoints) {
         if (!endpoint.region) {
@@ -131,6 +132,19 @@ function emulatedFunctionsFromEndpoints(endpoints) {
         }
         else if (backend.isTaskQueueTriggered(endpoint)) {
             def.httpsTrigger = {};
+            def.taskQueueTrigger = {
+                retryConfig: {
+                    maxAttempts: (_a = endpoint.taskQueueTrigger.retryConfig) === null || _a === void 0 ? void 0 : _a.maxAttempts,
+                    maxRetrySeconds: (_b = endpoint.taskQueueTrigger.retryConfig) === null || _b === void 0 ? void 0 : _b.maxRetrySeconds,
+                    maxBackoffSeconds: (_c = endpoint.taskQueueTrigger.retryConfig) === null || _c === void 0 ? void 0 : _c.maxBackoffSeconds,
+                    maxDoublings: (_d = endpoint.taskQueueTrigger.retryConfig) === null || _d === void 0 ? void 0 : _d.maxDoublings,
+                    minBackoffSeconds: (_e = endpoint.taskQueueTrigger.retryConfig) === null || _e === void 0 ? void 0 : _e.minBackoffSeconds,
+                },
+                rateLimits: {
+                    maxConcurrentDispatches: (_f = endpoint.taskQueueTrigger.rateLimits) === null || _f === void 0 ? void 0 : _f.maxConcurrentDispatches,
+                    maxDispatchesPerSecond: (_g = endpoint.taskQueueTrigger.rateLimits) === null || _g === void 0 ? void 0 : _g.maxDispatchesPerSecond,
+                },
+            };
         }
         else {
         }
@@ -189,6 +203,9 @@ function getFunctionService(def) {
     if (def.httpsTrigger) {
         return "https";
     }
+    if (def.taskQueueTrigger) {
+        return constants_1.Constants.SERVICE_CLOUD_TASKS;
+    }
     return "unknown";
 }
 exports.getFunctionService = getFunctionService;

package/lib/emulator/portUtils.js

@@ -156,6 +156,7 @@ const EMULATOR_CAN_LISTEN_ON_PRIMARY_ONLY = {
     functions: true,
     logging: true,
     storage: true,
+    tasks: true,
     hosting: true,
 };
 const MAX_PORT = 65535;

package/lib/emulator/registry.js

@@ -49,6 +49,7 @@ class EmulatorRegistry {
             storage: 3.5,
             eventarc: 3.6,
             dataconnect: 3.7,
+            tasks: 3.8,
             hub: 4,
             logging: 5,
         };

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

@@ -16,6 +16,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,
@@ -41,6 +42,7 @@ exports.ALL_SERVICE_EMULATORS = [
     Emulators.STORAGE,
     Emulators.EVENTARC,
     Emulators.DATACONNECT,
+    Emulators.TASKS,
 ].filter((v) => v);
 exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = [
     Emulators.FIRESTORE,
@@ -48,6 +50,7 @@ exports.EMULATORS_SUPPORTED_BY_FUNCTIONS = [
     Emulators.PUBSUB,
     Emulators.STORAGE,
     Emulators.EVENTARC,
+    Emulators.TASKS,
 ];
 exports.EMULATORS_SUPPORTED_BY_UI = [
     Emulators.AUTH,

package/lib/init/features/dataconnect/index.js

@@ -179,7 +179,10 @@ async function promptForService(setup, info) {
                         info.schemaGql = choice.schema.source.files;
                     }
                     info.cloudSqlDatabase = (_d = (_c = choice.schema.primaryDatasource.postgresql) === null || _c === void 0 ? void 0 : _c.database) !== null && _d !== void 0 ? _d : "";
-                    const connectors = await (0, client_1.listConnectors)(choice.service.name);
+                    const connectors = await (0, client_1.listConnectors)(choice.service.name, [
+                        "connectors.name",
+                        "connectors.source.files",
+                    ]);
                     if (connectors.length) {
                         info.connectors = connectors.map((c) => {
                             const id = c.name.split("/").pop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "13.15.4",
+  "version": "13.16.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {

package/schema/firebase-config.json

@@ -500,6 +500,18 @@
                     },
                     "type": "object"
                 },
+                "tasks": {
+                    "additionalProperties": false,
+                    "properties": {
+                        "host": {
+                            "type": "string"
+                        },
+                        "port": {
+                            "type": "number"
+                        }
+                    },
+                    "type": "object"
+                },
                 "ui": {
                     "additionalProperties": false,
                     "properties": {