Run prettier on src and test js files

Author: Benaiah

src/commands/dev/index.js

@@ -1,13 +1,13 @@
-const {flags} = require('@oclif/command')
-const {spawn} = require('child_process')
+const { flags } = require('@oclif/command')
+const { spawn } = require('child_process')
 const http = require('http')
 const httpProxy = require('http-proxy')
 const waitPort = require('wait-port')
 const getPort = require('get-port')
-const {serveFunctions} = require('@netlify/zip-it-and-ship-it')
-const {serverSettings} = require('../../detect-server')
+const { serveFunctions } = require('@netlify/zip-it-and-ship-it')
+const { serverSettings } = require('../../detect-server')
 const Command = require('@netlify/cli-utils')
-const {getAddons} = require('netlify/src/addons')
+const { getAddons } = require('netlify/src/addons')
 
 function cleanExit() {
   process.exit()
@@ -26,47 +26,45 @@ function addonUrl(addonUrls, req) {
 async function startProxy(settings, addonUrls) {
   const rulesProxy = require('netlify-rules-proxy')
 
-  await waitPort({port: settings.proxyPort})
+  await waitPort({ port: settings.proxyPort })
   if (settings.functionsPort) {
-    await waitPort({port: settings.functionsPort})
+    await waitPort({ port: settings.functionsPort })
   }
-  const port = await getPort({port: settings.port})
-  const functionsServer = settings.functionsPort ?
-    `http://localhost:${settings.functionsPort}` :
-    null
+  const port = await getPort({ port: settings.port })
+  const functionsServer = settings.functionsPort ? `http://localhost:${settings.functionsPort}` : null
 
   const proxy = httpProxy.createProxyServer({
     target: {
       host: 'localhost',
-      port: settings.proxyPort,
-    },
+      port: settings.proxyPort
+    }
   })
 
-  const rewriter = rulesProxy({publicFolder: settings.dist})
+  const rewriter = rulesProxy({ publicFolder: settings.dist })
 
-  const server = http.createServer(function (req, res) {
+  const server = http.createServer(function(req, res) {
     if (isFunction(settings, req)) {
-      return proxy.web(req, res, {target: functionsServer})
+      return proxy.web(req, res, { target: functionsServer })
     }
     let url = addonUrl(addonUrls, req)
     if (url) {
-      return proxy.web(req, res, {target: url})
+      return proxy.web(req, res, { target: url })
     }
 
     rewriter(req, res, () => {
       if (isFunction(settings, req)) {
-        return proxy.web(req, res, {target: functionsServer})
+        return proxy.web(req, res, { target: functionsServer })
       }
       url = addonUrl(addonUrls, req)
       if (url) {
-        return proxy.web(req, res, {target: url})
+        return proxy.web(req, res, { target: url })
       }
 
-      proxy.web(req, res, {target: `http://localhost:${settings.proxyPort}`})
+      proxy.web(req, res, { target: `http://localhost:${settings.proxyPort}` })
     })
   })
 
-  server.on('upgrade', function (req, socket, head) {
+  server.on('upgrade', function(req, socket, head) {
     proxy.ws(req, socket, head)
   })
 
@@ -82,17 +80,17 @@ function startDevServer(settings, log, error) {
       name: 'netlify-dev',
       port: settings.proxyPort,
       templates: {
-        notFound: '404.html',
-      },
+        notFound: '404.html'
+      }
     })
 
-    server.start(function () {
+    server.start(function() {
       log('Server listening to', settings.proxyPort)
     })
     return
   }
 
-  const ps = spawn(settings.cmd, settings.args, {env: settings.env})
+  const ps = spawn(settings.cmd, settings.args, { env: settings.env })
 
   ps.stdout.on('data', data => {
     log(`${data}`.replace(settings.urlRegexp, `$1$2${settings.port}$3`))
@@ -112,24 +110,21 @@ function startDevServer(settings, log, error) {
 
 class DevCommand extends Command {
   async run() {
-    const {flags, args} = this.parse(DevCommand)
-    const {api, site, config} = this.netlify
-    const functionsDir =
-      flags.functions || (config.build && config.build.functions)
+    const { flags, args } = this.parse(DevCommand)
+    const { api, site, config } = this.netlify
+    const functionsDir = flags.functions || (config.build && config.build.functions)
     const addonUrls = {}
     if (site.id && !flags.offline) {
       const accessToken = await this.authenticate()
       const addons = await getAddons(site.id, accessToken)
       addons.forEach(addon => {
-        addonUrls[addon.slug] = `${addon.config.site_url}/.netlify/${
-          addon.slug
-        }`
+        addonUrls[addon.slug] = `${addon.config.site_url}/.netlify/${addon.slug}`
         for (const key in addon.env) {
           process.env[key] = process.env[key] || addon.env[key]
         }
       })
       const api = this.netlify.api
-      const apiSite = await api.getSite({site_id: site.id})
+      const apiSite = await api.getSite({ site_id: site.id })
       // TODO: We should move the environment outside of build settings and possibly have a
       // `/api/v1/sites/:site_id/environment` endpoint for it that we can also gate access to
       // In the future and that we could make context dependend
@@ -147,12 +142,12 @@ class DevCommand extends Command {
         noCmd: true,
         port: 8888,
         proxyPort: 3999,
-        dist: config.build && config.build.publish,
+        dist: config.build && config.build.publish
       }
     }
     startDevServer(settings, this.log, this.error)
     if (functionsDir) {
-      const fnSettings = await serveFunctions({functionsDir})
+      const fnSettings = await serveFunctions({ functionsDir })
       settings.functionsPort = fnSettings.port
     }
 
@@ -165,30 +160,26 @@ DevCommand.description = `Local dev server
 The dev command will run a local dev server with Netlify's proxy and redirect rules
 `
 
-DevCommand.examples = [
-  '$ netlify dev',
-  '$ netlify dev -c "yarn start"',
-  '$ netlify dev -c hugo',
-]
+DevCommand.examples = ['$ netlify dev', '$ netlify dev -c "yarn start"', '$ netlify dev -c hugo']
 
 DevCommand.strict = false
 
 DevCommand.flags = {
-  cmd: flags.string({char: 'c', description: 'command to run'}),
+  cmd: flags.string({ char: 'c', description: 'command to run' }),
   devport: flags.integer({
     char: 'd',
-    description: 'port of the dev server started by command',
+    description: 'port of the dev server started by command'
   }),
-  port: flags.integer({char: 'p', description: 'port of netlify dev'}),
-  dir: flags.integer({char: 'd', description: 'dir with static files'}),
+  port: flags.integer({ char: 'p', description: 'port of netlify dev' }),
+  dir: flags.integer({ char: 'd', description: 'dir with static files' }),
   functions: flags.string({
     char: 'f',
-    description: 'Specify a functions folder to serve',
+    description: 'Specify a functions folder to serve'
   }),
   offline: flags.boolean({
     char: 'o',
-    description: 'disables any features that require network access',
-  }),
+    description: 'disables any features that require network access'
+  })
 }
 
 module.exports = DevCommand

src/commands/functions/build.js

@@ -1,12 +1,12 @@
 const fs = require('fs')
-const {flags} = require('@oclif/command')
+const { flags } = require('@oclif/command')
 const Command = require('@netlify/cli-utils')
-const {zipFunctions} = require('@netlify/zip-it-and-ship-it')
+const { zipFunctions } = require('@netlify/zip-it-and-ship-it')
 
 class FunctionsBuildCommand extends Command {
   async run() {
-    const {flags, args} = this.parse(FunctionsBuildCommand)
-    const {config} = this.netlify
+    const { flags, args } = this.parse(FunctionsBuildCommand)
+    const { config } = this.netlify
 
     const src = flags.src || config.build.functionsSource
     const dst = flags.functions || config.build.functions
@@ -26,10 +26,10 @@ class FunctionsBuildCommand extends Command {
       process.exit(1)
     }
 
-    fs.mkdirSync(dst, {recursive: true})
+    fs.mkdirSync(dst, { recursive: true })
 
     this.log('Building functions')
-    zipFunctions(src, dst, {skipGo: true})
+    zipFunctions(src, dst, { skipGo: true })
     this.log('Functions buildt to ', dst)
   }
 }
@@ -40,12 +40,12 @@ FunctionsBuildCommand.description = `build functions locally
 FunctionsBuildCommand.flags = {
   functions: flags.string({
     char: 'f',
-    description: 'Specify a functions folder to build to',
+    description: 'Specify a functions folder to build to'
   }),
   src: flags.string({
     char: 's',
-    description: 'Specify the source folder for the functions',
-  }),
+    description: 'Specify the source folder for the functions'
+  })
 }
 
 module.exports = FunctionsBuildCommand

src/commands/functions/create.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const {flags} = require('@oclif/command')
+const { flags } = require('@oclif/command')
 const Command = require('@netlify/cli-utils')
 
 const template = `async function hello() {
@@ -19,76 +19,61 @@ exports.handler = async function(event, context) {
 
 class FunctionsCreateCommand extends Command {
   async run() {
-    const {flags, args} = this.parse(FunctionsCreateCommand)
-    const {name} = args
-    const {config} = this.netlify
+    const { flags, args } = this.parse(FunctionsCreateCommand)
+    const { name } = args
+    const { config } = this.netlify
 
     this.log(`Creating function ${name}`)
 
-    const functionsDir =
-      flags.functions || (config.build && config.build.functions)
+    const functionsDir = flags.functions || (config.build && config.build.functions)
     if (!functionsDir) {
-      this.log(
-        'No functions folder specified in netlify.toml or as an argument'
-      )
+      this.log('No functions folder specified in netlify.toml or as an argument')
       process.exit(1)
     }
 
     if (!fs.existsSync(functionsDir)) {
       fs.mkdir(functionsDir)
     }
 
-    const functionPath = flags.dir ?
-      path.join(functionsDir, name, name + '.js') :
-      path.join(functionsDir, name + '.js')
+    const functionPath = flags.dir ? path.join(functionsDir, name, name + '.js') : path.join(functionsDir, name + '.js')
     if (fs.existsSync(functionPath)) {
       this.log(`Function ${functionPath} already exists`)
       process.exit(1)
     }
 
     if (flags.dir) {
       const fnFolder = path.join(functionsDir, name)
-      if (
-        fs.existsSync(fnFolder + '.js') &&
-        fs.lstatSync(fnFolder + '.js').isFile()
-      ) {
-        this.log(
-          `A single file version of the function ${name} already exists at ${fnFolder}.js`
-        )
+      if (fs.existsSync(fnFolder + '.js') && fs.lstatSync(fnFolder + '.js').isFile()) {
+        this.log(`A single file version of the function ${name} already exists at ${fnFolder}.js`)
         process.exit(1)
       }
 
       try {
-        fs.mkdirSync(fnFolder, {recursive: true})
+        fs.mkdirSync(fnFolder, { recursive: true })
       } catch (e) {
         // Ignore
       }
     } else if (fs.existsSync(functionPath.replace(/\.js/, ''))) {
-      this.log(
-        `A folder version of the function ${name} alreadt exists at ${functionPath.replace(
-          /\.js/,
-          ''
-        )}`
-      )
+      this.log(`A folder version of the function ${name} alreadt exists at ${functionPath.replace(/\.js/, '')}`)
       process.exit(1)
     }
 
     fs.writeFileSync(functionPath, template)
   }
 }
 
-FunctionsCreateCommand.args = [{name: 'name'}]
+FunctionsCreateCommand.args = [{ name: 'name' }]
 
 FunctionsCreateCommand.description = `create a new function locally
 `
 
 FunctionsCreateCommand.examples = ['netlify functions:create hello-world']
 
 FunctionsCreateCommand.flags = {
-  functions: flags.string({char: 'f', description: 'functions folder'}),
+  functions: flags.string({ char: 'f', description: 'functions folder' }),
   dir: flags.boolean({
     char: 'd',
-    description: 'create function as a directory',
-  }),
+    description: 'create function as a directory'
+  })
 }
 module.exports = FunctionsCreateCommand

src/commands/functions/index.js

@@ -1,8 +1,8 @@
 const chalk = require('chalk')
-const {Command} = require('@oclif/command')
+const { Command } = require('@oclif/command')
 
 function showHelp(command) {
-  execSync(`netlify ${command} --help`, {stdio: [0, 1, 2]})
+  execSync(`netlify ${command} --help`, { stdio: [0, 1, 2] })
 }
 
 function isEmptyCommand(flags, args) {
@@ -22,7 +22,7 @@ function hasArgs(args) {
 
 class FunctionsCommand extends Command {
   async run() {
-    const {flags, args} = this.parse(FunctionsCommand)
+    const { flags, args } = this.parse(FunctionsCommand)
     // run help command if no args passed
     if (isEmptyCommand(flags, args)) {
       showHelp(this.id)
@@ -38,7 +38,7 @@ The ${name} command will help you manage the functions in this site
 `
 FunctionsCommand.examples = [
   'netlify functions:create --name function-xyz --runtime nodejs',
-  'netlify functions:update --name function-abc --timeout 30s',
+  'netlify functions:update --name function-abc --timeout 30s'
 ]
 
 // TODO make visible once implementation complete

src/commands/functions/serve.js

@@ -12,7 +12,7 @@ Extra documentation goes here
 `
 
 FunctionsServeCommand.flags = {
-  name: flags.string({char: 'n', description: 'name to print'}),
+  name: flags.string({ char: 'n', description: 'name to print' })
 }
 
 // TODO make visible once implementation complete

src/commands/functions/update.js

@@ -12,7 +12,7 @@ Extra documentation goes here
 `
 
 FunctionsUpdateCommand.flags = {
-  name: flags.string({char: 'n', description: 'name to print'}),
+  name: flags.string({ char: 'n', description: 'name to print' })
 }
 
 // TODO make visible once implementation complete