firebase-tools 11.26.0 → 11.28.0

package/lib/firestore/{indexes-api.js → api-types.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateTtl = exports.State = exports.ArrayConfig = exports.Order = exports.QueryScope = exports.Mode = void 0;
+exports.DatabaseDeleteProtectionState = exports.DatabaseDeleteProtectionStateOption = exports.DatabaseType = exports.StateTtl = exports.State = exports.ArrayConfig = exports.Order = exports.QueryScope = exports.Mode = void 0;
 var Mode;
 (function (Mode) {
     Mode["ASCENDING"] = "ASCENDING";
@@ -33,3 +33,18 @@ var StateTtl;
     StateTtl["ACTIVE"] = "ACTIVE";
     StateTtl["NEEDS_REPAIR"] = "NEEDS_REPAIR";
 })(StateTtl = exports.StateTtl || (exports.StateTtl = {}));
+var DatabaseType;
+(function (DatabaseType) {
+    DatabaseType["DATASTORE_MODE"] = "DATASTORE_MODE";
+    DatabaseType["FIRESTORE_NATIVE"] = "FIRESTORE_NATIVE";
+})(DatabaseType = exports.DatabaseType || (exports.DatabaseType = {}));
+var DatabaseDeleteProtectionStateOption;
+(function (DatabaseDeleteProtectionStateOption) {
+    DatabaseDeleteProtectionStateOption["ENABLED"] = "ENABLED";
+    DatabaseDeleteProtectionStateOption["DISABLED"] = "DISABLED";
+})(DatabaseDeleteProtectionStateOption = exports.DatabaseDeleteProtectionStateOption || (exports.DatabaseDeleteProtectionStateOption = {}));
+var DatabaseDeleteProtectionState;
+(function (DatabaseDeleteProtectionState) {
+    DatabaseDeleteProtectionState["ENABLED"] = "DELETE_PROTECTION_ENABLED";
+    DatabaseDeleteProtectionState["DISABLED"] = "DELETE_PROTECTION_DISABLED";
+})(DatabaseDeleteProtectionState = exports.DatabaseDeleteProtectionState || (exports.DatabaseDeleteProtectionState = {}));

package/lib/firestore/{indexes.js → api.js}

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FirestoreIndexes = void 0;
+exports.FirestoreApi = void 0;
 const clc = require("colorette");
 const logger_1 = require("../logger");
 const utils = require("../utils");
 const validator = require("./validator");
-const API = require("./indexes-api");
-const sort = require("./indexes-sort");
+const types = require("./api-types");
+const sort = require("./api-sort");
 const util = require("./util");
 const prompt_1 = require("../prompt");
 const api_1 = require("../api");
+const error_1 = require("../error");
 const apiv2_1 = require("../apiv2");
-class FirestoreIndexes {
+class FirestoreApi {
     constructor() {
         this.apiClient = new apiv2_1.Client({ urlPrefix: api_1.firestoreOrigin, apiVersion: "v1" });
     }
@@ -193,6 +194,44 @@ class FirestoreIndexes {
             logger_1.logger.info(this.prettyIndexString(index));
         });
     }
+    prettyPrintDatabases(databases) {
+        if (databases.length === 0) {
+            logger_1.logger.info("No databases found.");
+            return;
+        }
+        const sortedDatabases = databases.sort(sort.compareApiDatabase);
+        const Table = require("cli-table");
+        const table = new Table({
+            head: ["Database Name"],
+            colWidths: [Math.max(...sortedDatabases.map((database) => database.name.length + 5), 20)],
+        });
+        table.push(...sortedDatabases.map((database) => [this.prettyDatabaseString(database)]));
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintDatabase(database) {
+        const Table = require("cli-table");
+        const table = new Table({
+            head: ["Field", "Value"],
+            colWidths: [25, Math.max(50, 5 + database.name.length)],
+        });
+        table.push(["Name", clc.yellow(database.name)], ["Create Time", clc.yellow(database.createTime)], ["Last Update Time", clc.yellow(database.updateTime)], ["Type", clc.yellow(database.type)], ["Location", clc.yellow(database.locationId)], ["Delete Protection State", clc.yellow(database.deleteProtectionState)]);
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintLocations(locations) {
+        if (locations.length === 0) {
+            logger_1.logger.info("No Locations Available");
+            return;
+        }
+        const Table = require("cli-table");
+        const table = new Table({
+            head: ["Display Name", "LocationId"],
+            colWidths: [20, 30],
+        });
+        table.push(...locations
+            .sort(sort.compareLocation)
+            .map((location) => [location.displayName, location.locationId]));
+        logger_1.logger.info(table.toString());
+    }
     printFieldOverrides(fields) {
         if (fields.length === 0) {
             logger_1.logger.info("None");
@@ -217,16 +256,16 @@ class FirestoreIndexes {
     validateIndex(index) {
         validator.assertHas(index, "collectionGroup");
         validator.assertHas(index, "queryScope");
-        validator.assertEnum(index, "queryScope", Object.keys(API.QueryScope));
+        validator.assertEnum(index, "queryScope", Object.keys(types.QueryScope));
         validator.assertHas(index, "fields");
         index.fields.forEach((field) => {
             validator.assertHas(field, "fieldPath");
             validator.assertHasOneOf(field, ["order", "arrayConfig"]);
             if (field.order) {
-                validator.assertEnum(field, "order", Object.keys(API.Order));
+                validator.assertEnum(field, "order", Object.keys(types.Order));
             }
             if (field.arrayConfig) {
-                validator.assertEnum(field, "arrayConfig", Object.keys(API.ArrayConfig));
+                validator.assertEnum(field, "arrayConfig", Object.keys(types.ArrayConfig));
             }
         });
     }
@@ -240,13 +279,13 @@ class FirestoreIndexes {
         field.indexes.forEach((index) => {
             validator.assertHasOneOf(index, ["arrayConfig", "order"]);
             if (index.arrayConfig) {
-                validator.assertEnum(index, "arrayConfig", Object.keys(API.ArrayConfig));
+                validator.assertEnum(index, "arrayConfig", Object.keys(types.ArrayConfig));
             }
             if (index.order) {
-                validator.assertEnum(index, "order", Object.keys(API.Order));
+                validator.assertEnum(index, "order", Object.keys(types.Order));
             }
             if (index.queryScope) {
-                validator.assertEnum(index, "queryScope", Object.keys(API.QueryScope));
+                validator.assertEnum(index, "queryScope", Object.keys(types.QueryScope));
             }
         });
     }
@@ -376,7 +415,7 @@ class FirestoreIndexes {
         result.indexes = spec.indexes.map((index) => {
             const i = {
                 collectionGroup: index.collectionGroup || index.collectionId,
-                queryScope: index.queryScope || API.QueryScope.COLLECTION,
+                queryScope: index.queryScope || types.QueryScope.COLLECTION,
                 fields: [],
             };
             if (index.fields) {
@@ -390,8 +429,8 @@ class FirestoreIndexes {
                     else if (field.arrayConfig) {
                         f.arrayConfig = field.arrayConfig;
                     }
-                    else if (field.mode === API.Mode.ARRAY_CONTAINS) {
-                        f.arrayConfig = API.ArrayConfig.CONTAINS;
+                    else if (field.mode === types.Mode.ARRAY_CONTAINS) {
+                        f.arrayConfig = types.ArrayConfig.CONTAINS;
                     }
                     else {
                         f.order = field.mode;
@@ -403,14 +442,78 @@ class FirestoreIndexes {
         });
         return result;
     }
+    async listDatabases(project) {
+        const url = `/projects/${project}/databases`;
+        const res = await this.apiClient.get(url);
+        const databases = res.body.databases;
+        if (!databases) {
+            return [];
+        }
+        return databases;
+    }
+    async locations(project) {
+        const url = `/projects/${project}/locations`;
+        const res = await this.apiClient.get(url);
+        const locations = res.body.locations;
+        if (!locations) {
+            return [];
+        }
+        return locations;
+    }
+    async getDatabase(project, databaseId) {
+        const url = `/projects/${project}/databases/${databaseId}`;
+        const res = await this.apiClient.get(url);
+        const database = res.body;
+        if (!database) {
+            throw new error_1.FirebaseError("Not found");
+        }
+        return database;
+    }
+    async createDatabase(project, databaseId, locationId, type, deleteProtectionState) {
+        const url = `/projects/${project}/databases`;
+        const payload = {
+            type,
+            locationId,
+            deleteProtectionState,
+        };
+        const options = { queryParams: { databaseId: databaseId } };
+        const res = await this.apiClient.post(url, payload, options);
+        const database = res.body.response;
+        if (!database) {
+            throw new error_1.FirebaseError("Not found");
+        }
+        return database;
+    }
+    async updateDatabase(project, databaseId, type, deleteProtectionState) {
+        const url = `/projects/${project}/databases/${databaseId}`;
+        const payload = {
+            type,
+            deleteProtectionState,
+        };
+        const res = await this.apiClient.patch(url, payload);
+        const database = res.body.response;
+        if (!database) {
+            throw new error_1.FirebaseError("Not found");
+        }
+        return database;
+    }
+    async deleteDatabase(project, databaseId) {
+        const url = `/projects/${project}/databases/${databaseId}`;
+        const res = await this.apiClient.delete(url);
+        const database = res.body.response;
+        if (!database) {
+            throw new error_1.FirebaseError("Not found");
+        }
+        return database;
+    }
     prettyIndexString(index, includeState = true) {
         let result = "";
         if (index.state && includeState) {
             const stateMsg = `[${index.state}] `;
-            if (index.state === API.State.READY) {
+            if (index.state === types.State.READY) {
                 result += clc.green(stateMsg);
             }
-            else if (index.state === API.State.CREATING) {
+            else if (index.state === types.State.CREATING) {
                 result += clc.yellow(stateMsg);
             }
             else {
@@ -429,6 +532,9 @@ class FirestoreIndexes {
         });
         return result;
     }
+    prettyDatabaseString(database) {
+        return clc.yellow(database.name);
+    }
     prettyFieldString(field) {
         let result = "";
         const parsedName = util.parseFieldName(field.name);
@@ -456,4 +562,4 @@ class FirestoreIndexes {
         return result;
     }
 }
-exports.FirestoreIndexes = FirestoreIndexes;
+exports.FirestoreApi = FirestoreApi;

package/lib/frameworks/astro/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDevModeHandle = exports.ɵcodegenFunctionsDirectory = exports.ɵcodegenPublicDirectory = exports.build = exports.discover = exports.type = exports.support = exports.name = void 0;
+const cross_spawn_1 = require("cross-spawn");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const __1 = require("..");
+const error_1 = require("../../error");
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+exports.name = "Astro";
+exports.support = "experimental";
+exports.type = 2;
+function getAstroVersion(cwd) {
+    var _a;
+    return (_a = (0, __1.findDependency)("astro", { cwd, depth: 0, omitDev: false })) === null || _a === void 0 ? void 0 : _a.version;
+}
+async function discover(dir) {
+    if (!(0, fs_extra_1.existsSync)((0, path_1.join)(dir, "package.json")))
+        return;
+    if (!getAstroVersion(dir))
+        return;
+    const { output, publicDir: publicDirectory } = await (0, utils_2.getConfig)(dir);
+    return {
+        mayWantBackend: output === "server",
+        publicDirectory,
+    };
+}
+exports.discover = discover;
+const DEFAULT_BUILD_SCRIPT = ["astro build"];
+async function build(cwd) {
+    const cli = (0, __1.getNodeModuleBin)("astro", cwd);
+    await (0, utils_1.warnIfCustomBuildScript)(cwd, exports.name, DEFAULT_BUILD_SCRIPT);
+    const { output, adapter } = await (0, utils_2.getConfig)(cwd);
+    if (output === "server" && (adapter === null || adapter === void 0 ? void 0 : adapter.name) !== "@astrojs/node") {
+        throw new error_1.FirebaseError("Deploying an Astro application with SSR on Firebase Hosting requires the @astrojs/node adapter.");
+    }
+    const build = (0, cross_spawn_1.sync)(cli, ["build"], { cwd, stdio: "inherit" });
+    if (build.status)
+        throw new error_1.FirebaseError("Unable to build your Astro app");
+    return { wantsBackend: output === "server" };
+}
+exports.build = build;
+async function ɵcodegenPublicDirectory(root, dest) {
+    const { outDir, output } = await (0, utils_2.getConfig)(root);
+    const assetPath = (0, path_1.join)(root, outDir, output === "server" ? "client" : "");
+    await (0, fs_extra_1.copy)(assetPath, dest);
+}
+exports.ɵcodegenPublicDirectory = ɵcodegenPublicDirectory;
+async function ɵcodegenFunctionsDirectory(sourceDir, destDir) {
+    const { outDir } = await (0, utils_2.getConfig)(sourceDir);
+    const packageJson = await (0, utils_1.readJSON)((0, path_1.join)(sourceDir, "package.json"));
+    await (0, fs_extra_1.copy)((0, path_1.join)(sourceDir, outDir, "server"), (0, path_1.join)(destDir));
+    return {
+        packageJson,
+        bootstrapScript: (0, utils_2.getBootstrapScript)(),
+    };
+}
+exports.ɵcodegenFunctionsDirectory = ɵcodegenFunctionsDirectory;
+async function getDevModeHandle(cwd) {
+    const host = new Promise((resolve) => {
+        const cli = (0, __1.getNodeModuleBin)("astro", cwd);
+        const serve = (0, cross_spawn_1.spawn)(cli, ["dev"], { cwd });
+        serve.stdout.on("data", (data) => {
+            process.stdout.write(data);
+            const match = data.toString().match(/(http:\/\/.+:\d+)/);
+            if (match)
+                resolve(match[1]);
+        });
+        serve.stderr.on("data", (data) => {
+            process.stderr.write(data);
+        });
+    });
+    return (0, utils_1.simpleProxy)(await host);
+}
+exports.getDevModeHandle = getDevModeHandle;

package/lib/frameworks/astro/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = exports.getBootstrapScript = void 0;
+const path_1 = require("path");
+const { dynamicImport } = require(true && "../../dynamicImport");
+function getBootstrapScript() {
+    return `const entry = import('./entry.mjs');\nexport const handle = async (req, res) => (await entry).handler(req, res)`;
+}
+exports.getBootstrapScript = getBootstrapScript;
+async function getConfig(cwd) {
+    const astroDirectory = (0, path_1.dirname)(require.resolve("astro/package.json", { paths: [cwd] }));
+    const { openConfig } = await dynamicImport((0, path_1.join)(astroDirectory, "dist", "core", "config", "config.js"));
+    const logging = undefined;
+    const { astroConfig: config } = await openConfig({ cmd: "build", cwd, logging });
+    return {
+        outDir: (0, path_1.relative)(cwd, config.outDir.pathname),
+        publicDir: (0, path_1.relative)(cwd, config.publicDir.pathname),
+        output: config.output,
+        adapter: config.adapter,
+    };
+}
+exports.getConfig = getConfig;

package/lib/frameworks/nuxt/index.js

@@ -1,32 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ɵcodegenFunctionsDirectory = exports.ɵcodegenPublicDirectory = exports.build = exports.discover = exports.type = exports.support = exports.name = void 0;
+exports.getConfig = exports.getDevModeHandle = exports.ɵcodegenFunctionsDirectory = exports.ɵcodegenPublicDirectory = exports.build = exports.discover = exports.type = exports.support = exports.name = void 0;
 const fs_extra_1 = require("fs-extra");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const semver_1 = require("semver");
+const cross_spawn_1 = require("cross-spawn");
 const __1 = require("..");
 const utils_1 = require("../utils");
+const utils_2 = require("./utils");
 exports.name = "Nuxt";
 exports.support = "experimental";
 exports.type = 4;
-const utils_2 = require("./utils");
-const DEFAULT_BUILD_SCRIPT = ["nuxt build"];
+const utils_3 = require("./utils");
+const DEFAULT_BUILD_SCRIPT = ["nuxt build", "nuxi build"];
 async function discover(dir) {
     if (!(await (0, fs_extra_1.pathExists)((0, path_1.join)(dir, "package.json"))))
         return;
-    const nuxtDependency = (0, __1.findDependency)("nuxt", {
-        cwd: dir,
-        depth: 0,
-        omitDev: false,
-    });
-    const version = nuxtDependency === null || nuxtDependency === void 0 ? void 0 : nuxtDependency.version;
-    const anyConfigFileExists = await (0, utils_2.nuxtConfigFilesExist)(dir);
-    if (!anyConfigFileExists && !nuxtDependency)
+    const anyConfigFileExists = await (0, utils_3.nuxtConfigFilesExist)(dir);
+    const nuxtVersion = (0, utils_2.getNuxtVersion)(dir);
+    if (!anyConfigFileExists && !nuxtVersion)
+        return;
+    if (nuxtVersion && (0, semver_1.lt)(nuxtVersion, "3.0.0-0"))
         return;
-    if (version && (0, semver_1.gte)(version, "3.0.0-0"))
-        return { mayWantBackend: true };
-    return;
+    const { dir: { public: publicDirectory }, } = await getConfig(dir);
+    return { publicDirectory, mayWantBackend: true };
 }
 exports.discover = discover;
 async function build(root) {
@@ -60,3 +58,25 @@ async function ɵcodegenFunctionsDirectory(sourceDir, destDir) {
     return { packageJson: Object.assign(Object.assign({}, packageJson), outputPackageJson), frameworksEntry: "nuxt3" };
 }
 exports.ɵcodegenFunctionsDirectory = ɵcodegenFunctionsDirectory;
+async function getDevModeHandle(cwd) {
+    const host = new Promise((resolve) => {
+        const cli = (0, __1.getNodeModuleBin)("nuxt", cwd);
+        const serve = (0, cross_spawn_1.spawn)(cli, ["dev"], { cwd: cwd });
+        serve.stdout.on("data", (data) => {
+            process.stdout.write(data);
+            const match = data.toString().match(/(http:\/\/.+:\d+)/);
+            if (match)
+                resolve(match[1]);
+        });
+        serve.stderr.on("data", (data) => {
+            process.stderr.write(data);
+        });
+    });
+    return (0, utils_1.simpleProxy)(await host);
+}
+exports.getDevModeHandle = getDevModeHandle;
+async function getConfig(dir) {
+    const { loadNuxtConfig } = await (0, __1.relativeRequire)(dir, "@nuxt/kit");
+    return await loadNuxtConfig(dir);
+}
+exports.getConfig = getConfig;

package/lib/frameworks/nuxt/utils.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nuxtConfigFilesExist = void 0;
+exports.nuxtConfigFilesExist = exports.getNuxtVersion = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
+const __1 = require("..");
+function getNuxtVersion(cwd) {
+    var _a;
+    return (_a = (0, __1.findDependency)("nuxt", {
+        cwd,
+        depth: 0,
+        omitDev: false,
+    })) === null || _a === void 0 ? void 0 : _a.version;
+}
+exports.getNuxtVersion = getNuxtVersion;
 async function nuxtConfigFilesExist(dir) {
     const configFilesExist = await Promise.all([
         (0, fs_extra_1.pathExists)((0, path_1.join)(dir, "nuxt.config.js")),

package/lib/frameworks/nuxt2/index.js

@@ -13,18 +13,12 @@ exports.type = 2;
 async function discover(dir) {
     if (!(await (0, fs_extra_1.pathExists)((0, path_1.join)(dir, "package.json"))))
         return;
-    const nuxtDependency = (0, __1.findDependency)("nuxt", {
-        cwd: dir,
-        depth: 0,
-        omitDev: false,
-    });
-    const version = nuxtDependency === null || nuxtDependency === void 0 ? void 0 : nuxtDependency.version;
+    const nuxtVersion = (0, utils_1.getNuxtVersion)(dir);
     const anyConfigFileExists = await (0, utils_1.nuxtConfigFilesExist)(dir);
-    if (!anyConfigFileExists && !nuxtDependency)
+    if (!anyConfigFileExists && !nuxtVersion)
         return;
-    if (version && (0, semver_1.lt)(version, "3.0.0-0"))
+    if (nuxtVersion && (0, semver_1.lt)(nuxtVersion, "3.0.0-0"))
         return { mayWantBackend: true };
-    return;
 }
 exports.discover = discover;
 async function getNuxtApp(cwd) {

package/lib/gcp/cloudfunctions.js

@@ -44,6 +44,7 @@ exports.generateUploadUrl = generateUploadUrl;
 async function createFunction(cloudFunction) {
     const apiPath = cloudFunction.name.substring(0, cloudFunction.name.lastIndexOf("/"));
     const endpoint = `/${apiPath}`;
+    cloudFunction.buildEnvironmentVariables = Object.assign(Object.assign({}, cloudFunction.buildEnvironmentVariables), { GOOGLE_NODE_RUN_SCRIPTS: "" });
     try {
         const res = await client.post(endpoint, cloudFunction);
         return {
@@ -131,6 +132,8 @@ exports.setInvokerUpdate = setInvokerUpdate;
 async function updateFunction(cloudFunction) {
     const endpoint = `/${cloudFunction.name}`;
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "environmentVariables", "secretEnvironmentVariables");
+    cloudFunction.buildEnvironmentVariables = Object.assign(Object.assign({}, cloudFunction.buildEnvironmentVariables), { GOOGLE_NODE_RUN_SCRIPTS: "" });
+    fieldMasks.push("buildEnvironmentVariables");
     try {
         const res = await client.patch(endpoint, cloudFunction, {
             queryParams: {

package/lib/gcp/cloudfunctionsv2.js

@@ -80,6 +80,7 @@ exports.generateUploadUrl = generateUploadUrl;
 async function createFunction(cloudFunction) {
     const components = cloudFunction.name.split("/");
     const functionId = components.splice(-1, 1)[0];
+    cloudFunction.buildConfig.environmentVariables = Object.assign(Object.assign({}, cloudFunction.buildConfig.environmentVariables), { GOOGLE_NODE_RUN_SCRIPTS: "" });
     try {
         const res = await client.post(components.join("/"), cloudFunction, { queryParams: { functionId } });
         return res.body;
@@ -133,6 +134,8 @@ async function listFunctionsInternal(projectId, region) {
 }
 async function updateFunction(cloudFunction) {
     const fieldMasks = proto.fieldMasks(cloudFunction, "labels", "serviceConfig.environmentVariables", "serviceConfig.secretEnvironmentVariables");
+    cloudFunction.buildConfig.environmentVariables = Object.assign(Object.assign({}, cloudFunction.buildConfig.environmentVariables), { GOOGLE_NODE_RUN_SCRIPTS: "" });
+    fieldMasks.push("buildConfig.buildEnvironmentVariables");
     try {
         const queryParams = {
             updateMask: fieldMasks.join(","),
@@ -322,39 +325,49 @@ function endpointFromFunction(gcfFunction) {
     }
     const endpoint = Object.assign(Object.assign({ platform: "gcfv2", id,
         project,
-        region }, trigger), { entryPoint: gcfFunction.buildConfig.entryPoint, runtime: gcfFunction.buildConfig.runtime, uri: gcfFunction.serviceConfig.uri });
-    proto.copyIfPresent(endpoint, gcfFunction.serviceConfig, "ingressSettings", "environmentVariables", "secretEnvironmentVariables", "timeoutSeconds");
-    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "serviceAccount", "serviceAccountEmail");
-    proto.convertIfPresent(endpoint, gcfFunction.serviceConfig, "availableMemoryMb", "availableMemory", (prod) => {
-        if (prod === null) {
-            logger_1.logger.debug("Prod should always return a valid memory amount");
-            return prod;
+        region }, trigger), { entryPoint: gcfFunction.buildConfig.entryPoint, runtime: gcfFunction.buildConfig.runtime });
+    if (gcfFunction.serviceConfig) {
+        proto.copyIfPresent(endpoint, gcfFunction.serviceConfig, "ingressSettings", "environmentVariables", "secretEnvironmentVariables", "timeoutSeconds", "uri");
+        proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "serviceAccount", "serviceAccountEmail");
+        proto.convertIfPresent(endpoint, gcfFunction.serviceConfig, "availableMemoryMb", "availableMemory", (prod) => {
+            if (prod === null) {
+                logger_1.logger.debug("Prod should always return a valid memory amount");
+                return prod;
+            }
+            const mem = mebibytes(prod);
+            if (!backend.isValidMemoryOption(mem)) {
+                logger_1.logger.warn("Converting a function to an endpoint with an invalid memory option", mem);
+            }
+            return mem;
+        });
+        proto.convertIfPresent(endpoint, gcfFunction.serviceConfig, "cpu", "availableCpu", (cpu) => {
+            let cpuVal = Number(cpu);
+            if (Number.isNaN(cpuVal)) {
+                cpuVal = null;
+            }
+            return cpuVal;
+        });
+        proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "minInstances", "minInstanceCount");
+        proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "maxInstances", "maxInstanceCount");
+        proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "concurrency", "maxInstanceRequestConcurrency");
+        proto.copyIfPresent(endpoint, gcfFunction, "labels");
+        if (gcfFunction.serviceConfig.vpcConnector) {
+            endpoint.vpc = { connector: gcfFunction.serviceConfig.vpcConnector };
+            proto.renameIfPresent(endpoint.vpc, gcfFunction.serviceConfig, "egressSettings", "vpcConnectorEgressSettings");
         }
-        const mem = mebibytes(prod);
-        if (!backend.isValidMemoryOption(mem)) {
-            logger_1.logger.warn("Converting a function to an endpoint with an invalid memory option", mem);
+        const serviceName = gcfFunction.serviceConfig.service;
+        if (!serviceName) {
+            logger_1.logger.debug("Got a v2 function without a service name." +
+                "Maybe we've migrated to using the v2 API everywhere and missed this code");
+        }
+        else {
+            endpoint.runServiceId = utils.last(serviceName.split("/"));
         }
-        return mem;
-    });
-    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "minInstances", "minInstanceCount");
-    proto.renameIfPresent(endpoint, gcfFunction.serviceConfig, "maxInstances", "maxInstanceCount");
-    proto.copyIfPresent(endpoint, gcfFunction, "labels");
-    if (gcfFunction.serviceConfig.vpcConnector) {
-        endpoint.vpc = { connector: gcfFunction.serviceConfig.vpcConnector };
-        proto.renameIfPresent(endpoint.vpc, gcfFunction.serviceConfig, "egressSettings", "vpcConnectorEgressSettings");
     }
     endpoint.codebase = ((_e = gcfFunction.labels) === null || _e === void 0 ? void 0 : _e[constants_1.CODEBASE_LABEL]) || projectConfig.DEFAULT_CODEBASE;
     if ((_f = gcfFunction.labels) === null || _f === void 0 ? void 0 : _f[constants_1.HASH_LABEL]) {
         endpoint.hash = gcfFunction.labels[constants_1.HASH_LABEL];
     }
-    const serviceName = gcfFunction.serviceConfig.service;
-    if (!serviceName) {
-        logger_1.logger.debug("Got a v2 function without a service name." +
-            "Maybe we've migrated to using the v2 API everywhere and missed this code");
-    }
-    else {
-        endpoint.runServiceId = utils.last(serviceName.split("/"));
-    }
     return endpoint;
 }
 exports.endpointFromFunction = endpointFromFunction;

package/lib/init/features/extensions/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doSetup = void 0;
+const requirePermissions_1 = require("../../../requirePermissions");
+const ensureApiEnabled_1 = require("../../../ensureApiEnabled");
+const manifest = require("../../../extensions/manifest");
+async function doSetup(setup, config, options) {
+    var _a, _b;
+    const projectId = (_b = (_a = setup === null || setup === void 0 ? void 0 : setup.rcfile) === null || _a === void 0 ? void 0 : _a.projects) === null || _b === void 0 ? void 0 : _b.default;
+    if (projectId) {
+        await (0, requirePermissions_1.requirePermissions)(Object.assign(Object.assign({}, options), { project: projectId }));
+        await Promise.all([(0, ensureApiEnabled_1.ensure)(projectId, "firebaseextensions.googleapis.com", "unused", true)]);
+    }
+    return manifest.writeEmptyManifest(config, options);
+}
+exports.doSetup = doSetup;

package/lib/init/features/firestore/indexes.js

@@ -4,11 +4,11 @@ exports.initIndexes = void 0;
 const clc = require("colorette");
 const fs = require("fs");
 const error_1 = require("../../../error");
-const iv2 = require("../../../firestore/indexes");
+const api = require("../../../firestore/api");
 const fsutils = require("../../../fsutils");
 const prompt_1 = require("../../../prompt");
 const logger_1 = require("../../../logger");
-const indexes = new iv2.FirestoreIndexes();
+const indexes = new api.FirestoreApi();
 const INDEXES_TEMPLATE = fs.readFileSync(__dirname + "/../../../../templates/init/firestore/firestore.indexes.json", "utf8");
 function initIndexes(setup, config) {
     logger_1.logger.info();

package/lib/init/features/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hostingGithub = exports.remoteconfig = exports.project = exports.emulators = exports.storage = exports.hosting = exports.functions = exports.firestore = exports.database = exports.account = void 0;
+exports.hostingGithub = exports.remoteconfig = exports.project = exports.extensions = exports.emulators = exports.storage = exports.hosting = exports.functions = exports.firestore = exports.database = exports.account = void 0;
 var account_1 = require("./account");
 Object.defineProperty(exports, "account", { enumerable: true, get: function () { return account_1.doSetup; } });
 var database_1 = require("./database");
@@ -15,6 +15,8 @@ var storage_1 = require("./storage");
 Object.defineProperty(exports, "storage", { enumerable: true, get: function () { return storage_1.doSetup; } });
 var emulators_1 = require("./emulators");
 Object.defineProperty(exports, "emulators", { enumerable: true, get: function () { return emulators_1.doSetup; } });
+var extensions_1 = require("./extensions");
+Object.defineProperty(exports, "extensions", { enumerable: true, get: function () { return extensions_1.doSetup; } });
 var project_1 = require("./project");
 Object.defineProperty(exports, "project", { enumerable: true, get: function () { return project_1.doSetup; } });
 var remoteconfig_1 = require("./remoteconfig");

package/lib/init/index.js

@@ -14,6 +14,7 @@ const featureFns = new Map([
     ["hosting", features.hosting],
     ["storage", features.storage],
     ["emulators", features.emulators],
+    ["extensions", features.extensions],
     ["project", features.project],
     ["remoteconfig", features.remoteconfig],
     ["hosting:github", features.hostingGithub],