firebase-tools 9.18.0 → 9.22.0

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,33 +53,34 @@ 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) {
-        return await extensionsApi.updateInstanceFromRegistry(projectId, instanceId, extRef, params);
+        return await extensionsApi.updateInstanceFromRegistry({
+            projectId,
+            instanceId,
+            extRef,
+            params,
+        });
     }
     else if (source) {
-        return await extensionsApi.updateInstance(projectId, instanceId, source, params);
+        return await extensionsApi.updateInstance({
+            projectId,
+            instanceId,
+            extensionSource: source,
+            params,
+        });
     }
     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 +90,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 +105,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 +136,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 +146,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 +171,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/versionHelper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersionPredicate = void 0;
+const error_1 = require("../error");
+function parseVersionPredicate(versionPredicate) {
+    const versionPredicateRegex = "^(?<comparator>>=|<=|>|<)?(?<targetSemVer>.*)";
+    const matches = versionPredicate.match(versionPredicateRegex);
+    if (!matches || !matches.groups.targetSemVer) {
+        throw new error_1.FirebaseError("Invalid version predicate.");
+    }
+    const comparator = matches.groups.comparator || "=";
+    return { comparator, targetSemVer: matches.groups.targetSemVer };
+}
+exports.parseVersionPredicate = parseVersionPredicate;

package/lib/extensions/warnings.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayWarningPrompts = void 0;
+exports.displayWarningsForDeploy = exports.displayWarningPrompts = void 0;
 const marked = require("marked");
 const clc = require("cli-color");
 const extensionsApi_1 = require("./extensionsApi");
 const displayExtensionInfo_1 = require("./displayExtensionInfo");
 const extensionsHelper_1 = require("./extensionsHelper");
 const resolveSource_1 = require("./resolveSource");
+const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
+const planner_1 = require("../deploy/extensions/planner");
+const functional_1 = require("../functional");
 const utils = require("../utils");
 function displayEAPWarning({ publisherId, sourceDownloadUri, githubLink, }) {
     const publisherNameLink = githubLink ? `[${publisherId}](${githubLink})` : publisherId;
@@ -35,3 +38,32 @@ async function displayWarningPrompts(publisherId, launchStage, extensionVersion)
     }
 }
 exports.displayWarningPrompts = displayWarningPrompts;
+const toListEntry = (i) => {
+    var _a, _b, _c, _d;
+    const idAndRef = deploymentSummary_1.humanReadable(i);
+    const sourceCodeLink = `\n\t[Source Code](${(_a = i.extensionVersion) === null || _a === void 0 ? void 0 : _a.sourceDownloadUri})`;
+    const githubLink = ((_c = (_b = i.extensionVersion) === null || _b === void 0 ? void 0 : _b.spec) === null || _c === void 0 ? void 0 : _c.sourceUrl) ? `\n\t[Publisher Contact](${(_d = i.extensionVersion) === null || _d === void 0 ? void 0 : _d.spec.sourceUrl})`
+        : "";
+    return `${idAndRef}${sourceCodeLink}${githubLink}`;
+};
+async function displayWarningsForDeploy(instancesToCreate) {
+    const trustedPublishers = await resolveSource_1.getTrustedPublishers();
+    for (const i of instancesToCreate) {
+        await planner_1.getExtension(i);
+        await planner_1.getExtensionVersion(i);
+    }
+    const [eapExtensions, nonEapExtensions] = functional_1.partition(instancesToCreate, (i) => { var _a, _b; return !trustedPublishers.includes((_b = (_a = i.ref) === null || _a === void 0 ? void 0 : _a.publisherId) !== null && _b !== void 0 ? _b : ""); });
+    const experimental = nonEapExtensions.filter((i) => i.extension.registryLaunchStage === extensionsApi_1.RegistryLaunchStage.EXPERIMENTAL);
+    if (experimental.length) {
+        const humanReadableList = experimental.map((i) => `\t${deploymentSummary_1.humanReadable(i)}`).join("\n");
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`The following are instances of ${clc.bold("experimental")} extensions.They may not be production-ready. Their functionality may change in backward-incompatible ways before their official release, or they may be discontinued.\n${humanReadableList}\n`));
+    }
+    if (eapExtensions.length) {
+        const humanReadableList = eapExtensions.map(toListEntry).join("\n");
+        utils.logLabeledBullet(extensionsHelper_1.logPrefix, marked(`These extensions are in preview and are built by a developer in the Extensions Publisher Early Access Program (http://bit.ly/firex-provider. Their functionality might change in backwards-incompatible ways. Since these extensions aren't built by Firebase, reach out to their publisher with questions about them.` +
+            ` They are provided “AS IS”, without any warranty, express or implied, from Google.` +
+            ` Google disclaims all liability for any damages, direct or indirect, resulting from the use of these extensions\n${humanReadableList}`));
+    }
+    return experimental.length > 0 || eapExtensions.length > 0;
+}
+exports.displayWarningsForDeploy = displayWarningsForDeploy;

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

package/lib/gcp/artifactregistry.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deletePackage = exports.API_VERSION = void 0;
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
+exports.API_VERSION = "v1beta2";
+const client = new apiv2_1.Client({
+    urlPrefix: api_1.artifactRegistryDomain,
+    auth: true,
+    apiVersion: exports.API_VERSION,
+});
+async function deletePackage(name) {
+    const res = await client.delete(name);
+    return res.body;
+}
+exports.deletePackage = deletePackage;