firebase-tools 11.8.0 → 11.8.1

package/lib/auth.js

@@ -23,7 +23,7 @@ const uuid_1 = require("uuid");
 const crypto_1 = require("crypto");
 const track_1 = require("./track");
 const api_1 = require("./api");
-portfinder.basePort = 9005;
+portfinder.setBasePort(9005);
 function getGlobalDefaultAccount() {
     const user = configstore_1.configstore.get("user");
     const tokens = configstore_1.configstore.get("tokens");

package/lib/deploy/functions/build.js

@@ -9,7 +9,6 @@ const previews_1 = require("../../previews");
 const error_1 = require("../../error");
 const functional_1 = require("../../functional");
 const env_1 = require("../../functions/env");
-const logger_1 = require("../../logger");
 function empty() {
     return {
         requiredAPIs: [],
@@ -61,39 +60,58 @@ exports.AllIngressSettings = [
     "ALLOW_INTERNAL_AND_GCLB",
 ];
 async function resolveBackend(build, userEnvOpt, userEnvs, nonInteractive) {
-    var _a;
     const projectId = userEnvOpt.projectId;
     let paramValues = {};
     if (previews_1.previews.functionsparams) {
-        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(userEnvs), nonInteractive);
+        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(build.params, userEnvs), nonInteractive);
         const toWrite = {};
         for (const paramName of Object.keys(paramValues)) {
-            if (userEnvs.hasOwnProperty(paramName)) {
+            const paramValue = paramValues[paramName];
+            if (Object.prototype.hasOwnProperty.call(userEnvs, paramName) || paramValue.secret) {
                 continue;
             }
-            toWrite[paramName] = ((_a = paramValues[paramName]) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+            toWrite[paramName] = paramValue.toString();
         }
         (0, env_1.writeUserEnvs)(toWrite, userEnvOpt);
     }
-    return toBackend(build, paramValues);
+    return { backend: toBackend(build, paramValues), envs: paramValues };
 }
 exports.resolveBackend = resolveBackend;
-function envWithTypes(rawEnvs) {
+function envWithTypes(definedParams, rawEnvs) {
     const out = {};
     for (const envName of Object.keys(rawEnvs)) {
         const value = rawEnvs[envName];
-        if (!isNaN(+value) && isFinite(+value) && !value.includes("e")) {
-            out[envName] = +value;
-        }
-        else if (value === "true") {
-            out[envName] = true;
-        }
-        else if (value === "false") {
-            out[envName] = false;
-        }
-        else {
-            out[envName] = value;
+        let providedType = {
+            string: true,
+            boolean: true,
+            number: true,
+        };
+        for (const param of definedParams) {
+            if (param.name === envName) {
+                if (param.type === "string") {
+                    providedType = {
+                        string: true,
+                        boolean: false,
+                        number: false,
+                    };
+                }
+                else if (param.type === "int") {
+                    providedType = {
+                        string: false,
+                        boolean: false,
+                        number: true,
+                    };
+                }
+                else if (param.type === "boolean") {
+                    providedType = {
+                        string: false,
+                        boolean: true,
+                        number: false,
+                    };
+                }
+            }
         }
+        out[envName] = new params.ParamValue(value, false, providedType);
     }
     return out;
 }
@@ -152,10 +170,6 @@ function toBackend(build, paramValues) {
             if (typeof bdEndpoint.platform === "undefined") {
                 throw new error_1.FirebaseError("platform can't be undefined");
             }
-            if (bdEndpoint.availableMemoryMb != null &&
-                !backend.isValidMemoryOption(bdEndpoint.availableMemoryMb)) {
-                throw new error_1.FirebaseError("available memory must be a supported value, if present");
-            }
             const bkEndpoint = Object.assign({ id: endpointId, project: bdEndpoint.project, region: region, entryPoint: bdEndpoint.entryPoint, platform: bdEndpoint.platform, runtime: bdEndpoint.runtime }, trigger);
             proto.copyIfPresent(bkEndpoint, bdEndpoint, "environmentVariables", "labels", "secretEnvironmentVariables", "serviceAccount");
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", (from) => {
@@ -167,9 +181,9 @@ function toBackend(build, paramValues) {
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "availableMemoryMb", (from) => {
                 const mem = r.resolveInt(from);
                 if (mem !== null && !backend.isValidMemoryOption(mem)) {
-                    logger_1.logger.debug("Warning; setting memory to unexpected value", mem);
+                    throw new error_1.FirebaseError(`Function memory (${mem}) must resolve to a supported value, if present: ${JSON.stringify(allMemoryOptions)}`);
                 }
-                return mem;
+                return mem || null;
             });
             r.resolveInts(bkEndpoint, bdEndpoint, "timeoutSeconds", "maxInstances", "minInstances", "concurrency");
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "cpu", (0, functional_1.nullsafeVisitor)((cpu) => (cpu === "gcf_gen1" ? cpu : r.resolveInt(cpu))));

package/lib/deploy/functions/cache/applyHash.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyBackendHashToBackends = void 0;
+const backend_1 = require("../backend");
+const hash_1 = require("./hash");
+const functionsDeployHelper_1 = require("../functionsDeployHelper");
+function applyBackendHashToBackends(wantBackends, context) {
+    var _a;
+    for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
+        if ((0, functionsDeployHelper_1.isCodebaseFiltered)(codebase, context.filters || [])) {
+            continue;
+        }
+        const source = (_a = context === null || context === void 0 ? void 0 : context.sources) === null || _a === void 0 ? void 0 : _a[codebase];
+        const envHash = (0, hash_1.getEnvironmentVariablesHash)(wantBackend);
+        applyBackendHashToEndpoints(wantBackend, envHash, context.filters || [], source === null || source === void 0 ? void 0 : source.functionsSourceV1Hash, source === null || source === void 0 ? void 0 : source.functionsSourceV2Hash);
+    }
+}
+exports.applyBackendHashToBackends = applyBackendHashToBackends;
+function applyBackendHashToEndpoints(wantBackend, envHash, endpointFilters, sourceV1Hash, sourceV2Hash) {
+    for (const endpoint of (0, backend_1.allEndpoints)(wantBackend)) {
+        const secretsHash = (0, hash_1.getSecretsHash)(endpoint);
+        const isV2 = endpoint.platform === "gcfv2";
+        const sourceHash = isV2 ? sourceV2Hash : sourceV1Hash;
+        if ((0, functionsDeployHelper_1.isEndpointFiltered)(endpoint, endpointFilters)) {
+            continue;
+        }
+        endpoint.hash = (0, hash_1.getEndpointHash)(sourceHash, envHash, secretsHash);
+    }
+}

package/lib/deploy/functions/cache/hash.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndpointHash = exports.getSecretsHash = exports.getSourceHash = exports.getEnvironmentVariablesHash = void 0;
+const promises_1 = require("node:fs/promises");
+const crypto = require("crypto");
+const secrets_1 = require("../../../functions/secrets");
+function getEnvironmentVariablesHash(backend) {
+    return createHash(JSON.stringify(backend.environmentVariables || {}));
+}
+exports.getEnvironmentVariablesHash = getEnvironmentVariablesHash;
+async function getSourceHash(pathToFile) {
+    const data = await (0, promises_1.readFile)(pathToFile);
+    return createHash(data);
+}
+exports.getSourceHash = getSourceHash;
+function getSecretsHash(endpoint) {
+    const secretVersions = (0, secrets_1.getSecretVersions)(endpoint);
+    return createHash(JSON.stringify(secretVersions || {}));
+}
+exports.getSecretsHash = getSecretsHash;
+function getEndpointHash(sourceHash, envHash, secretsHash) {
+    const combined = [sourceHash, envHash, secretsHash].filter((hash) => !!hash).join("");
+    return createHash(combined);
+}
+exports.getEndpointHash = getEndpointHash;
+function createHash(data, algorithm = "sha1") {
+    const hash = crypto.createHash(algorithm);
+    hash.update(data);
+    return hash.digest("hex");
+}

package/lib/deploy/functions/cel.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpression = exports.ExprParseError = exports.isCelExpression = void 0;
+const error_1 = require("../../error");
+const functional_1 = require("../../functional");
+const identityRegexp = /{{ params\.(\S+) }}/;
+const dualEqualityRegexp = /{{ params\.(\S+) == params\.(\S+) }}/;
+const equalityRegexp = /{{ params\.(\S+) == (.+) }}/;
+const dualTernaryRegexp = /{{ params\.(\S+) == params\.(\S+) \? (.+) : (.+) }/;
+const ternaryRegexp = /{{ params\.(\S+) == (.+) \? (.+) : (.+) }/;
+const literalTernaryRegexp = /{{ params\.(\S+) \? (.+) : (.+) }/;
+const paramRegexp = /params\.(\S+)/;
+function isCelExpression(value) {
+    return typeof value === "string" && value.includes("{{") && value.includes("}}");
+}
+exports.isCelExpression = isCelExpression;
+function isIdentityExpression(value) {
+    return identityRegexp.test(value);
+}
+function isEqualityExpression(value) {
+    return equalityRegexp.test(value);
+}
+function isDualEqualityExpression(value) {
+    return dualEqualityRegexp.test(value);
+}
+function isTernaryExpression(value) {
+    return ternaryRegexp.test(value);
+}
+function isLiteralTernaryExpression(value) {
+    return literalTernaryRegexp.test(value);
+}
+function isDualTernaryExpression(value) {
+    return dualTernaryRegexp.test(value);
+}
+class ExprParseError extends error_1.FirebaseError {
+}
+exports.ExprParseError = ExprParseError;
+function resolveExpression(wantType, expr, params) {
+    if (isIdentityExpression(expr)) {
+        return resolveIdentity(wantType, expr, params);
+    }
+    else if (isDualTernaryExpression(expr)) {
+        return resolveDualTernary(wantType, expr, params);
+    }
+    else if (isLiteralTernaryExpression(expr)) {
+        return resolveLiteralTernary(wantType, expr, params);
+    }
+    else if (isTernaryExpression(expr)) {
+        return resolveTernary(wantType, expr, params);
+    }
+    else if (isDualEqualityExpression(expr)) {
+        return resolveDualEquality(expr, params);
+    }
+    else if (isEqualityExpression(expr)) {
+        return resolveEquality(expr, params);
+    }
+    else {
+        throw new ExprParseError("CEL expression '" + expr + "' is of an unsupported form");
+    }
+}
+exports.resolveExpression = resolveExpression;
+function assertType(wantType, paramName, paramValue) {
+    if ((wantType === "string" && !paramValue.legalString) ||
+        (wantType === "number" && !paramValue.legalNumber) ||
+        (wantType === "boolean" && !paramValue.legalBoolean)) {
+        throw new ExprParseError(`Illegal type coercion of param ${paramName} to type ${wantType}`);
+    }
+}
+function readParamValue(wantType, paramName, paramValue) {
+    assertType(wantType, paramName, paramValue);
+    if (wantType === "string") {
+        return paramValue.asString();
+    }
+    else if (wantType === "number") {
+        return paramValue.asNumber();
+    }
+    else if (wantType === "boolean") {
+        return paramValue.asBoolean();
+    }
+    else {
+        (0, functional_1.assertExhaustive)(wantType);
+    }
+}
+function resolveIdentity(wantType, expr, params) {
+    const match = identityRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("Malformed CEL identity expression '" + expr + "'");
+    }
+    const name = match[1];
+    const value = params[name];
+    if (!value) {
+        throw new ExprParseError("CEL identity expression '" + expr + "' was not resolvable to a param");
+    }
+    return readParamValue(wantType, name, value);
+}
+function resolveEquality(expr, params) {
+    const match = equalityRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("Malformed CEL equality expression '" + expr + "'");
+    }
+    const lhsName = match[1];
+    const lhsVal = params[lhsName];
+    if (!lhsVal) {
+        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+    }
+    let rhs;
+    if (lhsVal.legalString) {
+        rhs = resolveLiteral("string", match[2]);
+        return lhsVal.asString() === rhs;
+    }
+    else if (lhsVal.legalNumber) {
+        rhs = resolveLiteral("number", match[2]);
+        return lhsVal.asNumber() === rhs;
+    }
+    else if (lhsVal.legalBoolean) {
+        rhs = resolveLiteral("boolean", match[2]);
+        return lhsVal.asBoolean() === rhs;
+    }
+    else {
+        throw new ExprParseError(`Could not infer type of param ${lhsName} used in equality operation`);
+    }
+}
+function resolveDualEquality(expr, params) {
+    const match = dualEqualityRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("Malformed CEL equality expression '" + expr + "'");
+    }
+    const lhsName = match[1];
+    const lhsVal = params[lhsName];
+    if (!lhsVal) {
+        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+    }
+    const rhsName = match[2];
+    const rhsVal = params[rhsName];
+    if (!rhsVal) {
+        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+    }
+    if (lhsVal.legalString) {
+        if (!rhsVal.legalString) {
+            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+        }
+        return lhsVal.asString() === rhsVal.asString();
+    }
+    else if (lhsVal.legalNumber) {
+        if (!rhsVal.legalNumber) {
+            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+        }
+        return lhsVal.asNumber() === rhsVal.asNumber();
+    }
+    else if (lhsVal.legalBoolean) {
+        if (!rhsVal.legalBoolean) {
+            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+        }
+        return lhsVal.asBoolean() === rhsVal.asBoolean();
+    }
+    else {
+        throw new ExprParseError(`could not infer type of param ${lhsName} used in equality operation`);
+    }
+}
+function resolveTernary(wantType, expr, params) {
+    const match = ternaryRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("malformed CEL ternary expression '" + expr + "'");
+    }
+    const equalityExpr = `{{ params.${match[1]} == ${match[2]} }}`;
+    const isTrue = resolveEquality(equalityExpr, params);
+    if (isTrue) {
+        return resolveParamOrLiteral(wantType, match[3], params);
+    }
+    else {
+        return resolveParamOrLiteral(wantType, match[4], params);
+    }
+}
+function resolveDualTernary(wantType, expr, params) {
+    const match = dualTernaryRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("Malformed CEL ternary expression '" + expr + "'");
+    }
+    const equalityExpr = `{{ params.${match[1]} == params.${match[2]} }}`;
+    const isTrue = resolveDualEquality(equalityExpr, params);
+    if (isTrue) {
+        return resolveParamOrLiteral(wantType, match[3], params);
+    }
+    else {
+        return resolveParamOrLiteral(wantType, match[4], params);
+    }
+}
+function resolveLiteralTernary(wantType, expr, params) {
+    const match = literalTernaryRegexp.exec(expr);
+    if (!match) {
+        throw new ExprParseError("Malformed CEL ternary expression '" + expr + "'");
+    }
+    const paramName = match[1];
+    const paramValue = params[match[1]];
+    if (!paramValue) {
+        throw new ExprParseError("CEL ternary expression '" + expr + "' references missing param " + paramName);
+    }
+    if (!paramValue.legalBoolean) {
+        throw new ExprParseError("CEL ternary expression '" + expr + "' is conditional on non-boolean param " + paramName);
+    }
+    if (paramValue.asBoolean()) {
+        return resolveParamOrLiteral(wantType, match[2], params);
+    }
+    else {
+        return resolveParamOrLiteral(wantType, match[3], params);
+    }
+}
+function resolveParamOrLiteral(wantType, field, params) {
+    const match = paramRegexp.exec(field);
+    if (!match) {
+        return resolveLiteral(wantType, field);
+    }
+    const paramValue = params[match[1]];
+    if (!paramValue) {
+        throw new ExprParseError("CEL expression resolved to the value of a missing param " + match[1]);
+    }
+    return readParamValue(wantType, match[1], paramValue);
+}
+function resolveLiteral(wantType, value) {
+    if (paramRegexp.exec(value)) {
+        throw new ExprParseError("CEL tried to evaluate param." + value + " in a context which only permits literal values");
+    }
+    if (wantType === "number") {
+        if (isNaN(+value)) {
+            throw new ExprParseError("CEL literal " + value + " does not seem to be a number");
+        }
+        return +value;
+    }
+    else if (wantType === "string") {
+        if (!value.startsWith('"') || !value.endsWith('"')) {
+            throw new ExprParseError("CEL literal " + value + ' does not seem to be a "-delimited string');
+        }
+        return value.slice(1, -1);
+    }
+    else if (wantType === "boolean") {
+        if (value === "true") {
+            return true;
+        }
+        else if (value === "false") {
+            return false;
+        }
+        else {
+            throw new ExprParseError("CEL literal " + value + "does not seem to be a true/false boolean");
+        }
+    }
+    else {
+        throw new ExprParseError("CEL literal '" + value + "' somehow was resolved with a non-string/number/boolean type");
+    }
+}

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupEndpointsByCodebase = exports.targetCodebases = exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+exports.isEndpointFiltered = exports.isCodebaseFiltered = exports.groupEndpointsByCodebase = exports.targetCodebases = exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
 const backend = require("./backend");
 const projectConfig_1 = require("../../functions/projectConfig");
 function endpointMatchesAnyFilter(endpoint, filters) {
@@ -114,3 +114,14 @@ function groupEndpointsByCodebase(wantBackends, haveEndpoints) {
     return grouped;
 }
 exports.groupEndpointsByCodebase = groupEndpointsByCodebase;
+function isCodebaseFiltered(codebase, filters) {
+    return filters.some((filter) => {
+        const noIdChunks = (filter.idChunks || []).length === 0;
+        return noIdChunks && filter.codebase === codebase;
+    });
+}
+exports.isCodebaseFiltered = isCodebaseFiltered;
+function isEndpointFiltered(endpoint, filters) {
+    return filters.some((filter) => endpointMatchesFilter(endpoint, filter));
+}
+exports.isEndpointFiltered = isEndpointFiltered;