feat: extract implementation from ZISI

Author: Skn0tt

.eslintrc.cjs

@@ -4,5 +4,23 @@ const { overrides } = require('@netlify/eslint-config-node/.eslintrc_esm.cjs')
 
 module.exports = {
   extends: '@netlify/eslint-config-node/.eslintrc_esm.cjs',
-  overrides: [...overrides],
+  rules: {
+    'n/no-missing-import': 'off',
+    // This is disabled because TypeScript transpiles some features currently
+    // unsupported by Node 12, i.e. optional chaining
+    // TODO: re-enable after dropping support for Node 12
+    'n/no-unsupported-features/es-syntax': 'off',
+  },
+  overrides: [
+    ...overrides,
+    {
+      files: '*.ts',
+      rules: {
+        // Pure ES modules with TypeScript require using `.js` instead of `.ts`
+        // in imports
+        'import/extensions': 'off',
+        'import/no-namespace': 'off',
+      },
+    },
+  ],
 }

package-lock.json

@@ -57,5 +57,9 @@
   },
   "engines": {
     "node": "^12.20.0 || ^14.14.0 || >=16.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.18.6",
+    "@babel/types": "^7.18.7"
   }
 }

package.json

@@ -0,0 +1,88 @@
+import { CallExpression, Statement } from '@babel/types'
+
+import { isModuleExports } from './helpers.js'
+
+import type { ISCExport } from './index.js'
+
+// Finds the main handler export in an AST.
+export const getMainExport = (nodes: Statement[]) => {
+  let handlerExport: ISCExport[] = []
+
+  nodes.find((node) => {
+    const esmExports = getMainExportFromESM(node)
+
+    if (esmExports.length !== 0) {
+      handlerExport = esmExports
+
+      return true
+    }
+
+    const cjsExports = getMainExportFromCJS(node)
+
+    if (cjsExports.length !== 0) {
+      handlerExport = cjsExports
+
+      return true
+    }
+
+    return false
+  })
+
+  return handlerExport
+}
+
+// Finds the main handler export in a CJS AST.
+const getMainExportFromCJS = (node: Statement) => {
+  const handlerPaths = [
+    ['module', 'exports', 'handler'],
+    ['exports', 'handler'],
+  ]
+
+  return handlerPaths.flatMap((handlerPath) => {
+    if (!isModuleExports(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+      return []
+    }
+
+    return getExportsFromCallExpression(node.expression.right)
+  })
+}
+
+// Finds the main handler export in an ESM AST.
+// eslint-disable-next-line complexity
+const getMainExportFromESM = (node: Statement) => {
+  if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
+    return []
+  }
+
+  const { declaration } = node
+
+  if (!declaration || declaration.type !== 'VariableDeclaration') {
+    return []
+  }
+
+  const handlerDeclaration = declaration.declarations.find((childDeclaration) => {
+    const { id, type } = childDeclaration
+
+    return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === 'handler'
+  })
+
+  if (handlerDeclaration?.init?.type !== 'CallExpression') {
+    return []
+  }
+
+  const exports = getExportsFromCallExpression(handlerDeclaration.init)
+
+  return exports
+}
+
+const getExportsFromCallExpression = (node: CallExpression) => {
+  const { arguments: args, callee } = node
+
+  if (callee.type !== 'Identifier') {
+    return []
+  }
+
+  const exports = [{ local: callee.name, args }]
+
+  return exports
+}

src/exports.ts

@@ -0,0 +1,57 @@
+import {
+  AssignmentExpression,
+  Expression,
+  ExpressionStatement,
+  ImportDeclaration,
+  Statement,
+  StringLiteral,
+  V8IntrinsicIdentifier,
+} from '@babel/types'
+
+// eslint-disable-next-line complexity
+const isDotExpression = (node: Expression, expression: string[]): boolean => {
+  if (node.type !== 'MemberExpression') {
+    return false
+  }
+
+  const object = expression.slice(0, -1)
+  const [property] = expression.slice(-1)
+
+  if (node.property.type !== 'Identifier' || node.property.name !== property) {
+    return false
+  }
+
+  if (object.length > 1) {
+    return isDotExpression(node.object, object)
+  }
+
+  return node.object.type === 'Identifier' && object[0] === node.object.name && property === node.property.name
+}
+
+export const isImport = (node: Statement, importPath: string): node is ImportDeclaration =>
+  node.type === 'ImportDeclaration' && node.source.value === importPath
+
+export const isModuleExports = (
+  node: Statement,
+  dotExpression = ['module', 'exports'],
+): node is ExpressionStatement & { expression: AssignmentExpression } =>
+  node.type === 'ExpressionStatement' &&
+  node.expression.type === 'AssignmentExpression' &&
+  node.expression.left.type === 'MemberExpression' &&
+  isDotExpression(node.expression.left, dotExpression)
+
+export const isRequire = (node: Expression | undefined | null, requirePath: string) => {
+  if (!node || node.type !== 'CallExpression') {
+    return false
+  }
+
+  const { arguments: args, callee } = node
+  const isRequiredModule = args[0]?.type === 'StringLiteral' && isRequirePath(args[0], requirePath)
+
+  return isRequireCall(callee) && isRequiredModule
+}
+
+const isRequireCall = (node: Expression | V8IntrinsicIdentifier) =>
+  node.type === 'Identifier' && node.name === 'require'
+
+const isRequirePath = (node: StringLiteral, path: string) => node.type === 'StringLiteral' && node.value === path

src/helpers.ts

@@ -0,0 +1,78 @@
+import { Statement } from '@babel/types'
+
+import { isImport, isRequire } from './helpers.js'
+import { nonNullable } from './utils.js'
+
+// Finds import/require statements of a given path in an AST.
+export const getImports = (node: Statement, importPath: string) => {
+  const esmImports = getImportsFromESM(node, importPath)
+
+  if (esmImports.length !== 0) {
+    return esmImports
+  }
+
+  const cjsImports = getImportsFromCJS(node, importPath)
+
+  return cjsImports
+}
+
+// Finds import/require statements of a given path in a CJS AST.
+const getImportsFromCJS = (node: Statement, importPath: string) => {
+  if (node.type !== 'VariableDeclaration') {
+    return []
+  }
+
+  const { declarations } = node
+  const requireDeclaration = declarations.find(
+    (declaration) => declaration.type === 'VariableDeclarator' && isRequire(declaration.init, importPath),
+  )
+
+  if (requireDeclaration === undefined || requireDeclaration.id.type !== 'ObjectPattern') {
+    return []
+  }
+
+  const imports = requireDeclaration.id.properties
+    .map((property) => {
+      if (property.type !== 'ObjectProperty') {
+        return
+      }
+
+      const { key, value } = property
+
+      if (key.type !== 'Identifier' || value.type !== 'Identifier') {
+        return
+      }
+
+      return { imported: key.name, local: value.name }
+    })
+    .filter(nonNullable)
+
+  return imports
+}
+
+// Finds import/require statements of a given path in an ESM AST.
+const getImportsFromESM = (node: Statement, importPath: string) => {
+  if (!isImport(node, importPath)) {
+    return []
+  }
+
+  const { specifiers } = node
+
+  const imports = specifiers
+    .map((specifier) => {
+      if (specifier.type !== 'ImportSpecifier') {
+        return
+      }
+
+      const { imported, local } = specifier
+
+      if (imported.type !== 'Identifier' || local.type !== 'Identifier') {
+        return
+      }
+
+      return { imported: imported.name, local: local.name }
+    })
+    .filter(nonNullable)
+
+  return imports
+}