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

package/src/runtimes/node/list_imports.js

@@ -1,59 +0,0 @@
-const esbuild = require('@netlify/esbuild')
-const isBuiltinModule = require('is-builtin-module')
-const { tmpName } = require('tmp-promise')
-
-const { safeUnlink } = require('../../utils/fs')
-
-// Maximum number of log messages that an esbuild instance will produce. This
-// limit is important to avoid out-of-memory errors due to too much data being
-// sent in the Go<>Node IPC channel.
-const ESBUILD_LOG_LIMIT = 10
-
-const getListImportsPlugin = ({ imports, path }) => ({
-  name: 'list-imports',
-  setup(build) {
-    build.onResolve({ filter: /.*/ }, (args) => {
-      const isEntryPoint = args.path === path
-      const isImport = !isEntryPoint && !isBuiltinModule(args.path)
-
-      if (isImport) {
-        imports.add(args.path)
-      }
-
-      return {
-        namespace: 'list-imports',
-        external: isImport,
-      }
-    })
-  },
-})
-
-const listImports = async ({ path }) => {
-  // We're not interested in the output that esbuild generates, we're just
-  // using it for its parsing capabilities in order to find import/require
-  // statements. However, if we don't give esbuild a path in `outfile`, it
-  // will pipe the output to stdout, which we also don't want. So we create
-  // a temporary file to serve as the esbuild output and then get rid of it
-  // when we're done.
-  const targetPath = await tmpName()
-  const imports = new Set()
-
-  try {
-    await esbuild.build({
-      bundle: true,
-      entryPoints: [path],
-      logLevel: 'error',
-      logLimit: ESBUILD_LOG_LIMIT,
-      outfile: targetPath,
-      platform: 'node',
-      plugins: [getListImportsPlugin({ imports, path })],
-      target: 'esnext',
-    })
-  } finally {
-    await safeUnlink(targetPath)
-  }
-
-  return [...imports]
-}
-
-module.exports = { listImports }

package/src/runtimes/node/native_modules/detector.js

@@ -1,21 +0,0 @@
-const { extname } = require('path')
-
-const markerModules = ['bindings', 'nan', 'node-gyp', 'node-gyp-build', 'node-pre-gyp', 'prebuild']
-
-const isNativeModule = ({ binary, dependencies = {}, devDependencies = {}, files = [], gypfile }) => {
-  if (binary || gypfile) {
-    return true
-  }
-
-  const hasMarkerModule = markerModules.some((marker) => dependencies[marker] || devDependencies[marker])
-
-  if (hasMarkerModule) {
-    return true
-  }
-
-  const hasBinaryFile = files.some((path) => !path.startsWith('!') && extname(path) === '.node')
-
-  return hasBinaryFile
-}
-
-module.exports = { isNativeModule }

package/src/runtimes/node/native_modules/plugin.js

@@ -1,77 +0,0 @@
-const path = require('path')
-
-const readPackageJson = require('read-package-json-fast')
-
-const { isNativeModule } = require('./detector')
-
-// Filters out relative or absolute file paths.
-const packageFilter = /^([^./]*)$/
-
-// Filters valid package names and extracts the base directory.
-const packageName = /^([^@][^/]*|@[^/]*\/[^/]+)(?:\/|$)/
-
-const findNativeModule = (packageJsonPath, cache) => {
-  if (cache[packageJsonPath] === undefined) {
-    // eslint-disable-next-line no-param-reassign, promise/prefer-await-to-then
-    cache[packageJsonPath] = readPackageJson(packageJsonPath).then(
-      (data) => [Boolean(isNativeModule(data), data), data],
-      () => [],
-    )
-  }
-
-  return cache[packageJsonPath]
-}
-
-const getNativeModulesPlugin = (externalizedModules) => ({
-  name: 'external-native-modules',
-  setup(build) {
-    const cache = {}
-
-    // eslint-disable-next-line complexity, max-statements
-    build.onResolve({ filter: packageFilter }, async (args) => {
-      const package = packageName.exec(args.path)
-
-      if (!package) return
-
-      let directory = args.resolveDir
-
-      while (true) {
-        if (path.basename(directory) !== 'node_modules') {
-          const modulePath = path.join(directory, 'node_modules', package[1])
-          const packageJsonPath = path.join(modulePath, 'package.json')
-          // eslint-disable-next-line no-await-in-loop
-          const [isNative, packageJsonData] = await findNativeModule(packageJsonPath, cache)
-
-          // eslint-disable-next-line max-depth
-          if (isNative === true) {
-            // eslint-disable-next-line max-depth
-            if (externalizedModules[args.path] === undefined) {
-              // eslint-disable-next-line no-param-reassign
-              externalizedModules[args.path] = {}
-            }
-
-            // eslint-disable-next-line no-param-reassign
-            externalizedModules[args.path][modulePath] = packageJsonData.version
-
-            return { path: args.path, external: true }
-          }
-
-          // eslint-disable-next-line max-depth
-          if (isNative === false) {
-            return
-          }
-        }
-
-        const parentDirectory = path.dirname(directory)
-
-        if (parentDirectory === directory) {
-          break
-        }
-
-        directory = parentDirectory
-      }
-    })
-  },
-})
-
-module.exports = { getNativeModulesPlugin }

