firebase-tools 11.2.0 → 11.3.0

package/lib/checkValidTargetFilters.js

@@ -20,7 +20,7 @@ function targetsHaveNoFilters(...targets) {
     return targets.some((t) => !t.includes(":"));
 }
 async function checkValidTargetFilters(options) {
-    const only = (options.only || "").split(",");
+    const only = !options.only ? [] : options.only.split(",");
     return new Promise((resolve, reject) => {
         if (!only.length) {
             return resolve();
@@ -28,10 +28,10 @@ async function checkValidTargetFilters(options) {
         if (options.except) {
             return reject(new error_1.FirebaseError("Cannot specify both --only and --except"));
         }
-        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !["hosting", "functions"].includes(t));
+        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !["hosting", "functions", "firestore"].includes(t));
         const targetsForNonFilteredTypes = targetsForTypes(only, ...nonFilteredTypes);
         if (targetsForNonFilteredTypes.length && targetsHaveFilters(...targetsForNonFilteredTypes)) {
-            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions and hosting"));
+            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions, hosting, and firestore"));
         }
         const targetsForFunctions = targetsForTypes(only, "functions");
         if (targetsForFunctions.length &&

package/lib/commands/ext-export.js

@@ -4,6 +4,7 @@ exports.command = void 0;
 const checkMinRequiredVersion_1 = require("../checkMinRequiredVersion");
 const command_1 = require("../command");
 const planner = require("../deploy/extensions/planner");
+const etags_1 = require("../extensions/etags");
 const export_1 = require("../extensions/export");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const manifest = require("../extensions/manifest");
@@ -63,4 +64,5 @@ exports.command = new command_1.Command("ext:export")
         nonInteractive: options.nonInteractive,
         force: options.force,
     }, true);
+    (0, etags_1.saveEtags)(options.rc, projectId, have);
 });

package/lib/deploy/extensions/planner.js

