Merge pull request #4 from netlify/functions-build-cmd

Add functions:build command

Author: biilmann

src/commands/functions/build.js

@@ -1,19 +1,51 @@
-const { Command, flags } = require('@oclif/command')
+const fs = require('fs')
+const {flags} = require('@oclif/command')
+const Command = require('@netlify/cli-utils')
+const {zipFunctions} = require('@netlify/zip-it-and-ship-it')
 
 class FunctionsBuildCommand extends Command {
   async run() {
-    this.log(`build a function locally`)
+    const {flags, args} = this.parse(FunctionsBuildCommand)
+    const {config} = this.netlify
+
+    const src = flags.src || config.build.functionsSource
+    const dst = flags.functions || config.build.functions
+
+    if (src === dst) {
+      this.log("Source and destination for function build can't be the same")
+      process.exit(1)
+    }
+
+    if (!src) {
+      this.log('You must specify a source folder')
+      process.exit(1)
+    }
+
+    if (!dst) {
+      this.log('You must specify a functions folder')
+      process.exit(1)
+    }
+
+    fs.mkdirSync(dst, {recursive: true})
+
+    this.log('Building functions')
+    zipFunctions(src, dst, {skipGo: true})
+    this.log('Functions buildt to ', dst)
   }
 }
 
 FunctionsBuildCommand.description = `build functions locally
 `
 
 FunctionsBuildCommand.flags = {
-  name: flags.string({char: 'n', description: 'name to print'}),
+  functions: flags.string({
+    char: 'f',
+    description: 'Specify a functions folder to build to',
+  }),
+  src: flags.string({
+    char: 's',
+    description: 'Specify the source folder for the functions',
+  }),
 }
 
-// TODO make visible once implementation complete
-FunctionsBuildCommand.hidden = true
-
 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,64 +19,76 @@ 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/, '')}`)
-        process.exit(1)
-      }
+    } else if (fs.existsSync(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' }),
-  dir: flags.boolean({ char: 'd', description: 'create function as a directory' })
+  functions: flags.string({char: 'f', description: 'functions folder'}),
+  dir: flags.boolean({
+    char: 'd',
+    description: 'create function as a directory',
+  }),
 }
-
-// TODO make visible once implementation complete
-FunctionsCreateCommand.hidden = true
-
 module.exports = FunctionsCreateCommand