@netlify/zip-it-and-ship-it 4.23.3 → 4.23.5-setup-typescript-4

package/src/utils/fs.js

@@ -1,88 +0,0 @@
-const { lstat, readdir, readFile, unlink, writeFile } = require('fs')
-const { format, join, parse, resolve } = require('path')
-const { promisify } = require('util')
-
-const pLstat = promisify(lstat)
-const pReaddir = promisify(readdir)
-const pReadFile = promisify(readFile)
-const pUnlink = promisify(unlink)
-const pWriteFile = promisify(writeFile)
-
-// This caches multiple FS calls to the same path. It creates a cache key with
-// the name of the function and the path (e.g. "readdir:/some/directory").
-const cachedIOFunction = (func, cache, path, ...args) => {
-  const key = `${func.name}:${path}`
-
-  if (cache[key] === undefined) {
-    // eslint-disable-next-line no-param-reassign
-    cache[key] = func(path, ...args)
-  }
-
-  return cache[key]
-}
-
-const cachedLstat = (...args) => cachedIOFunction(pLstat, ...args)
-const cachedReaddir = (...args) => cachedIOFunction(pReaddir, ...args)
-const cachedReadFile = (...args) => cachedIOFunction(pReadFile, ...args)
-
-const getPathWithExtension = (path, extension) => format({ ...parse(path), base: undefined, ext: extension })
-
-const safeUnlink = async (path) => {
-  try {
-    await pUnlink(path)
-  } catch (_) {}
-}
-
-// Takes a list of absolute paths and returns an array containing all the
-// filenames within those directories, if at least one of the directories
-// exists. If not, an error is thrown.
-const listFunctionsDirectories = async function (srcFolders) {
-  const filenamesByDirectory = await Promise.all(
-    srcFolders.map(async (srcFolder) => {
-      try {
-        const filenames = await listFunctionsDirectory(srcFolder)
-
-        return filenames
-      } catch (error) {
-        return null
-      }
-    }),
-  )
-  const validDirectories = filenamesByDirectory.filter(Boolean)
-
-  if (validDirectories.length === 0) {
-    throw new Error(`Functions folder does not exist: ${srcFolders.join(', ')}`)
-  }
-
-  return validDirectories.flat()
-}
-
-const listFunctionsDirectory = async function (srcFolder) {
-  try {
-    const filenames = await pReaddir(srcFolder)
-
-    return filenames.map((name) => join(srcFolder, name))
-  } catch (error) {
-    throw new Error(`Functions folder does not exist: ${srcFolder}`)
-  }
-}
-
-const resolveFunctionsDirectories = (input) => {
-  const directories = Array.isArray(input) ? input : [input]
-  const absoluteDirectories = directories.map((srcFolder) => resolve(srcFolder))
-
-  return absoluteDirectories
-}
-
-module.exports = {
-  cachedLstat,
-  cachedReaddir,
-  cachedReadFile,
-  lstat: pLstat,
-  getPathWithExtension,
-  listFunctionsDirectories,
-  listFunctionsDirectory,
-  resolveFunctionsDirectories,
-  safeUnlink,
-  writeFile: pWriteFile,
-}

package/src/utils/remove_falsy.js

@@ -1,12 +0,0 @@
-const filterObj = require('filter-obj')
-
-// Remove falsy values from object
-const removeFalsy = function (obj) {
-  return filterObj(obj, isDefined)
-}
-
-const isDefined = function (key, value) {
-  return value !== undefined && value !== ''
-}
-
-module.exports = { removeFalsy }

package/src/utils/shell.js

@@ -1,3 +0,0 @@
-const execa = require('execa')
-
-module.exports = { runCommand: execa }

package/src/zip.js

