firebase-tools 12.3.0 → 12.3.1

package/lib/commands/functions-secrets-access.js

@@ -5,8 +5,10 @@ const command_1 = require("../command");
 const logger_1 = require("../logger");
 const projectUtils_1 = require("../projectUtils");
 const secretManager_1 = require("../gcp/secretManager");
+const secrets = require("../functions/secrets");
 exports.command = new command_1.Command("functions:secrets:access <KEY>[@version]")
     .description("Access secret value given secret and its version. Defaults to accessing the latest version.")
+    .before(secrets.ensureApi)
     .action(async (key, options) => {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     let [name, version] = key.split("@");

package/lib/commands/functions-secrets-destroy.js

@@ -11,6 +11,7 @@ const backend = require("../deploy/functions/backend");
 exports.command = new command_1.Command("functions:secrets:destroy <KEY>[@version]")
     .description("Destroy a secret. Defaults to destroying the latest version.")
     .withForce("Destroys a secret without confirmation.")
+    .before(secrets.ensureApi)
     .action(async (key, options) => {
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);

package/lib/commands/functions-secrets-get.js

@@ -7,8 +7,10 @@ const logger_1 = require("../logger");
 const projectUtils_1 = require("../projectUtils");
 const secretManager_1 = require("../gcp/secretManager");
 const requirePermissions_1 = require("../requirePermissions");
+const secrets = require("../functions/secrets");
 exports.command = new command_1.Command("functions:secrets:get <KEY>")
     .description("Get metadata for secret and its versions")
+    .before(secrets.ensureApi)
     .before(requirePermissions_1.requirePermissions, ["secretmanager.secrets.get"])
     .action(async (key, options) => {
     const projectId = (0, projectUtils_1.needProjectId)(options);

package/lib/commands/functions-secrets-prune.js

@@ -4,7 +4,7 @@ exports.command = void 0;
 const backend = require("../deploy/functions/backend");
 const command_1 = require("../command");
 const projectUtils_1 = require("../projectUtils");
-const secrets_1 = require("../functions/secrets");
+const secrets = require("../functions/secrets");
 const requirePermissions_1 = require("../requirePermissions");
 const deploymentTool_1 = require("../deploymentTool");
 const utils_1 = require("../utils");
@@ -13,6 +13,7 @@ const secretManager_1 = require("../gcp/secretManager");
 exports.command = new command_1.Command("functions:secrets:prune")
     .withForce("Destroys unused secrets without prompt")
     .description("Destroys unused secrets")
+    .before(secrets.ensureApi)
     .before(requirePermissions_1.requirePermissions, [
     "cloudfunctions.functions.list",
     "secretmanager.secrets.list",
@@ -27,7 +28,7 @@ exports.command = new command_1.Command("functions:secrets:prune")
     const haveEndpoints = backend
         .allEndpoints(haveBackend)
         .filter((e) => (0, deploymentTool_1.isFirebaseManaged)(e.labels || []));
-    const pruned = await (0, secrets_1.pruneSecrets)({ projectNumber, projectId }, haveEndpoints);
+    const pruned = await secrets.pruneSecrets({ projectNumber, projectId }, haveEndpoints);
     if (pruned.length === 0) {
         (0, utils_1.logBullet)("All secrets are in use. Nothing to prune today.");
         return;

package/lib/commands/functions-secrets-set.js

@@ -4,6 +4,7 @@ exports.command = void 0;
 const tty = require("tty");
 const fs = require("fs");
 const clc = require("colorette");
+const logger_1 = require("../logger");
 const secrets_1 = require("../functions/secrets");
 const command_1 = require("../command");
 const requirePermissions_1 = require("../requirePermissions");
@@ -13,9 +14,11 @@ const projectUtils_1 = require("../projectUtils");
 const secretManager_1 = require("../gcp/secretManager");
 const secrets = require("../functions/secrets");
 const backend = require("../deploy/functions/backend");
+const ensureApiEnabled_1 = require("../ensureApiEnabled");
 exports.command = new command_1.Command("functions:secrets:set <KEY>")
     .description("Create or update a secret for use in Cloud Functions for Firebase.")
     .withForce("Automatically updates functions to use the new secret.")
+    .before(secrets.ensureApi)
     .before(requirePermissions_1.requirePermissions, [
     "secretmanager.secrets.create",
     "secretmanager.secrets.get",
@@ -50,6 +53,11 @@ exports.command = new command_1.Command("functions:secrets:set <KEY>")
             clc.bold("firebase deploy --only functions"));
         return;
     }
+    const functionsEnabled = await (0, ensureApiEnabled_1.check)(projectId, "cloudfunctions.googleapis.com", "functions", true);
+    if (!functionsEnabled) {
+        logger_1.logger.debug("Customer set secrets before enabling functions. Exiting");
+        return;
+    }
     const haveBackend = await backend.existingBackend({ projectId });
     const endpointsToUpdate = backend
         .allEndpoints(haveBackend)

package/lib/commands/index.js

@@ -137,6 +137,8 @@ function load(client) {
     client.init = loadCommand("init");
     if (experiments.isEnabled("internaltesting")) {
         client.internaltesting = {};
+        client.internaltesting.frameworks = {};
+        client.internaltesting.frameworks.compose = loadCommand("internaltesting-frameworks-compose");
         client.internaltesting.functions = {};
         client.internaltesting.functions.discover = loadCommand("internaltesting-functions-discover");
     }

package/lib/commands/internaltesting-frameworks-compose.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const driver_1 = require("../frameworks/compose/driver");
+const compose_1 = require("../frameworks/compose");
+const error_1 = require("../error");
+exports.command = new command_1.Command("internaltesting:frameworks:compose")
+    .option("-m, --mode <mode>", "Composer mode (local or docker)", "local")
+    .description("compose framework in current directory")
+    .action((options) => {
+    const mode = options.mode;
+    if (!driver_1.SUPPORTED_MODES.includes(mode)) {
+        throw new error_1.FirebaseError(`Unsupported mode ${mode}. Supported modes are [${driver_1.SUPPORTED_MODES.join(", ")}]`);
+    }
+    const bundle = (0, compose_1.compose)(mode);
+    logger_1.logger.info(JSON.stringify(bundle, null, 2));
+    return {};
+});

package/lib/deploy/functions/release/executor.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InlineExecutor = exports.QueueExecutor = void 0;
+exports.InlineExecutor = exports.QueueExecutor = exports.DEFAULT_RETRY_CODES = void 0;
 const queue_1 = require("../../../throttler/queue");
-async function handler(op) {
+exports.DEFAULT_RETRY_CODES = [429, 409, 503];
+function parseErrorCode(err) {
     var _a, _b, _c, _d, _e, _f;
+    return (err.status ||
+        err.code ||
+        ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) ||
+        ((_c = err.original) === null || _c === void 0 ? void 0 : _c.code) ||
+        ((_f = (_e = (_d = err.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode));
+}
+async function handler(op) {
     try {
         op.result = await op.func();
     }
     catch (err) {
-        const code = err.status ||
-            err.code ||
-            ((_b = (_a = err.context) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.statusCode) ||
-            ((_c = err.original) === null || _c === void 0 ? void 0 : _c.code) ||
-            ((_f = (_e = (_d = err.original) === null || _d === void 0 ? void 0 : _d.context) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.statusCode);
-        if (code === 429 || code === 409 || code === 503) {
+        const code = parseErrorCode(err);
+        if (op.retryCodes.includes(code)) {
             throw err;
         }
+        err.code = code;
         op.error = err;
     }
     return;
@@ -24,8 +29,12 @@ class QueueExecutor {
     constructor(options) {
         this.queue = new queue_1.Queue(Object.assign(Object.assign({}, options), { handler }));
     }
-    async run(func) {
-        const op = { func };
+    async run(func, opts) {
+        const retryCodes = (opts === null || opts === void 0 ? void 0 : opts.retryCodes) || exports.DEFAULT_RETRY_CODES;
+        const op = {
+            func,
+            retryCodes,
+        };
         await this.queue.run(op);
         if (op.error) {
             throw op.error;

package/lib/deploy/functions/release/fabricator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Fabricator = void 0;
 const clc = require("colorette");
+const executor_1 = require("./executor");
 const error_1 = require("../../../error");
 const sourceTokenScraper_1 = require("./sourceTokenScraper");
 const timer_1 = require("./timer");
@@ -44,6 +45,7 @@ const eventarcPollerOptions = {
     masterTimeout: 25 * 60 * 1000,
     maxBackoff: 10000,
 };
+const CLOUD_RUN_RESOURCE_EXHAUSTED_CODE = 8;
 const rethrowAs = (endpoint, op) => (err) => {
     logger_1.logger.error(err.message);
     throw new reporter.DeploymentError(endpoint, op, err);
@@ -269,12 +271,24 @@ class Fabricator {
             })
                 .catch(rethrowAs(endpoint, "upsert eventarc channel"));
         }
-        const resultFunction = await this.functionExecutor
-            .run(async () => {
-            const op = await gcfV2.createFunction(apiFunction);
-            return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
-        })
-            .catch(rethrowAs(endpoint, "create"));
+        let resultFunction = null;
+        while (!resultFunction) {
+            resultFunction = await this.functionExecutor
+                .run(async () => {
+                const op = await gcfV2.createFunction(apiFunction);
+                return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `create-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+            })
+                .catch(async (err) => {
+                if (err.code === CLOUD_RUN_RESOURCE_EXHAUSTED_CODE) {
+                    await this.deleteV2Function(endpoint);
+                    return null;
+                }
+                else {
+                    logger_1.logger.error(err.message);
+                    throw new reporter.DeploymentError(endpoint, "create", err);
+                }
+            });
+        }
         endpoint.uri = (_d = resultFunction.serviceConfig) === null || _d === void 0 ? void 0 : _d.uri;
         const serviceName = (_e = resultFunction.serviceConfig) === null || _e === void 0 ? void 0 : _e.service;
         endpoint.runServiceId = utils.last(serviceName === null || serviceName === void 0 ? void 0 : serviceName.split("/"));
@@ -367,7 +381,7 @@ class Fabricator {
             .run(async () => {
             const op = await gcfV2.updateFunction(apiFunction);
             return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
-        })
+        }, { retryCodes: [...executor_1.DEFAULT_RETRY_CODES, CLOUD_RUN_RESOURCE_EXHAUSTED_CODE] })
             .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = (_c = resultFunction.serviceConfig) === null || _c === void 0 ? void 0 : _c.uri;
         const serviceName = (_d = resultFunction.serviceConfig) === null || _d === void 0 ? void 0 : _d.service;
@@ -414,7 +428,7 @@ class Fabricator {
             const op = await gcfV2.deleteFunction(fnName);
             const pollerOptions = Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `delete-${endpoint.codebase}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name });
             await poller.pollOperation(pollerOptions);
-        })
+        }, { retryCodes: [...executor_1.DEFAULT_RETRY_CODES, CLOUD_RUN_RESOURCE_EXHAUSTED_CODE] })
             .catch(rethrowAs(endpoint, "delete"));
     }
     async setRunTraits(serviceName, endpoint) {

package/lib/frameworks/compose/discover/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discover = void 0;
+function discover() {
+    return {
+        baseImage: "us-docker.pkg.dev/firestack-build/test/run:latest",
+        environmentVariables: {
+            NODE_ENV: "PRODUCTION",
+        },
+        installCommand: "npm install",
+        buildCommand: "npm run build",
+        startCommand: "npm run start",
+        afterInstall: (b) => {
+            console.log("HOOK: AFTER INSTALL");
+            return Object.assign(Object.assign({}, b), { version: "v1alpha", notes: "afterInstall" });
+        },
+        afterBuild(b) {
+            console.log("HOOK: AFTER BUILD");
+            return Object.assign(Object.assign({}, b), { version: "v1alpha", notes: "afterBuild" });
+        },
+    };
+}
+exports.discover = discover;

package/lib/frameworks/compose/driver/docker.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerDriver = exports.DockerfileBuilder = void 0;
+const fs = require("node:fs");
+const path = require("node:path");
+const spawn = require("cross-spawn");
+const hooks_1 = require("./hooks");
+const ADAPTER_SCRIPTS_PATH = "./.firebase/adapters";
+const DOCKER_STAGE_INSTALL = "installer";
+const DOCKER_STAGE_BUILD = "builder";
+class DockerfileBuilder {
+    constructor() {
+        this.dockerfile = "";
+        this.lastStage = "";
+    }
+    from(image, name) {
+        this.dockerfile += `FROM ${image}`;
+        if (name) {
+            this.dockerfile += ` AS ${name}`;
+            this.lastStage = name;
+        }
+        this.dockerfile += "\n";
+        return this;
+    }
+    fromLastStage(name) {
+        return this.from(this.lastStage, name);
+    }
+    tempFrom(image, name) {
+        this.dockerfile += `FROM ${image}`;
+        if (name) {
+            this.dockerfile += ` AS ${name}`;
+        }
+        this.dockerfile += "\n";
+        return this;
+    }
+    workdir(dir) {
+        this.dockerfile += `WORKDIR ${dir}\n`;
+        return this;
+    }
+    copyForFirebase(src, dest, from) {
+        if (from) {
+            this.dockerfile += `COPY --chown=firebase:firebase --from=${from} ${src} ${dest}\n`;
+        }
+        else {
+            this.dockerfile += `COPY --chown=firebase:firebase ${src} ${dest}\n`;
+        }
+        return this;
+    }
+    copyFrom(src, dest, from) {
+        this.dockerfile += `COPY --from=${from} ${src} ${dest}\n`;
+        return this;
+    }
+    run(cmd, mount) {
+        if (mount) {
+            this.dockerfile += `RUN --mount=${mount} ${cmd}\n`;
+        }
+        else {
+            this.dockerfile += `RUN ${cmd}\n`;
+        }
+        return this;
+    }
+    env(key, value) {
+        this.dockerfile += `ENV ${key}="${value}"\n`;
+        return this;
+    }
+    envs(envs) {
+        for (const [key, value] of Object.entries(envs)) {
+            this.env(key, value);
+        }
+        return this;
+    }
+    cmd(cmds) {
+        this.dockerfile += `CMD [${cmds.map((c) => `"${c}"`).join(", ")}]\n`;
+        return this;
+    }
+    user(user) {
+        this.dockerfile += `USER ${user}\n`;
+        return this;
+    }
+    toString() {
+        return this.dockerfile;
+    }
+}
+exports.DockerfileBuilder = DockerfileBuilder;
+class DockerDriver {
+    constructor(spec) {
+        this.spec = spec;
+        this.dockerfileBuilder = new DockerfileBuilder();
+        this.dockerfileBuilder.from(spec.baseImage, "base").user("firebase");
+    }
+    execDockerPush(args) {
+        console.log(`executing docker build: ${args.join(" ")}`);
+        return spawn.sync("docker", ["push", ...args], {
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+    }
+    execDockerBuild(args, contextDir) {
+        console.log(`executing docker build: ${args.join(" ")} ${contextDir}`);
+        console.log(this.dockerfileBuilder.toString());
+        return spawn.sync("docker", ["buildx", "build", ...args, "-f", "-", contextDir], {
+            env: Object.assign(Object.assign({}, process.env), this.spec.environmentVariables),
+            input: this.dockerfileBuilder.toString(),
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+    }
+    buildStage(stage, contextDir, tag) {
+        console.log(`Building stage: ${stage}`);
+        const args = ["--target", stage];
+        if (tag) {
+            args.push("--tag", tag);
+        }
+        const ret = this.execDockerBuild(args, contextDir);
+        if (ret.error || ret.status !== 0) {
+            throw new Error(`Failed to execute stage ${stage}: error=${ret.error} status=${ret.status}`);
+        }
+    }
+    exportBundle(stage, contextDir) {
+        const exportStage = `${stage}-export`;
+        this.dockerfileBuilder
+            .tempFrom("scratch", exportStage)
+            .copyFrom(hooks_1.BUNDLE_PATH, "/bundle.json", stage);
+        const ret = this.execDockerBuild(["--target", exportStage, "--output", ".firebase/.output"], contextDir);
+        if (ret.error || ret.status !== 0) {
+            throw new Error(`Failed to export bundle ${stage}: error=${ret.error} status=${ret.status}`);
+        }
+        return JSON.parse(fs.readFileSync("./.firebase/.output/bundle.json", "utf8"));
+    }
+    install() {
+        this.dockerfileBuilder
+            .fromLastStage(DOCKER_STAGE_INSTALL)
+            .workdir("/home/firebase/app")
+            .envs(this.spec.environmentVariables || {})
+            .copyForFirebase("package.json", ".")
+            .run(this.spec.installCommand);
+        this.buildStage(DOCKER_STAGE_INSTALL, ".");
+    }
+    build() {
+        this.dockerfileBuilder
+            .fromLastStage(DOCKER_STAGE_BUILD)
+            .copyForFirebase(".", ".")
+            .run(this.spec.buildCommand);
+        this.buildStage(DOCKER_STAGE_BUILD, ".");
+    }
+    export(bundle) {
+        var _a;
+        const startCmd = (_a = bundle.server) === null || _a === void 0 ? void 0 : _a.start.cmd;
+        if (startCmd) {
+            const exportStage = "exporter";
+            this.dockerfileBuilder
+                .from(this.spec.baseImage, exportStage)
+                .workdir("/home/firebase/app")
+                .copyForFirebase("/home/firebase/app", ".", DOCKER_STAGE_BUILD)
+                .cmd(startCmd);
+            const imageName = `us-docker.pkg.dev/${process.env.PROJECT_ID}/test/demo-nodappe`;
+            this.buildStage(exportStage, ".", imageName);
+            const ret = this.execDockerPush([imageName]);
+            if (ret.error || ret.status !== 0) {
+                throw new Error(`Failed to push image ${imageName}: error=${ret.error} status=${ret.status}`);
+            }
+        }
+    }
+    execHook(bundle, hook) {
+        const hookScript = `hook-${Date.now()}.js`;
+        const hookScriptSrc = (0, hooks_1.genHookScript)(bundle, hook);
+        if (!fs.existsSync(ADAPTER_SCRIPTS_PATH)) {
+            fs.mkdirSync(ADAPTER_SCRIPTS_PATH, { recursive: true });
+        }
+        fs.writeFileSync(path.join(ADAPTER_SCRIPTS_PATH, hookScript), hookScriptSrc);
+        const hookStage = path.basename(hookScript, ".js");
+        this.dockerfileBuilder
+            .fromLastStage(hookStage)
+            .run(`NODE_PATH=./node_modules node /framework/adapters/${hookScript}`, `source=${ADAPTER_SCRIPTS_PATH},target=/framework/adapters`);
+        this.buildStage(hookStage, ".");
+        return this.exportBundle(hookStage, ".");
+    }
+}
+exports.DockerDriver = DockerDriver;

package/lib/frameworks/compose/driver/hooks.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genHookScript = exports.BUNDLE_PATH = void 0;
+exports.BUNDLE_PATH = "/home/firebase/app/.firebase/.output/bundle.json";
+function genHookScript(bundle, hook) {
+    let hookSrc = hook.toString().trimLeft();
+    if (!hookSrc.startsWith("(") && !hookSrc.startsWith("function ")) {
+        hookSrc = `function ${hookSrc}`;
+    }
+    return `
+const fs = require("node:fs");
+const path = require("node:path");
+
+const bundleDir = path.dirname("${exports.BUNDLE_PATH}");
+if (!fs.existsSync(bundleDir)) {
+  fs.mkdirSync(bundleDir, { recursive: true });
+}
+const bundle = (${hookSrc})(${JSON.stringify(bundle)});
+fs.writeFileSync("${exports.BUNDLE_PATH}", JSON.stringify(bundle));
+`;
+}
+exports.genHookScript = genHookScript;

package/lib/frameworks/compose/driver/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDriver = exports.SUPPORTED_MODES = void 0;
+const local_1 = require("./local");
+const docker_1 = require("./docker");
+exports.SUPPORTED_MODES = ["local", "docker"];
+function getDriver(mode, app) {
+    if (mode === "local") {
+        return new local_1.LocalDriver(app);
+    }
+    else if (mode === "docker") {
+        return new docker_1.DockerDriver(app);
+    }
+    throw new Error(`Unsupported mode ${mode}`);
+}
+exports.getDriver = getDriver;

package/lib/frameworks/compose/driver/local.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalDriver = void 0;
+const fs = require("node:fs");
+const spawn = require("cross-spawn");
+const hooks_1 = require("./hooks");
+class LocalDriver {
+    constructor(spec) {
+        this.spec = spec;
+    }
+    execCmd(cmd, args) {
+        const ret = spawn.sync(cmd, args, {
+            env: Object.assign(Object.assign({}, process.env), this.spec.environmentVariables),
+            stdio: ["pipe", "inherit", "inherit"],
+        });
+        if (ret.error) {
+            throw ret.error;
+        }
+    }
+    install() {
+        const [cmd, ...args] = this.spec.installCommand.split(" ");
+        this.execCmd(cmd, args);
+    }
+    build() {
+        const [cmd, ...args] = this.spec.buildCommand.split(" ");
+        this.execCmd(cmd, args);
+    }
+    export(bundle) {
+    }
+    execHook(bundle, hook) {
+        const script = (0, hooks_1.genHookScript)(bundle, hook);
+        this.execCmd("node", ["-e", script]);
+        if (!fs.existsSync(hooks_1.BUNDLE_PATH)) {
+            console.warn(`Expected hook to generate app bundle at ${hooks_1.BUNDLE_PATH} but got nothing.`);
+            console.warn("Returning original bundle.");
+            return bundle;
+        }
+        const newBundle = JSON.parse(fs.readFileSync(hooks_1.BUNDLE_PATH, "utf8"));
+        return newBundle;
+    }
+}
+exports.LocalDriver = LocalDriver;

package/lib/frameworks/compose/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const driver_1 = require("./driver");
+const discover_1 = require("./discover");
+function compose(mode) {
+    let bundle = { version: "v1alpha" };
+    const spec = (0, discover_1.discover)();
+    const driver = (0, driver_1.getDriver)(mode, spec);
+    if (spec.startCommand) {
+        bundle.server = {
+            start: {
+                cmd: spec.startCommand.split(" "),
+            },
+        };
+    }
+    driver.install();
+    if (spec.afterInstall) {
+        bundle = driver.execHook(bundle, spec.afterInstall);
+    }
+    driver.build();
+    if (spec.afterBuild) {
+        bundle = driver.execHook(bundle, spec.afterBuild);
+    }
+    if (bundle.server) {
+        driver.export(bundle);
+    }
+    return bundle;
+}
+exports.compose = compose;

package/lib/frameworks/compose/interfaces.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driver = void 0;
+class Driver {
+    constructor(spec) {
+        this.spec = spec;
+    }
+    install() {
+        throw new Error("install() not implemented");
+    }
+    build() {
+        throw new Error("build() not implemented");
+    }
+    export(bundle) {
+        throw new Error("export() not implemented");
+    }
+    execHook(bundle, hook) {
+        throw new Error("execHook() not implemented");
+    }
+}
+exports.Driver = Driver;

package/lib/functions/secrets.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateEndpointSecret = exports.pruneAndDestroySecrets = exports.pruneSecrets = exports.inUse = exports.getSecretVersions = exports.of = exports.ensureSecret = exports.ensureValidKey = exports.labels = exports.isFirebaseManaged = void 0;
+exports.updateEndpointSecret = exports.pruneAndDestroySecrets = exports.pruneSecrets = exports.inUse = exports.getSecretVersions = exports.of = exports.ensureSecret = exports.ensureValidKey = exports.ensureApi = exports.labels = exports.isFirebaseManaged = void 0;
 const utils = require("../utils");
 const poller = require("../operation-poller");
 const gcf = require("../gcp/cloudfunctions");
+const ensureApiEnabled = require("../ensureApiEnabled");
 const secretManager_1 = require("../gcp/secretManager");
 const error_1 = require("../error");
 const utils_1 = require("../utils");
@@ -12,6 +13,7 @@ const env_1 = require("./env");
 const logger_1 = require("../logger");
 const api_1 = require("../api");
 const functional_1 = require("../functional");
+const projectUtils_1 = require("../projectUtils");
 const FIREBASE_MANAGED = "firebase-managed";
 function isFirebaseManaged(secret) {
     return Object.keys(secret.labels || []).includes(FIREBASE_MANAGED);
@@ -27,6 +29,11 @@ function toUpperSnakeCase(key) {
         .replace(/([a-z])([A-Z])/g, "$1_$2")
         .toUpperCase();
 }
+function ensureApi(options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    return ensureApiEnabled.ensure(projectId, "secretmanager.googleapis.com", "runtimeconfig", true);
+}
+exports.ensureApi = ensureApi;
 async function ensureValidKey(key, options) {
     const transformedKey = toUpperSnakeCase(key);
     if (transformedKey !== key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "12.3.0",
+  "version": "12.3.1",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {