feat: add local dev experience for scheduled functions

package.json

@@ -85,7 +85,7 @@
     "@netlify/plugin-edge-handlers": "^3.0.0",
     "@netlify/plugins-list": "^6.2.0",
     "@netlify/routing-local-proxy": "^0.34.1",
-    "@netlify/zip-it-and-ship-it": "5.3.1",
+    "@netlify/zip-it-and-ship-it": "5.4.0",
     "@octokit/rest": "^18.0.0",
     "@sindresorhus/slugify": "^1.1.0",
     "ansi-styles": "^5.0.0",

src/commands/functions/functions-invoke.js

@@ -150,7 +150,9 @@ const functionsInvoke = async (nameArgument, options, command) => {
   const functions = await getFunctions(functionsDir)
   const functionToTrigger = await getNameFromArgs(functions, options, nameArgument)
 
-  let headers = {}
+  const headers = {
+    'user-agent': 'netlify-cli',
+  }
   let body = {}
 
   if (eventTriggeredFunctions.has(functionToTrigger)) {
@@ -201,10 +203,8 @@ const functionsInvoke = async (nameArgument, options, command) => {
       isAuthenticated = options.identity
     }
     if (isAuthenticated) {
-      headers = {
-        authorization:
-          'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJuZXRsaWZ5IGZ1bmN0aW9uczp0cmlnZ2VyIiwidGVzdERhdGEiOiJORVRMSUZZX0RFVl9MT0NBTExZX0VNVUxBVEVEX0pXVCJ9.Xb6vOFrfLUZmyUkXBbCvU4bM7q8tPilF0F03Wupap_c',
-      }
+      headers.authorization =
+        'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJuZXRsaWZ5IGZ1bmN0aW9uczp0cmlnZ2VyIiwidGVzdERhdGEiOiJORVRMSUZZX0RFVl9MT0NBTExZX0VNVUxBVEVEX0pXVCJ9.Xb6vOFrfLUZmyUkXBbCvU4bM7q8tPilF0F03Wupap_c'
       // you can decode this https://jwt.io/
       // {
       //   "source": "netlify functions:trigger",

src/lib/functions/config.js

@@ -12,6 +12,7 @@ const normalizeFunctionsConfig = ({ functionsConfig = {}, projectRoot }) =>
         ignoredNodeModules: config.ignored_node_modules,
         nodeBundler: config.node_bundler === 'esbuild' ? 'esbuild_zisi' : config.node_bundler,
         processDynamicNodeImports: true,
+        schedule: config.schedule,
       },
     }),
     {},

src/lib/functions/netlify-function.js

