feat: bring in new changes from ZISI

Author: Skn0tt

src/bindings.ts

@@ -0,0 +1,57 @@
+import type { Expression, Statement, VariableDeclaration } from '@babel/types'
+
+type Bindings = Map<string, Expression>
+
+const getBindingFromVariableDeclaration = function (node: VariableDeclaration, bindings: Bindings): void {
+  node.declarations.forEach((declaration) => {
+    if (declaration.id.type === 'Identifier' && declaration.init) {
+      bindings.set(declaration.id.name, declaration.init)
+    }
+  })
+}
+
+// eslint-disable-next-line complexity
+const getBindingsFromNode = function (node: Statement, bindings: Bindings): void {
+  if (node.type === 'VariableDeclaration') {
+    // A variable was created, so create it and store the potential value
+    getBindingFromVariableDeclaration(node, bindings)
+  } else if (
+    node.type === 'ExpressionStatement' &&
+    node.expression.type === 'AssignmentExpression' &&
+    node.expression.left.type === 'Identifier'
+  ) {
+    // The variable was reassigned, so let's store the new value
+    bindings.set(node.expression.left.name, node.expression.right)
+  } else if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+    // A `export const|let ...` creates a binding that can later be referenced again
+    getBindingFromVariableDeclaration(node.declaration, bindings)
+  }
+}
+
+/**
+ * Goes through all relevant nodes and creates a map from binding name to assigned value/expression
+ */
+const getAllBindings = function (nodes: Statement[]): Bindings {
+  const bindings: Bindings = new Map()
+
+  nodes.forEach((node) => {
+    getBindingsFromNode(node, bindings)
+  })
+
+  return bindings
+}
+
+export type BindingMethod = () => Bindings
+
+export const createBindingsMethod = function (nodes: Statement[]): BindingMethod {
+  // memoize the result for these nodes
+  let result: Bindings
+
+  return () => {
+    if (!result) {
+      result = getAllBindings(nodes)
+    }
+
+    return result
+  }
+}

src/exports.ts

@@ -1,15 +1,16 @@
-import { CallExpression, Statement } from '@babel/types'
+import type { ExportNamedDeclaration, ExportSpecifier, Expression, Statement } from '@babel/types'
 
+import type { BindingMethod } from './bindings.js'
 import { isModuleExports } from './helpers.js'
 
 import type { ISCExport } from './index.js'
 
 // Finds the main handler export in an AST.
