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

package/src/node_dependencies/published.js

@@ -1,37 +0,0 @@
-const { promisify } = require('util')
-
-const glob = require('glob')
-
-const pGlob = promisify(glob)
-
-// We use all the files published by the Node.js except some that are not needed
-const getPublishedFiles = async function (modulePath) {
-  const ignore = getIgnoredFiles(modulePath)
-  const publishedFiles = await pGlob(`${modulePath}/**`, {
-    ignore,
-    nodir: true,
-    absolute: true,
-    dot: true,
-  })
-  return publishedFiles
-}
-
-const getIgnoredFiles = function (modulePath) {
-  return IGNORED_FILES.map((ignoreFile) => `${modulePath}/${ignoreFile}`)
-}
-
-// To make the zip archive smaller, we remove those.
-const IGNORED_FILES = [
-  'node_modules/**',
-  '.npmignore',
-  'package-lock.json',
-  'yarn.lock',
-  '*.log',
-  '*.lock',
-  '*~',
-  '*.map',
-  '*.ts',
-  '*.patch',
-]
-
-module.exports = { getPublishedFiles }

package/src/node_dependencies/resolve.js

@@ -1,108 +0,0 @@
-const { version: nodeVersion } = require('process')
-
-const findUp = require('find-up')
-const pathExists = require('path-exists')
-const resolveLib = require('resolve')
-const { lt: ltVersion } = require('semver')
-
-const BACKSLASH_REGEXP = /\\/g
-
-// Find the path to a module's `package.json`
-// We need to use `resolve` instead of `require.resolve()` because:
-//  - it is async
-//  - it preserves symlinks:
-//     - this is important because if a file does a `require('./symlink')`, we
-//       need to bundle the symlink and its target, not only the target
-//     - `path.resolve()` cannot be used for relative|absolute file paths
-//       because it does not resolve ommitted file extension,
-//       e.g. `require('./file')` instead of `require('./file.js')`
-//     - the CLI flag `--preserve-symlinks` can be used with Node.js, but it
-//       cannot be set runtime
-// However it does not give helpful error messages.
-//   https://github.com/browserify/resolve/issues/223
-// So, on errors, we fallback to `require.resolve()`
-const resolvePackage = async function (moduleName, baseDirs) {
-  try {
-    return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, baseDirs)
-  } catch (error) {
-    if (ltVersion(nodeVersion, REQUEST_RESOLVE_MIN_VERSION)) {
-      throw error
-    }
-
-    try {
-      return resolvePathFollowSymlinks(`${moduleName}/package.json`, baseDirs)
-    } catch (error_) {
-      return await resolvePackageFallback(moduleName, baseDirs, error_)
-    }
-  }
-}
-
-// TODO: remove after dropping support for Node <8.9.0
-// `require.resolve()` option `paths` was introduced in Node 8.9.0
-const REQUEST_RESOLVE_MIN_VERSION = '8.9.0'
-
-// We need to use `new Promise()` due to a bug with `utils.promisify()` on
-// `resolve`:
-//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
-const resolvePathPreserveSymlinksForDir = function (path, basedir) {
-  return new Promise((resolve, reject) => {
-    // eslint-disable-next-line promise/prefer-await-to-callbacks
-    resolveLib(path, { basedir, preserveSymlinks: true }, (error, resolvedLocation) => {
-      if (error) {
-        return reject(error)
-      }
-
-      resolve(resolvedLocation)
-    })
-  })
-}
-
-// the resolve library has a `paths` option but it's not the same as multiple basedirs
-// see https://github.com/browserify/resolve/issues/188#issuecomment-679010477
-// we return the first resolved location or the first error if all failed
-const resolvePathPreserveSymlinks = async function (path, baseDirs) {
-  let firstError
-  for (const basedir of baseDirs) {
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      return await resolvePathPreserveSymlinksForDir(path, basedir)
-    } catch (error) {
-      firstError = firstError || error
-    }
-  }
-
-  throw firstError
-}
-
-const resolvePathFollowSymlinks = function (path, baseDirs) {
-  return require.resolve(path, { paths: baseDirs })
-}
-
-// `require.resolve()` on a module's specific file (like `package.json`)
-// can be forbidden by the package author by using an `exports` field in
-// their `package.json`. We need this fallback.
-// It looks for the first directory up from a package's `main` file that:
-//   - is named like the package
-//   - has a `package.json`
-// Theoretically, this might not the root `package.json`, but this is very
-// unlikely, and we don't have any better alternative.
-const resolvePackageFallback = async function (moduleName, baseDirs, error) {
-  const mainFilePath = resolvePathFollowSymlinks(moduleName, baseDirs)
-  const packagePath = await findUp(isPackageDir.bind(null, moduleName), { cwd: mainFilePath, type: 'directory' })
-  if (packagePath === undefined) {
-    throw error
-  }
-  return packagePath
-}
-
-const isPackageDir = async function (moduleName, dir) {
-  // Need to use `endsWith()` to take into account `@scope/package`.
-  // Backslashes need to be converted for Windows.
-  if (!dir.replace(BACKSLASH_REGEXP, '/').endsWith(moduleName) || !(await pathExists(`${dir}/package.json`))) {
-    return
-  }
-
-  return dir
-}
-
-module.exports = { resolvePackage, resolvePathPreserveSymlinks }