@@ -32,6 +32,7 @@ class NetlifyFunction {
     // Determines whether this is a background function based on the function
     // name.
     this.isBackground = name.endsWith(BACKGROUND_SUFFIX)
+    this.schedule = null
 
     // List of the function's source files. This starts out as an empty set
     // and will get populated on every build.
@@ -44,6 +45,12 @@ class NetlifyFunction {
     return /^[A-Za-z0-9_-]+$/.test(this.name)
   }
 
+  async isScheduled() {
+    await this.buildQueue
+
+    return Boolean(this.schedule)
+  }
+
   // The `build` method transforms source files into invocable functions. Its
   // return value is an object with:
   //
@@ -61,12 +68,13 @@ class NetlifyFunction {
     this.buildQueue = buildFunction({ cache })
 
     try {
-      const { srcFiles, ...buildData } = await this.buildQueue
+      const { schedule, srcFiles, ...buildData } = await this.buildQueue
       const srcFilesSet = new Set(srcFiles)
       const srcFilesDiff = this.getSrcFilesDiff(srcFilesSet)
 
       this.buildData = buildData
       this.srcFiles = srcFilesSet
+      this.schedule = schedule
 
       return { srcFilesDiff }
     } catch (error) {

src/lib/functions/runtimes/js/builders/zisi.js

@@ -1,7 +1,7 @@
 const { writeFile } = require('fs').promises
 const path = require('path')
 
-const { zipFunction } = require('@netlify/zip-it-and-ship-it')
+const { listFunction, zipFunction } = require('@netlify/zip-it-and-ship-it')
 const decache = require('decache')
 const makeDir = require('make-dir')
 const readPkgUp = require('read-pkg-up')
@@ -36,7 +36,11 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
   // root of the functions directory (e.g. `functions/my-func.js`). In
   // this case, we use `mainFile` as the function path of `zipFunction`.
   const entryPath = functionDirectory === directory ? func.mainFile : functionDirectory
-  const { inputs, path: functionPath } = await memoizedBuild({
+  const {
+    inputs,
+    path: functionPath,
+    schedule,
+  } = await memoizedBuild({
     cache,
     cacheKey: `zisi-${entryPath}`,
     command: () => zipFunction(entryPath, targetDirectory, zipOptions),
@@ -57,7 +61,19 @@ const buildFunction = async ({ cache, config, directory, func, hasTypeModule, pr
 
   clearFunctionsCache(targetDirectory)
 
-  return { buildPath, srcFiles }
+  return { buildPath, srcFiles, schedule }
+}
+
+/**
+ * @param {string} mainFile
+ */
+const parseForSchedule = async ({ config, mainFile, projectRoot }) => {
+  const listedFunction = await listFunction(mainFile, {
+    config: netlifyConfigToZisiConfig({ config, projectRoot }),
+    parseISC: true,
+  })
+
+  return listedFunction && listedFunction.schedule
 }
 
 // Clears the cache for any files inside the directory from which functions are
@@ -80,10 +96,11 @@ const getTargetDirectory = async ({ errorExit }) => {
   return targetDirectory
 }
 
+const netlifyConfigToZisiConfig = ({ config, projectRoot }) =>
+  addFunctionsConfigDefaults(normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot }))
+
 module.exports = async ({ config, directory, errorExit, func, projectRoot }) => {
-  const functionsConfig = addFunctionsConfigDefaults(
-    normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot }),
-  )
+  const functionsConfig = netlifyConfigToZisiConfig({ config, projectRoot })
 
   const packageJson = await readPkgUp(func.mainFile)
   const hasTypeModule = packageJson && packageJson.packageJson.type === 'module'
@@ -116,3 +133,5 @@ module.exports = async ({ config, directory, errorExit, func, projectRoot }) =>
     target: targetDirectory,
   }
 }
+
+module.exports.parseForSchedule = parseForSchedule

src/lib/functions/runtimes/js/index.js

@@ -46,8 +46,9 @@ const getBuildFunction = async ({ config, directory, errorExit, func, projectRoo
   // main file otherwise.
   const functionDirectory = dirname(func.mainFile)
   const srcFiles = functionDirectory === directory ? [func.mainFile] : [functionDirectory]
+  const schedule = await detectZisiBuilder.parseForSchedule({ mainFile: func.mainFile, config, projectRoot })
 
-  return () => ({ srcFiles })
+  return () => ({ schedule, srcFiles })
 }
 
 const invokeFunction = async ({ context, event, func, timeout }) => {

src/lib/functions/scheduled.js

@@ -0,0 +1,24 @@
+const { NETLIFYDEVERR, NETLIFYDEVLOG } = require('../../utils')
+
+const { formatLambdaError, styleFunctionName } = require('./utils')
+
+const SCHEDULED_FUNCTION_STATUS_CODE = 202
+
+const handleScheduledFunction = (functionName, response) => {
+  console.log(`${NETLIFYDEVLOG} Running scheduled function ${styleFunctionName(functionName)}`)
+  response.status(SCHEDULED_FUNCTION_STATUS_CODE)
+  response.end()
+}
+
+const handleScheduledFunctionResult = (functionName, err) => {
+  if (err) {
+    console.log(
+      `${NETLIFYDEVERR} Error during scheduled function ${styleFunctionName(functionName)} execution:`,
+      formatLambdaError(err),
+    )
+  } else {
+    console.log(`${NETLIFYDEVLOG} Done executing scheduled function ${styleFunctionName(functionName)}`)
+  }
+}
+
+module.exports = { handleScheduledFunction, handleScheduledFunctionResult }

src/lib/functions/server.js

@@ -6,6 +6,7 @@ const { NETLIFYDEVERR, NETLIFYDEVLOG, error: errorExit, getInternalFunctionsDir,
 const { handleBackgroundFunction, handleBackgroundFunctionResult } = require('./background')
 const { createFormSubmissionHandler } = require('./form-submissions-handler')
 const { FunctionsRegistry } = require('./registry')
+const { handleScheduledFunction, handleScheduledFunctionResult } = require('./scheduled')
 const { handleSynchronousFunction } = require('./synchronous')
 const { shouldBase64Encode } = require('./utils')
 
@@ -105,6 +106,16 @@ const createHandler = function ({ functionsRegistry }) {
       const { error } = await func.invoke(event, clientContext)
 
       handleBackgroundFunctionResult(functionName, error)
+    } else if (await func.isScheduled()) {
+      if (event.headers['user-agent'] !== 'netlify-cli') {
+        return response.status(400).send('Scheduled functions can only be invoked using `netlify functions:invoke`.')
+      }
+
+      handleScheduledFunction(functionName, response)
+
+      const { error } = await func.invoke(event, clientContext)
+
+      handleScheduledFunctionResult(functionName, error)
     } else {
       const { error, result } = await func.invoke(event, clientContext)