-export const getMainExport = (nodes: Statement[]) => {
+export const getMainExport = (nodes: Statement[], getAllBindings: BindingMethod) => {
   let handlerExport: ISCExport[] = []
 
   nodes.find((node) => {
-    const esmExports = getMainExportFromESM(node)
+    const esmExports = getMainExportFromESM(node, getAllBindings)
 
     if (esmExports.length !== 0) {
       handlerExport = esmExports
@@ -39,24 +40,27 @@ const getMainExportFromCJS = (node: Statement) => {
   ]
 
   return handlerPaths.flatMap((handlerPath) => {
-    if (!isModuleExports(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+    if (!isModuleExports(node, handlerPath)) {
       return []
     }
 
-    return getExportsFromCallExpression(node.expression.right)
+    return getExportsFromExpression(node.expression.right)
   })
 }
 
 // Finds the main handler export in an ESM AST.
-// eslint-disable-next-line complexity
-const getMainExportFromESM = (node: Statement) => {
+const getMainExportFromESM = (node: Statement, getAllBindings: BindingMethod) => {
   if (node.type !== 'ExportNamedDeclaration' || node.exportKind !== 'value') {
     return []
   }
 
-  const { declaration } = node
+  const { declaration, specifiers } = node
 
-  if (!declaration || declaration.type !== 'VariableDeclaration') {
+  if (specifiers?.length > 0) {
+    return getExportsFromBindings(specifiers, getAllBindings)
+  }
+
+  if (declaration?.type !== 'VariableDeclaration') {
     return []
   }
 
@@ -66,16 +70,47 @@ const getMainExportFromESM = (node: Statement) => {
     return type === 'VariableDeclarator' && id.type === 'Identifier' && id.name === 'handler'
   })
 
-  if (handlerDeclaration?.init?.type !== 'CallExpression') {
+  const exports = getExportsFromExpression(handlerDeclaration?.init)
+
+  return exports
+}
+
+// Check if the Node is an ExportSpecifier that has a named export called `handler`
+// either with Identifier `export { handler }`
+// or with StringLiteral `export { x as "handler" }`
+const isHandlerExport = (node: ExportNamedDeclaration['specifiers'][number]): node is ExportSpecifier => {
+  const { type, exported } = node
+
+  return (
+    type === 'ExportSpecifier' &&
+    ((exported.type === 'Identifier' && exported.name === 'handler') ||
+      (exported.type === 'StringLiteral' && exported.value === 'handler'))
+  )
+}
+
+// Tries to resolve the export from a binding (variable)
+// for example `let handler; handler = () => {}; export { handler }` would
+// resolve correctly to the handler function
+const getExportsFromBindings = (specifiers: ExportNamedDeclaration['specifiers'], getAllBindings: BindingMethod) => {
+  const specifier = specifiers.find(isHandlerExport)
+
+  if (!specifier) {
     return []
   }
 
-  const exports = getExportsFromCallExpression(handlerDeclaration.init)
+  const binding = getAllBindings().get(specifier.local.name)
+  const exports = getExportsFromExpression(binding)
 
   return exports
 }
 
-const getExportsFromCallExpression = (node: CallExpression) => {
+const getExportsFromExpression = (node: Expression | undefined | null) => {
+  // We're only interested in expressions representing function calls, because
+  // the ISC patterns we implement at the moment are all helper functions.
+  if (node?.type !== 'CallExpression') {
+    return []
+  }
+
   const { arguments: args, callee } = node
 
   if (callee.type !== 'Identifier') {

src/index.ts

@@ -3,6 +3,7 @@ import { promises as fs } from 'fs'
 import { parse } from '@babel/parser'
 import { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName, Program } from '@babel/types'
 
+import { createBindingsMethod } from './bindings.js'
 import { getMainExport } from './exports.js'
 import { getImports } from './imports.js'
 import { parse as parseSchedule } from './properties/schedule.js'
@@ -22,7 +23,12 @@ interface ISCConfig {
 // the property and `data` its value.
 export const findISCDeclarationsInProgram = (ast: Program, config: ISCConfig): ISCValues => {
   const imports = ast.body.flatMap((node) => getImports(node, config.isHelperModule))
-  const mainExports = getMainExport(ast.body)
+
+  const scheduledFuncsExpected = imports.filter(({ imported }) => imported === 'schedule').length
+  let scheduledFuncsFound = 0
+
+  const getAllBindings = createBindingsMethod(ast.body)
+  const mainExports = getMainExport(ast.body, getAllBindings)
   const iscExports = mainExports
     .map(({ args, local: exportName }) => {
       const matchingImport = imports.find(({ local: importName }) => importName === exportName)
@@ -32,16 +38,29 @@ export const findISCDeclarationsInProgram = (ast: Program, config: ISCConfig): I
       }
 
       switch (matchingImport.imported) {
-        case 'schedule':
-          return parseSchedule({ args })
+        case 'schedule': {
+          const parsed = parseSchedule({ args }, getAllBindings)
+
+          if (parsed.schedule) {
+            scheduledFuncsFound += 1
+          }
 
+          return parsed
+        }
         default:
         // no-op
       }
 
       return null
     })
     .filter(nonNullable)
+
+  if (scheduledFuncsFound < scheduledFuncsExpected) {
+    throw new Error(
+      'Warning: unable to find cron expression for scheduled function. `schedule` imported but not called or exported. If you meant to schedule a function, please check that `schedule` is invoked with an appropriate cron expression.',
+    )
+  }
+
   const mergedExports: ISCValues = iscExports.reduce((acc, obj) => ({ ...acc, ...obj }), {})
 
   return mergedExports

src/properties/schedule.ts

@@ -1,7 +1,17 @@
+import type { BindingMethod } from '../bindings.js'
 import type { ISCHandlerArg } from '../index.js'
 
-export const parse = ({ args }: { args: ISCHandlerArg[] }) => {
-  const [expression] = args
+export const parse = ({ args }: { args: ISCHandlerArg[] }, getAllBindings: BindingMethod) => {
+  let [expression] = args
+
+  if (expression.type === 'Identifier') {
+    const binding = getAllBindings().get(expression.name)
+
+    if (binding) {
+      expression = binding
+    }
+  }
+
   const schedule = expression.type === 'StringLiteral' ? expression.value : undefined
 
   return {

test/fixtures/cron_cjs_invalid_cron_expression.js

@@ -0,0 +1,5 @@
+const { schedule } = require('@netlify/functions')
+
+module.exports.handler = schedule(null, () => {
+  // function handler
+})

test/fixtures/cron_cjs_schedule_not_called.js

@@ -0,0 +1,4 @@
+const { schedule } = require('@netlify/functions')
+
+// Should throw an error that `schedule` is imported but cron expression not found
+module.exports.handler = {}

test/fixtures/cron_esm_additional_schedule_import.js

@@ -0,0 +1,9 @@
+import { schedule as nfySchedule } from '@netlify/functions'
+import { schedule } from '../node_modules/@netlify/functions/index.js'
+// make sure cron expression is found/doesn't error if `schedule` is also imported from another source
+
+schedule()
+
+export const handler = nfySchedule('@daily', () => {
+  // function handler
+})

test/fixtures/cron_esm_no_direct_export.js

@@ -0,0 +1,7 @@
+import { schedule } from '@netlify/functions'
+
+const handler = schedule('@daily', async () => {
+  // function handler
+})
+
+export { handler }

test/fixtures/cron_esm_no_direct_export_renamed.js

@@ -0,0 +1,6 @@
+import { schedule } from '@netlify/functions'
+
+const _handler = schedule('@daily', async () => {
+  // function handler
+})
+export { _handler as handler }

test/fixtures/cron_esm_no_direct_export_renamed_reassigned.js

@@ -0,0 +1,8 @@
+import { schedule } from '@netlify/functions'
+
+const handler = async () => {
+  // function handler
+}
+
+const _handler = schedule('@daily', handler)
+export { _handler as handler }