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

package/src/runtimes/node/bundler.js

@@ -1,151 +0,0 @@
-const { basename, dirname, extname, resolve, join } = require('path')
-
-const esbuild = require('@netlify/esbuild')
-const { tmpName } = require('tmp-promise')
-
-const { RUNTIME_JS } = require('../../utils/consts')
-const { getPathWithExtension, safeUnlink } = require('../../utils/fs')
-
-const { getBundlerTarget } = require('./bundler_target')
-const { getDynamicImportsPlugin } = require('./dynamic_imports/plugin')
-const { getNativeModulesPlugin } = require('./native_modules/plugin')
-
-// 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
-
-// When resolving imports with no extension (e.g. require('./foo')), these are
-// the extensions that esbuild will look for, in this order.
-const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.json']
-
-// eslint-disable-next-line max-statements
-const bundleJsFile = async function ({
-  additionalModulePaths,
-  basePath,
-  config,
-  externalModules = [],
-  ignoredModules = [],
-  name,
-  srcDir,
-  srcFile,
-}) {
-  // We use a temporary directory as the destination for esbuild files to avoid
-  // any naming conflicts with files generated by other functions.
-  const targetDirectory = await tmpName()
-
-  // De-duping external and ignored modules.
-  const external = [...new Set([...externalModules, ...ignoredModules])]
-
-  // To be populated by the native modules plugin with the names, versions and
-  // paths of any Node modules with native dependencies.
-  const nativeNodeModules = {}
-
-  // To be populated by the dynamic imports plugin with the names of the Node
-  // modules that include imports with dynamic expressions.
-  const nodeModulesWithDynamicImports = new Set()
-
-  // To be populated by the dynamic imports plugin with any paths (in a glob
-  // format) to be included in the bundle in order to make a dynamic import
-  // work at runtime.
-  const dynamicImportsIncludedPaths = new Set()
-
-  // The list of esbuild plugins to enable for this build.
-  const plugins = [
-    getNativeModulesPlugin(nativeNodeModules),
-    getDynamicImportsPlugin({
-      basePath,
-      includedPaths: dynamicImportsIncludedPaths,
-      moduleNames: nodeModulesWithDynamicImports,
-      processImports: config.processDynamicNodeImports !== false,
-      srcDir,
-    }),
-  ]
-
-  // The version of ECMAScript to use as the build target. This will determine
-  // whether certain features are transpiled down or left untransformed.
-  const nodeTarget = getBundlerTarget(config.nodeVersion)
-
-  // esbuild will format `sources` relative to the sourcemap file, which lives
-  // in `destFolder`. We use `sourceRoot` to establish that relation. They are
-  // URLs, not paths, so even on Windows they should use forward slashes.
-  const sourceRoot = targetDirectory.replace(/\\/g, '/')
-
-  try {
-    const { metafile, warnings } = await esbuild.build({
-      bundle: true,
-      entryPoints: [srcFile],
-      external,
-      logLevel: 'warning',
-      logLimit: ESBUILD_LOG_LIMIT,
-      metafile: true,
-      nodePaths: additionalModulePaths,
-      outdir: targetDirectory,
-      platform: 'node',
-      plugins,
-      resolveExtensions: RESOLVE_EXTENSIONS,
-      sourcemap: Boolean(config.nodeSourcemap),
-      sourceRoot,
-      target: [nodeTarget],
-    })
-    const bundlePaths = getBundlePaths({
-      destFolder: targetDirectory,
-      outputs: metafile.outputs,
-      srcFile,
-    })
-    const inputs = Object.keys(metafile.inputs).map((path) => resolve(path))
-    const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()])
-
-    return {
-      additionalPaths: [...dynamicImportsIncludedPaths],
-      bundlePaths,
-      cleanTempFiles,
-      inputs,
-      nativeNodeModules,
-      nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
-      warnings,
-    }
-  } catch (error) {
-    error.customErrorInfo = { type: 'functionsBundling', location: { functionName: name, runtime: RUNTIME_JS } }
-
-    throw error
-  }
-}
-
-// Takes the `outputs` object produced by esbuild and returns a Map with the
-// absolute paths of the generated files as keys, and the paths that those
-// files should take in the generated bundle as values. This is compatible
-// with the `aliases` format used upstream.
-const getBundlePaths = ({ destFolder, outputs, srcFile }) => {
-  const bundleFilename = `${basename(srcFile, extname(srcFile))}.js`
-  const mainFileDirectory = dirname(srcFile)
-  const bundlePaths = new Map()
-
-  // The paths returned by esbuild are relative to the current directory, which
-  // is a problem on Windows if the target directory is in a different drive
-  // letter. To get around that, instead of using `path.resolve`, we compute
-  // the absolute path by joining `destFolder` with the `basename` of each
-  // entry of the `outputs` object.
-  Object.entries(outputs).forEach(([path, output]) => {
-    const filename = basename(path)
-    const extension = extname(path)
-    const absolutePath = join(destFolder, filename)
-
-    if (output.entryPoint && basename(output.entryPoint) === basename(srcFile)) {
-      // Ensuring the main file has a `.js` extension.
-      const normalizedSrcFile = getPathWithExtension(srcFile, '.js')
-
-      bundlePaths.set(absolutePath, normalizedSrcFile)
-    } else if (extension === '.js' || filename === `${bundleFilename}.map`) {
-      bundlePaths.set(absolutePath, join(mainFileDirectory, filename))
-    }
-  })
-
-  return bundlePaths
-}
-
-const getCleanupFunction = (paths) => async () => {
-  await Promise.all(paths.filter(Boolean).map(safeUnlink))
-}
-
-module.exports = { bundleJsFile, ESBUILD_LOG_LIMIT }