@@ -1,161 +0,0 @@
-const { resolve } = require('path')
-
-const makeDir = require('make-dir')
-const pMap = require('p-map')
-
-const { getFlags } = require('./feature_flags')
-const { createManifest } = require('./manifest')
-const { getPluginsModulesPath } = require('./node_dependencies')
-const { getFunctionsFromPaths } = require('./runtimes')
-const { ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP } = require('./utils/consts')
-const { listFunctionsDirectories, resolveFunctionsDirectories } = require('./utils/fs')
-const { removeFalsy } = require('./utils/remove_falsy')
-
-const DEFAULT_PARALLEL_LIMIT = 5
-
-const validateArchiveFormat = (archiveFormat) => {
-  if (![ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP].includes(archiveFormat)) {
-    throw new Error(`Invalid archive format: ${archiveFormat}`)
-  }
-}
-
-// Takes the result of zipping a function and formats it for output.
-const formatZipResult = (result) => {
-  const {
-    bundler,
-    bundlerErrors,
-    bundlerWarnings,
-    config = {},
-    inputs,
-    mainFile,
-    name,
-    nativeNodeModules,
-    nodeModulesWithDynamicImports,
-    path,
-    runtime,
-  } = result
-
-  return removeFalsy({
-    bundler,
-    bundlerErrors,
-    bundlerWarnings,
-    config,
-    inputs,
-    mainFile,
-    name,
-    nativeNodeModules,
-    nodeModulesWithDynamicImports,
-    path,
-    runtime: runtime.name,
-  })
-}
-
-// Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
-// used by AWS Lambda
-const zipFunctions = async function (
-  relativeSrcFolders,
-  destFolder,
-  {
-    archiveFormat = ARCHIVE_FORMAT_ZIP,
-    basePath,
-    config = {},
-    featureFlags: inputFeatureFlags,
-    manifest,
-    parallelLimit = DEFAULT_PARALLEL_LIMIT,
-  } = {},
-) {
-  validateArchiveFormat(archiveFormat)
-
-  const featureFlags = getFlags(inputFeatureFlags)
-  const srcFolders = resolveFunctionsDirectories(relativeSrcFolders)
-  const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), makeDir(destFolder)])
-  const [functions, pluginsModulesPath] = await Promise.all([
-    getFunctionsFromPaths(paths, { config, dedupe: true, featureFlags }),
-
-    // All function directories should be part of the same project root, so we
-    // can get away with computing the plugins modules path from any of the
-    // source directories.
-    getPluginsModulesPath(srcFolders[0]),
-  ])
-  const results = await pMap(
-    functions.values(),
-    async (func) => {
-      const zipResult = await func.runtime.zipFunction({
-        archiveFormat,
-        basePath,
-        config: func.config,
-        destFolder,
-        extension: func.extension,
-        filename: func.filename,
-        mainFile: func.mainFile,
-        name: func.name,
-        pluginsModulesPath,
-        runtime: func.runtime,
-        srcDir: func.srcDir,
-        srcPath: func.srcPath,
-        stat: func.stat,
-        featureFlags,
-      })
-
-      return { ...zipResult, mainFile: func.mainFile, name: func.name, runtime: func.runtime }
-    },
-    {
-      concurrency: parallelLimit,
-    },
-  )
-  const formattedResults = results.filter(Boolean).map(formatZipResult)
-
-  if (manifest !== undefined) {
-    await createManifest({ functions: formattedResults, path: resolve(manifest) })
-  }
-
-  return formattedResults
-}
-
-const zipFunction = async function (
-  relativeSrcPath,
-  destFolder,
-  {
-    archiveFormat = ARCHIVE_FORMAT_ZIP,
-    basePath,
-    config: inputConfig = {},
-    featureFlags: inputFeatureFlags,
-    pluginsModulesPath: defaultModulesPath,
-  } = {},
-) {
-  validateArchiveFormat(archiveFormat)
-
-  const featureFlags = getFlags(inputFeatureFlags)
-  const srcPath = resolve(relativeSrcPath)
-  const functions = await getFunctionsFromPaths([srcPath], { config: inputConfig, dedupe: true, featureFlags })
-
-  if (functions.size === 0) {
-    return
-  }
-
-  const { config, extension, filename, mainFile, name, runtime, srcDir, stat } = functions.values().next().value
-  const pluginsModulesPath =
-    defaultModulesPath === undefined ? await getPluginsModulesPath(srcPath) : defaultModulesPath
-
-  await makeDir(destFolder)
-
-  const zipResult = await runtime.zipFunction({
-    archiveFormat,
-    basePath,
-    config,
-    srcPath,
-    destFolder,
-    mainFile,
-    filename,
-    extension,
-    srcDir,
-    stat,
-    runtime,
-    pluginsModulesPath,
-    featureFlags,
-  })
-
-  return formatZipResult({ ...zipResult, mainFile, name, runtime })
-}
-
-module.exports = { zipFunction, zipFunctions }

package/src/zip_binary.js

@@ -1,11 +0,0 @@
-const { startZip, addZipFile, addZipContent, endZip } = require('./archive')
-
-// Zip a binary function file
-const zipBinary = async function ({ srcPath, destPath, filename, stat, runtime }) {
-  const { archive, output } = startZip(destPath)
-  addZipFile(archive, srcPath, filename, stat)
-  addZipContent(archive, JSON.stringify({ runtime: runtime.name }), 'netlify-toolchain')
-  await endZip(archive, output)
-}
-
-module.exports = { zipBinary }

package/src/zip_node.js