package/src/node_dependencies/side_files.js

@@ -1,18 +0,0 @@
-const { getPublishedFiles } = require('./published')
-
-// Some modules generate source files on `postinstall` that are not located
-// inside the module's directory itself.
-const getSideFiles = function (modulePath, moduleName) {
-  const sideFiles = SIDE_FILES[moduleName]
-  if (sideFiles === undefined) {
-    return []
-  }
-
-  return getPublishedFiles(`${modulePath}/${sideFiles}`)
-}
-
-const SIDE_FILES = {
-  '@prisma/client': '../../.prisma',
-}
-
-module.exports = { getSideFiles }

package/src/node_dependencies/special_cases.js

@@ -1,42 +0,0 @@
-const { getPackageJson } = require('./package_json')
-
-const EXTERNAL_MODULES = ['@prisma/client']
-const IGNORED_MODULES = ['aws-sdk']
-
-const getPackageJsonIfAvailable = async (srcDir) => {
-  try {
-    const packageJson = await getPackageJson(srcDir)
-
-    return packageJson
-  } catch (_) {
-    return {}
-  }
-}
-
-const getModulesForNextJs = ({ dependencies, devDependencies }) => {
-  const allDependencies = { ...dependencies, ...devDependencies }
-  const externalModules = allDependencies.next ? ['critters', 'nanoid'] : []
-  const ignoredModules = []
-
-  return {
-    externalModules,
-    ignoredModules,
-  }
-}
-
-const getExternalAndIgnoredModulesFromSpecialCases = async ({ srcDir }) => {
-  const { dependencies = {}, devDependencies = {} } = await getPackageJsonIfAvailable(srcDir)
-  const { externalModules: nextJsExternalModules, ignoredModules: nextJsIgnoredModules } = getModulesForNextJs({
-    dependencies,
-    devDependencies,
-  })
-  const externalModules = [...EXTERNAL_MODULES, ...nextJsExternalModules]
-  const ignoredModules = [...IGNORED_MODULES, ...nextJsIgnoredModules]
-
-  return {
-    externalModules,
-    ignoredModules,
-  }
-}
-
-module.exports = { getExternalAndIgnoredModulesFromSpecialCases }

package/src/node_dependencies/traverse.js

