firebase-tools 11.3.0 → 11.4.0

package/lib/apiv2.js

@@ -15,6 +15,7 @@ const responseToError_1 = require("./responseToError");
 const FormData = require("form-data");
 const pkg = require("../package.json");
 const CLI_VERSION = pkg.version;
+const GOOG_QUOTA_USER = "x-goog-quota-user";
 let accessToken = "";
 let refreshToken = "";
 function setRefreshToken(token = "") {
@@ -309,6 +310,10 @@ class Client {
         }
         const logURL = this.requestURL(options);
         logger_1.logger.debug(`>>> [apiv2][query] ${options.method} ${logURL} ${queryParamsLog}`);
+        const headers = options.headers;
+        if (headers && headers.has(GOOG_QUOTA_USER)) {
+            logger_1.logger.debug(`>>> [apiv2][(partial)header] ${options.method} ${logURL} x-goog-quota-user=${headers.get(GOOG_QUOTA_USER) || ""}`);
+        }
         if (options.body !== undefined) {
             let logBody = "[omitted]";
             if (!((_b = options.skipLog) === null || _b === void 0 ? void 0 : _b.body)) {

package/lib/checkValidTargetFilters.js

@@ -19,6 +19,7 @@ function targetsHaveFilters(...targets) {
 function targetsHaveNoFilters(...targets) {
     return targets.some((t) => !t.includes(":"));
 }
+const FILTERABLE_TARGETS = new Set(["hosting", "functions", "firestore", "storage", "database"]);
 async function checkValidTargetFilters(options) {
     const only = !options.only ? [] : options.only.split(",");
     return new Promise((resolve, reject) => {
@@ -28,10 +29,10 @@ async function checkValidTargetFilters(options) {
         if (options.except) {
             return reject(new error_1.FirebaseError("Cannot specify both --only and --except"));
         }
-        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !["hosting", "functions", "firestore"].includes(t));
+        const nonFilteredTypes = deploy_1.VALID_DEPLOY_TARGETS.filter((t) => !FILTERABLE_TARGETS.has(t));
         const targetsForNonFilteredTypes = targetsForTypes(only, ...nonFilteredTypes);
         if (targetsForNonFilteredTypes.length && targetsHaveFilters(...targetsForNonFilteredTypes)) {
-            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions, hosting, and firestore"));
+            return reject(new error_1.FirebaseError("Filters specified with colons (e.g. --only functions:func1,functions:func2) are only supported for functions, hosting, storage, and firestore"));
         }
         const targetsForFunctions = targetsForTypes(only, "functions");
         if (targetsForFunctions.length &&

package/lib/database/rulesConfig.js

@@ -19,6 +19,23 @@ function getRulesConfig(projectId, options) {
     if (dbConfig === undefined) {
         return [];
     }
+    const rc = options.rc;
+    let allDatabases = !options.only;
+    const onlyDatabases = new Set();
+    if (options.only) {
+        const split = options.only.split(",");
+        if (split.includes("database")) {
+            allDatabases = true;
+        }
+        else {
+            for (const value of split) {
+                if (value.startsWith("database:")) {
+                    const target = value.split(":")[1];
+                    onlyDatabases.add(target);
+                }
+            }
+        }
+    }
     if (!Array.isArray(dbConfig)) {
         if (dbConfig && dbConfig.rules) {
             utils.assertIsStringOrUndefined(options.instance);
@@ -31,22 +48,32 @@ function getRulesConfig(projectId, options) {
         }
     }
     const results = [];
-    const rc = options.rc;
     for (const c of dbConfig) {
-        if (c.target) {
-            rc.requireTarget(projectId, "database", c.target);
-            const instances = rc.target(projectId, "database", c.target);
-            for (const i of instances) {
-                results.push({ instance: i, rules: c.rules });
+        const { instance, target } = c;
+        if (target) {
+            if (allDatabases || onlyDatabases.has(target)) {
+                rc.requireTarget(projectId, "database", target);
+                const instances = rc.target(projectId, "database", target);
+                for (const i of instances) {
+                    results.push({ instance: i, rules: c.rules });
+                }
+                onlyDatabases.delete(target);
             }
         }
-        else if (c.instance) {
-            results.push(c);
+        else if (instance) {
+            if (allDatabases) {
+                results.push(c);
+            }
         }
         else {
             throw new error_1.FirebaseError('Must supply either "target" or "instance" in database config');
         }
     }
+    if (!allDatabases && onlyDatabases.size !== 0) {
+        throw new error_1.FirebaseError(`Could not find configurations in firebase.json for the following database targets: ${[
+            ...onlyDatabases,
+        ].join(", ")}`);
+    }
     return results;
 }
 exports.getRulesConfig = getRulesConfig;

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

@@ -67,6 +67,10 @@ async function release(context, options, payload) {
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };
+        logger_1.logger.debug("Functions deploy failed.");
+        for (const error of allErrors) {
+            logger_1.logger.debug(JSON.stringify(error, null, 2));
+        }
         throw new error_1.FirebaseError("There was an error deploying functions", Object.assign(Object.assign({}, opts), { exit: 2 }));
     }
 }

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -28,10 +28,12 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
     (0, parsing_1.requireKeys)("", manifest, "endpoints");
     (0, parsing_1.assertKeyTypes)("", manifest, {
         specVersion: "string",
+        params: "array",
         requiredAPIs: "array",
         endpoints: "object",
     });
     const bd = build.empty();
+    bd.params = manifest.params || [];
     bd.requiredAPIs = parseRequiredAPIs(manifest);
     for (const id of Object.keys(manifest.endpoints)) {
         const me = manifest.endpoints[id];
@@ -49,6 +51,7 @@ function backendFromV1Alpha1(yaml, project, region, runtime) {
     (0, parsing_1.requireKeys)("", manifest, "endpoints");
     (0, parsing_1.assertKeyTypes)("", manifest, {
         specVersion: "string",
+        params: "array",
         requiredAPIs: "array",
         endpoints: "object",
     });

package/lib/deploy/hosting/convertConfig.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertConfig = void 0;
 const error_1 = require("../../error");
 const backend_1 = require("../functions/backend");
+const backend = require("../functions/backend");
 function has(obj, k) {
     return obj[k] !== undefined;
 }
@@ -39,24 +40,66 @@ async function convertConfig(context, payload, config, finalize) {
     if (!config) {
         return out;
     }
-    const endpointBeingDeployed = (serviceId, region = "us-central1") => {
-        var _a;
+    const endpointFromBackend = (targetBackend, functionsEndpointInfo) => {
+        const backendsForId = backend.allEndpoints(targetBackend).filter((endpoint) => {
+            return endpoint.id === functionsEndpointInfo.serviceId;
+        });
+        const matchingBackends = backendsForId.filter((endpoint) => {
+            return ((!functionsEndpointInfo.region || endpoint.region === functionsEndpointInfo.region) &&
+                (!functionsEndpointInfo.platform || endpoint.platform === functionsEndpointInfo.platform));
+        });
+        if (matchingBackends.length > 1) {
+            throw new error_1.FirebaseError(`More than one backend found for function name: ${functionsEndpointInfo.serviceId}. If the function is deployed in multiple regions, you must specify a region.`);
+        }
+        if (matchingBackends.length === 1) {
+            const endpoint = matchingBackends[0];
+            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint)) {
+                return endpoint;
+            }
+        }
+        return;
+    };
+    const endpointBeingDeployed = (functionsEndpointInfo) => {
         for (const { wantBackend } of Object.values(payload.functions || {})) {
-            const endpoint = (_a = wantBackend === null || wantBackend === void 0 ? void 0 : wantBackend.endpoints[region]) === null || _a === void 0 ? void 0 : _a[serviceId];
-            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint) && endpoint.platform === "gcfv2")
+            if (!wantBackend) {
+                continue;
+            }
+            const endpoint = endpointFromBackend(wantBackend, functionsEndpointInfo);
+            if (endpoint) {
                 return endpoint;
+            }
         }
-        return undefined;
+        return;
     };
-    const matchingEndpoint = async (serviceId, region = "us-central1") => {
-        const pendingEndpoint = endpointBeingDeployed(serviceId, region);
+    const matchingEndpoint = async (functionsEndpointInfo) => {
+        const pendingEndpoint = endpointBeingDeployed(functionsEndpointInfo);
         if (pendingEndpoint)
             return pendingEndpoint;
         const backend = await (0, backend_1.existingBackend)(context);
         return (0, backend_1.allEndpoints)(backend).find((it) => (0, backend_1.isHttpsTriggered)(it) &&
-            it.platform === "gcfv2" &&
-            it.id === serviceId &&
-            it.region === region);
+            it.id === functionsEndpointInfo.serviceId &&
+            (!functionsEndpointInfo.platform || it.platform === functionsEndpointInfo.platform) &&
+            (!functionsEndpointInfo.region || it.region === functionsEndpointInfo.region));
+    };
+    const findEndpointWithValidRegion = async (rewrite, context) => {
+        if ("function" in rewrite) {
+            const foundEndpointToBeDeployed = endpointBeingDeployed({
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (foundEndpointToBeDeployed) {
+                return foundEndpointToBeDeployed;
+            }
+            const existingBackend = await backend.existingBackend(context);
+            const endpointAlreadyDeployed = endpointFromBackend(existingBackend, {
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (endpointAlreadyDeployed) {
+                return endpointAlreadyDeployed;
+            }
+        }
+        return;
     };
     if (Array.isArray(config.rewrites)) {
         out.rewrites = [];
@@ -66,19 +109,30 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.path = rewrite.destination;
             }
             else if ("function" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.function, rewrite.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.function,
+                        platform: "gcfv2",
+                        region: rewrite.region,
+                    })) {
                     continue;
-                const endpoint = await matchingEndpoint(rewrite.function, rewrite.region);
+                }
+                const endpoint = await matchingEndpoint({
+                    serviceId: rewrite.function,
+                    platform: "gcfv2",
+                    region: rewrite.region,
+                });
                 if (endpoint) {
                     vRewrite.run = { serviceId: endpoint.id, region: endpoint.region };
                 }
                 else {
                     vRewrite.function = rewrite.function;
-                    if (rewrite.region) {
-                        vRewrite.functionRegion = rewrite.region;
+                    const foundEndpoint = await findEndpointWithValidRegion(rewrite, context);
+                    if (foundEndpoint) {
+                        vRewrite.functionRegion = foundEndpoint.region;
                     }
                     else {
-                        vRewrite.functionRegion = "us-central1";
+                        throw new error_1.FirebaseError(`Unable to find a valid endpoint for function ${vRewrite.function}`);
                     }
                 }
             }
@@ -86,8 +140,14 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.dynamicLinks = rewrite.dynamicLinks;
             }
             else if ("run" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.run.serviceId, rewrite.run.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.run.serviceId,
+                        platform: "gcfv2",
+                        region: rewrite.run.region,
+                    })) {
                     continue;
+                }
                 vRewrite.run = Object.assign({ region: "us-central1" }, rewrite.run);
             }
             out.rewrites.push(vRewrite);

package/lib/deploy/index.js

@@ -52,7 +52,7 @@ const deploy = async function (targetNames, options, customContext = {}) {
     for (const targetName of targetNames) {
         const target = TARGETS[targetName];
         if (!target) {
-            return Promise.reject(new error_1.FirebaseError((0, cli_color_1.bold)(targetName) + " is not a valid deploy target", { exit: 1 }));
+            return Promise.reject(new error_1.FirebaseError(`${(0, cli_color_1.bold)(targetName)} is not a valid deploy target`));
         }
         predeploys.push((0, lifecycleHooks_1.lifecycleHooks)(targetName, "predeploy"));
         prepares.push(target.prepare);

package/lib/deploy/storage/prepare.js

@@ -3,25 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require("lodash");
 const gcp = require("../../gcp");
 const rulesDeploy_1 = require("../../rulesDeploy");
+const error_1 = require("../../error");
 async function default_1(context, options) {
     let rulesConfig = options.config.get("storage");
     if (!rulesConfig) {
         return;
     }
+    const onlyTargets = new Set();
+    let allStorage = !options.only;
+    if (options.only) {
+        const split = options.only.split(",");
+        if (split.includes("storage")) {
+            allStorage = true;
+        }
+        else {
+            for (const value of split) {
+                if (value.startsWith("storage:")) {
+                    onlyTargets.add(value.split(":")[1]);
+                }
+            }
+        }
+    }
     _.set(context, "storage.rules", rulesConfig);
     const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.FIREBASE_STORAGE);
     _.set(context, "storage.rulesDeploy", rulesDeploy);
-    if (typeof rulesConfig === "object" && rulesConfig !== null) {
+    if (!Array.isArray(rulesConfig)) {
         const defaultBucket = await gcp.storage.getDefaultBucket(options.project);
         rulesConfig = [Object.assign(rulesConfig, { bucket: defaultBucket })];
         _.set(context, "storage.rules", rulesConfig);
     }
-    rulesConfig.forEach((ruleConfig) => {
-        if (ruleConfig.target) {
-            options.rc.requireTarget(context.projectId, "storage", ruleConfig.target);
+    for (const ruleConfig of rulesConfig) {
+        const target = ruleConfig.target;
+        if (target) {
+            options.rc.requireTarget(context.projectId, "storage", target);
         }
-        rulesDeploy.addFile(ruleConfig.rules);
-    });
+        if (allStorage || onlyTargets.has(target)) {
+            rulesDeploy.addFile(ruleConfig.rules);
+            onlyTargets.delete(target);
+        }
+    }
+    if (!allStorage && onlyTargets.size !== 0) {
+        throw new error_1.FirebaseError(`Could not find rules for the following storage targets: ${[...onlyTargets].join(", ")}`);
+    }
     await rulesDeploy.compile();
 }
 exports.default = default_1;

package/lib/emulator/controller.js

@@ -301,7 +301,6 @@ async function startAll(options, showUI = true) {
         const extensionsBackends = await extensionEmulator.getExtensionBackends();
         const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
         emulatableBackends.push(...filteredExtensionsBackends);
-        void (0, track_1.track)("Emulator Run", types_1.Emulators.EXTENSIONS);
         await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {

package/lib/emulator/functionsEmulator.js

@@ -646,6 +646,9 @@ class FunctionsEmulator {
         envs.GCLOUD_PROJECT = this.args.projectId;
         envs.K_REVISION = "1";
         envs.PORT = "80";
+        if (trigger === null || trigger === void 0 ? void 0 : trigger.timeoutSeconds) {
+            envs.FUNCTIONS_EMULATOR_TIMEOUT_SECONDS = trigger.timeoutSeconds.toString();
+        }
         if (trigger) {
             const target = trigger.entryPoint;
             envs.FUNCTION_TARGET = target;

package/lib/emulator/functionsEmulatorRuntime.js

@@ -537,8 +537,8 @@ async function processHTTPS(trigger) {
                 rejectEphemeralServer(err);
             }
         });
-        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
         server = ephemeralServer.listen(process.env.PORT);
+        logDebug(`Listening to port: ${process.env.PORT}`);
         server.on("error", rejectEphemeralServer);
     });
 }

package/lib/functions/env.js

@@ -51,6 +51,17 @@ const ESCAPE_SEQUENCES_TO_CHARACTERS = {
     "\\'": "'",
     '\\"': '"',
 };
+const ALL_ESCAPE_SEQUENCES_RE = /\\[nrtv\\'"]/g;
+const CHARACTERS_TO_ESCAPE_SEQUENCES = {
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\v": "\\v",
+    "\\": "\\\\",
+    "'": "\\'",
+    '"': '\\"',
+};
+const ALL_ESCAPABLE_CHARACTERS_RE = /[\n\r\t\v\\'"]/g;
 function parse(data) {
     const envs = {};
     const errors = [];
@@ -63,7 +74,7 @@ function parse(data) {
         if ((quotesMatch = /^(["'])(.*)\1$/ms.exec(v)) != null) {
             v = quotesMatch[2];
             if (quotesMatch[1] === '"') {
-                v = v.replace(/\\[nrtv\\'"]/g, (match) => ESCAPE_SEQUENCES_TO_CHARACTERS[match]);
+                v = v.replace(ALL_ESCAPE_SEQUENCES_RE, (match) => ESCAPE_SEQUENCES_TO_CHARACTERS[match]);
             }
         }
         envs[k] = v;
@@ -146,9 +157,43 @@ function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, })
 }
 exports.hasUserEnvs = hasUserEnvs;
 function writeUserEnvs(toWrite, envOpts) {
-    throw new error_1.FirebaseError("Persisting user-defined parameters to .env files is not yet implemented.");
+    if (Object.keys(toWrite).length === 0) {
+        return;
+    }
+    const { functionsSource, projectId, projectAlias, isEmulator } = envOpts;
+    let envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
+    if (envFiles.length === 0) {
+        envFiles = [createEnvFile(envOpts)];
+    }
+    const currentEnvs = loadUserEnvs(envOpts);
+    for (const k of Object.keys(toWrite)) {
+        validateKey(k);
+        if (currentEnvs.hasOwnProperty(k)) {
+            throw new error_1.FirebaseError(`Attempted to write param-defined key ${k} to .env files, but it was already defined.`);
+        }
+    }
+    const mostSpecificEnv = path.join(functionsSource, envFiles[envFiles.length - 1]);
+    (0, utils_1.logBullet)(clc.cyan.bold("functions: ") + `Writing new parameter values to disk: ${mostSpecificEnv}`);
+    for (const k of Object.keys(toWrite)) {
+        fs.appendFileSync(mostSpecificEnv, formatUserEnvForWrite(k, toWrite[k]));
+    }
 }
 exports.writeUserEnvs = writeUserEnvs;
+function createEnvFile(envOpts) {
+    const fileToWrite = envOpts.isEmulator
+        ? FUNCTIONS_EMULATOR_DOTENV
+        : `.env.${envOpts.projectAlias || envOpts.projectId}`;
+    logger_1.logger.debug(`Creating ${fileToWrite}...`);
+    fs.writeFileSync(path.join(envOpts.functionsSource, fileToWrite), "", { flag: "wx" });
+    return fileToWrite;
+}
+function formatUserEnvForWrite(key, value) {
+    const escapedValue = value.replace(ALL_ESCAPABLE_CHARACTERS_RE, (match) => CHARACTERS_TO_ESCAPE_SEQUENCES[match]);
+    if (escapedValue !== value) {
+        return `${key}="${escapedValue}"\n`;
+    }
+    return `${key}=${escapedValue}\n`;
+}
 function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
     const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);

package/lib/gcp/iam.js

@@ -2,11 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testIamPermissions = exports.testResourceIamPermissions = exports.getRole = exports.deleteServiceAccount = exports.createServiceAccountKey = exports.getServiceAccount = exports.createServiceAccount = void 0;
 const api_1 = require("../api");
-const lodash_1 = require("lodash");
 const logger_1 = require("../logger");
 const apiv2_1 = require("../apiv2");
-const API_VERSION = "v1";
-const apiClient = new apiv2_1.Client({ urlPrefix: api_1.iamOrigin, apiVersion: API_VERSION });
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.iamOrigin, apiVersion: "v1" });
 async function createServiceAccount(projectId, accountId, description, displayName) {
     const response = await apiClient.post(`/projects/${projectId}/serviceAccounts`, {
         accountId,
@@ -31,8 +29,8 @@ async function createServiceAccountKey(projectId, serviceAccountName) {
     return response.body;
 }
 exports.createServiceAccountKey = createServiceAccountKey;
-function deleteServiceAccount(projectId, accountEmail) {
-    return apiClient.delete(`/projects/${projectId}/serviceAccounts/${accountEmail}`, {
+async function deleteServiceAccount(projectId, accountEmail) {
+    await apiClient.delete(`/projects/${projectId}/serviceAccounts/${accountEmail}`, {
         resolveOnHTTPError: true,
     });
 }
@@ -44,25 +42,30 @@ async function getRole(role) {
     return response.body;
 }
 exports.getRole = getRole;
-async function testResourceIamPermissions(origin, apiVersion, resourceName, permissions) {
+async function testResourceIamPermissions(origin, apiVersion, resourceName, permissions, quotaUser = "") {
     const localClient = new apiv2_1.Client({ urlPrefix: origin, apiVersion });
     if (process.env.FIREBASE_SKIP_INFORMATIONAL_IAM) {
-        logger_1.logger.debug("[iam] skipping informational check of permissions", JSON.stringify(permissions), "on resource", resourceName);
-        return { allowed: permissions, missing: [], passed: true };
+        logger_1.logger.debug(`[iam] skipping informational check of permissions ${JSON.stringify(permissions)} on resource ${resourceName}`);
+        return { allowed: Array.from(permissions).sort(), missing: [], passed: true };
+    }
+    const headers = {};
+    if (quotaUser) {
+        headers["x-goog-quota-user"] = quotaUser;
+    }
+    const response = await localClient.post(`/${resourceName}:testIamPermissions`, { permissions }, { headers });
+    const allowed = new Set(response.body.permissions || []);
+    const missing = new Set(permissions);
+    for (const p of allowed) {
+        missing.delete(p);
     }
-    const response = await localClient.post(`/${resourceName}:testIamPermissions`, {
-        permissions,
-    });
-    const allowed = (response.body.permissions || []).sort();
-    const missing = (0, lodash_1.difference)(permissions, allowed);
     return {
-        allowed,
-        missing,
-        passed: missing.length === 0,
+        allowed: Array.from(allowed).sort(),
+        missing: Array.from(missing).sort(),
+        passed: missing.size === 0,
     };
 }
 exports.testResourceIamPermissions = testResourceIamPermissions;
 async function testIamPermissions(projectId, permissions) {
-    return testResourceIamPermissions(api_1.resourceManagerOrigin, "v1", `projects/${projectId}`, permissions);
+    return testResourceIamPermissions(api_1.resourceManagerOrigin, "v1", `projects/${projectId}`, permissions, `projects/${projectId}`);
 }
 exports.testIamPermissions = testIamPermissions;

package/lib/rc.js

@@ -136,15 +136,9 @@ class RC {
     requireTarget(project, type, name) {
         const target = this.target(project, type, name);
         if (!target.length) {
-            throw new error_1.FirebaseError("Deploy target " +
-                clc.bold(name) +
-                " not configured for project " +
-                clc.bold(project) +
-                ". Configure with:\n\n  firebase target:apply " +
-                type +
-                " " +
-                name +
-                " <resources...>");
+            throw new error_1.FirebaseError(`Deploy target ${clc.bold(name)} not configured for project ${clc.bold(project)}. Configure with:
+
+  firebase target:apply ${type} ${name} <resources...>`);
         }
         return target;
     }

package/lib/rulesDeploy.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RulesDeploy = exports.RulesetServiceType = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
-const fs = require("fs");
+const fs = require("fs-extra");
 const gcp = require("./gcp");
 const logger_1 = require("./logger");
 const error_1 = require("./error");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "firebase-tools",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "firebase-tools",
-      "version": "11.3.0",
+      "version": "11.4.0",
       "license": "MIT",
       "dependencies": {
         "@google-cloud/pubsub": "^3.0.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firebase-tools",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Command-Line Interface for Firebase",
   "main": "./lib/index.js",
   "bin": {
@@ -30,6 +30,7 @@
     "test:extensions-deploy": "bash ./scripts/extensions-deploy-tests/run.sh",
     "test:extensions-emulator": "bash ./scripts/extensions-emulator-tests/run.sh",
     "test:hosting": "bash ./scripts/hosting-tests/run.sh",
+    "test:hosting-rewrites": "bash ./scripts/hosting-tests/rewrites-tests/run.sh",
     "test:triggers-end-to-end": "bash ./scripts/triggers-end-to-end-tests/run.sh",
     "test:storage-deploy": "bash ./scripts/storage-deploy-tests/run.sh",
     "test:storage-emulator-integration": "bash ./scripts/storage-emulator-integration/run.sh"