package/src/runtimes/node/bundler_target.js

@@ -1,22 +0,0 @@
-const DEFAULT_VERSION = 'node12'
-
-const versionMap = {
-  '8.x': 'node8',
-  '10.x': 'node10',
-  '12.x': 'node12',
-  '14.x': 'node14',
-}
-
-const getBundlerTarget = (suppliedVersion) => {
-  const version = normalizeVersion(suppliedVersion)
-
-  return versionMap[version] || DEFAULT_VERSION
-}
-
-const normalizeVersion = (version) => {
-  const match = version && version.match(/^nodejs(.*)$/)
-
-  return match ? match[1] : version
-}
-
-module.exports = { getBundlerTarget }

package/src/runtimes/node/detect_es_module.js

@@ -1,24 +0,0 @@
-const { readFile } = require('fs')
-const { promisify } = require('util')
-
-const pReadFile = promisify(readFile)
-
-const { init, parse } = require('es-module-lexer')
-
-const detectEsModule = async ({ mainFile }) => {
-  if (!mainFile) {
-    return false
-  }
-
-  try {
-    const [mainFileContents] = await Promise.all([pReadFile(mainFile, 'utf8'), init])
-    const [imports, exports] = parse(mainFileContents)
-
-    return imports.length !== 0 || exports.length !== 0
-  } catch {
-    // If there are any problems with init or parsing, assume it's not an ES module
-    return false
-  }
-}
-
-module.exports = { detectEsModule }

package/src/runtimes/node/dynamic_imports/parser.js