@@ -54,6 +54,7 @@ async function have(projectId) {
             params: i.config.params,
             allowedEventTypes: i.config.allowedEventTypes,
             eventarcChannel: i.config.eventarcChannel,
+            etag: i.etag,
         };
         if (i.config.extensionRef) {
             const ref = refs.parse(i.config.extensionRef);

package/lib/deploy/extensions/prepare.js

@@ -13,6 +13,7 @@ const extensionsHelper_1 = require("../../extensions/extensionsHelper");
 const secretsUtils_1 = require("../../extensions/secretsUtils");
 const secrets_1 = require("./secrets");
 const warnings_1 = require("../../extensions/warnings");
+const etags_1 = require("../../extensions/etags");
 async function prepare(context, options, payload) {
     var _a;
     const projectId = (0, projectUtils_1.needProjectId)(options);
@@ -28,6 +29,22 @@ async function prepare(context, options, payload) {
         projectDir: options.config.projectDir,
         extensions: options.config.get("extensions"),
     });
+    const etagsChanged = (0, etags_1.detectEtagChanges)(options.rc, projectId, context.have);
+    if (etagsChanged.length) {
+        (0, warnings_1.outOfBandChangesWarning)(etagsChanged);
+        if (!options.force && options.nonInteractive) {
+            throw new error_1.FirebaseError("Pass the --force flag to overwrite out of band changes in non-interactive mode");
+        }
+        else if (!options.force &&
+            !options.nonInteractive &&
+            !(await prompt.promptOnce({
+                type: "confirm",
+                message: `Do you wish to continue deploying these extension instances?`,
+                default: false,
+            }))) {
+            throw new error_1.FirebaseError("Deployment cancelled");
+        }
+    }
     const usingSecrets = await Promise.all((_a = context.want) === null || _a === void 0 ? void 0 : _a.map(secrets_1.checkSpecForSecrets));
     if (usingSecrets.some((i) => i)) {
         await (0, secretsUtils_1.ensureSecretManagerApiEnabled)(options);
@@ -44,7 +61,7 @@ async function prepare(context, options, payload) {
             !options.nonInteractive &&
             !(await prompt.promptOnce({
                 type: "confirm",
-                message: `Do you wish to continue deploying these extensions?`,
+                message: `Do you wish to continue deploying these extension instances?`,
                 default: true,
             }))) {
             throw new error_1.FirebaseError("Deployment cancelled");

package/lib/deploy/extensions/release.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.release = void 0;
 const queue_1 = require("../../throttler/queue");
 const tasks = require("./tasks");
+const planner = require("./planner");
 const error_1 = require("../../error");
 const errors_1 = require("./errors");
 const projectUtils_1 = require("../../projectUtils");
+const etags_1 = require("../../extensions/etags");
 async function release(context, options, payload) {
     var _a, _b, _c, _d;
     const projectId = (0, projectUtils_1.needProjectId)(options);
@@ -35,6 +37,8 @@ async function release(context, options, payload) {
     deploymentQueue.process();
     deploymentQueue.close();
     await deploymentPromise;
+    const newHave = await planner.have(projectId);
+    (0, etags_1.saveEtags)(options.rc, projectId, newHave);
     if (errorHandler.hasErrors()) {
         errorHandler.print();
         throw new error_1.FirebaseError(`Extensions deployment failed.`);

package/lib/deploy/functions/build.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveBackend = exports.of = exports.empty = void 0;
+exports.toBackend = exports.resolveBackend = exports.of = exports.empty = void 0;
 const backend = require("./backend");
 const proto = require("../../gcp/proto");
 const api = require("../../.../../api");
+const params = require("./params");
+const previews_1 = require("../../previews");
 const error_1 = require("../../error");
 const functional_1 = require("../../functional");
 function empty() {
@@ -20,45 +22,19 @@ function of(endpoints) {
     return build;
 }
 exports.of = of;
-function resolveInt(from) {
-    if (from == null) {
-        return 0;
-    }
-    else if (typeof from === "string") {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
-function resolveString(from) {
-    if (from == null) {
-        return "";
-    }
-    else if (from.includes("{{") && from.includes("}}")) {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
-function resolveBoolean(from) {
-    if (from == null) {
-        return false;
-    }
-    else if (typeof from === "string") {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    return from;
-}
 function isMemoryOption(value) {
     return value == null || [128, 256, 512, 1024, 2048, 4096, 8192].includes(value);
 }
-function resolveBackend(build, userEnvs) {
-    for (const param of build.params) {
-        const expectedEnv = param.param;
-        if (!userEnvs.hasOwnProperty(expectedEnv)) {
-            throw new error_1.FirebaseError("Build specified parameter " +
-                expectedEnv +
-                " but it was not present in the user dotenv files or Cloud Secret Manager");
-        }
+async function resolveBackend(build, userEnvOpt, userEnvs) {
+    const projectId = userEnvOpt.projectId;
+    let paramValues = {};
+    if (previews_1.previews.functionsparams) {
+        paramValues = await params.resolveParams(build.params, projectId, userEnvs);
     }
+    return toBackend(build, paramValues);
+}
+exports.resolveBackend = resolveBackend;
+function toBackend(build, paramValues) {
     const bkEndpoints = [];
     for (const endpointId of Object.keys(build.endpoints)) {
         const bdEndpoint = build.endpoints[endpointId];
@@ -67,7 +43,7 @@ function resolveBackend(build, userEnvs) {
             regions = [api.functionsDefaultRegion];
         }
         for (const region of regions) {
-            const trigger = discoverTrigger(bdEndpoint);
+            const trigger = discoverTrigger(bdEndpoint, paramValues);
             if (typeof bdEndpoint.platform === "undefined") {
                 throw new error_1.FirebaseError("platform can't be undefined");
             }
@@ -76,21 +52,25 @@ function resolveBackend(build, userEnvs) {
             }
             let timeout;
             if (bdEndpoint.timeoutSeconds) {
-                timeout = resolveInt(bdEndpoint.timeoutSeconds);
+                timeout = params.resolveInt(bdEndpoint.timeoutSeconds, paramValues);
             }
             else {
                 timeout = 60;
             }
             const bkEndpoint = Object.assign({ id: endpointId, project: bdEndpoint.project, region: region, entryPoint: bdEndpoint.entryPoint, platform: bdEndpoint.platform, runtime: bdEndpoint.runtime, timeoutSeconds: timeout }, trigger);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "maxInstances", "maxInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "minInstances", "minInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, bdEndpoint, "concurrency", "concurrency", resolveInt);
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "maxInstances", "maxInstances", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "minInstances", "minInstances", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "concurrency", "concurrency", (from) => {
+                return params.resolveInt(from, paramValues);
+            });
             proto.copyIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
             proto.copyIfPresent(bkEndpoint, bdEndpoint, "secretEnvironmentVariables");
             if (bdEndpoint.vpc) {
-                bkEndpoint.vpc = {
-                    connector: resolveString(bdEndpoint.vpc.connector).replace("$REGION", region),
-                };
+                bkEndpoint.vpc = { connector: params.resolveString(bdEndpoint.vpc.connector, paramValues) };
                 proto.copyIfPresent(bkEndpoint.vpc, bdEndpoint.vpc, "egressSettings");
             }
             proto.renameIfPresent(bkEndpoint, bdEndpoint, "serviceAccountEmail", "serviceAccount");
@@ -104,13 +84,16 @@ function resolveBackend(build, userEnvs) {
     bkend.requiredAPIs = build.requiredAPIs;
     return bkend;
 }
-exports.resolveBackend = resolveBackend;
-function discoverTrigger(endpoint) {
+exports.toBackend = toBackend;
+function discoverTrigger(endpoint, paramValues) {
+    const resolveInt = (from) => params.resolveInt(from, paramValues);
+    const resolveString = (from) => params.resolveString(from, paramValues);
+    const resolveBoolean = (from) => params.resolveBoolean(from, paramValues);
     let trigger;
     if ("httpsTrigger" in endpoint) {
         const bkHttps = {};
         if (endpoint.httpsTrigger.invoker) {
-            bkHttps.invoker = [endpoint.httpsTrigger.invoker];
+            bkHttps.invoker = endpoint.httpsTrigger.invoker;
         }
         trigger = { httpsTrigger: bkHttps };
     }
@@ -122,22 +105,30 @@ function discoverTrigger(endpoint) {
     }
     else if ("eventTrigger" in endpoint) {
         const bkEventFilters = {};
-        for (const key in endpoint.eventTrigger.eventFilters) {
-            if (typeof key === "string") {
-                bkEventFilters[key] = resolveString(endpoint.eventTrigger.eventFilters[key]);
-            }
+        for (const [key, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
+            bkEventFilters[key] = params.resolveString(value, paramValues);
         }
         const bkEvent = {
             eventType: endpoint.eventTrigger.eventType,
             eventFilters: bkEventFilters,
-            retry: resolveBoolean(endpoint.eventTrigger.retry),
+            retry: resolveBoolean(endpoint.eventTrigger.retry || false),
         };
+        if (endpoint.eventTrigger.eventFilterPathPatterns) {
+            const bkEventFiltersPathPatterns = {};
+            for (const [key, value] of Object.entries(endpoint.eventTrigger.eventFilterPathPatterns)) {
+                bkEventFiltersPathPatterns[key] = params.resolveString(value, paramValues);
+            }
+            bkEvent.eventFilterPathPatterns = bkEventFiltersPathPatterns;
+        }
         if (endpoint.eventTrigger.serviceAccount) {
             bkEvent.serviceAccountEmail = endpoint.eventTrigger.serviceAccount;
         }
         if (endpoint.eventTrigger.region) {
             bkEvent.region = resolveString(endpoint.eventTrigger.region);
         }
+        if (endpoint.eventTrigger.channel) {
+            bkEvent.channel = endpoint.eventTrigger.channel;
+        }
         trigger = { eventTrigger: bkEvent };
     }
     else if ("scheduleTrigger" in endpoint) {

package/lib/deploy/functions/params.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveParams = exports.resolveBoolean = exports.resolveString = exports.resolveInt = void 0;
+const logger_1 = require("../../logger");
+const error_1 = require("../../error");
+const prompt_1 = require("../../prompt");
+const functional_1 = require("../../functional");
+function isCEL(expr) {
+    return typeof expr === "string" && expr.includes("{{") && expr.includes("}}");
+}
+function dependenciesCEL(expr) {
+    const deps = [];
+    const paramCapture = /{{ params\.(\w+) }}/g;
+    let match;
+    while ((match = paramCapture.exec(expr)) != null) {
+        deps.push(match[1]);
+    }
+    return deps;
+}
+function resolveInt(from, paramValues) {
+    if (typeof from === "number") {
+        return from;
+    }
+    const match = /\A{{ params\.(\w+) }}\z/.exec(from);
+    if (!match) {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    const referencedParamValue = paramValues[match[1]];
+    if (typeof referencedParamValue !== "number") {
+        throw new error_1.FirebaseError("Referenced numeric parameter '" +
+            match +
+            "' resolved to non-number value " +
+            referencedParamValue);
+    }
+    return referencedParamValue;
+}
+exports.resolveInt = resolveInt;
+function resolveString(from, paramValues) {
+    if (!isCEL(from)) {
+        return from;
+    }
+    let output = from;
+    const paramCapture = /{{ params\.(\w+) }}/g;
+    let match;
+    while ((match = paramCapture.exec(from)) != null) {
+        const referencedParamValue = paramValues[match[1]];
+        if (typeof referencedParamValue !== "string") {
+            throw new error_1.FirebaseError("Referenced string parameter '" +
+                match[1] +
+                "' resolved to non-string value " +
+                referencedParamValue);
+        }
+        output = output.replace(`{{ params.${match[1]} }}`, referencedParamValue);
+    }
+    if (isCEL(output)) {
+        throw new error_1.FirebaseError("CEL evaluation of non-identity expression '" + from + "' not yet supported");
+    }
+    return output;
+}
+exports.resolveString = resolveString;
+function resolveBoolean(from, paramValues) {
+    if (typeof from === "string" && /{{ params\.(\w+) }}/.test(from)) {
+        const match = /{{ params\.(\w+) }}/.exec(from);
+        const referencedParamValue = paramValues[match[1]];
+        if (typeof referencedParamValue !== "boolean") {
+            throw new error_1.FirebaseError("Referenced boolean parameter '" +
+                match +
+                "' resolved to non-boolean value " +
+                referencedParamValue);
+        }
+        return referencedParamValue;
+    }
+    else if (typeof from === "string") {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    return from;
+}
+exports.resolveBoolean = resolveBoolean;
+function resolveDefaultCEL(type, expr, currentEnv) {
+    const deps = dependenciesCEL(expr);
+    const allDepsFound = deps.every((dep) => !!currentEnv[dep]);
+    if (!allDepsFound) {
+        throw new error_1.FirebaseError("Build specified parameter with un-resolvable default value " +
+            expr +
+            "; dependencies missing.");
+    }
+    switch (type) {
+        case "string":
+            return resolveString(expr, currentEnv);
+        case "int":
+            return resolveInt(expr, currentEnv);
+        default:
+            throw new error_1.FirebaseError("Build specified parameter with default " + expr + " of unsupported type");
+    }
+}
+function canSatisfyParam(param, value) {
+    if (param.type === "string") {
+        return typeof value === "string";
+    }
+    else if (param.type === "int") {
+        return typeof value === "number" && Number.isInteger(value);
+    }
+    (0, functional_1.assertExhaustive)(param);
+}
+async function resolveParams(params, projectId, userEnvs) {
+    const paramValues = {};
+    for (const param of params.filter((param) => userEnvs.hasOwnProperty(param.param))) {
+        if (!canSatisfyParam(param, userEnvs[param.param])) {
+            throw new error_1.FirebaseError("Parameter " +
+                param.param +
+                " resolved to value from dotenv files " +
+                userEnvs[param.param] +
+                " of wrong type");
+        }
+        paramValues[param.param] = userEnvs[param.param];
+    }
+    for (const param of params.filter((param) => !userEnvs.hasOwnProperty(param.param))) {
+        let paramDefault = param.default;
+        if (paramDefault && isCEL(paramDefault)) {
+            paramDefault = resolveDefaultCEL(param.type, paramDefault, paramValues);
+        }
+        if (paramDefault && !canSatisfyParam(param, paramDefault)) {
+            throw new error_1.FirebaseError("Parameter " + param.param + " has default value " + paramDefault + " of wrong type");
+        }
+        paramValues[param.param] = await promptParam(param, paramDefault);
+    }
+    return paramValues;
+}
+exports.resolveParams = resolveParams;
+async function promptParam(param, resolvedDefault) {
+    if (param.type === "string") {
+        return promptStringParam(param, resolvedDefault);
+    }
+    else if (param.type === "int") {
+        return promptIntParam(param, resolvedDefault);
+    }
+    (0, functional_1.assertExhaustive)(param);
+}
+async function promptStringParam(param, resolvedDefault) {
+    if (!param.input) {
+        const defaultToText = { type: "text", text: {} };
+        param.input = defaultToText;
+    }
+    switch (param.input.type) {
+        case "select":
+            throw new error_1.FirebaseError("Build specified string parameter " + param.param + " with unsupported input type 'select'");
+        case "text":
+        default:
+            let prompt = `Enter a value for ${param.label || param.param}`;
+            if (param.description) {
+                prompt += ` \n(${param.description})`;
+            }
+            return await (0, prompt_1.promptOnce)({
+                name: param.param,
+                type: "input",
+                default: resolvedDefault,
+                message: prompt,
+            });
+    }
+}
+async function promptIntParam(param, resolvedDefault) {
+    if (!param.input) {
+        const defaultToText = { type: "text", text: {} };
+        param.input = defaultToText;
+    }
+    switch (param.input.type) {
+        case "select":
+            throw new error_1.FirebaseError("Build specified int parameter " + param.param + " with unsupported input type 'select'");
+        case "text":
+        default:
+            let prompt = `Enter a value for ${param.label || param.param}`;
+            if (param.description) {
+                prompt += ` \n(${param.description})`;
+            }
+            let res;
+            while (true) {
+                res = await (0, prompt_1.promptOnce)({
+                    name: param.param,
+                    type: "number",
+                    default: resolvedDefault,
+                    message: prompt,
+                });
+                if (Number.isInteger(res)) {
+                    return res;
+                }
+                logger_1.logger.error(`${param.label || param.param} must be an integer; retrying...`);
+            }
+    }
+}

package/lib/deploy/functions/prepare.js

@@ -39,7 +39,7 @@ async function prepare(context, options, payload) {
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
         ensure.cloudBuildEnabled(projectId),
-        ensureApiEnabled.check(projectId, "artifactregistry.googleapis.com", "artifactregistry"),
+        ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "artifactregistry"),
     ]);
     const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
     context.firebaseConfig = firebaseConfig;
@@ -78,7 +78,7 @@ async function prepare(context, options, payload) {
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
         const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
-        const wantBackend = build.resolveBackend(wantBuild, userEnvs);
+        const wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
         wantBackend.environmentVariables = envs;
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;

package/lib/deploy/functions/runtimes/node/parseTriggers.js

@@ -126,7 +126,7 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
                 logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
             }
             if (annotation.httpsTrigger.invoker) {
-                trigger.invoker = annotation.httpsTrigger.invoker[0];
+                trigger.invoker = annotation.httpsTrigger.invoker;
             }
             triggered = { httpsTrigger: trigger };
         }
@@ -179,7 +179,7 @@ function addResourcesToBuild(projectId, runtime, annotation, want) {
         };
     }
     const endpointId = annotation.name;
-    const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", region: regions, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime, serviceAccount: annotation.serviceAccountEmail || "default" }, triggered);
+    const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", region: regions, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime, serviceAccount: annotation.serviceAccountEmail || null }, triggered);
     if (annotation.vpcConnector != null) {
         let maybeId = annotation.vpcConnector;
         if (maybeId && !maybeId.includes("/")) {

package/lib/deploy/lifecycleHooks.js

@@ -31,7 +31,7 @@ function runCommand(command, childOptions) {
                 reject(new Error("Command terminated with signal " + signal));
             }
             else if (code !== 0) {
-                reject(new Error("Command terminated with non-zero exit code" + code));
+                reject(new Error("Command terminated with non-zero exit code " + code));
             }
             else {
                 resolve();

package/lib/deploy/storage/prepare.js

@@ -11,7 +11,7 @@ async function default_1(context, options) {
     _.set(context, "storage.rules", rulesConfig);
     const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.FIREBASE_STORAGE);
     _.set(context, "storage.rulesDeploy", rulesDeploy);
-    if (_.isPlainObject(rulesConfig)) {
+    if (typeof rulesConfig === "object" && rulesConfig !== null) {
         const defaultBucket = await gcp.storage.getDefaultBucket(options.project);
         rulesConfig = [Object.assign(rulesConfig, { bucket: defaultBucket })];
         _.set(context, "storage.rules", rulesConfig);

package/lib/downloadUtils.js

@@ -20,7 +20,7 @@ async function downloadToTmp(remoteUrl) {
         resolveOnHTTPError: true,
     });
     if (res.status !== 200) {
-        throw new error_1.FirebaseError(`download failed, status ${res.status}`, { exit: 1 });
+        throw new error_1.FirebaseError(`download failed, status ${res.status}: ${await res.response.text()}`);
     }
     const total = parseInt(res.response.headers.get("content-length") || "0", 10);
     const totalMb = Math.ceil(total / 1000000);

package/lib/emulator/downloadableEmulators.js

@@ -29,13 +29,13 @@ exports.DownloadDetails = {
         },
     },
     firestore: {
-        downloadPath: path.join(CACHE_DIR, "cloud-firestore-emulator-v1.14.3.jar"),
-        version: "1.14.3",
+        downloadPath: path.join(CACHE_DIR, "cloud-firestore-emulator-v1.14.4.jar"),
+        version: "1.14.4",
         opts: {
             cacheDir: CACHE_DIR,
-            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-firestore-emulator-v1.14.3.jar",
-            expectedSize: 60442855,
-            expectedChecksum: "63517534875818689639ee5dee57dd52",
+            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-firestore-emulator-v1.14.4.jar",
+            expectedSize: 61017177,
+            expectedChecksum: "953d10e73798484aa0b84c45005faadb",
             namePrefix: "cloud-firestore-emulator",
         },
     },
@@ -55,7 +55,7 @@ exports.DownloadDetails = {
             version: "SNAPSHOT",
             downloadPath: path.join(CACHE_DIR, "ui-vSNAPSHOT.zip"),
             unzipDir: path.join(CACHE_DIR, "ui-vSNAPSHOT"),
-            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server.bundle.js"),
+            binaryPath: path.join(CACHE_DIR, "ui-vSNAPSHOT", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
                 remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-vSNAPSHOT.zip",
@@ -67,15 +67,15 @@ exports.DownloadDetails = {
             },
         }
         : {
-            version: "1.7.0",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.7.0.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.7.0"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.7.0", "server.bundle.js"),
+            version: "1.8.1",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.8.1.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.8.1"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.8.1", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.7.0.zip",
-                expectedSize: 4053708,
-                expectedChecksum: "aea9ae19091df5974a88a8847aaf127c",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.8.1.zip",
+                expectedSize: 3056552,
+                expectedChecksum: "92590fdda20f9883588438d9551111b5",
                 namePrefix: "ui",
             },
         },
@@ -164,7 +164,7 @@ const Commands = {
     },
     ui: {
         binary: "node",
-        args: ["--dns-result-order=ipv4first", getExecPath(types_1.Emulators.UI)],
+        args: [getExecPath(types_1.Emulators.UI)],
         optionalArgs: [],
         joinArgs: false,
     },

package/lib/emulator/functionsEmulator.js

@@ -272,8 +272,13 @@ class FunctionsEmulator {
             await runtimeDelegate.build();
             logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
             const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: this.getFirebaseConfig() }), emulatableBackend.env);
+            const userEnvOpt = {
+                functionsSource: emulatableBackend.functionsDir,
+                projectId: this.args.projectId,
+                projectAlias: this.args.projectAlias,
+            };
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const discoveredBackend = (0, build_1.resolveBackend)(discoveredBuild, environment);
+            const discoveredBackend = await (0, build_1.resolveBackend)(discoveredBuild, userEnvOpt, environment);
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
             for (const e of endpoints) {
@@ -778,9 +783,10 @@ class FunctionsEmulator {
         }
         const runtimeEnv = this.getRuntimeEnvs(backend, trigger);
         const secretEnvs = await this.resolveSecretEnvs(backend, trigger);
+        const socketPath = (0, functionsEmulatorShared_1.getTemporarySocketPath)();
         const childProcess = spawn(opts.nodeBinary, args, {
             cwd: backend.functionsDir,
-            env: Object.assign(Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), runtimeEnv), secretEnvs),
+            env: Object.assign(Object.assign(Object.assign(Object.assign({ node: opts.nodeBinary }, process.env), runtimeEnv), secretEnvs), { PORT: socketPath }),
             stdio: ["pipe", "pipe", "pipe", "ipc"],
         });
         if (!childProcess.stderr) {
@@ -812,6 +818,7 @@ class FunctionsEmulator {
             }),
             events: emitter,
             cwd: backend.functionsDir,
+            socketPath,
             shutdown: () => {
                 childProcess.kill();
             },
@@ -950,12 +957,6 @@ class FunctionsEmulator {
         await worker.waitForSocketReady();
         void (0, track_1.track)(EVENT_INVOKE, "https");
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
-        if (!worker.lastArgs) {
-            throw new error_1.FirebaseError("Cannot execute on a worker with no arguments");
-        }
-        if (!worker.lastArgs.frb.socketPath) {
-            throw new error_1.FirebaseError(`Cannot execute on a worker without a socketPath: ${JSON.stringify(worker.lastArgs)}`);
-        }
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
         const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${triggerName}\/?`), "/");
         this.logger.log("DEBUG", `[functions] Got req.url=${req.url}, mapping to path=${path}`);
@@ -963,7 +964,7 @@ class FunctionsEmulator {
             method,
             path,
             headers: req.headers,
-            socketPath: worker.lastArgs.frb.socketPath,
+            socketPath: worker.runtime.socketPath,
         }, (runtimeRes) => {
             function forwardStatusAndHeaders() {
                 res.status(runtimeRes.statusCode || 200);