firebase-tools 9.16.6 → 9.20.0

package/lib/extensions/updateHelper.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferUpdateSource = exports.updateFromRegistryFile = exports.updateToVersionFromRegistryFile = 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");
+const changelog = require("./changelog");
 function invalidSourceErrMsgTemplate(instanceId, source) {
     return `Unable to update from the source \`${clc.bold(source)}\`. To update this instance, you can either:\n
   - Run \`${clc.bold("firebase ext:update " + instanceId)}\` to update from the published source.\n
@@ -19,26 +20,12 @@ function invalidSourceErrMsgTemplate(instanceId, source) {
 }
 async function getExistingSourceOrigin(projectId, instanceId, extensionName, existingSource) {
     const instance = await extensionsApi.getInstance(projectId, instanceId);
-    if (instance && instance.config.extensionRef) {
-        return extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION;
-    }
-    let existingSourceOrigin;
-    try {
-        const registryEntry = await resolveSource.resolveRegistryEntry(extensionName);
-        if (resolveSource.isOfficialSource(registryEntry, existingSource)) {
-            existingSourceOrigin = extensionsHelper_1.SourceOrigin.OFFICIAL_EXTENSION;
-        }
-        else {
-            existingSourceOrigin = extensionsHelper_1.SourceOrigin.LOCAL;
-        }
-    }
-    catch (_a) {
-        existingSourceOrigin = extensionsHelper_1.SourceOrigin.LOCAL;
-    }
-    return existingSourceOrigin;
+    return instance && instance.config.extensionRef
+        ? extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION
+        : 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);
     }
@@ -47,19 +34,13 @@ 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;
 }
-async function warningUpdateToOtherSource(sourceOrigin) {
+function warningUpdateToOtherSource(sourceOrigin) {
     let targetText;
-    if ([
-        extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION,
-        extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION_VERSION,
-        extensionsHelper_1.SourceOrigin.OFFICIAL_EXTENSION,
-        extensionsHelper_1.SourceOrigin.OFFICIAL_EXTENSION_VERSION,
-    ].includes(sourceOrigin)) {
+    if ([extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION, extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION_VERSION].includes(sourceOrigin)) {
         targetText = "published extension";
     }
     else if (sourceOrigin === extensionsHelper_1.SourceOrigin.LOCAL) {
@@ -70,31 +51,14 @@ async function warningUpdateToOtherSource(sourceOrigin) {
     }
     const warning = `All the instance's resources and logic will be overwritten to use the source code and files from the ${targetText}.\n`;
     logger_1.logger.info(marked(warning));
-    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.`, { exit: 2 });
-    }
 }
 exports.warningUpdateToOtherSource = warningUpdateToOtherSource;
-async function displayChanges(spec, newSpec, isOfficial = true) {
-    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, isOfficial);
-    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) {
@@ -106,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 {
@@ -116,12 +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);
-    await warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.LOCAL);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, localSource);
+    warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.LOCAL);
     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 {
@@ -131,17 +95,18 @@ 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);
-    await warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.URL);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, urlSource);
+    warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.URL);
     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;
-    displayExtensionInfo_1.displayExtInfo(instanceId, refObj.publisherId, existingSpec, true);
-    const extension = await extensionsApi.getExtension(`${refObj.publisherId}/${refObj.extensionId}`);
+    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);
     }
@@ -149,66 +114,35 @@ async function updateToVersionFromPublisherSource(projectId, instanceId, extVers
         throw new error_1.FirebaseError(`Could not find source '${clc.bold(extVersionRef)}' because (${clc.bold(version)}) is not a published version. To update, use the latest version of this extension (${clc.bold(extension.latestVersion)}).`);
     }
     let registryEntry;
-    let sourceOrigin;
     try {
         registryEntry = await resolveSource.resolveRegistryEntry(existingSpec.name);
-        sourceOrigin =
-            registryEntry.publisher === refObj.publisherId
-                ? extensionsHelper_1.SourceOrigin.OFFICIAL_EXTENSION
-                : extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION;
     }
     catch (err) {
-        sourceOrigin = extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION;
+        logger_1.logger.debug(`Unable to fetch registry.json entry for ${existingSpec.name}`);
     }
-    utils.logLabeledBullet(extensionsHelper_1.logPrefix, `${clc.bold(`You are updating this extension instance to a(n) ${sourceOrigin}.`)}`);
     if (registryEntry) {
         const minVer = resolveSource.getMinRequiredVersion(registryEntry);
         if (minVer && semver.gt(minVer, source.spec.version)) {
             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);
-    await warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION);
-    if (registryEntry) {
-        await resolveSource.promptForUpdateWarnings(registryEntry, existingSpec.version, source.spec.version);
+    showUpdateVersionInfo(instanceId, existingSpec.version, source.spec.version, extVersionRef);
+    warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.PUBLISHED_EXTENSION);
+    const releaseNotes = await changelog.getReleaseNotesForUpdate({
+        extensionRef,
+        fromVersion: existingSpec.version,
+        toVersion: source.spec.version,
+    });
+    if (Object.keys(releaseNotes).length) {
+        changelog.displayReleaseNotes(releaseNotes, existingSpec.version);
     }
     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;
-async function updateToVersionFromRegistryFile(projectId, instanceId, existingSpec, existingSource, version) {
-    if (version !== "latest" && !semver.valid(version)) {
-        throw new error_1.FirebaseError(`cannot update to invalid version ${version}`);
-    }
-    let registryEntry;
-    try {
-        registryEntry = await resolveSource.resolveRegistryEntry(existingSpec.name);
-    }
-    catch (err) {
-        throw new error_1.FirebaseError(`Cannot find the latest version of this extension. To update this instance to a local source or URL source, run "firebase ext:update ${instanceId} <localSourceOrURL>".`);
-    }
-    displayExtensionInfo_1.displayExtInfo(instanceId, registryEntry.publisher, existingSpec, true);
-    utils.logLabeledBullet(extensionsHelper_1.logPrefix, clc.bold("You are updating this extension instance to an official source."));
-    const minVer = resolveSource.getMinRequiredVersion(registryEntry);
-    if (minVer) {
-        if (version !== "latest" && semver.gt(minVer, version)) {
-            throw new error_1.FirebaseError(`The version you are trying to upgrade to (${clc.bold(version)}) is less than the minimum version required (${clc.bold(minVer)}) to use this extension.`);
-        }
-    }
-    const targetVersion = resolveSource.getTargetVersion(registryEntry, version);
-    await showUpdateVersionInfo(instanceId, existingSpec.version, targetVersion);
-    await warningUpdateToOtherSource(extensionsHelper_1.SourceOrigin.OFFICIAL_EXTENSION);
-    await resolveSource.promptForUpdateWarnings(registryEntry, existingSpec.version, targetVersion);
-    return resolveSource.resolveSourceUrl(registryEntry, existingSpec.name, targetVersion);
-}
-exports.updateToVersionFromRegistryFile = updateToVersionFromRegistryFile;
-async function updateFromRegistryFile(projectId, instanceId, existingSpec, existingSource) {
-    return updateToVersionFromRegistryFile(projectId, instanceId, existingSpec, existingSource, "latest");
-}
-exports.updateFromRegistryFile = updateFromRegistryFile;
 function inferUpdateSource(updateSource, existingRef) {
     if (!updateSource) {
         return `${existingRef}@latest`;

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;

package/lib/functions/listFunctions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFunctions = void 0;
+const backend = require("../deploy/functions/backend");
+async function listFunctions(context) {
+    const functionSpecs = (await backend.existingBackend(context, true)).cloudFunctions;
+    functionSpecs.sort(backend.compareFunctions);
+    return { functions: functionSpecs };
+}
+exports.listFunctions = listFunctions;

package/lib/functions/runtimeConfigExport.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDotenvFilename = exports.toDotenvFormat = exports.hydrateEnvs = exports.configToEnv = exports.convertKey = exports.hydrateConfigs = exports.getProjectInfos = void 0;
+const clc = require("cli-color");
+const env = require("./env");
+const functionsConfig = require("../functionsConfig");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const rc_1 = require("../rc");
+const utils_1 = require("../utils");
+const functional_1 = require("../functional");
+function getProjectInfos(options) {
+    const result = {};
+    const rc = rc_1.loadRC(options);
+    if (rc.projects) {
+        for (const [alias, projectId] of Object.entries(rc.projects)) {
+            if (Object.keys(result).includes(projectId)) {
+                utils_1.logWarning(`Multiple aliases found for ${clc.bold(projectId)}. ` +
+                    `Preferring alias (${clc.bold(result[projectId])}) over (${clc.bold(alias)}).`);
+                continue;
+            }
+            result[projectId] = alias;
+        }
+    }
+    const projectId = projectUtils_1.getProjectId(options);
+    if (projectId && !Object.keys(result).includes(projectId)) {
+        result[projectId] = projectId;
+    }
+    return Object.entries(result).map(([k, v]) => {
+        const result = { projectId: k };
+        if (k !== v) {
+            result.alias = v;
+        }
+        return result;
+    });
+}
+exports.getProjectInfos = getProjectInfos;
+async function hydrateConfigs(pInfos) {
+    const hydrate = pInfos.map((info) => {
+        return functionsConfig
+            .materializeAll(info.projectId)
+            .then((config) => {
+            info.config = config;
+            return;
+        })
+            .catch((err) => {
+            logger_1.logger.debug(`Failed to fetch runtime config for project ${info.projectId}: ${err.message}`);
+        });
+    });
+    await Promise.all(hydrate);
+}
+exports.hydrateConfigs = hydrateConfigs;
+function convertKey(configKey, prefix) {
+    const baseKey = configKey
+        .toUpperCase()
+        .replace(/\./g, "_")
+        .replace(/-/g, "_");
+    let envKey = baseKey;
+    try {
+        env.validateKey(envKey);
+    }
+    catch (err) {
+        if (err instanceof env.KeyValidationError) {
+            envKey = prefix + envKey;
+            env.validateKey(envKey);
+        }
+    }
+    return envKey;
+}
+exports.convertKey = convertKey;
+function configToEnv(configs, prefix) {
+    const success = [];
+    const errors = [];
+    for (const [configKey, value] of functional_1.flatten(configs)) {
+        try {
+            const envKey = convertKey(configKey, prefix);
+            success.push({ origKey: configKey, newKey: envKey, value: value });
+        }
+        catch (err) {
+            if (err instanceof env.KeyValidationError) {
+                errors.push({
+                    origKey: configKey,
+                    newKey: err.key,
+                    err: err.message,
+                    value: value,
+                });
+            }
+            else {
+                throw new error_1.FirebaseError("Unexpected error while converting config", {
+                    exit: 2,
+                    original: err,
+                });
+            }
+        }
+    }
+    return { success, errors };
+}
+exports.configToEnv = configToEnv;
+function hydrateEnvs(pInfos, prefix) {
+    let errMsg = "";
+    for (const pInfo of pInfos) {
+        const { success, errors } = configToEnv(pInfo.config, prefix);
+        if (errors.length > 0) {
+            const msg = `${pInfo.projectId} ` +
+                `${pInfo.alias ? "(" + pInfo.alias + ")" : ""}:\n` +
+                errors.map((err) => `\t${err.origKey} => ${clc.bold(err.newKey)} (${err.err})`).join("\n") +
+                "\n";
+            errMsg += msg;
+        }
+        else {
+            pInfo.envs = success;
+        }
+    }
+    return errMsg;
+}
+exports.hydrateEnvs = hydrateEnvs;
+function escape(s) {
+    const result = s
+        .replace("\n", "\\n")
+        .replace("\r", "\\r")
+        .replace("\t", "\\t")
+        .replace("\v", "\\v");
+    return result.replace(/(['"])/g, "\\$1");
+}
+function toDotenvFormat(envs, header = "") {
+    const lines = envs.map(({ newKey, value }) => `${newKey}="${escape(value)}"`);
+    const maxLineLen = Math.max(...lines.map((l) => l.length));
+    return (`${header}\n` +
+        lines.map((line, idx) => `${line.padEnd(maxLineLen)} # from ${envs[idx].origKey}`).join("\n"));
+}
+exports.toDotenvFormat = toDotenvFormat;
+function generateDotenvFilename(pInfo) {
+    var _a;
+    return `.env.${(_a = pInfo.alias) !== null && _a !== void 0 ? _a : pInfo.projectId}`;
+}
+exports.generateDotenvFilename = generateDotenvFilename;