@@ -1,162 +0,0 @@
-const { join, relative, resolve } = require('path')
-
-const babel = require('@babel/parser')
-
-const GLOB_WILDCARD = '**'
-
-// Transforms an array of glob nodes into a glob string including an absolute
-// path.
-//
-// Example: ["./files/", "*", ".json"] => "/home/ntl/files/*.json"
-const getAbsoluteGlob = ({ basePath, globNodes, resolveDir }) => {
-  if (!validateGlobNodes(globNodes)) {
-    return null
-  }
-
-  const globStarIndex = globNodes.indexOf(GLOB_WILDCARD)
-  const [staticPath, dynamicPath] =
-    globStarIndex === -1
-      ? [globNodes.join(''), '']
-      : [globNodes.slice(0, globStarIndex).join(''), globNodes.slice(globStarIndex).join('')]
-  const absoluteStaticPath = resolve(resolveDir, staticPath)
-  const relativeStaticPath = relative(basePath, absoluteStaticPath)
-  const absoluteGlob = join(relativeStaticPath, dynamicPath)
-
-  return absoluteGlob
-}
-
-// Returns GLOB_WILDCARD for AST nodes that are accepted as part of a dynamic
-// expression and convertable to a wildcard character. This determines whether
-// we convert an expression or leave it alone. For example:
-//
-// - `./files/${someVariable}`: Convert `someVariable` to GLOB_WILDCARD
-// - `./files/${[some, array]}`: Don't convert expression
-//
-// The following AST nodes are converted to a wildcard:
-//
-// - CallExpression: `someFunction()`
-// - ConditionalExpression: `someCond ? someValue : otherValue`
-// - Identifier: `someVariable`
-// - MemberExpression: `someArray[index]` or `someObject.property`
-const getWildcardFromASTNode = (node) => {
-  switch (node.type) {
-    case 'CallExpression':
-    case 'ConditionalExpression':
-    case 'Identifier':
-    case 'MemberExpression':
-      return GLOB_WILDCARD
-
-    default:
-      throw new Error('Expression member not supported')
-  }
-}
-
-// Tries to parse an expression, returning an object with:
-// - `includedPathsGlob`: A glob with the files to be included in the bundle
-// - `type`: The expression type (e.g. "require", "import")
-const parseExpression = ({ basePath, expression: rawExpression, resolveDir }) => {
-  const { program } = babel.parse(rawExpression, {
-    sourceType: 'module',
-  })
-  const [topLevelExpression] = program.body
-  const { expression } = topLevelExpression
-
-  if (expression.type === 'CallExpression' && expression.callee.name === 'require') {
-    try {
-      const includedPathsGlob = parseRequire({ basePath, expression, resolveDir })
-
-      return {
-        includedPathsGlob,
-        type: expression.callee.name,
-      }
-    } catch (_) {
-      // no-op
-    }
-  }
-}
-
-// Parses a `require()` and returns a glob string with an absolute path.
-const parseRequire = ({ basePath, expression, resolveDir }) => {
-  const { arguments: args = [] } = expression
-  const argType = args.length === 0 ? null : args[0].type
-
-  if (argType === 'BinaryExpression') {
-    try {
-      const globNodes = parseBinaryExpression(args[0])
-
-      return getAbsoluteGlob({ basePath, globNodes, resolveDir })
-    } catch (_) {
-      // no-op
-    }
-  }
-
-  if (argType === 'TemplateLiteral') {
-    const globNodes = parseTemplateLiteral(args[0])
-
-    return getAbsoluteGlob({ basePath, globNodes, resolveDir })
-  }
-}
-
-// Transforms a binary expression AST node into an array of glob nodes, where
-// static parts will be left untouched and identifiers will be replaced by
-// `GLOB_WILDCARD`.
-//
-// Example: './files/' + lang + '.json' => ["./files/", "**", ".json"]
-const parseBinaryExpression = (expression) => {
-  const { left, operator, right } = expression
-
-  if (operator !== '+') {
-    throw new Error('Expression operator not supported')
-  }
-
-  const operands = [left, right].flatMap((operand) => {
-    switch (operand.type) {
-      case 'BinaryExpression':
-        return parseBinaryExpression(operand)
-
-      case 'StringLiteral':
-        return operand.value
-
-      default:
-        return getWildcardFromASTNode(operand)
-    }
-  })
-
-  return operands
-}
-
-// Transforms a template literal AST node into an array of glob nodes, where
-// static parts will be left untouched and identifiers will be replaced by
-// `GLOB_WILDCARD`.
-//
-// Example: `./files/${lang}.json` => ["./files/", "**", ".json"]
-const parseTemplateLiteral = (expression) => {
-  const { expressions, quasis } = expression
-  const parts = [...expressions, ...quasis].sort((partA, partB) => partA.start - partB.start)
-  const globNodes = parts.map((part) => {
-    switch (part.type) {
-      case 'TemplateElement':
-        return part.value.cooked
-
-      default:
-        return getWildcardFromASTNode(part)
-    }
-  })
-
-  return globNodes.filter(Boolean)
-}
-
-// For our purposes, we consider a glob to be valid if all the nodes are
-// strings and the first node is static (i.e. not a wildcard character).
-const validateGlobNodes = (globNodes) => {
-  if (!globNodes) {
-    return false
-  }
-
-  const hasStrings = globNodes.every((node) => typeof node === 'string')
-  const hasStaticHead = globNodes[0] !== GLOB_WILDCARD
-
-  return hasStrings && hasStaticHead
-}
-
-module.exports = { parseExpression }

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