package/src/runtimes/node/src_files.js

@@ -1,99 +0,0 @@
-const { normalize } = require('path')
-const { promisify } = require('util')
-
-const glob = require('glob')
-
-const pGlob = promisify(glob)
-
-const { getDependencyNamesAndPathsForDependencies, listFilesUsingLegacyBundler } = require('../../node_dependencies')
-const { JS_BUNDLER_ZISI } = require('../../utils/consts')
-
-const getPathsOfIncludedFiles = async (includedFiles, basePath) => {
-  // Some of the globs in `includedFiles` might be exclusion patterns, which
-  // means paths that should NOT be included in the bundle. We need to treat
-  // these differently, so we iterate on the array and put those paths in a
-  // `exclude` array and the rest of the paths in an `include` array.
-  const { include, exclude } = includedFiles.reduce(
-    (acc, path) => {
-      if (path.startsWith('!')) {
-        return {
-          ...acc,
-          exclude: [...acc.exclude, path.slice(1)],
-        }
-      }
-
-      return {
-        ...acc,
-        include: [...acc.include, path],
-      }
-    },
-    { include: [], exclude: [] },
-  )
-  const pathGroups = await Promise.all(
-    include.map((expression) => pGlob(expression, { absolute: true, cwd: basePath, ignore: exclude, nodir: true })),
-  )
-
-  // `pathGroups` is an array containing the paths for each expression in the
-  // `include` array. We flatten it into a single dimension.
-  const paths = pathGroups.flat()
-  const normalizedPaths = paths.map(normalize)
-
-  return [...new Set(normalizedPaths)]
-}
-
-const getSrcFiles = async function ({ config, ...parameters }) {
-  const { paths } = await getSrcFilesAndExternalModules({
-    ...parameters,
-    externalNodeModules: config.externalNodeModules,
-  })
-
-  return paths
-}
-
-const getSrcFilesAndExternalModules = async function ({
-  bundler,
-  externalNodeModules = [],
-  featureFlags,
-  includedFiles = [],
-  includedFilesBasePath,
-  mainFile,
-  pluginsModulesPath,
-  srcDir,
-  srcPath,
-  stat,
-}) {
-  const includedFilePaths = await getPathsOfIncludedFiles(includedFiles, includedFilesBasePath)
-
-  if (bundler === JS_BUNDLER_ZISI) {
-    const paths = await listFilesUsingLegacyBundler({
-      featureFlags,
-      srcPath,
-      mainFile,
-      srcDir,
-      stat,
-      pluginsModulesPath,
-    })
-
-    return {
-      moduleNames: [],
-      paths: [...paths, ...includedFilePaths],
-    }
-  }
-
-  if (externalNodeModules.length !== 0) {
-    const { moduleNames, paths } = await getDependencyNamesAndPathsForDependencies({
-      dependencies: externalNodeModules,
-      basedir: srcDir,
-      pluginsModulesPath,
-    })
-
-    return { moduleNames, paths: [...paths, ...includedFilePaths, mainFile] }
-  }
-
-  return {
-    moduleNames: externalNodeModules,
-    paths: [mainFile, ...includedFilePaths],
-  }
-}
-
-module.exports = { getSrcFiles, getSrcFilesAndExternalModules }

package/src/runtimes/node/zip_esbuild.js