@@ -1,147 +0,0 @@
-const { dirname } = require('path')
-
-const { getModuleName } = require('./module')
-const { getNestedDependencies, handleModuleNotFound } = require('./nested')
-const { getPackageJson } = require('./package_json')
-const { getPublishedFiles } = require('./published')
-const { resolvePackage } = require('./resolve')
-const { getSideFiles } = require('./side_files')
-
-const EXCLUDED_MODULES = new Set(['aws-sdk'])
-
-// Local cache used for optimizing the traversal of module dependencies.
-const getNewCache = () => ({ localFiles: new Set(), moduleNames: new Set(), modulePaths: new Set() })
-
-// When a file requires a module, we find its path inside `node_modules` and
-// use all its published files. We also recurse on the module's dependencies.
-const getDependencyPathsForDependency = async function ({
-  dependency,
-  basedir,
-  state,
-  packageJson,
-  pluginsModulesPath,
-}) {
-  const moduleName = getModuleName(dependency)
-
-  // Happens when doing require("@scope") (not "@scope/name") or other oddities
-  // Ignore those.
-  if (moduleName === null) {
-    return []
-  }
-
-  try {
-    return await getDependenciesForModuleName({ moduleName, basedir, state, pluginsModulesPath })
-  } catch (error) {
-    return handleModuleNotFound({ error, moduleName, packageJson })
-  }
-}
-
-const getDependencyNamesAndPathsForDependencies = async function ({
-  dependencies: dependencyNames,
-  basedir,
-  state = getNewCache(),
-  pluginsModulesPath,
-}) {
-  const packageJson = await getPackageJson(basedir)
-  const dependencies = await Promise.all(
-    dependencyNames.map((dependencyName) =>
-      getDependencyNamesAndPathsForDependency({
-        dependency: dependencyName,
-        basedir,
-        state,
-        packageJson,
-        pluginsModulesPath,
-      }),
-    ),
-  )
-  const moduleNames = new Set(dependencies.flatMap((dependency) => [...dependency.moduleNames]))
-  const paths = new Set(dependencies.flatMap((dependency) => [...dependency.paths]))
-
-  return {
-    moduleNames: [...moduleNames],
-    paths: [...paths],
-  }
-}
-
-const getDependencyNamesAndPathsForDependency = async function ({
-  dependency,
-  basedir,
-  state = getNewCache(),
-  packageJson,
-  pluginsModulesPath,
-}) {
-  try {
-    const paths = await getDependencyPathsForDependency({ dependency, basedir, state, packageJson, pluginsModulesPath })
-
-    return {
-      moduleNames: [...state.moduleNames],
-      paths,
-    }
-  } catch (error) {
-    if (error.code === 'MODULE_NOT_FOUND') {
-      return {
-        moduleNames: [],
-        paths: [],
-      }
-    }
-
-    throw error
-  }
-}
-
-const getDependenciesForModuleName = async function ({ moduleName, basedir, state, pluginsModulesPath }) {
-  if (isExcludedModule(moduleName)) {
-    return []
-  }
-
-  // Find the Node.js module directory path
-  const packagePath = await resolvePackage(moduleName, [basedir, pluginsModulesPath].filter(Boolean))
-
-  if (packagePath === undefined) {
-    return []
-  }
-
-  const modulePath = dirname(packagePath)
-
-  if (state.modulePaths.has(modulePath)) {
-    return []
-  }
-
-  state.moduleNames.add(moduleName)
-  state.modulePaths.add(modulePath)
-
-  // The path depends on the user's build, i.e. must be dynamic
-  // eslint-disable-next-line import/no-dynamic-require, node/global-require
-  const packageJson = require(packagePath)
-
-  const [publishedFiles, sideFiles, depsPaths] = await Promise.all([
-    getPublishedFiles(modulePath),
-    getSideFiles(modulePath, moduleName),
-    getNestedModules({ modulePath, state, packageJson, pluginsModulesPath }),
-  ])
-  return [...publishedFiles, ...sideFiles, ...depsPaths]
-}
-
-const isExcludedModule = function (moduleName) {
-  return EXCLUDED_MODULES.has(moduleName) || moduleName.startsWith('@types/')
-}
-
-const getNestedModules = async function ({ modulePath, state, packageJson, pluginsModulesPath }) {
-  const dependencies = getNestedDependencies(packageJson)
-
-  const depsPaths = await Promise.all(
-    dependencies.map((dependency) =>
-      getDependencyPathsForDependency({ dependency, basedir: modulePath, state, packageJson, pluginsModulesPath }),
-    ),
-  )
-  // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
-  // eslint-disable-next-line unicorn/prefer-spread
-  return [].concat(...depsPaths)
-}
-
-module.exports = {
-  getDependencyPathsForDependency,
-  getDependencyNamesAndPathsForDependencies,
-  getDependencyNamesAndPathsForDependency,
-  getNewCache,
-}

package/src/node_dependencies/tree_files.js