@@ -1,116 +0,0 @@
-const { basename, join, relative } = require('path')
-
-const findUp = require('find-up')
-const readPackageJson = require('read-package-json-fast')
-const unixify = require('unixify')
-
-const { parseExpression } = require('./parser')
-
-// This plugin intercepts module imports using dynamic expressions and does a
-// couple of things with them. First of all, it figures out whether the call
-// is being made from within a Node module, and if so it adds the name of the
-// module to `moduleNames`, so that we can warn the user of potential runtime
-// issues. Secondly, it parses the dynamic expressions and tries to include in
-// the bundle all the files that are possibly needed to make the import work at
-// runtime. This is not always possible, but we do our best.
-const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, processImports, srcDir }) => ({
-  name: 'dynamic-imports',
-  setup(build) {
-    const cache = new Map()
-
-    // eslint-disable-next-line complexity
-    build.onDynamicImport({}, async (args) => {
-      const { expression, resolveDir } = args
-
-      // Don't attempt to parse the expression if the base path isn't defined,
-      // since we won't be able to generate the globs for the included paths.
-      // Also don't parse the expression if we're not interested in processing
-      // the dynamic import expressions.
-      if (basePath && processImports) {
-        const { includedPathsGlob, type: expressionType } = parseExpression({ basePath, expression, resolveDir }) || {}
-
-        if (includedPathsGlob) {
-          // The parser has found a glob of paths that should be included in the
-          // bundle to make this import work, so we add it to `includedPaths`.
-          includedPaths.add(includedPathsGlob)
-
-          // Create the shim that will handle the import at runtime.
-          const contents = getShimContents({ expressionType, resolveDir, srcDir })
-
-          // This is the only branch where we actually solve a dynamic import.
-          // eslint-disable-next-line max-depth
-          if (contents) {
-            return {
-              contents,
-            }
-          }
-        }
-      }
-
-      // If we're here, it means we weren't able to solve the dynamic import.
-      // We add it to the list of modules with dynamic imports, which allows
-      // consumers like Netlify Build or CLI to advise users on how to proceed.
-      await registerModuleWithDynamicImports({ cache, moduleNames, resolveDir, srcDir })
-    })
-  },
-})
-
-const getPackageName = async ({ resolveDir, srcDir }) => {
-  const packageJsonPath = await findUp(
-    async (directory) => {
-      // We stop traversing if we're about to leave the boundaries of the
-      // function directory or any node_modules directory.
-      if (directory === srcDir || basename(directory) === 'node_modules') {
-        return findUp.stop
-      }
-
-      const path = join(directory, 'package.json')
-      const hasPackageJson = await findUp.exists(path)
-
-      return hasPackageJson ? path : false
-    },
-    { cwd: resolveDir },
-  )
-
-  if (packageJsonPath !== undefined) {
-    const { name } = await readPackageJson(packageJsonPath)
-
-    return name
-  }
-}
-
-const getPackageNameCached = ({ cache, resolveDir, srcDir }) => {
-  if (!cache.has(resolveDir)) {
-    cache.set(resolveDir, getPackageName({ resolveDir, srcDir }))
-  }
-
-  return cache.get(resolveDir)
-}
-
-const getShimContents = ({ expressionType, resolveDir, srcDir }) => {
-  // The shim needs to modify the path of the import, since originally it was
-  // relative to wherever the importer sat in the file tree (i.e. anywhere in
-  // the user space or inside `node_modules`), but at runtime paths must be
-  // relative to the main bundle file, since esbuild will flatten everything
-  // into a single file.
-  const relativeResolveDir = relative(srcDir, resolveDir)
-  const requireArg = relativeResolveDir ? `\`./${unixify(relativeResolveDir)}/$\{args}\`` : 'args'
-
-  if (expressionType === 'require') {
-    return `module.exports = args => require(${requireArg})`
-  }
-}
-
-const registerModuleWithDynamicImports = async ({ cache, moduleNames, resolveDir, srcDir }) => {
-  try {
-    const packageName = await getPackageNameCached({ cache, resolveDir, srcDir })
-
-    if (packageName !== undefined) {
-      moduleNames.add(packageName)
-    }
-  } catch (_) {
-    // no-op
-  }
-}
-
-module.exports = { getDynamicImportsPlugin }

