firebase-tools 11.6.0 → 11.8.1

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/checkIam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.getDefaultComputeServiceAgent = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
 const colorette_1 = require("colorette");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
@@ -68,11 +68,12 @@ async function checkHttpIam(context, options, payload) {
 }
 exports.checkHttpIam = checkHttpIam;
 function getPubsubServiceAgent(projectNumber) {
-    return `serviceAccount:service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
+    return `service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
 }
 function getDefaultComputeServiceAgent(projectNumber) {
-    return `serviceAccount:${projectNumber}-compute@developer.gserviceaccount.com`;
+    return `${projectNumber}-compute@developer.gserviceaccount.com`;
 }
+exports.getDefaultComputeServiceAgent = getDefaultComputeServiceAgent;
 function reduceEventsToServices(services, endpoint) {
     const service = (0, services_1.serviceForEndpoint)(endpoint);
     if (service.requiredProjectBindings && !services.find((s) => s.name === service.name)) {
@@ -83,13 +84,13 @@ function reduceEventsToServices(services, endpoint) {
 function obtainPubSubServiceAgentBindings(projectNumber) {
     const serviceAccountTokenCreatorBinding = {
         role: exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE,
-        members: [getPubsubServiceAgent(projectNumber)],
+        members: [`serviceAccount:${getPubsubServiceAgent(projectNumber)}`],
     };
     return [serviceAccountTokenCreatorBinding];
 }
 exports.obtainPubSubServiceAgentBindings = obtainPubSubServiceAgentBindings;
 function obtainDefaultComputeServiceAgentBindings(projectNumber) {
-    const defaultComputeServiceAgent = getDefaultComputeServiceAgent(projectNumber);
+    const defaultComputeServiceAgent = `serviceAccount:${getDefaultComputeServiceAgent(projectNumber)}`;
     const runInvokerBinding = {
         role: exports.RUN_INVOKER_ROLE,
         members: [defaultComputeServiceAgent],

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;