@@ -1,20 +0,0 @@
-const { promisify } = require('util')
-
-const glob = require('glob')
-
-const pGlob = promisify(glob)
-
-// When using a directory, we include all its descendants except `node_modules`
-const getTreeFiles = function (srcPath, stat) {
-  if (!stat.isDirectory()) {
-    return [srcPath]
-  }
-
-  return pGlob(`${srcPath}/**`, {
-    ignore: `${srcPath}/**/node_modules/**`,
-    nodir: true,
-    absolute: true,
-  })
-}
-
-module.exports = { getTreeFiles }

package/src/runtimes/detect_runtime.js

@@ -1,20 +0,0 @@
-const { detect, Runtime } = require('elf-cam')
-
-const { RUNTIME_GO, RUNTIME_RUST } = require('../utils/consts')
-const { cachedReadFile } = require('../utils/fs')
-
-// Try to guess the runtime by inspecting the binary file.
-const detectBinaryRuntime = async function ({ fsCache, path }) {
-  try {
-    const buffer = await cachedReadFile(fsCache, path)
-
-    return RUNTIMES[detect(buffer)]
-  } catch (error) {}
-}
-
-const RUNTIMES = {
-  [Runtime.Go]: RUNTIME_GO,
-  [Runtime.Rust]: RUNTIME_RUST,
-}
-
-module.exports = { detectBinaryRuntime }

package/src/runtimes/go/builder.js

@@ -1,37 +0,0 @@
-const { basename } = require('path')
-
-const { RUNTIME_GO } = require('../../utils/consts')
-const { lstat } = require('../../utils/fs')
-const { runCommand } = require('../../utils/shell')
-
-const build = async ({ destPath, mainFile, srcDir }) => {
-  const functionName = basename(srcDir)
-
-  try {
-    await runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
-      cwd: srcDir,
-      env: {
-        CGO_ENABLED: '0',
-        GOOS: 'linux',
-      },
-    })
-  } catch (error) {
-    error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_GO } }
-
-    console.error(`Could not compile Go function ${functionName}:\n`)
-
-    throw error
-  }
-
-  const stat = await lstat(destPath)
-
-  return {
-    mainFile,
-    name: functionName,
-    srcDir,
-    srcPath: destPath,
-    stat,
-  }
-}
-
-module.exports = { build }

package/src/runtimes/go/index.js

@@ -1,89 +0,0 @@
-const { basename, dirname, extname, join } = require('path')
-
-const cpFile = require('cp-file')
-
-const { RUNTIME_GO } = require('../../utils/consts')
-const { cachedLstat, cachedReaddir } = require('../../utils/fs')
-const { detectBinaryRuntime } = require('../detect_runtime')
-
-const { build } = require('./builder')
-
-const detectGoFunction = async ({ fsCache, path }) => {
-  const stat = await cachedLstat(fsCache, path)
-
-  if (!stat.isDirectory()) {
-    return
-  }
-
-  const directoryName = basename(path)
-  const files = await cachedReaddir(fsCache, path)
-  const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name))
-
-  if (mainFileName === undefined) {
-    return
-  }
-
-  return mainFileName
-}
-
-const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
-  const functions = await Promise.all(
-    paths.map(async (path) => {
-      const runtime = await detectBinaryRuntime({ fsCache, path })
-
-      if (runtime === RUNTIME_GO) {
-        return processBinary({ fsCache, path })
-      }
-
-      if (featureFlags.buildGoSource !== true) {
-        return
-      }
-
-      const goSourceFile = await detectGoFunction({ fsCache, path })
-
-      if (goSourceFile) {
-        return processSource({ fsCache, mainFile: goSourceFile, path })
-      }
-    }),
-  )
-
-  return functions.filter(Boolean)
-}
-
-const processBinary = async ({ fsCache, path }) => {
-  const stat = await cachedLstat(fsCache, path)
-  const name = basename(path, extname(path))
-
-  return {
-    mainFile: path,
-    name,
-    srcDir: dirname(path),
-    srcPath: path,
-    stat,
-  }
-}
-
-const processSource = ({ mainFile, path }) => {
-  const functionName = basename(path)
-
-  return {
-    mainFile: join(path, mainFile),
-    name: functionName,
-    srcDir: path,
-    srcPath: path,
-  }
-}
-
-const zipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath }) {
-  const destPath = join(destFolder, filename)
-  const isSource = extname(mainFile) === '.go'
-
-  // If we're building a Go function from source, we call the build method and
-  // it'll take care of placing the binary in the right location. If not, we
-  // need to copy the existing binary file to the destination directory.
-  await (isSource ? build({ destPath, mainFile, srcDir }) : cpFile(srcPath, destPath))
-
-  return { config, path: destPath }
-}
-
-module.exports = { findFunctionsInPaths, name: RUNTIME_GO, zipFunction }