package/src/runtimes/node/finder.js

@@ -1,93 +0,0 @@
-const { lstat } = require('fs')
-const { join, dirname, basename, extname } = require('path')
-const { promisify } = require('util')
-
-const locatePath = require('locate-path')
-
-const pLstat = promisify(lstat)
-
-// List of extensions that this runtime will look for, in order of precedence.
-const allowedExtensions = ['.js', '.zip', '.cjs', '.mjs', '.ts']
-
-// Sorting function, compatible with the callback of Array.sort, which sorts
-// entries by extension according to their position in `allowedExtensions`.
-// It places extensions with a higher precedence last in the array, so that
-// they "win" when the array is flattened into a Map.
-const sortByExtension = (fA, fB) => {
-  const indexA = allowedExtensions.indexOf(fA.extension)
-  const indexB = allowedExtensions.indexOf(fB.extension)
-
-  return indexB - indexA
-}
-
-const findFunctionsInPaths = async function ({ paths }) {
-  const functions = await Promise.all(paths.map(getFunctionAtPath))
-
-  // It's fine to mutate the array since its scope is local to this function.
-  const sortedFunctions = functions.filter(Boolean).sort((fA, fB) => {
-    // We first sort the functions array to put directories first. This is so
-    // that `{name}/{name}.js` takes precedence over `{name}.js`.
-    const directorySort = Number(fA.stat.isDirectory()) - Number(fB.stat.isDirectory())
-
-    if (directorySort !== 0) {
-      return directorySort
-    }
-
-    // If the functions have the same name, we sort them according to the order
-    // defined in `allowedExtensions`.
-    if (fA.name === fB.name) {
-      return sortByExtension(fA, fB)
-    }
-
-    return 0
-  })
-
-  return sortedFunctions
-}
-
-const getFunctionAtPath = async function (srcPath) {
-  const filename = basename(srcPath)
-
-  if (filename === 'node_modules') {
-    return
-  }
-
-  const stat = await pLstat(srcPath)
-  const mainFile = await getMainFile(srcPath, filename, stat)
-
-  if (mainFile === undefined) {
-    return
-  }
-
-  const extension = extname(srcPath)
-  const srcDir = stat.isDirectory() ? srcPath : dirname(srcPath)
-  const name = basename(srcPath, extname(srcPath))
-
-  return { extension, mainFile, name, srcDir, srcPath, stat }
-}
-
-// Each `srcPath` can also be a directory with an `index` file or a file using
-// the same filename as its directory.
-const getMainFile = function (srcPath, filename, stat) {
-  if (stat.isDirectory()) {
-    return locatePath(
-      [
-        join(srcPath, `${filename}.js`),
-        join(srcPath, 'index.js'),
-        join(srcPath, `${filename}.mjs`),
-        join(srcPath, 'index.mjs'),
-        join(srcPath, `${filename}.ts`),
-        join(srcPath, 'index.ts'),
-      ],
-      { type: 'file' },
-    )
-  }
-
-  const extension = extname(srcPath)
-
-  if (allowedExtensions.includes(extension)) {
-    return srcPath
-  }
-}
-
-module.exports = { findFunctionsInPaths, getFunctionAtPath }

