firebase-tools 9.17.0 → 9.21.0

package/lib/extensions/paramHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readParamsFile = exports.promptForNewParams = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
+exports.readEnvFile = exports.getParamsFromFile = exports.promptForNewParams = exports.getParamsForUpdate = exports.getParams = exports.getParamsWithCurrentValuesAsDefaults = void 0;
 const _ = require("lodash");
 const path = require("path");
 const clc = require("cli-color");
@@ -25,70 +25,113 @@ function getParamsWithCurrentValuesAsDefaults(extensionInstance) {
     return setNewDefaults(specParams, currentParams);
 }
 exports.getParamsWithCurrentValuesAsDefaults = getParamsWithCurrentValuesAsDefaults;
-async function getParams(projectId, paramSpecs, envFilePath) {
-    let commandLineParams;
-    if (envFilePath) {
-        try {
-            const buf = fs.readFileSync(path.resolve(envFilePath), "utf8");
-            commandLineParams = dotenv.parse(buf.toString().trim(), { debug: true });
-            track("Extension Env File", "Present");
-        }
-        catch (err) {
-            track("Extension Env File", "Invalid");
-            throw new error_1.FirebaseError(`Error reading env file: ${err.message}\n`, { original: err });
-        }
+async function getParams(args) {
+    let params;
+    if (args.nonInteractive && !args.paramsEnvPath) {
+        const paramsMessage = args.paramSpecs
+            .map((p) => {
+            return `\t${p.param}${p.required ? "" : " (Optional)"}`;
+        })
+            .join("\n");
+        throw new error_1.FirebaseError("In non-interactive mode but no `--params` flag found. " +
+            "To install this extension in non-interactive mode, set `--params` to a path to an .env file" +
+            " containing values for this extension's params:\n" +
+            paramsMessage);
+    }
+    else if (args.paramsEnvPath) {
+        params = getParamsFromFile({
+            projectId: args.projectId,
+            paramSpecs: args.paramSpecs,
+            noninteractive: args.nonInteractive,
+            paramsEnvPath: args.paramsEnvPath,
+        });
     }
     else {
-        track("Extension Env File", "Not Present");
+        const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(args.projectId);
+        params = await askUserForParam.ask(args.projectId, args.instanceId, args.paramSpecs, firebaseProjectParams, !!args.reconfiguring);
     }
-    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(projectId);
+    track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
+    return params;
+}
+exports.getParams = getParams;
+async function getParamsForUpdate(args) {
     let params;
-    if (commandLineParams) {
-        params = extensionsHelper_1.populateDefaultParams(commandLineParams, paramSpecs);
-        extensionsHelper_1.validateCommandLineParams(params, paramSpecs);
+    if (args.nonInteractive && !args.paramsEnvPath) {
+        const paramsMessage = args.newSpec.params
+            .map((p) => {
+            return `\t${p.param}${p.required ? "" : " (Optional)"}`;
+        })
+            .join("\n");
+        throw new error_1.FirebaseError("In non-interactive mode but no `--params` flag found. " +
+            "To update this extension in non-interactive mode, set `--params` to a path to an .env file" +
+            " containing values for this extension's params:\n" +
+            paramsMessage);
+    }
+    else if (args.paramsEnvPath) {
+        params = getParamsFromFile({
+            projectId: args.projectId,
+            paramSpecs: args.newSpec.params,
+            noninteractive: args.nonInteractive,
+            paramsEnvPath: args.paramsEnvPath,
+        });
     }
     else {
-        params = await askUserForParam.ask(paramSpecs, firebaseProjectParams);
+        params = await promptForNewParams({
+            spec: args.spec,
+            newSpec: args.newSpec,
+            currentParams: args.currentParams,
+            projectId: args.projectId,
+            instanceId: args.instanceId,
+        });
     }
     track("Extension Params", _.isEmpty(params) ? "Not Present" : "Present", _.size(params));
     return params;
 }
-exports.getParams = getParams;
-async function promptForNewParams(spec, newSpec, currentParams, projectId) {
-    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(projectId);
+exports.getParamsForUpdate = getParamsForUpdate;
+async function promptForNewParams(args) {
+    const firebaseProjectParams = await extensionsHelper_1.getFirebaseProjectParams(args.projectId);
     const comparer = (param1, param2) => {
         return param1.type === param2.type && param1.param === param2.param;
     };
-    let paramsDiffDeletions = _.differenceWith(spec.params, _.get(newSpec, "params", []), comparer);
+    let paramsDiffDeletions = _.differenceWith(args.spec.params, _.get(args.newSpec, "params", []), comparer);
     paramsDiffDeletions = extensionsHelper_1.substituteParams(paramsDiffDeletions, firebaseProjectParams);
-    let paramsDiffAdditions = _.differenceWith(newSpec.params, _.get(spec, "params", []), comparer);
+    let paramsDiffAdditions = _.differenceWith(args.newSpec.params, _.get(args.spec, "params", []), comparer);
     paramsDiffAdditions = extensionsHelper_1.substituteParams(paramsDiffAdditions, firebaseProjectParams);
     if (paramsDiffDeletions.length) {
         logger_1.logger.info("The following params will no longer be used:");
         paramsDiffDeletions.forEach((param) => {
-            logger_1.logger.info(clc.red(`- ${param.param}: ${currentParams[param.param.toUpperCase()]}`));
-            delete currentParams[param.param.toUpperCase()];
+            logger_1.logger.info(clc.red(`- ${param.param}: ${args.currentParams[param.param.toUpperCase()]}`));
+            delete args.currentParams[param.param.toUpperCase()];
         });
     }
     if (paramsDiffAdditions.length) {
         logger_1.logger.info("To update this instance, configure the following new parameters:");
         for (const param of paramsDiffAdditions) {
-            const chosenValue = await askUserForParam.askForParam(param);
-            currentParams[param.param] = chosenValue;
+            const chosenValue = await askUserForParam.askForParam(args.projectId, args.instanceId, param, false);
+            args.currentParams[param.param] = chosenValue;
         }
     }
-    return currentParams;
+    return args.currentParams;
 }
 exports.promptForNewParams = promptForNewParams;
-function readParamsFile(envFilePath) {
+function getParamsFromFile(args) {
+    let envParams;
     try {
-        const buf = fs.readFileSync(path.resolve(envFilePath), "utf8");
-        return dotenv.parse(buf.toString().trim(), { debug: true });
+        envParams = readEnvFile(args.paramsEnvPath);
+        track("Extension Env File", "Present");
     }
     catch (err) {
-        throw new error_1.FirebaseError(`Error reading --test-params file: ${err.message}\n`, {
-            original: err,
-        });
+        track("Extension Env File", "Invalid");
+        throw new error_1.FirebaseError(`Error reading env file: ${err.message}\n`, { original: err });
     }
+    const params = extensionsHelper_1.populateDefaultParams(envParams, args.paramSpecs);
+    extensionsHelper_1.validateCommandLineParams(params, args.paramSpecs);
+    logger_1.logger.info(`Using param values from ${args.paramsEnvPath}`);
+    return params;
+}
+exports.getParamsFromFile = getParamsFromFile;
+function readEnvFile(envPath) {
+    const buf = fs.readFileSync(path.resolve(envPath), "utf8");
+    return dotenv.parse(buf.toString().trim(), { debug: true });
 }
-exports.readParamsFile = readParamsFile;
+exports.readEnvFile = readEnvFile;

package/lib/extensions/refs.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExtensionVersionName = exports.toExtensionName = exports.toExtensionVersionRef = exports.toExtensionRef = exports.parse = void 0;
+const semver = require("semver");
+const error_1 = require("../error");
+const refRegex = new RegExp(/^([^/@\n]+)\/{1}([^/@\n]+)(@{1}([^\n]+)|)$/);
+function parse(refOrName) {
+    const ret = parseRef(refOrName) || parseName(refOrName);
+    if (!ret || !ret.publisherId || !ret.extensionId) {
+        throw new error_1.FirebaseError(`Unable to parse ${refOrName} as an extension ref`);
+    }
+    if (ret.version &&
+        !semver.valid(ret.version) &&
+        !semver.validRange(ret.version) &&
+        ret.version !== "latest") {
+        throw new error_1.FirebaseError(`Extension reference ${ret} contains an invalid version ${ret.version}.`);
+    }
+    return ret;
+}
+exports.parse = parse;
+function parseRef(ref) {
+    const parts = refRegex.exec(ref);
+    if (parts && (parts.length == 5 || parts.length == 7)) {
+        const publisherId = parts[1];
+        const extensionId = parts[2];
+        const version = parts[4];
+        return { publisherId, extensionId, version };
+    }
+}
+function parseName(name) {
+    const parts = name.split("/");
+    return {
+        publisherId: parts[1],
+        extensionId: parts[3],
+        version: parts[5],
+    };
+}
+function toExtensionRef(ref) {
+    return `${ref.publisherId}/${ref.extensionId}`;
+}
+exports.toExtensionRef = toExtensionRef;
+function toExtensionVersionRef(ref) {
+    if (!ref.version) {
+        throw new error_1.FirebaseError(`Ref does not have a version`);
+    }
+    return `${ref.publisherId}/${ref.extensionId}@${ref.version}`;
+}
+exports.toExtensionVersionRef = toExtensionVersionRef;
+function toExtensionName(ref) {
+    return `publishers/${ref.publisherId}/extensions/${ref.extensionId}`;
+}
+exports.toExtensionName = toExtensionName;
+function toExtensionVersionName(ref) {
+    if (!ref.version) {
+        throw new error_1.FirebaseError(`Ref does not have a version`);
+    }
+    return `publishers/${ref.publisherId}/extensions/${ref.extensionId}/versions/${ref.version}`;
+}
+exports.toExtensionVersionName = toExtensionVersionName;

package/lib/extensions/secretsUtils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettySecretName = exports.getSecretLabels = exports.getManagedSecrets = exports.grantFirexServiceAgentSecretAdminRole = exports.usesSecrets = exports.ensureSecretManagerApiEnabled = void 0;
+const getProjectNumber_1 = require("../getProjectNumber");
+const utils = require("../utils");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+const projectUtils_1 = require("../projectUtils");
+const extensionsApi = require("./extensionsApi");
+const secretManagerApi = require("../gcp/secretManager");
+const logger_1 = require("../logger");
+const SECRET_LABEL = "firebase-extensions-managed";
+async function ensureSecretManagerApiEnabled(options) {
+    const projectId = projectUtils_1.needProjectId(options);
+    return await ensureApiEnabled_1.ensure(projectId, "secretmanager.googleapis.com", "extensions", options.markdown);
+}
+exports.ensureSecretManagerApiEnabled = ensureSecretManagerApiEnabled;
+function usesSecrets(spec) {
+    return spec.params && !!spec.params.find((p) => p.type == extensionsApi.ParamType.SECRET);
+}
+exports.usesSecrets = usesSecrets;
+async function grantFirexServiceAgentSecretAdminRole(secret) {
+    const projectNumber = await getProjectNumber_1.getProjectNumber({ projectId: secret.projectId });
+    const firexSaProjectId = utils.envOverride("FIREBASE_EXTENSIONS_SA_PROJECT_ID", "gcp-sa-firebasemods");
+    const saEmail = `service-${projectNumber}@${firexSaProjectId}.iam.gserviceaccount.com`;
+    return secretManagerApi.grantServiceAgentRole(secret, saEmail, "roles/secretmanager.admin");
+}
+exports.grantFirexServiceAgentSecretAdminRole = grantFirexServiceAgentSecretAdminRole;
+async function getManagedSecrets(instance) {
+    return (await Promise.all(getActiveSecrets(instance).map(async (secretResourceName) => {
+        const secret = secretManagerApi.parseSecretResourceName(secretResourceName);
+        const labels = await secretManagerApi.getSecretLabels(secret.projectId, secret.name);
+        if (labels && labels[SECRET_LABEL]) {
+            return secretResourceName;
+        }
+        return Promise.resolve("");
+    }))).filter((secretId) => !!secretId);
+}
+exports.getManagedSecrets = getManagedSecrets;
+function getActiveSecrets(instance) {
+    return instance.config.source.spec.params
+        .map((p) => p.type == extensionsApi.ParamType.SECRET && instance.config.params[p.param])
+        .filter((pv) => !!pv);
+}
+function getSecretLabels(instanceId) {
+    const labels = {};
+    labels[SECRET_LABEL] = instanceId;
+    return labels;
+}
+exports.getSecretLabels = getSecretLabels;
+function prettySecretName(secretResourceName) {
+    const nameTokens = secretResourceName.split("/");
+    if (nameTokens.length != 4 && nameTokens.length != 6) {
+        logger_1.logger.debug(`unable to parse secret secretResourceName: ${secretResourceName}`);
+        return secretResourceName;
+    }
+    return nameTokens.slice(0, 4).join("/");
+}
+exports.prettySecretName = prettySecretName;

package/lib/extensions/updateHelper.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirmUpdate = exports.inferUpdateSource = exports.updateFromPublisherSource = exports.updateToVersionFromPublisherSource = exports.updateFromUrlSource = exports.updateFromLocalSource = exports.update = exports.retryUpdate = exports.displayChanges = exports.warningUpdateToOtherSource = exports.getExistingSourceOrigin = void 0;
+exports.inferUpdateSource = exports.updateFromPublisherSource = exports.updateToVersionFromPublisherSource = exports.updateFromUrlSource = exports.updateFromLocalSource = exports.update = exports.displayChanges = exports.warningUpdateToOtherSource = exports.getExistingSourceOrigin = void 0;
 const clc = require("cli-color");
 const semver = require("semver");
+const marked = require("marked");
 const error_1 = require("../error");
 const logger_1 = require("../logger");
 const resolveSource = require("./resolveSource");
 const extensionsApi = require("./extensionsApi");
-const prompt_1 = require("../prompt");
-const marked = require("marked");
+const refs = require("./refs");
 const extensionsHelper_1 = require("./extensionsHelper");
 const utils = require("../utils");
 const displayExtensionInfo_1 = require("./displayExtensionInfo");
@@ -25,7 +25,7 @@ async function getExistingSourceOrigin(projectId, instanceId, extensionName, exi
         : extensionsHelper_1.SourceOrigin.LOCAL;
 }
 exports.getExistingSourceOrigin = getExistingSourceOrigin;
-async function showUpdateVersionInfo(instanceId, from, to, source) {
+function showUpdateVersionInfo(instanceId, from, to, source) {
     if (source) {
         source = clc.bold(source);
     }
@@ -34,8 +34,7 @@ async function showUpdateVersionInfo(instanceId, from, to, source) {
     }
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `Updating ${clc.bold(instanceId)} from version ${clc.bold(from)} to ${source} (${clc.bold(to)})`);
     if (semver.lt(to, from)) {
-        utils.logLabeledBullet(extensionsHelper_1.logPrefix, "The version you are updating to is less than the current version for this extension. This extension may not be backwards compatible.");
-        return await displayExtensionInfo_1.getConsent("version", "Do you wish to continue?");
+        utils.logLabeledWarning(extensionsHelper_1.logPrefix, "The version you are updating to is less than the current version for this extension. This extension may not be backwards compatible.");
     }
     return;
 }
@@ -54,21 +53,12 @@ function warningUpdateToOtherSource(sourceOrigin) {
     logger_1.logger.info(marked(warning));
 }
 exports.warningUpdateToOtherSource = warningUpdateToOtherSource;
-async function displayChanges(spec, newSpec) {
-    logger_1.logger.info("This update contains the following changes (in green and red). " +
-        "If at any point you choose not to continue, the extension will not be updated and the changes will be discarded:\n");
-    displayExtensionInfo_1.displayUpdateChangesNoInput(spec, newSpec);
-    await displayExtensionInfo_1.displayUpdateChangesRequiringConfirmation(spec, newSpec);
+async function displayChanges(args) {
+    utils.logLabeledBullet("extensions", "This update contains the following changes:");
+    displayExtensionInfo_1.displayUpdateChangesNoInput(args.spec, args.newSpec);
+    await displayExtensionInfo_1.displayUpdateChangesRequiringConfirmation(args);
 }
 exports.displayChanges = displayChanges;
-async function retryUpdate() {
-    return prompt_1.promptOnce({
-        type: "confirm",
-        message: "Are you sure you wish to continue with updating anyways?",
-        default: false,
-    });
-}
-exports.retryUpdate = retryUpdate;
 async function update(updateOptions) {
     const { projectId, instanceId, source, extRef, params } = updateOptions;
     if (extRef) {
@@ -80,7 +70,7 @@ async function update(updateOptions) {
     throw new error_1.FirebaseError(`Neither a source nor a version of the extension was supplied for ${instanceId}. Please make sure this is a valid extension and try again.`);
 }
 exports.update = update;
-async function updateFromLocalSource(projectId, instanceId, localSource, existingSpec, existingSource) {
+async function updateFromLocalSource(projectId, instanceId, localSource, existingSpec) {
     displayExtensionInfo_1.displayExtInfo(instanceId, "", existingSpec, false);
     let source;
     try {
@@ -90,13 +80,12 @@ async function updateFromLocalSource(projectId, instanceId, localSource, existin
         throw new error_1.FirebaseError(invalidSourceErrMsgTemplate(instanceId, localSource));
     }
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `${clc.bold("You are updating this extension instance to a local source.")}`);
-    await showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, localSource);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, localSource);
     warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.LOCAL);
-    await confirmUpdate();
     return source.name;
 }
 exports.updateFromLocalSource = updateFromLocalSource;
-async function updateFromUrlSource(projectId, instanceId, urlSource, existingSpec, existingSource) {
+async function updateFromUrlSource(projectId, instanceId, urlSource, existingSpec) {
     displayExtensionInfo_1.displayExtInfo(instanceId, "", existingSpec, false);
     let source;
     try {
@@ -106,18 +95,17 @@ async function updateFromUrlSource(projectId, instanceId, urlSource, existingSpe
         throw new error_1.FirebaseError(invalidSourceErrMsgTemplate(instanceId, urlSource));
     }
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `${clc.bold("You are updating this extension instance to a URL source.")}`);
-    await showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, urlSource);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, urlSource);
     warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.URL);
-    await confirmUpdate();
     return source.name;
 }
 exports.updateFromUrlSource = updateFromUrlSource;
-async function updateToVersionFromPublisherSource(projectId, instanceId, extVersionRef, existingSpec, existingSource) {
+async function updateToVersionFromPublisherSource(projectId, instanceId, extVersionRef, existingSpec) {
     let source;
-    const refObj = extensionsApi.parseRef(extVersionRef);
-    const version = refObj.version;
-    const extensionRef = `${refObj.publisherId}/${refObj.extensionId}`;
-    displayExtensionInfo_1.displayExtInfo(instanceId, refObj.publisherId, existingSpec, true);
+    const ref = refs.parse(extVersionRef);
+    const version = ref.version;
+    const extensionRef = refs.toExtensionRef(ref);
+    displayExtensionInfo_1.displayExtInfo(instanceId, ref.publisherId, existingSpec, true);
     const extension = await extensionsApi.getExtension(extensionRef);
     try {
         source = await extensionsApi.getExtensionVersion(extVersionRef);
@@ -138,7 +126,7 @@ async function updateToVersionFromPublisherSource(projectId, instanceId, extVers
             throw new error_1.FirebaseError(`The version you are trying to update to (${clc.bold(source.spec.version)}) is less than the minimum version required (${clc.bold(minVer)}) to use this extension.`);
         }
     }
-    await showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, extVersionRef);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, extVersionRef);
     warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION);
     const releaseNotes = await changelog.getReleaseNotesForUpdate({
         extensionRef,
@@ -148,12 +136,11 @@ async function updateToVersionFromPublisherSource(projectId, instanceId, extVers
     if (Object.keys(releaseNotes).length) {
         changelog.displayReleaseNotes(releaseNotes, existingSpec.version);
     }
-    await confirmUpdate();
     return source.name;
 }
 exports.updateToVersionFromPublisherSource = updateToVersionFromPublisherSource;
-async function updateFromPublisherSource(projectId, instanceId, extRef, existingSpec, existingSource) {
-    return updateToVersionFromPublisherSource(projectId, instanceId, `${extRef}@latest`, existingSpec, existingSource);
+async function updateFromPublisherSource(projectId, instanceId, extRef, existingSpec) {
+    return updateToVersionFromPublisherSource(projectId, instanceId, `${extRef}@latest`, existingSpec);
 }
 exports.updateFromPublisherSource = updateFromPublisherSource;
 function inferUpdateSource(updateSource, existingRef) {
@@ -174,14 +161,3 @@ function inferUpdateSource(updateSource, existingRef) {
     return updateSource;
 }
 exports.inferUpdateSource = inferUpdateSource;
-async function confirmUpdate() {
-    const continueUpdate = await prompt_1.promptOnce({
-        type: "confirm",
-        message: "Do you wish to continue with this update?",
-        default: false,
-    });
-    if (!continueUpdate) {
-        throw new error_1.FirebaseError(`Update cancelled.`);
-    }
-}
-exports.confirmUpdate = confirmUpdate;

package/lib/extensions/warnings.js

@@ -7,7 +7,6 @@ const extensionsApi_1 = require("./extensionsApi");
 const displayExtensionInfo_1 = require("./displayExtensionInfo");
 const extensionsHelper_1 = require("./extensionsHelper");
 const resolveSource_1 = require("./resolveSource");
-const prompt_1 = require("../prompt");
 const utils = require("../utils");
 function displayEAPWarning({ publisherId, sourceDownloadUri, githubLink, }) {
     const publisherNameLink = githubLink ? `[${publisherId}](${githubLink})` : publisherId;
@@ -32,12 +31,7 @@ async function displayWarningPrompts(publisherId, launchStage, extensionVersion)
         displayExperimentalWarning();
     }
     else {
-        return true;
+        return;
     }
-    return await prompt_1.promptOnce({
-        type: "confirm",
-        message: "Do you acknowledge the status of this extension?",
-        default: true,
-    });
 }
 exports.displayWarningPrompts = displayWarningPrompts;

package/lib/functional.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partition = exports.assertExhaustive = exports.zipIn = exports.zip = exports.reduceFlat = exports.flatten = exports.flattenArray = exports.flattenObject = void 0;
+function* flattenObject(obj) {
+    function* helper(path, obj) {
+        for (const [k, v] of Object.entries(obj)) {
+            if (typeof v !== "object" || v === null) {
+                yield [[...path, k].join("."), v];
+            }
+            else {
+                yield* helper([...path, k], v);
+            }
+        }
+    }
+    yield* helper([], obj);
+}
+exports.flattenObject = flattenObject;
+function* flattenArray(arr) {
+    for (const val of arr) {
+        if (Array.isArray(val)) {
+            yield* flattenArray(val);
+        }
+        else {
+            yield val;
+        }
+    }
+}
+exports.flattenArray = flattenArray;
+function flatten(objOrArr) {
+    if (Array.isArray(objOrArr)) {
+        return flattenArray(objOrArr);
+    }
+    else {
+        return flattenObject(objOrArr);
+    }
+}
+exports.flatten = flatten;
+function reduceFlat(accum, next) {
+    return [...(accum || []), ...flatten([next])];
+}
+exports.reduceFlat = reduceFlat;
+function* zip(left, right) {
+    if (left.length != right.length) {
+        throw new Error("Cannot zip between two lists of differen lengths");
+    }
+    for (let i = 0; i < left.length; i++) {
+        yield [left[i], right[i]];
+    }
+}
+exports.zip = zip;
+exports.zipIn = (other) => (elem, ndx) => {
+    return [elem, other[ndx]];
+};
+function assertExhaustive(val) {
+    throw new Error(`Never has a value (${val}). This should be impossible`);
+}
+exports.assertExhaustive = assertExhaustive;
+function partition(arr, callbackFn) {
+    return arr.reduce((acc, elem) => {
+        acc[callbackFn(elem) ? 0 : 1].push(elem);
+        return acc;
+    }, [[], []]);
+}
+exports.partition = partition;

package/lib/functions/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.validateKey = exports.parse = void 0;
+exports.loadFirebaseEnvs = exports.loadUserEnvs = exports.hasUserEnvs = exports.validateKey = exports.KeyValidationError = exports.parse = void 0;
 const clc = require("cli-color");
 const fs = require("fs");
 const path = require("path");
@@ -8,6 +8,7 @@ const error_1 = require("../error");
 const logger_1 = require("../logger");
 const previews_1 = require("../previews");
 const utils_1 = require("../utils");
+const FUNCTIONS_EMULATOR_DOTENV = ".env.local";
 const RESERVED_KEYS = [
     "FIREBASE_CONFIG",
     "CLOUD_RUNTIME_CONFIG",
@@ -35,7 +36,7 @@ const LINE_RE = new RegExp("^" +
     "(" +
     "\\s*'(?:\\\\'|[^'])*'|" +
     '\\s*"(?:\\\\"|[^"])*"|' +
-    "[^\\#\\r\\n]+" +
+    "[^#\\r\\n]+" +
     ")?" +
     "\\s*" +
     "(?:#[^\\n]*)?" +
@@ -71,17 +72,23 @@ function parse(data) {
 }
 exports.parse = parse;
 class KeyValidationError extends Error {
+    constructor(key, message) {
+        super(`Failed to validate key ${key}: ${message}`);
+        this.key = key;
+        this.message = message;
+    }
 }
+exports.KeyValidationError = KeyValidationError;
 function validateKey(key) {
     if (RESERVED_KEYS.includes(key)) {
-        throw new KeyValidationError(`Key ${key} is reserved for internal use.`);
+        throw new KeyValidationError(key, `Key ${key} is reserved for internal use.`);
     }
     if (!/^[A-Z_][A-Z0-9_]*$/.test(key)) {
-        throw new KeyValidationError(`Key ${key} must start with an uppercase ASCII letter or underscore` +
+        throw new KeyValidationError(key, `Key ${key} must start with an uppercase ASCII letter or underscore` +
             ", and then consist of uppercase ASCII letters, digits, and underscores.");
     }
     if (key.startsWith("X_GOOGLE_") || key.startsWith("FIREBASE_")) {
-        throw new KeyValidationError(`Key ${key} starts with a reserved prefix (X_GOOGLE_ or FIREBASE_)`);
+        throw new KeyValidationError(key, `Key ${key} starts with a reserved prefix (X_GOOGLE_ or FIREBASE_)`);
     }
 }
 exports.validateKey = validateKey;
@@ -110,26 +117,32 @@ function parseStrict(data) {
     }
     return envs;
 }
-function findEnvfiles(functionsSource, projectId, projectAlias) {
-    const files = [".env", `.env.${projectId}`];
-    if (projectAlias && projectAlias.length) {
-        files.push(`.env.${projectAlias}`);
+function findEnvfiles(functionsSource, projectId, projectAlias, isEmulator) {
+    const files = [".env"];
+    if (isEmulator) {
+        files.push(FUNCTIONS_EMULATOR_DOTENV);
+    }
+    else {
+        files.push(`.env.${projectId}`);
+        if (projectAlias && projectAlias.length) {
+            files.push(`.env.${projectAlias}`);
+        }
     }
     return files
         .map((f) => path.join(functionsSource, f))
         .filter(fs.existsSync)
         .map((p) => path.basename(p));
 }
-function hasUserEnvs({ functionsSource, projectId, projectAlias }) {
-    return findEnvfiles(functionsSource, projectId, projectAlias).length > 0;
+function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
+    return findEnvfiles(functionsSource, projectId, projectAlias, isEmulator).length > 0;
 }
 exports.hasUserEnvs = hasUserEnvs;
-function loadUserEnvs({ functionsSource, projectId, projectAlias, }) {
+function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
     if (!previews_1.previews.dotenv) {
         return {};
     }
-    const envFiles = findEnvfiles(functionsSource, projectId, projectAlias);
+    const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
     if (envFiles.length == 0) {
         return {};
     }

package/lib/functions/functionslog.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEntries = exports.getApiFilter = void 0;
+const logger_1 = require("../logger");
+const previews_1 = require("../previews");
+function getApiFilter(functionList) {
+    const baseFilter = previews_1.previews.functionsv2
+        ? 'resource.type="cloud_function" OR ' +
+            '(resource.type="cloud_run_revision" AND ' +
+            'labels."goog-managed-by"="cloudfunctions")'
+        : 'resource.type="cloud_function"';
+    if (functionList) {
+        const apiFuncFilters = functionList.split(",").map((fn) => {
+            return previews_1.previews.functionsv2
+                ? `resource.labels.function_name="${fn}" ` + `OR resource.labels.service_name="${fn}"`
+                : `resource.labels.function_name="${fn}"`;
+        });
+        return baseFilter + `\n(${apiFuncFilters.join(" OR ")})`;
+    }
+    return baseFilter;
+}
+exports.getApiFilter = getApiFilter;
+function logEntries(entries) {
+    if (!entries || entries.length === 0) {
+        logger_1.logger.info("No log entries found.");
+        return;
+    }
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        const timestamp = entry.timestamp || "---";
+        const severity = (entry.severity || "?").substring(0, 1);
+        const name = entry.resource.labels.function_name || entry.resource.labels.service_name;
+        const message = entry.textPayload ||
+            JSON.stringify(entry.jsonPayload) ||
+            JSON.stringify(entry.protoPayload) ||
+            "";
+        logger_1.logger.info(`${timestamp} ${severity} ${name}: ${message}`);
+    }
+}
+exports.logEntries = logEntries;