package/src/runtimes/index.js

@@ -1,96 +0,0 @@
-const { extname, basename } = require('path')
-
-const { getConfigForFunction } = require('../config')
-
-const goRuntime = require('./go')
-const jsRuntime = require('./node')
-const rustRuntime = require('./rust')
-
-/**
- * Finds functions for a list of paths using a specific runtime. The return
- * value is an object containing an array of the functions found (`functions`)
- * and an array with the paths that haven't been recognized by the runtime
- * (`remainingPaths`).
- *
- * @param   {Boolean} dedupe
- * @param   {Object} fsCache
- * @param   {Array<String>} paths
- * @param   {Object} runtime
- * @returns {Promise<Object>}
- */
-const findFunctionsInRuntime = async function ({ dedupe = false, featureFlags, fsCache, paths, runtime }) {
-  const functions = await runtime.findFunctionsInPaths({ featureFlags, fsCache, paths })
-
-  // If `dedupe` is true, we use the function name (`filename`) as the map key,
-  // so that `function-1.js` will overwrite `function-1.go`. Otherwise, we use
-  // `srcPath`, so that both functions are returned.
-  const key = dedupe ? 'name' : 'srcPath'
-
-  // Augmenting the function objects with additional information.
-  const augmentedFunctions = functions.map((func) => [
-    func[key],
-    {
-      ...func,
-      extension: extname(func.mainFile),
-      filename: basename(func.srcPath),
-      runtime,
-    },
-  ])
-  const usedPaths = new Set(augmentedFunctions.map(([path]) => path))
-  const remainingPaths = paths.filter((path) => !usedPaths.has(path))
-
-  return { functions: augmentedFunctions, remainingPaths }
-}
-
-/**
- * Gets a list of functions found in a list of paths.
- *
- * @param   {Object} config
- * @param   {Boolean} dedupe
- * @param   {String} path
- * @returns {Promise<Map>}
- */
-const getFunctionsFromPaths = async (paths, { config, dedupe = false, featureFlags } = {}) => {
-  // An object to cache filesystem operations. This allows different functions
-  // to perform IO operations on the same file (i.e. getting its stats or its
-  // contents) without duplicating work.
-  const fsCache = {}
-
-  // The order of this array determines the priority of the runtimes. If a path
-  // is used by the first time, it won't be made available to the subsequent
-  // runtimes.
-  const runtimes = [jsRuntime, goRuntime, rustRuntime]
-
-  // We cycle through the ordered array of runtimes, passing each one of them
-  // through `findFunctionsInRuntime`. For each iteration, we collect all the
-  // functions found plus the list of paths that still need to be evaluated,
-  // using them as the input for the next iteration until the last runtime.
-  const { functions } = await runtimes.reduce(
-    async (aggregate, runtime) => {
-      const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = await aggregate
-      const { functions: runtimeFunctions, remainingPaths: runtimePaths } = await findFunctionsInRuntime({
-        dedupe,
-        featureFlags,
-        fsCache,
-        paths: aggregatePaths,
-        runtime,
-      })
-
-      return {
-        functions: [...aggregateFunctions, ...runtimeFunctions],
-        remainingPaths: runtimePaths,
-      }
-    },
-    { functions: [], remainingPaths: paths },
-  )
-  const functionsWithConfig = functions.map(([name, func]) => [
-    name,
-    { ...func, config: getConfigForFunction({ config, func }) },
-  ])
-
-  return new Map(functionsWithConfig)
-}
-
-module.exports = {
-  getFunctionsFromPaths,
-}

package/src/runtimes/node/base_path.js

@@ -1,11 +0,0 @@
-const commonPathPrefix = require('common-path-prefix')
-
-const getBasePath = (dirnames) => {
-  if (dirnames.length === 1) {
-    return dirnames[0]
-  }
-
-  return commonPathPrefix(dirnames)
-}
-
-module.exports = { getBasePath }