package/src/runtimes/node/index.js

@@ -1,122 +0,0 @@
-const { join } = require('path')
-
-const cpFile = require('cp-file')
-
-const { JS_BUNDLER_ESBUILD, JS_BUNDLER_ESBUILD_ZISI, JS_BUNDLER_ZISI, RUNTIME_JS } = require('../../utils/consts')
-
-const { detectEsModule } = require('./detect_es_module')
-const { findFunctionsInPaths } = require('./finder')
-const { getSrcFiles } = require('./src_files')
-const { zipEsbuild } = require('./zip_esbuild')
-const { zipZisi } = require('./zip_zisi')
-
-// We use ZISI as the default bundler, except for certain extensions, for which
-// esbuild is the only option.
-const getDefaultBundler = async ({ extension, mainFile, featureFlags = {} }) => {
-  if (['.mjs', '.ts'].includes(extension)) {
-    return JS_BUNDLER_ESBUILD
-  }
-
-  if (featureFlags.defaultEsModulesToEsbuild) {
-    const isEsModule = await detectEsModule({ mainFile })
-
-    if (isEsModule) {
-      return JS_BUNDLER_ESBUILD
-    }
-  }
-
-  return JS_BUNDLER_ZISI
-}
-
-// A proxy for the `getSrcFiles` function which adds a default `bundler` using
-// the `getDefaultBundler` function.
-const getSrcFilesWithBundler = async (parameters) => {
-  const bundler = parameters.config.nodeBundler || (await getDefaultBundler({ extension: parameters.extension }))
-
-  return getSrcFiles({ ...parameters, bundler })
-}
-
-const zipFunction = async function ({
-  archiveFormat,
-  basePath,
-  config = {},
-  destFolder,
-  extension,
-  featureFlags,
-  filename,
-  mainFile,
-  name,
-  pluginsModulesPath,
-  srcDir,
-  srcPath,
-  stat,
-}) {
-  const bundler = config.nodeBundler || (await getDefaultBundler({ extension, mainFile, featureFlags }))
-  // If the file is a zip, we assume the function is bundled and ready to go.
-  // We simply copy it to the destination path with no further processing.
-  if (extension === '.zip') {
-    const destPath = join(destFolder, filename)
-    await cpFile(srcPath, destPath)
-    return { config, path: destPath }
-  }
-
-  if (bundler === JS_BUNDLER_ZISI) {
-    return zipZisi({
-      archiveFormat,
-      basePath,
-      config,
-      destFolder,
-      extension,
-      featureFlags,
-      filename,
-      mainFile,
-      pluginsModulesPath,
-      srcDir,
-      srcPath,
-      stat,
-    })
-  }
-
-  return zipEsbuild({
-    archiveFormat,
-    basePath,
-    config,
-    destFolder,
-    extension,
-    filename,
-    mainFile,
-    name,
-    pluginsModulesPath,
-    srcDir,
-    srcPath,
-    stat,
-  })
-}
-
-const zipWithFunctionWithFallback = async ({ config = {}, ...parameters }) => {
-  // If a specific JS bundler version is specified, we'll use it.
-  if (config.nodeBundler !== JS_BUNDLER_ESBUILD_ZISI) {
-    return zipFunction({ ...parameters, config })
-  }
-
-  // Otherwise, we'll try to bundle with esbuild and, if that fails, fallback
-  // to zisi.
-  try {
-    return await zipFunction({ ...parameters, config: { ...config, nodeBundler: JS_BUNDLER_ESBUILD } })
-  } catch (esbuildError) {
-    try {
-      const data = await zipFunction({ ...parameters, config: { ...config, nodeBundler: JS_BUNDLER_ZISI } })
-
-      return { ...data, bundlerErrors: esbuildError.errors }
-    } catch (zisiError) {
-      throw esbuildError
-    }
-  }
-}
-
-module.exports = {
-  findFunctionsInPaths,
-  getSrcFiles: getSrcFilesWithBundler,
-  name: RUNTIME_JS,
-  zipFunction: zipWithFunctionWithFallback,
-}