firebase-tools 10.1.5 → 10.2.2

package/lib/emulator/emulatorLogger.js

@@ -13,6 +13,7 @@ const TYPE_VERBOSITY = {
     USER: 2,
     WARN: 2,
     WARN_ONCE: 2,
+    ERROR: 2,
 };
 var Verbosity;
 (function (Verbosity) {
@@ -33,7 +34,7 @@ class EmulatorLogger {
             },
         });
     }
-    static forFunction(functionName) {
+    static forFunction(functionName, extensionLogInfo) {
         return new EmulatorLogger({
             metadata: {
                 emulator: {
@@ -42,6 +43,17 @@ class EmulatorLogger {
                 function: {
                     name: functionName,
                 },
+                extension: extensionLogInfo,
+            },
+        });
+    }
+    static forExtension(extensionLogInfo) {
+        return new EmulatorLogger({
+            metadata: {
+                emulator: {
+                    name: "extensions",
+                },
+                extension: extensionLogInfo,
             },
         });
     }
@@ -79,6 +91,9 @@ class EmulatorLogger {
             case "SUCCESS":
                 utils.logSuccess(text, "info", mergedData);
                 break;
+            case "ERROR":
+                utils.logBullet(text, "error", mergedData);
+                break;
         }
     }
     handleRuntimeLog(log, ignore = []) {
@@ -196,6 +211,9 @@ You can probably fix this by running "npm install ${systemLog.data.name}@latest"
                     EmulatorLogger.warnOnceCache.add(text);
                 }
                 break;
+            case "ERROR":
+                utils.logLabeledError(label, text, "error", mergedData);
+                break;
         }
     }
     static shouldSupress(type) {

package/lib/emulator/extensions/validation.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnemulatedAPIs = void 0;
+const planner = require("../../deploy/extensions/planner");
+const ensureApiEnabled_1 = require("../../ensureApiEnabled");
+const EMULATED_APIS = [
+    "storage-component.googleapis.com",
+    "firestore.googleapis.com",
+    "pubsub.googleapis.com",
+    "identitytoolkit.googleapis.com",
+];
+async function getUnemulatedAPIs(projectId, instances) {
+    var _a;
+    const unemulatedAPIs = {};
+    for (const i of instances) {
+        const extensionVersion = await planner.getExtensionVersion(i);
+        for (const api of (_a = extensionVersion.spec.apis) !== null && _a !== void 0 ? _a : []) {
+            if (!EMULATED_APIS.includes(api.apiName)) {
+                if (unemulatedAPIs[api.apiName]) {
+                    unemulatedAPIs[api.apiName].instanceIds.push(i.instanceId);
+                }
+                else {
+                    const enabled = await (0, ensureApiEnabled_1.check)(projectId, api.apiName, "extensions", true);
+                    unemulatedAPIs[api.apiName] = {
+                        apiName: api.apiName,
+                        instanceIds: [i.instanceId],
+                        enabled,
+                    };
+                }
+            }
+        }
+    }
+    return Object.values(unemulatedAPIs);
+}
+exports.getUnemulatedAPIs = getUnemulatedAPIs;

package/lib/emulator/extensionsEmulator.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsEmulator = void 0;
+const fs = require("fs-extra");
+const os = require("os");
+const path = require("path");
+const clc = require("cli-color");
+const Table = require("cli-table");
+const child_process_1 = require("child_process");
+const planner = require("../deploy/extensions/planner");
+const error_1 = require("../error");
+const refs_1 = require("../extensions/refs");
+const download_1 = require("./download");
+const optionsHelper_1 = require("../extensions/emulator/optionsHelper");
+const emulatorLogger_1 = require("./emulatorLogger");
+const types_1 = require("./types");
+const validation_1 = require("./extensions/validation");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
+const shortenUrl_1 = require("../shortenUrl");
+class ExtensionsEmulator {
+    constructor(args) {
+        this.want = [];
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EXTENSIONS);
+        this.args = args;
+    }
+    async readManifest() {
+        var _a;
+        this.want = await planner.want({
+            projectId: this.args.projectId,
+            projectNumber: this.args.projectNumber,
+            aliases: (_a = this.args.aliases) !== null && _a !== void 0 ? _a : [],
+            projectDir: this.args.projectDir,
+            extensions: this.args.extensions,
+            checkLocal: true,
+        });
+    }
+    async ensureSourceCode(instance) {
+        if (!instance.ref) {
+            throw new error_1.FirebaseError(`No ref found for ${instance.instanceId}. Emulating local extensions is not yet supported.`);
+        }
+        const ref = (0, refs_1.toExtensionVersionRef)(instance.ref);
+        const cacheDir = process.env.FIREBASE_EXTENSIONS_CACHE_PATH ||
+            path.join(os.homedir(), ".cache", "firebase", "extensions");
+        const sourceCodePath = path.join(cacheDir, ref);
+        if (!this.hasValidSource({ path: sourceCodePath, extRef: ref })) {
+            const extensionVersion = await planner.getExtensionVersion(instance);
+            await (0, download_1.downloadExtensionVersion)(ref, extensionVersion.sourceDownloadUri, sourceCodePath);
+            this.installAndBuildSourceCode(sourceCodePath);
+        }
+        return sourceCodePath;
+    }
+    hasValidSource(args) {
+        const requiredFiles = [
+            "./extension.yaml",
+            "./functions/package.json",
+            "./functions/node_modules",
+        ];
+        for (const requiredFile of requiredFiles) {
+            const f = path.join(args.path, requiredFile);
+            if (!fs.existsSync(f)) {
+                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extRef }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extRef}, expected to find ${f}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    installAndBuildSourceCode(sourceCodePath) {
+        const npmInstall = (0, child_process_1.spawnSync)("npm", ["--prefix", `/${sourceCodePath}/functions/`, "install"], {
+            encoding: "utf8",
+        });
+        if (npmInstall.error) {
+            throw npmInstall.error;
+        }
+        const npmRunGCPBuild = (0, child_process_1.spawnSync)("npm", ["--prefix", `/${sourceCodePath}/functions/`, "run", "gcp-build"], { encoding: "utf8" });
+        if (npmRunGCPBuild.error) {
+            throw npmRunGCPBuild.error;
+        }
+    }
+    async getExtensionBackends() {
+        await this.readManifest();
+        await this.checkAndWarnAPIs(this.want);
+        return Promise.all(this.want.map((i) => {
+            return this.toEmulatableBackend(i);
+        }));
+    }
+    async toEmulatableBackend(instance) {
+        const extensionDir = await this.ensureSourceCode(instance);
+        const functionsDir = path.join(extensionDir, "functions");
+        const env = Object.assign(this.autoPopulatedParams(instance), instance.params);
+        const { extensionTriggers, nodeMajorVersion } = await (0, optionsHelper_1.getExtensionFunctionInfo)(extensionDir, instance.instanceId, env);
+        const extension = await planner.getExtension(instance);
+        const extensionVersion = await planner.getExtensionVersion(instance);
+        return {
+            functionsDir,
+            env,
+            predefinedTriggers: extensionTriggers,
+            nodeMajorVersion: nodeMajorVersion,
+            extensionInstanceId: instance.instanceId,
+            extension,
+            extensionVersion,
+        };
+    }
+    autoPopulatedParams(instance) {
+        const projectId = this.args.projectId;
+        return {
+            PROJECT_ID: projectId !== null && projectId !== void 0 ? projectId : "",
+            EXT_INSTANCE_ID: instance.instanceId,
+            DATABASE_INSTANCE: projectId !== null && projectId !== void 0 ? projectId : "",
+            DATABASE_URL: `https://${projectId}.firebaseio.com`,
+            STORAGE_BUCKET: `${projectId}.appspot.com`,
+        };
+    }
+    async checkAndWarnAPIs(instances) {
+        const apisToWarn = await (0, validation_1.getUnemulatedAPIs)(this.args.projectId, instances);
+        if (apisToWarn.length) {
+            const table = new Table({
+                head: [
+                    "API Name",
+                    "Instances using this API",
+                    `Enabled on ${this.args.projectId}`,
+                    `Enable this API`,
+                ],
+                style: { head: ["yellow"] },
+            });
+            for (const apiToWarn of apisToWarn) {
+                const enablementUri = await (0, shortenUrl_1.shortenUrl)((0, ensureApiEnabled_1.enableApiURI)(this.args.projectId, apiToWarn.apiName));
+                table.push([
+                    apiToWarn.apiName,
+                    apiToWarn.instanceIds,
+                    apiToWarn.enabled ? "Yes" : "No",
+                    apiToWarn.enabled ? "" : clc.bold.underline(enablementUri),
+                ]);
+            }
+            this.logger.logLabeled("WARN", "Extensions", `The following Extensions make calls to Google Cloud APIs that do not have Emulators. ` +
+                `These calls will go to production Google Cloud APIs which may have real effects on ${this.args.projectId}.\n` +
+                table.toString());
+        }
+    }
+}
+exports.ExtensionsEmulator = ExtensionsEmulator;