@@ -1,119 +0,0 @@
-const { dirname, normalize } = require('path')
-
-const { getExternalAndIgnoredModulesFromSpecialCases } = require('../../node_dependencies')
-const { JS_BUNDLER_ESBUILD } = require('../../utils/consts')
-const { getPathWithExtension } = require('../../utils/fs')
-const { zipNodeJs } = require('../../zip_node')
-
-const { getBasePath } = require('./base_path')
-const { bundleJsFile } = require('./bundler')
-const { getSrcFilesAndExternalModules } = require('./src_files')
-
-const getFunctionBasePath = ({ basePathFromConfig, mainFile, supportingSrcFiles }) => {
-  // If there is a base path defined in the config, we use that.
-  if (basePathFromConfig !== undefined) {
-    return basePathFromConfig
-  }
-
-  // If not, the base path is the common path prefix between all the supporting
-  // files and the main file.
-  const dirnames = [...supportingSrcFiles, mainFile].map((filePath) => normalize(dirname(filePath)))
-
-  return getBasePath(dirnames)
-}
-
-// Convenience method for retrieving external and ignored modules from
-// different places and merging them together.
-const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
-  const { externalNodeModules: externalModulesFromConfig = [], ignoredNodeModules: ignoredModulesFromConfig = [] } =
-    config
-  const { externalModules: externalModulesFromSpecialCases, ignoredModules: ignoredModulesFromSpecialCases } =
-    await getExternalAndIgnoredModulesFromSpecialCases({ srcDir })
-  const externalModules = [...new Set([...externalModulesFromConfig, ...externalModulesFromSpecialCases])]
-  const ignoredModules = [...ignoredModulesFromConfig, ...ignoredModulesFromSpecialCases]
-
-  return { externalModules, ignoredModules }
-}
-
-const zipEsbuild = async ({
-  archiveFormat,
-  basePath,
-  config = {},
-  destFolder,
-  extension,
-  filename,
-  mainFile,
-  name,
-  pluginsModulesPath,
-  srcDir,
-  srcPath,
-  stat,
-}) => {
-  const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir })
-  const {
-    additionalPaths,
-    bundlePaths,
-    cleanTempFiles,
-    inputs,
-    nativeNodeModules = {},
-    nodeModulesWithDynamicImports,
-    warnings,
-  } = await bundleJsFile({
-    additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
-    basePath,
-    config,
-    destFilename: filename,
-    externalModules,
-    ignoredModules,
-    name,
-    srcDir,
-    srcFile: mainFile,
-  })
-  const bundlerWarnings = warnings.length === 0 ? undefined : warnings
-  const { paths: srcFiles } = await getSrcFilesAndExternalModules({
-    externalNodeModules: [...externalModules, ...Object.keys(nativeNodeModules)],
-    bundler: JS_BUNDLER_ESBUILD,
-    includedFiles: [...(config.includedFiles || []), ...additionalPaths],
-    includedFilesBasePath: config.includedFilesBasePath || basePath,
-    mainFile,
-    srcPath,
-    srcDir,
-    pluginsModulesPath,
-    stat,
-  })
-
-  // We want to remove `mainFile` from `srcFiles` because it represents the
-  // path of the original, pre-bundling function file. We'll add the actual
-  // bundled file further below.
-  const supportingSrcFiles = srcFiles.filter((path) => path !== mainFile)
-  const normalizedMainFile = getPathWithExtension(mainFile, '.js')
-  const functionBasePath = getFunctionBasePath({ basePathFromConfig: basePath, mainFile, supportingSrcFiles })
-
-  try {
-    const path = await zipNodeJs({
-      aliases: bundlePaths,
-      archiveFormat,
-      basePath: functionBasePath,
-      destFolder,
-      extension,
-      filename,
-      mainFile: normalizedMainFile,
-      pluginsModulesPath,
-      srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],
-    })
-
-    return {
-      bundler: JS_BUNDLER_ESBUILD,
-      bundlerWarnings,
-      config,
-      inputs,
-      nativeNodeModules,
-      nodeModulesWithDynamicImports,
-      path,
-    }
-  } finally {
-    await cleanTempFiles()
-  }
-}
-
-module.exports = { zipEsbuild }

package/src/runtimes/node/zip_zisi.js

