Delegate function scanning to zip-n-ship

Author: bcomnes

src/deploy/hash-fns.js

@@ -1,10 +1,10 @@
-const promisifyAll = require('util.promisify-all')
 const promisify = require('util.promisify')
 const pump = promisify(require('pump'))
-const fs = promisifyAll(require('fs'))
 const fromArray = require('from2-array')
+const zipIt = require('@netlify/zip-it-and-ship-it')
+const path = require('path')
 
-const { hasherCtor, manifestCollectorCtor, fnStatCtor } = require('./hasher-segments')
+const { hasherCtor, manifestCollectorCtor } = require('./hasher-segments')
 
 module.exports = hashFns
 async function hashFns(dir, opts) {
@@ -20,21 +20,32 @@ async function hashFns(dir, opts) {
   )
   // early out if the functions dir is omitted
   if (!dir) return { functions: {}, shaMap: {} }
-  if (!opts.filter) throw new Error('Missing required filter function')
   if (!opts.tmpDir) throw new Error('Missing tmpDir directory for zipping files')
 
-  const fileList = await fs.readdir(dir).then(files => files.filter(opts.filter))
-  const fileStream = fromArray.obj(fileList)
+  const functionZips = await zipIt.zipFunctions(dir, opts.tmpDir)
+
+  const fileObjs = functionZips.map(({ path: functionPath, runtime }) => ({
+    filepath: functionPath,
+    root: opts.tmpDir,
+    relname: path.relative(opts.tmpDir, functionPath),
+    basename: path.basename(functionPath),
+    extname: path.extname(functionPath),
+    type: 'file',
+    assetType: 'function',
+    normalizedPath: path.basename(functionPath, path.extname(functionPath)),
+    runtime
+  }))
+
+  const functionStream = fromArray.obj(fileObjs)
 
-  const fnStat = fnStatCtor({ root: dir, concurrentStat: opts.concurrentHash, tmpDir: opts.tmpDir })
   const hasher = hasherCtor(opts)
 
   // Written to by manifestCollector
   const functions = {} // normalizedPath: hash (wanted by deploy API)
   const fnShaMap = {} //hash: [fileObj, fileObj, fileObj]
   const manifestCollector = manifestCollectorCtor(functions, fnShaMap, opts)
 
-  await pump(fileStream, fnStat, hasher, manifestCollector)
+  await pump(functionStream, hasher, manifestCollector)
 
   return { functions, fnShaMap }
 }

src/deploy/hasher-segments.js

@@ -3,10 +3,7 @@ const objWriter = require('flush-write-stream').obj
 const { normalizePath } = require('./util')
 const transform = require('parallel-transform')
 const hasha = require('hasha')
-const path = require('path')
-const fs = require('fs')
 const map = require('through2-map').obj
-const zipIt = require('@netlify/zip-it-and-ship-it')
 
 // a parallel transform stream segment ctor that hashes fileObj's created by folder-walker
 exports.hasherCtor = ({ concurrentHash, hashAlgorithm = 'sha1' }) => {
@@ -61,40 +58,3 @@ exports.fnFilterCtor = objFilterCtor(fileObj => {
   // filter additional files out of our fn pipeline
   return fileObj && fileObj.type === 'file' && !!fileObj.runtime
 })
-
-// parallel stream ctor similar to folder-walker but specialized for netlify functions
-// Stream in names of files that may be functions, and this will stat the file and return a fileObj
-exports.fnStatCtor = ({ root, concurrentStat, tmpDir }) => {
-  if (!concurrentStat || !root || !tmpDir) throw new Error('Missing required opts')
-  return transform(concurrentStat, { objectMode: true }, (name, cb) => {
-    const filepath = path.resolve(path.join(root, name))
-    fs.stat(filepath, (err, stat) => {
-      if (err) return cb(err)
-      zipIt
-        .zipFunction(filepath, tmpDir)
-        .then(functionZip => {
-          if (functionZip === null) {
-            return cb(null, null)
-          }
-
-          const item = {
-            root,
-            filepath: functionZip.path,
-            stat,
-            relname: path.relative(root, filepath),
-            basename: path.basename(name),
-            extname: path.extname(name),
-            type: 'file',
-            assetType: 'function',
-            normalizedPath: path.basename(name, path.extname(name)),
-            runtime: functionZip.runtime
-          }
-
-          cb(null, item)
-        })
-        .catch(err => {
-          cb(err, null)
-        })
-    })
-  })
-}