firebase-tools 11.2.1 → 11.4.0

package/lib/apiv2.js

@@ -15,6 +15,7 @@ const responseToError_1 = require("./responseToError");
 const FormData = require("form-data");
 const pkg = require("../package.json");
 const CLI_VERSION = pkg.version;
+const GOOG_QUOTA_USER = "x-goog-quota-user";
 let accessToken = "";
 let refreshToken = "";
 function setRefreshToken(token = "") {
@@ -309,6 +310,10 @@ class Client {
         }
         const logURL = this.requestURL(options);
         logger_1.logger.debug(`>>> [apiv2][query] ${options.method} ${logURL} ${queryParamsLog}`);
+        const headers = options.headers;
+        if (headers && headers.has(GOOG_QUOTA_USER)) {
+            logger_1.logger.debug(`>>> [apiv2][(partial)header] ${options.method} ${logURL} x-goog-quota-user=${headers.get(GOOG_QUOTA_USER) || ""}`);
+        }
         if (options.body !== undefined) {
             let logBody = "[omitted]";
             if (!((_b = options.skipLog) === null || _b === void 0 ? void 0 : _b.body)) {

package/lib/checkValidTargetFilters.js

@@ -19,6 +19,7 @@ function targetsHaveFilters(...targets) {
 function targetsHaveNoFilters(...targets) {
     return targets.some((t) => !t.includes(":"));
 }
+const FILTERABLE_TARGETS = new Set(["hosting", "functions", "firestore", "storage", "database"]);
 async function checkValidTargetFilters(options) {
     const only = !options.only ? [] : options.only.split(",");
     return new Promise((resolve, reject) => {
@@ -28,10 +29,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) => !FILTERABLE_TARGETS.has(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, storage, 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/database/rulesConfig.js

@@ -19,6 +19,23 @@ function getRulesConfig(projectId, options) {
     if (dbConfig === undefined) {
         return [];
     }
+    const rc = options.rc;
+    let allDatabases = !options.only;
+    const onlyDatabases = new Set();
+    if (options.only) {
+        const split = options.only.split(",");
+        if (split.includes("database")) {
+            allDatabases = true;
+        }
+        else {
+            for (const value of split) {
+                if (value.startsWith("database:")) {
+                    const target = value.split(":")[1];
+                    onlyDatabases.add(target);
+                }
+            }
+        }
+    }
     if (!Array.isArray(dbConfig)) {
         if (dbConfig && dbConfig.rules) {
             utils.assertIsStringOrUndefined(options.instance);
@@ -31,22 +48,32 @@ function getRulesConfig(projectId, options) {
         }
     }
     const results = [];
-    const rc = options.rc;
     for (const c of dbConfig) {
-        if (c.target) {
-            rc.requireTarget(projectId, "database", c.target);
-            const instances = rc.target(projectId, "database", c.target);
-            for (const i of instances) {
-                results.push({ instance: i, rules: c.rules });
+        const { instance, target } = c;
+        if (target) {
+            if (allDatabases || onlyDatabases.has(target)) {
+                rc.requireTarget(projectId, "database", target);
+                const instances = rc.target(projectId, "database", target);
+                for (const i of instances) {
+                    results.push({ instance: i, rules: c.rules });
+                }
+                onlyDatabases.delete(target);
             }
         }
-        else if (c.instance) {
-            results.push(c);
+        else if (instance) {
+            if (allDatabases) {
+                results.push(c);
+            }
         }
         else {
             throw new error_1.FirebaseError('Must supply either "target" or "instance" in database config');
         }
     }
+    if (!allDatabases && onlyDatabases.size !== 0) {
+        throw new error_1.FirebaseError(`Could not find configurations in firebase.json for the following database targets: ${[
+            ...onlyDatabases,
+        ].join(", ")}`);
+    }
     return results;
 }
 exports.getRulesConfig = getRulesConfig;

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

@@ -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/release/index.js

@@ -67,6 +67,10 @@ async function release(context, options, payload) {
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };
+        logger_1.logger.debug("Functions deploy failed.");
+        for (const error of allErrors) {
+            logger_1.logger.debug(JSON.stringify(error, null, 2));
+        }
         throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
     }
 }

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -28,10 +28,12 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
     (0, parsing_1.requireKeys)("", manifest, "endpoints");
     (0, parsing_1.assertKeyTypes)("", manifest, {
         specVersion: "string",
+        params: "array",
         requiredAPIs: "array",
         endpoints: "object",
     });
     const bd = build.empty();
+    bd.params = manifest.params || [];
     bd.requiredAPIs = parseRequiredAPIs(manifest);
     for (const id of Object.keys(manifest.endpoints)) {
         const me = manifest.endpoints[id];
@@ -49,6 +51,7 @@ function backendFromV1Alpha1(yaml, project, region, runtime) {
     (0, parsing_1.requireKeys)("", manifest, "endpoints");
     (0, parsing_1.assertKeyTypes)("", manifest, {
         specVersion: "string",
+        params: "array",
         requiredAPIs: "array",
         endpoints: "object",
     });

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 };
         }