@@ -1,179 +0,0 @@
-const { Buffer } = require('buffer')
-const fs = require('fs')
-const os = require('os')
-const { basename, extname, join, normalize, resolve, sep } = require('path')
-const { promisify } = require('util')
-
-const copyFile = require('cp-file')
-const deleteFiles = require('del')
-const makeDir = require('make-dir')
-const pMap = require('p-map')
-const unixify = require('unixify')
-
-const { startZip, addZipFile, addZipContent, endZip } = require('./archive')
-const { ARCHIVE_FORMAT_ZIP } = require('./utils/consts')
-
-const pStat = promisify(fs.stat)
-const pWriteFile = promisify(fs.writeFile)
-
-// Taken from https://www.npmjs.com/package/cpy.
-const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2
-
-// Sub-directory to place all user-defined files  (i.e. everything other than
-// the entry file generated by zip-it-and-ship-it).
-const DEFAULT_USER_SUBDIRECTORY = 'src'
-
-const createDirectory = async function ({
-  aliases = new Map(),
-  basePath,
-  destFolder,
-  extension,
-  filename,
-  mainFile,
-  pluginsModulesPath,
-  srcFiles,
-}) {
-  const { contents: entryContents, filename: entryFilename } = getEntryFile({
-    commonPrefix: basePath,
-    filename,
-    mainFile,
-    userNamespace: DEFAULT_USER_SUBDIRECTORY,
-  })
-  const functionFolder = join(destFolder, basename(filename, extension))
-
-  // Deleting the functions directory in case it exists before creating it.
-  await deleteFiles(functionFolder, { force: true })
-  await makeDir(functionFolder)
-
-  // Writing entry file.
-  await pWriteFile(join(functionFolder, entryFilename), entryContents)
-
-  // Copying source files.
-  await pMap(
-    srcFiles,
-    (srcFile) => {
-      const srcPath = aliases.get(srcFile) || srcFile
-      const normalizedSrcPath = normalizeFilePath({
-        commonPrefix: basePath,
-        path: srcPath,
-        pluginsModulesPath,
-        userNamespace: DEFAULT_USER_SUBDIRECTORY,
-      })
-      const destPath = join(functionFolder, normalizedSrcPath)
-
-      return copyFile(srcFile, destPath)
-    },
-    { concurrency: COPY_FILE_CONCURRENCY },
-  )
-
-  return functionFolder
-}
-
-const createZipArchive = async function ({
-  aliases,
-  basePath,
-  destFolder,
-  extension,
-  filename,
-  mainFile,
-  pluginsModulesPath,
-  srcFiles,
-}) {
-  const destPath = join(destFolder, `${basename(filename, extension)}.zip`)
-  const { archive, output } = startZip(destPath)
-  const entryFilename = `${basename(filename, extension)}.js`
-  const entryFilePath = resolve(basePath, entryFilename)
-
-  // We don't need an entry file if it would end up with the same path as the
-  // function's main file.
-  const needsEntryFile = entryFilePath !== mainFile
-
-  // There is a naming conflict with the entry file if one of the supporting
-  // files (i.e. not the main file) has the path that the entry file needs to
-  // take.
-  const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile)
-
-  // If there is a naming conflict, we move all user files (everything other
-  // than the entry file) to its own sub-directory.
-  const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : ''
-
-  if (needsEntryFile) {
-    const entryFile = getEntryFile({ commonPrefix: basePath, filename, mainFile, userNamespace })
-
-    addEntryFileToZip(archive, entryFile)
-  }
-
-  const srcFilesInfos = await Promise.all(srcFiles.map(addStat))
-
-  // We ensure this is not async, so that the archive's checksum is
-  // deterministic. Otherwise it depends on the order the files were added.
-  srcFilesInfos.forEach(({ srcFile, stat }) => {
-    zipJsFile({ srcFile, commonPrefix: basePath, pluginsModulesPath, archive, stat, aliases, userNamespace })
-  })
-
-  await endZip(archive, output)
-
-  return destPath
-}
-
-const zipNodeJs = function ({ archiveFormat, ...options }) {
-  if (archiveFormat === ARCHIVE_FORMAT_ZIP) {
-    return createZipArchive(options)
-  }
-
-  return createDirectory(options)
-}
-
-const addEntryFileToZip = function (archive, { contents, filename }) {
-  const contentBuffer = Buffer.from(contents)
-
-  addZipContent(archive, contentBuffer, filename)
-}
-
-const addStat = async function (srcFile) {
-  const stat = await pStat(srcFile)
-  return { srcFile, stat }
-}
-
-const getEntryFile = ({ commonPrefix, filename, mainFile, userNamespace }) => {
-  const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace })
-  const extension = extname(filename)
-  const entryFilename = `${basename(filename, extension)}.js`
-
-  return {
-    contents: `module.exports = require('.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}')`,
-    filename: entryFilename,
-  }
-}
-
-const zipJsFile = function ({
-  srcFile,
-  commonPrefix,
-  pluginsModulesPath,
-  archive,
-  stat,
-  aliases = new Map(),
-  userNamespace,
-}) {
-  const filename = aliases.get(srcFile) || srcFile
-  const normalizedFilename = normalizeFilePath({ commonPrefix, path: filename, pluginsModulesPath, userNamespace })
-
-  addZipFile(archive, srcFile, normalizedFilename, stat)
-}
-
-// `adm-zip` and `require()` expect Unix paths.
-// We remove the common path prefix.
-// With files on different Windows drives, we remove the drive letter.
-const normalizeFilePath = function ({ commonPrefix, path, pluginsModulesPath, userNamespace }) {
-  const userNamespacePathSegment = userNamespace ? `${userNamespace}${sep}` : ''
-  const pathA = normalize(path)
-  const pathB =
-    pluginsModulesPath === undefined
-      ? pathA
-      : pathA.replace(pluginsModulesPath, `${userNamespacePathSegment}node_modules`)
-  const pathC = pathB.replace(commonPrefix, userNamespacePathSegment)
-  const pathD = unixify(pathC)
-  return pathD
-}
-
-module.exports = { zipNodeJs }