@@ -1,50 +0,0 @@
-const { dirname, normalize } = require('path')
-
-const { JS_BUNDLER_ZISI } = require('../../utils/consts')
-const { zipNodeJs } = require('../../zip_node')
-
-const { getBasePath } = require('./base_path')
-const { getSrcFilesAndExternalModules } = require('./src_files')
-
-const zipZisi = async ({
-  archiveFormat,
-  basePath,
-  config,
-  destFolder,
-  extension,
-  featureFlags,
-  filename,
-  mainFile,
-  pluginsModulesPath,
-  srcDir,
-  srcPath,
-  stat,
-}) => {
-  const { paths: srcFiles } = await getSrcFilesAndExternalModules({
-    bundler: JS_BUNDLER_ZISI,
-    extension,
-    featureFlags,
-    includedFiles: config.includedFiles,
-    includedFilesBasePath: config.includedFilesBasePath || basePath,
-    mainFile,
-    pluginsModulesPath,
-    srcDir,
-    srcPath,
-    stat,
-  })
-  const dirnames = srcFiles.map((filePath) => normalize(dirname(filePath)))
-  const path = await zipNodeJs({
-    archiveFormat,
-    basePath: getBasePath(dirnames),
-    destFolder,
-    extension,
-    filename,
-    mainFile,
-    pluginsModulesPath,
-    srcFiles,
-  })
-
-  return { bundler: JS_BUNDLER_ZISI, config, inputs: srcFiles, path }
-}
-
-module.exports = { zipZisi }

package/src/runtimes/rust/builder.js

@@ -1,114 +0,0 @@
-const { readFile } = require('fs')
-const { basename, join } = require('path')
-const { promisify } = require('util')
-
-const pReadFile = promisify(readFile)
-
-const makeDir = require('make-dir')
-const tmp = require('tmp-promise')
-const toml = require('toml')
-
-const { RUNTIME_RUST } = require('../../utils/consts')
-const { lstat } = require('../../utils/fs')
-const { runCommand } = require('../../utils/shell')
-
-const { BUILD_TARGET, MANIFEST_NAME } = require('./constants')
-
-const build = async ({ config, name, srcDir }) => {
-  const functionName = basename(srcDir)
-
-  try {
-    await installBuildTarget()
-  } catch (error) {
-    error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_RUST } }
-
-    throw error
-  }
-
-  const targetDirectory = await getTargetDirectory({ config, name })
-
-  await cargoBuild({ functionName, srcDir, targetDirectory })
-
-  // By default, the binary will have the same name as the crate and there's no
-  // way to override it (https://github.com/rust-lang/cargo/issues/1706). We
-  // must extract the crate name from the manifest and use it to form the path
-  // to the binary.
-  const manifest = await pReadFile(join(srcDir, MANIFEST_NAME))
-  const { package } = toml.parse(manifest)
-  const binaryPath = join(targetDirectory, BUILD_TARGET, 'release', package.name)
-  const stat = await lstat(binaryPath)
-
-  return {
-    path: binaryPath,
-    stat,
-  }
-}
-
-const cargoBuild = async ({ functionName, srcDir, targetDirectory }) => {
-  try {
-    await runCommand('cargo', ['build', '--target', BUILD_TARGET, '--release'], {
-      cwd: srcDir,
-      env: {
-        CARGO_TARGET_DIR: targetDirectory,
-      },
-    })
-  } catch (error) {
-    const hasToolchain = await checkRustToolchain()
-
-    if (hasToolchain) {
-      console.error(`Could not compile Rust function ${functionName}:\n`)
-    } else {
-      error.message =
-        'There is no Rust toolchain installed. Visit https://ntl.fyi/missing-rust-toolchain for more information.'
-    }
-
-    error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_RUST } }
-
-    throw error
-  }
-}
-
-const checkRustToolchain = async () => {
-  try {
-    await runCommand('cargo', ['-V'])
-
-    return true
-  } catch (_) {
-    return false
-  }
-}
-
-// Returns the path of the Cargo target directory.
-const getTargetDirectory = async ({ config, name }) => {
-  const { rustTargetDirectory } = config
-
-  // If the config includes a `rustTargetDirectory` path, we'll use that.
-  if (rustTargetDirectory) {
-    // We replace the [name] placeholder with the name of the function.
-    const path = rustTargetDirectory.replace(/\[name]/g, name)
-
-    await makeDir(path)
-
-    return path
-  }
-
-  // If the directory hasn't been configured, we'll use a temporary directory.
-  const { path } = await tmp.dir()
-
-  return path
-}
-
-let buildTargetInstallation
-
-// Installs the build target defined in `BUILD_TARGET`. The Promise is saved to
-// `buildTargetInstallation` so that we run the command just once for multiple
-// Rust functions.
-const installBuildTarget = () => {
-  if (buildTargetInstallation === undefined) {
-    buildTargetInstallation = runCommand('rustup', ['target', 'add', BUILD_TARGET])
-  }
-
-  return buildTargetInstallation
-}
-
-module.exports = { build }

