firebase-tools 10.9.2 → 11.1.0

package/lib/functionsConfigClone.js

@@ -1,68 +1,70 @@
 "use strict";
-var _ = require("lodash");
-var clc = require("cli-color");
-var { FirebaseError } = require("./error");
-var functionsConfig = require("./functionsConfig");
-var runtimeconfig = require("./gcp/runtimeconfig");
-var _matchPrefix = function (short, long) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsConfigClone = void 0;
+const _ = require("lodash");
+const clc = require("cli-color");
+const error_1 = require("./error");
+const functionsConfig = require("./functionsConfig");
+const runtimeconfig = require("./gcp/runtimeconfig");
+function matchPrefix(short, long) {
     if (short.length > long.length) {
         return false;
     }
-    return _.reduce(short, function (accum, x, i) {
+    return _.reduce(short, (accum, x, i) => {
         return accum && x === long[i];
     }, true);
-};
-var _applyExcept = function (json, except) {
-    _.forEach(except, function (key) {
+}
+function applyExcept(json, except) {
+    _.forEach(except, (key) => {
         _.unset(json, key);
     });
-};
-var _cloneVariable = function (varName, toProject) {
-    return runtimeconfig.variables.get(varName).then(function (variable) {
-        var id = functionsConfig.varNameToIds(variable.name);
+}
+function cloneVariable(varName, toProject) {
+    return runtimeconfig.variables.get(varName).then((variable) => {
+        const id = functionsConfig.varNameToIds(variable.name);
         return runtimeconfig.variables.set(toProject, id.config, id.variable, variable.text);
     });
-};
-var _cloneConfig = function (configName, toProject) {
-    return runtimeconfig.variables.list(configName).then(function (variables) {
-        return Promise.all(_.map(variables, function (variable) {
-            return _cloneVariable(variable.name, toProject);
+}
+function cloneConfig(configName, toProject) {
+    return runtimeconfig.variables.list(configName).then((variables) => {
+        return Promise.all(_.map(variables, (variable) => {
+            return cloneVariable(variable.name, toProject);
         }));
     });
-};
-var _cloneConfigOrVariable = function (key, fromProject, toProject) {
-    var parts = key.split(".");
+}
+async function cloneConfigOrVariable(key, fromProject, toProject) {
+    const parts = key.split(".");
     if (_.includes(functionsConfig.RESERVED_NAMESPACES, parts[0])) {
-        throw new FirebaseError("Cannot clone reserved namespace " + clc.bold(parts[0]));
+        throw new error_1.FirebaseError("Cannot clone reserved namespace " + clc.bold(parts[0]));
     }
-    var configName = _.join(["projects", fromProject, "configs", parts[0]], "/");
+    const configName = _.join(["projects", fromProject, "configs", parts[0]], "/");
     if (parts.length === 1) {
-        return _cloneConfig(configName, toProject);
+        return cloneConfig(configName, toProject);
     }
-    return runtimeconfig.variables.list(configName).then(function (variables) {
-        var promises = [];
-        _.forEach(variables, function (variable) {
-            var varId = functionsConfig.varNameToIds(variable.name).variable;
-            var variablePrefixFilter = parts.slice(1);
-            if (_matchPrefix(variablePrefixFilter, varId.split("/"))) {
-                promises.push(_cloneVariable(variable.name, toProject));
+    return runtimeconfig.variables.list(configName).then((variables) => {
+        const promises = [];
+        _.forEach(variables, (variable) => {
+            const varId = functionsConfig.varNameToIds(variable.name).variable;
+            const variablePrefixFilter = parts.slice(1);
+            if (matchPrefix(variablePrefixFilter, varId.split("/"))) {
+                promises.push(cloneVariable(variable.name, toProject));
             }
         });
         return Promise.all(promises);
     });
-};
-module.exports = function (fromProject, toProject, only, except) {
-    except = except || [];
+}
+async function functionsConfigClone(fromProject, toProject, only, except = []) {
     if (only) {
-        return Promise.all(_.map(only, function (key) {
-            return _cloneConfigOrVariable(key, fromProject, toProject);
+        return Promise.all(_.map(only, (key) => {
+            return cloneConfigOrVariable(key, fromProject, toProject);
         }));
     }
-    return functionsConfig.materializeAll(fromProject).then(function (toClone) {
+    return functionsConfig.materializeAll(fromProject).then((toClone) => {
         _.unset(toClone, "firebase");
-        _applyExcept(toClone, except);
-        return Promise.all(_.map(toClone, function (val, configId) {
+        applyExcept(toClone, except);
+        return Promise.all(_.map(toClone, (val, configId) => {
             return functionsConfig.setVariablesRecursive(toProject, configId, "", val);
         }));
     });
-};
+}
+exports.functionsConfigClone = functionsConfigClone;

package/lib/gcp/cloudfunctionsv2.js

@@ -209,6 +209,13 @@ function functionFromEndpoint(endpoint, source) {
             for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilters)) {
                 gcfFunction.eventTrigger.eventFilters.push({ attribute, value });
             }
+            for (const [attribute, value] of Object.entries(endpoint.eventTrigger.eventFilterPathPatterns || {})) {
+                gcfFunction.eventTrigger.eventFilters.push({
+                    attribute,
+                    value,
+                    operator: "match-path-pattern",
+                });
+            }
         }
         proto.renameIfPresent(gcfFunction.eventTrigger, endpoint.eventTrigger, "triggerRegion", "region");
         proto.copyIfPresent(gcfFunction.eventTrigger, endpoint.eventTrigger, "channel");
@@ -277,8 +284,16 @@ function endpointFromFunction(gcfFunction) {
             trigger.eventTrigger.eventFilters.topic = gcfFunction.eventTrigger.pubsubTopic;
         }
         else {
-            for (const { attribute, value } of gcfFunction.eventTrigger.eventFilters || []) {
-                trigger.eventTrigger.eventFilters[attribute] = value;
+            for (const eventFilter of gcfFunction.eventTrigger.eventFilters || []) {
+                if (eventFilter.operator === "match-path-pattern") {
+                    if (!trigger.eventTrigger.eventFilterPathPatterns) {
+                        trigger.eventTrigger.eventFilterPathPatterns = {};
+                    }
+                    trigger.eventTrigger.eventFilterPathPatterns[eventFilter.attribute] = eventFilter.value;
+                }
+                else {
+                    trigger.eventTrigger.eventFilters[eventFilter.attribute] = eventFilter.value;
+                }
             }
         }
         proto.copyIfPresent(trigger.eventTrigger, gcfFunction.eventTrigger, "channel");

package/lib/gcp/iam.js

@@ -14,7 +14,7 @@ async function createServiceAccount(projectId, accountId, description, displayNa
             displayName,
             description,
         },
-    });
+    }, { skipLog: { resBody: true } });
     return response.body;
 }
 exports.createServiceAccount = createServiceAccount;

package/lib/gcp/index.js

@@ -1,11 +1,11 @@
 "use strict";
-module.exports = {
-    cloudbilling: require("./cloudbilling"),
-    cloudfunctions: require("./cloudfunctions"),
-    cloudscheduler: require("./cloudscheduler"),
-    cloudlogging: require("./cloudlogging"),
-    iam: require("./iam"),
-    pubsub: require("./pubsub"),
-    storage: require("./storage"),
-    rules: require("./rules"),
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = exports.storage = exports.pubsub = exports.iam = exports.cloudlogging = exports.cloudscheduler = exports.cloudfunctions = exports.cloudbilling = void 0;
+exports.cloudbilling = require("./cloudbilling");
+exports.cloudfunctions = require("./cloudfunctions");
+exports.cloudscheduler = require("./cloudscheduler");
+exports.cloudlogging = require("./cloudlogging");
+exports.iam = require("./iam");
+exports.pubsub = require("./pubsub");
+exports.storage = require("./storage");
+exports.rules = require("./rules");

package/lib/gcp/runtimeconfig.js

@@ -1,66 +1,66 @@
 "use strict";
-const { runtimeconfigOrigin } = require("../api");
-const { Client } = require("../apiv2");
-const { logger } = require("../logger");
-var _ = require("lodash");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variables = exports.configs = void 0;
+const _ = require("lodash");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
+const logger_1 = require("../logger");
 const API_VERSION = "v1beta1";
-const apiClient = new Client({ urlPrefix: runtimeconfigOrigin, apiVersion: API_VERSION });
-function _listConfigs(projectId) {
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.runtimeconfigOrigin, apiVersion: API_VERSION });
+function listConfigs(projectId) {
     return apiClient
         .get(`/projects/${projectId}/configs`, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
-        return resp.body.configs;
-    });
+        .then((resp) => resp.body.configs);
 }
-function _createConfig(projectId, configId) {
-    var path = _.join(["projects", projectId, "configs"], "/");
+function createConfig(projectId, configId) {
+    const path = _.join(["projects", projectId, "configs"], "/");
     return apiClient
         .post(`/projects/${projectId}/configs`, {
         name: path + "/" + configId,
     }, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 409) {
             return Promise.resolve();
         }
         return Promise.reject(err);
     });
 }
-function _deleteConfig(projectId, configId) {
+function deleteConfig(projectId, configId) {
     return apiClient
         .delete(`/projects/${projectId}/configs/${configId}`, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            logger.debug("Config already deleted.");
+            logger_1.logger.debug("Config already deleted.");
             return Promise.resolve();
         }
-        return Promise.reject(err);
+        throw err;
     });
 }
-function _listVariables(configPath) {
+function listVariables(configPath) {
     return apiClient
         .get(`${configPath}/variables`, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
+        .then((resp) => {
         return Promise.resolve(resp.body.variables);
     });
 }
-function _getVariable(varPath) {
+function getVariable(varPath) {
     return apiClient
         .get(varPath, {
         retryCodes: [500, 503],
     })
-        .then(function (resp) {
+        .then((resp) => {
         return Promise.resolve(resp.body);
     });
 }
-function _createVariable(projectId, configId, varId, value) {
+function createVariable(projectId, configId, varId, value) {
     const path = `/projects/${projectId}/configs/${configId}/variables`;
     return apiClient
         .post(path, {
@@ -69,16 +69,16 @@ function _createVariable(projectId, configId, varId, value) {
     }, {
         retryCodes: [500, 503],
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            return _createConfig(projectId, configId).then(function () {
-                return _createVariable(projectId, configId, varId, value);
+            return createConfig(projectId, configId).then(() => {
+                return createVariable(projectId, configId, varId, value);
             });
         }
         return Promise.reject(err);
     });
 }
-function _updateVariable(projectId, configId, varId, value) {
+function updateVariable(projectId, configId, varId, value) {
     const path = `/projects/${projectId}/configs/${configId}/variables/${varId}`;
     return apiClient.put(path, {
         name: path,
@@ -87,43 +87,41 @@ function _updateVariable(projectId, configId, varId, value) {
         retryCodes: [500, 503],
     });
 }
-function _setVariable(projectId, configId, varId, value) {
-    var path = _.join(["projects", projectId, "configs", configId, "variables", varId], "/");
-    return _getVariable(path)
-        .then(function () {
-        return _updateVariable(projectId, configId, varId, value);
+function setVariable(projectId, configId, varId, value) {
+    const path = _.join(["projects", projectId, "configs", configId, "variables", varId], "/");
+    return getVariable(path)
+        .then(() => {
+        return updateVariable(projectId, configId, varId, value);
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            return _createVariable(projectId, configId, varId, value);
+            return createVariable(projectId, configId, varId, value);
         }
         return Promise.reject(err);
     });
 }
-function _deleteVariable(projectId, configId, varId) {
+function deleteVariable(projectId, configId, varId) {
     return apiClient
         .delete(`/projects/${projectId}/configs/${configId}/variables/${varId}`, {
         retryCodes: [500, 503],
         queryParams: { recursive: "true" },
     })
-        .catch(function (err) {
+        .catch((err) => {
         if (_.get(err, "context.response.statusCode") === 404) {
-            logger.debug("Variable already deleted.");
+            logger_1.logger.debug("Variable already deleted.");
             return Promise.resolve();
         }
         return Promise.reject(err);
     });
 }
-module.exports = {
-    configs: {
-        list: _listConfigs,
-        create: _createConfig,
-        delete: _deleteConfig,
-    },
-    variables: {
-        list: _listVariables,
-        get: _getVariable,
-        set: _setVariable,
-        delete: _deleteVariable,
-    },
+exports.configs = {
+    list: listConfigs,
+    create: createConfig,
+    delete: deleteConfig,
+};
+exports.variables = {
+    list: listVariables,
+    get: getVariable,
+    set: setVariable,
+    delete: deleteVariable,
 };

package/lib/gcp/storage.js

@@ -62,10 +62,8 @@ async function uploadObject(source, bucketName) {
 }
 exports.uploadObject = uploadObject;
 function deleteObject(location) {
-    return api_1.default.request("DELETE", location, {
-        auth: true,
-        origin: api_1.default.storageOrigin,
-    });
+    const localAPIClient = new apiv2_1.Client({ urlPrefix: api_1.storageOrigin });
+    return localAPIClient.delete(location);
 }
 exports.deleteObject = deleteObject;
 async function getBucket(bucketName) {

package/lib/hosting/cloudRunProxy.js

@@ -1,31 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
+const apiv2_1 = require("../apiv2");
+const api_1 = require("../api");
 const proxy_1 = require("./proxy");
-const projectUtils_1 = require("../projectUtils");
+const error_1 = require("../error");
 const logger_1 = require("../logger");
-const api_1 = require("../api");
+const projectUtils_1 = require("../projectUtils");
 const cloudRunCache = {};
-function getCloudRunUrl(rewrite, projectId) {
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.cloudRunApiOrigin, apiVersion: "v1" });
+async function getCloudRunUrl(rewrite, projectId) {
+    var _a;
     const alreadyFetched = cloudRunCache[`${rewrite.run.region}/${rewrite.run.serviceId}`];
     if (alreadyFetched) {
         return Promise.resolve(alreadyFetched);
     }
-    const path = `/v1/projects/${projectId}/locations/${rewrite.run.region || "us-central1"}/services/${rewrite.run.serviceId}`;
-    logger_1.logger.info(`[hosting] Looking up Cloud Run service "${path}" for its URL`);
-    return (0, api_1.request)("GET", path, { origin: api_1.cloudRunApiOrigin, auth: true })
-        .then((res) => {
-        const url = (0, lodash_1.get)(res, "body.status.url");
+    const path = `/projects/${projectId}/locations/${rewrite.run.region || "us-central1"}/services/${rewrite.run.serviceId}`;
+    try {
+        logger_1.logger.info(`[hosting] Looking up Cloud Run service "${path}" for its URL`);
+        const res = await apiClient.get(path);
+        const url = (_a = res.body.status) === null || _a === void 0 ? void 0 : _a.url;
         if (!url) {
-            return Promise.reject("Cloud Run URL doesn't exist in response.");
+            throw new error_1.FirebaseError("Cloud Run URL doesn't exist in response.");
         }
         cloudRunCache[`${rewrite.run.region}/${rewrite.run.serviceId}`] = url;
         return url;
-    })
-        .catch((err) => {
-        const errInfo = `error looking up URL for Cloud Run service: ${err}`;
-        return Promise.reject(errInfo);
-    });
+    }
+    catch (err) {
+        throw new error_1.FirebaseError(`Error looking up URL for Cloud Run service: ${err}`, {
+            original: err,
+        });
+    }
 }
 function default_1(options) {
     return async (rewrite) => {

package/lib/index.js

@@ -1,10 +1,10 @@
 "use strict";
-var program = require("commander");
-var pkg = require("../package.json");
-var clc = require("cli-color");
-const { logger } = require("./logger");
-var { setupLoggers } = require("./utils");
-var leven = require("leven");
+const program = require("commander");
+const clc = require("cli-color");
+const leven = require("leven");
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const pkg = require("../package.json");
 program.version(pkg.version);
 program.option("-P, --project <alias_or_project_id>", "the Firebase project to use for this command");
 program.option("--account <email>", "the Google account to use for authorization");
@@ -14,33 +14,34 @@ program.option("--non-interactive", "error out of the command instead of waiting
 program.option("-i, --interactive", "force prompts to be displayed");
 program.option("--debug", "print verbose debug output and keep a debug log file");
 program.option("-c, --config <path>", "path to the firebase.json file to use for configuration");
-var client = {};
-client.cli = program;
-client.logger = require("./logger");
-client.errorOut = require("./errorOut").errorOut;
-client.getCommand = function (name) {
-    for (var i = 0; i < client.cli.commands.length; i++) {
-        if (client.cli.commands[i]._name === name) {
-            return client.cli.commands[i];
+const client = {
+    cli: program,
+    logger: require("./logger"),
+    errorOut: require("./errorOut").errorOut,
+    getCommand: (name) => {
+        for (let i = 0; i < client.cli.commands.length; i++) {
+            if (client.cli.commands[i]._name === name) {
+                return client.cli.commands[i];
+            }
         }
-    }
-    return null;
+        return;
+    },
 };
-require("./commands")(client);
+require("./commands").load(client);
 function suggestCommands(cmd, cmdList) {
-    var suggestion = cmdList.find(function (c) {
+    const suggestion = cmdList.find((c) => {
         return leven(c, cmd) < c.length * 0.4;
     });
     if (suggestion) {
-        logger.error();
-        logger.error("Did you mean " + clc.bold(suggestion) + "?");
+        logger_1.logger.error();
+        logger_1.logger.error("Did you mean " + clc.bold(suggestion) + "?");
         return suggestion;
     }
 }
-var commandNames = program.commands.map(function (cmd) {
+const commandNames = program.commands.map((cmd) => {
     return cmd._name;
 });
-var RENAMED_COMMANDS = {
+const RENAMED_COMMANDS = {
     "delete-site": "hosting:disable",
     "disable:hosting": "hosting:disable",
     "data:get": "database:get",
@@ -52,13 +53,13 @@ var RENAMED_COMMANDS = {
     "deploy:database": "deploy --only database",
     "prefs:token": "login:ci",
 };
-program.action(function (_, args) {
-    setupLoggers();
-    var cmd = args[0];
-    logger.error(clc.bold.red("Error:"), clc.bold(cmd), "is not a Firebase command");
+program.action((_, args) => {
+    (0, utils_1.setupLoggers)();
+    const cmd = args[0];
+    logger_1.logger.error(clc.bold.red("Error:"), clc.bold(cmd), "is not a Firebase command");
     if (RENAMED_COMMANDS[cmd]) {
-        logger.error();
-        logger.error(clc.bold(cmd) + " has been renamed, please run", clc.bold("firebase " + RENAMED_COMMANDS[cmd]), "instead");
+        logger_1.logger.error();
+        logger_1.logger.error(clc.bold(cmd) + " has been renamed, please run", clc.bold("firebase " + RENAMED_COMMANDS[cmd]), "instead");
     }
     else {
         if (!suggestCommands(cmd, commandNames)) {

package/lib/init/features/database.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.doSetup = void 0;
 const clc = require("cli-color");
-const api = require("../../api");
 const prompt_1 = require("../../prompt");
 const logger_1 = require("../../logger");
 const utils = require("../../utils");
@@ -12,16 +11,23 @@ const ora = require("ora");
 const ensureApiEnabled_1 = require("../../ensureApiEnabled");
 const getDefaultDatabaseInstance_1 = require("../../getDefaultDatabaseInstance");
 const error_1 = require("../../error");
+const apiv2_1 = require("../../apiv2");
 const DEFAULT_RULES = JSON.stringify({ rules: { ".read": "auth != null", ".write": "auth != null" } }, null, 2);
 async function getDBRules(instanceDetails) {
     if (!instanceDetails || !instanceDetails.name) {
         return DEFAULT_RULES;
     }
-    const response = await api.request("GET", "/.settings/rules.json", {
-        auth: true,
-        origin: instanceDetails.databaseUrl,
+    const client = new apiv2_1.Client({ urlPrefix: instanceDetails.databaseUrl });
+    const response = await client.request({
+        method: "GET",
+        path: "/.settings/rules.json",
+        responseType: "stream",
+        resolveOnHTTPError: true,
     });
-    return response.body;
+    if (response.status !== 200) {
+        throw new error_1.FirebaseError(`Failed to fetch current rules. Code: ${response.status}`);
+    }
+    return await response.response.text();
 }
 function writeDBRules(rules, logMessagePrefix, filename, config) {
     config.writeProjectFile(filename, rules);

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

@@ -44,6 +44,6 @@ async function doSetup(setup, config, options) {
         default: "javascript",
         choices,
     });
-    return require("./" + language)(setup, config);
+    return require("./" + language).setup(setup, config);
 }
 exports.doSetup = doSetup;

package/lib/init/features/functions/javascript.js

@@ -1,17 +1,19 @@
 "use strict";
-var _ = require("lodash");
-var fs = require("fs");
-var path = require("path");
-var npmDependencies = require("./npm-dependencies");
-var { prompt } = require("../../../prompt");
-var TEMPLATE_ROOT = path.resolve(__dirname, "../../../../templates/init/functions/javascript/");
-var INDEX_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "index.js"), "utf8");
-var PACKAGE_LINTING_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "package.lint.json"), "utf8");
-var PACKAGE_NO_LINTING_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "package.nolint.json"), "utf8");
-var ESLINT_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "_eslintrc"), "utf8");
-var GITIGNORE_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "_gitignore"), "utf8");
-module.exports = function (setup, config) {
-    return prompt(setup.functions, [
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = void 0;
+const _ = require("lodash");
+const fs = require("fs");
+const path = require("path");
+const npm_dependencies_1 = require("./npm-dependencies");
+const prompt_1 = require("../../../prompt");
+const TEMPLATE_ROOT = path.resolve(__dirname, "../../../../templates/init/functions/javascript/");
+const INDEX_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "index.js"), "utf8");
+const PACKAGE_LINTING_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "package.lint.json"), "utf8");
+const PACKAGE_NO_LINTING_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "package.nolint.json"), "utf8");
+const ESLINT_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "_eslintrc"), "utf8");
+const GITIGNORE_TEMPLATE = fs.readFileSync(path.join(TEMPLATE_ROOT, "_gitignore"), "utf8");
+function setup(setup, config) {
+    return (0, prompt_1.prompt)(setup.functions, [
         {
             name: "lint",
             type: "confirm",
@@ -19,24 +21,25 @@ module.exports = function (setup, config) {
             default: false,
         },
     ])
-        .then(function () {
+        .then(() => {
         if (setup.functions.lint) {
             _.set(setup, "config.functions.predeploy", ['npm --prefix "$RESOURCE_DIR" run lint']);
             return config
                 .askWriteProjectFile("functions/package.json", PACKAGE_LINTING_TEMPLATE)
-                .then(function () {
+                .then(() => {
                 config.askWriteProjectFile("functions/.eslintrc.js", ESLINT_TEMPLATE);
             });
         }
         return config.askWriteProjectFile("functions/package.json", PACKAGE_NO_LINTING_TEMPLATE);
     })
-        .then(function () {
+        .then(() => {
         return config.askWriteProjectFile("functions/index.js", INDEX_TEMPLATE);
     })
-        .then(function () {
+        .then(() => {
         return config.askWriteProjectFile("functions/.gitignore", GITIGNORE_TEMPLATE);
     })
-        .then(function () {
-        return npmDependencies.askInstallDependencies(setup.functions, config);
+        .then(() => {
+        return (0, npm_dependencies_1.askInstallDependencies)(setup.functions, config);
     });
-};
+}
+exports.setup = setup;