package/src/runtimes/rust/constants.js

@@ -1,4 +0,0 @@
-const BUILD_TARGET = 'x86_64-unknown-linux-musl'
-const MANIFEST_NAME = 'Cargo.toml'
-
-module.exports = { BUILD_TARGET, MANIFEST_NAME }

package/src/runtimes/rust/index.js

@@ -1,112 +0,0 @@
-const { join, extname, dirname, basename } = require('path')
-
-const { RUNTIME_RUST } = require('../../utils/consts')
-const { cachedLstat, cachedReaddir } = require('../../utils/fs')
-const { zipBinary } = require('../../zip_binary')
-const { detectBinaryRuntime } = require('../detect_runtime')
-
-const { build } = require('./builder')
-const { MANIFEST_NAME } = require('./constants')
-
-const detectRustFunction = async ({ fsCache, path }) => {
-  const stat = await cachedLstat(fsCache, path)
-
-  if (!stat.isDirectory()) {
-    return
-  }
-
-  const files = await cachedReaddir(fsCache, path)
-  const hasCargoManifest = files.includes(MANIFEST_NAME)
-
-  if (!hasCargoManifest) {
-    return
-  }
-
-  const mainFilePath = join(path, 'src', 'main.rs')
-
-  try {
-    const mainFile = await cachedLstat(fsCache, mainFilePath)
-
-    if (mainFile.isFile()) {
-      return mainFilePath
-    }
-  } catch (_) {
-    // no-op
-  }
-}
-
-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_RUST) {
-        return processBinary({ fsCache, path })
-      }
-
-      if (featureFlags.buildRustSource !== true) {
-        return
-      }
-
-      const rustSourceFile = await detectRustFunction({ fsCache, path })
-
-      if (rustSourceFile) {
-        return processSource({ fsCache, mainFile: rustSourceFile, 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,
-    name: functionName,
-    srcDir: path,
-    srcPath: path,
-  }
-}
-
-// The name of the binary inside the zip file must always be `bootstrap`
-// because they include the Lambda runtime, and that's the name that AWS
-// expects for those kind of functions.
-const zipFunction = async function ({ config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat }) {
-  const destPath = join(destFolder, `${filename}.zip`)
-  const isSource = extname(mainFile) === '.rs'
-  const zipOptions = {
-    destPath,
-    filename: 'bootstrap',
-    runtime,
-  }
-
-  // If we're building from source, we first need to build the source and zip
-  // the resulting binary. Otherwise, we're dealing with a binary so we zip it
-  // directly.
-  if (isSource) {
-    const { path: binaryPath, stat: binaryStat } = await build({ config, name: filename, srcDir })
-
-    await zipBinary({ ...zipOptions, srcPath: binaryPath, stat: binaryStat })
-  } else {
-    await zipBinary({ ...zipOptions, srcPath, stat })
-  }
-
-  return { config, path: destPath }
-}
-
-module.exports = { findFunctionsInPaths, name: RUNTIME_RUST, zipFunction }

package/src/utils/consts.js

@@ -1,10 +0,0 @@
-module.exports = {
-  ARCHIVE_FORMAT_NONE: 'none',
-  ARCHIVE_FORMAT_ZIP: 'zip',
-  JS_BUNDLER_ESBUILD: 'esbuild',
-  JS_BUNDLER_ESBUILD_ZISI: 'esbuild_zisi',
-  JS_BUNDLER_ZISI: 'zisi',
-  RUNTIME_GO: 'go',
-  RUNTIME_JS: 'js',
-  RUNTIME_RUST: 'rs',
-}