serverless-offline 8.8.0 → 9.1.0

package/src/lambda/handler-runner/in-process-runner/InProcessRunner.js

@@ -0,0 +1,125 @@
+import { createRequire } from 'node:module'
+import { performance } from 'node:perf_hooks'
+import process from 'node:process'
+import { log } from '@serverless/utils/log.js'
+
+const { assign } = Object
+
+const require = createRequire(import.meta.url)
+
+export default class InProcessRunner {
+  #env = null
+
+  #functionKey = null
+
+  #handlerName = null
+
+  #handlerPath = null
+
+  #timeout = null
+
+  constructor(functionKey, handlerPath, handlerName, env, timeout) {
+    this.#env = env
+    this.#functionKey = functionKey
+    this.#handlerName = handlerName
+    this.#handlerPath = handlerPath
+    this.#timeout = timeout
+  }
+
+  // no-op
+  // () => void
+  cleanup() {}
+
+  async run(event, context) {
+    // check if the handler module path exists
+    if (!require.resolve(this.#handlerPath)) {
+      throw new Error(
+        `Could not find handler module '${this.#handlerPath}' for function '${
+          this.#functionKey
+        }'.`,
+      )
+    }
+
+    // process.env should be available in the handler module scope as well as in the handler function scope
+    // NOTE: Don't use Object spread (...) here!
+    // otherwise the values of the attached props are not coerced to a string
+    // e.g. process.env.foo = 1 should be coerced to '1' (string)
+    assign(process.env, this.#env)
+
+    let handler
+
+    try {
+      // const { [this.#handlerName]: handler } = await import(this.#handlerPath)
+      // eslint-disable-next-line import/no-dynamic-require
+      ;({ [this.#handlerName]: handler } = require(this.#handlerPath))
+    } catch (err) {
+      log.error(err)
+    }
+
+    if (typeof handler !== 'function') {
+      throw new Error(
+        `offline: handler '${this.#handlerName}' in ${
+          this.#handlerPath
+        } is not a function`,
+      )
+    }
+
+    let callback
+
+    const callbackCalled = new Promise((res, rej) => {
+      callback = (err, data) => {
+        if (err === 'Unauthorized') {
+          res('Unauthorized')
+          return
+        }
+        if (err) {
+          rej(err)
+          return
+        }
+        res(data)
+      }
+    })
+
+    const executionTimeout = performance.now() + this.#timeout
+
+    // attach doc-deprecated functions
+    // create new immutable object
+    const lambdaContext = {
+      ...context,
+      done: (err, data) => callback(err, data),
+      fail: (err) => callback(err),
+      getRemainingTimeInMillis: () => {
+        const timeLeft = executionTimeout - performance.now()
+
+        // just return 0 for now if we are beyond alotted time (timeout)
+        return timeLeft > 0 ? timeLeft : 0
+      },
+      succeed: (res) => callback(null, res),
+    }
+
+    let result
+
+    // execute (run) handler
+    try {
+      result = handler(event, lambdaContext, callback)
+    } catch {
+      throw new Error(`Uncaught error in '${this.#functionKey}' handler.`)
+    }
+
+    // // not a Promise, which is not supported by aws
+    // if (result == null || typeof result.then !== 'function') {
+    //   throw new Error(`Synchronous function execution is not supported.`)
+    // }
+
+    const callbacks = [callbackCalled]
+
+    // Promise was returned
+    if (result != null && typeof result.then === 'function') {
+      callbacks.push(result)
+    }
+
+    const callbackResult = await Promise.race(callbacks)
+
+    return callbackResult
+  }
+}

package/src/lambda/handler-runner/in-process-runner/index.js

@@ -0,0 +1 @@
+export { default } from './InProcessRunner.js'

package/src/lambda/handler-runner/index.js

@@ -0,0 +1 @@
+export { default } from './HandlerRunner.js'

package/src/lambda/handler-runner/java-runner/JavaRunner.js

@@ -0,0 +1,114 @@
+import { EOL } from 'node:os'
+import process from 'node:process'
+import { log } from '@serverless/utils/log.js'
+import { invokeJavaLocal } from 'java-invoke-local'
+
+const { parse, stringify } = JSON
+const { has } = Reflect
+
+export default class JavaRunner {
+  #deployPackage = null
+
+  #env = null
+
+  #functionName = null
+
+  #handler = null
+
+  constructor(funOptions, env) {
+    const { functionName, handler, servicePackage, functionPackage } =
+      funOptions
+
+    this.#deployPackage = functionPackage || servicePackage
+    this.#env = env
+    this.#functionName = functionName
+    this.#handler = handler
+  }
+
+  // no-op
+  // () => void
+  cleanup() {}
+
+  #parsePayload(value) {
+    for (const item of value.split(EOL)) {
+      let json
+
+      // first check if it's JSON
+      try {
+        json = parse(item)
+        // nope, it's not JSON
+      } catch {
+        // no-op
+      }
+
+      // now let's see if we have a property __offline_payload__
+      if (
+        json &&
+        typeof json === 'object' &&
+        has(json, '__offline_payload__')
+      ) {
+        return json.__offline_payload__
+      }
+    }
+
+    return undefined
+  }
+
+  async run(event, context) {
+    const input = stringify({
+      context,
+      event,
+    })
+
+    const data = stringify({
+      artifact: this.#deployPackage,
+      data: input,
+      function: this.#functionName,
+      handler: this.#handler,
+      jsonOutput: true,
+      serverlessOffline: true,
+    })
+
+    const httpOptions = {
+      body: data,
+      method: 'POST',
+    }
+
+    const port = process.env.JAVA_OFFLINE_SERVER || 8080
+
+    let result
+
+    try {
+      // Assume java-invoke-local server is running
+
+      const response = await fetch(
+        `http://localhost:${port}/invoke`,
+        httpOptions,
+      )
+      result = await response.text()
+    } catch {
+      log.notice(
+        'Local java server not running. For faster local invocations, run "java-invoke-local --server" in your project directory',
+      )
+
+      // Fallback invocation
+      const args = [
+        '-c',
+        this.#handler,
+        '-a',
+        this.#deployPackage,
+        '-f',
+        this.#functionName,
+        '-d',
+        input,
+        '--json-output',
+        '--serverless-offline',
+      ]
+      result = invokeJavaLocal(args, this.#env)
+
+      log.notice(result)
+    }
+
+    return this.#parsePayload(result)
+  }
+}

package/src/lambda/handler-runner/java-runner/index.js

@@ -0,0 +1 @@
+export { default } from './JavaRunner.js'

package/src/lambda/handler-runner/python-runner/PythonRunner.js

@@ -0,0 +1,138 @@
+import { spawn } from 'node:child_process'
+import { EOL, platform } from 'node:os'
+import { delimiter, dirname, join, relative, resolve } from 'node:path'
+import process, { cwd } from 'node:process'
+import readline from 'node:readline'
+import { fileURLToPath } from 'node:url'
+import { log } from '@serverless/utils/log.js'
+
+const { parse, stringify } = JSON
+const { assign } = Object
+const { has } = Reflect
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export default class PythonRunner {
+  #env = null
+
+  #handlerName = null
+
+  #handlerPath = null
+
+  #runtime = null
+
+  constructor(funOptions, env) {
+    const { handlerName, handlerPath, runtime } = funOptions
+
+    this.#env = env
+    this.#handlerName = handlerName
+    this.#handlerPath = handlerPath
+    this.#runtime = platform() === 'win32' ? 'python.exe' : runtime
+
+    if (process.env.VIRTUAL_ENV) {
+      const runtimeDir = platform() === 'win32' ? 'Scripts' : 'bin'
+
+      process.env.PATH = [
+        join(process.env.VIRTUAL_ENV, runtimeDir),
+        delimiter,
+        process.env.PATH,
+      ].join('')
+    }
+
+    const [pythonExecutable] = this.#runtime.split('.')
+
+    this.handlerProcess = spawn(
+      pythonExecutable,
+      [
+        '-u',
+        resolve(__dirname, 'invoke.py'),
+        relative(cwd(), this.#handlerPath),
+        this.#handlerName,
+      ],
+      {
+        env: assign(process.env, this.#env),
+        shell: true,
+      },
+    )
+
+    this.handlerProcess.stdout.readline = readline.createInterface({
+      input: this.handlerProcess.stdout,
+    })
+  }
+
+  // () => void
+  cleanup() {
+    this.handlerProcess.kill()
+  }
+
+  #parsePayload(value) {
+    let payload
+
+    for (const item of value.split(EOL)) {
+      let json
+
+      // first check if it's JSON
+      try {
+        json = parse(item)
+        // nope, it's not JSON
+      } catch {
+        // no-op
+      }
+
+      // now let's see if we have a property __offline_payload__
+      if (
+        json &&
+        typeof json === 'object' &&
+        has(json, '__offline_payload__')
+      ) {
+        payload = json.__offline_payload__
+        // everything else is print(), logging, ...
+      } else {
+        log.notice(item)
+      }
+    }
+
+    return payload
+  }
+
+  // invokeLocalPython, loosely based on:
+  // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/index.js#L410
+  // invoke.py, based on:
+  // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/invoke.py
+  async run(event, context) {
+    return new Promise((accept, reject) => {
+      const input = stringify({
+        context,
+        event,
+      })
+
+      const onErr = (data) => {
+        // TODO
+
+        log.notice(data.toString())
+      }
+
+      const onLine = (line) => {
+        try {
+          const parsed = this.#parsePayload(line.toString())
+          if (parsed) {
+            this.handlerProcess.stdout.readline.removeListener('line', onLine)
+            this.handlerProcess.stderr.removeListener('data', onErr)
+            return accept(parsed)
+          }
+          return null
+        } catch (err) {
+          return reject(err)
+        }
+      }
+
+      this.handlerProcess.stdout.readline.on('line', onLine)
+      this.handlerProcess.stderr.on('data', onErr)
+
+      process.nextTick(() => {
+        this.handlerProcess.stdin.write(input)
+        this.handlerProcess.stdin.write('\n')
+      })
+    })
+  }
+}

package/src/lambda/handler-runner/python-runner/index.js

@@ -0,0 +1 @@
+export { default } from './PythonRunner.js'

package/src/lambda/handler-runner/ruby-runner/RubyRunner.js

@@ -0,0 +1,107 @@
+import { EOL, platform } from 'node:os'
+import { dirname, relative, resolve } from 'node:path'
+import { cwd } from 'node:process'
+import { fileURLToPath } from 'node:url'
+import { log } from '@serverless/utils/log.js'
+import { execa } from 'execa'
+
+const { parse, stringify } = JSON
+const { has } = Reflect
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export default class RubyRunner {
+  #env = null
+
+  #handlerName = null
+
+  #handlerPath = null
+
+  constructor(funOptions, env) {
+    const { handlerName, handlerPath } = funOptions
+
+    this.#env = env
+    this.#handlerName = handlerName
+    this.#handlerPath = handlerPath
+  }
+
+  // no-op
+  // () => void
+  cleanup() {}
+
+  #parsePayload(value) {
+    let payload
+
+    for (const item of value.split(EOL)) {
+      let json
+
+      // first check if it's JSON
+      try {
+        json = parse(item)
+        // nope, it's not JSON
+      } catch {
+        // no-op
+      }
+
+      // now let's see if we have a property __offline_payload__
+      if (
+        json &&
+        typeof json === 'object' &&
+        has(json, '__offline_payload__')
+      ) {
+        payload = json.__offline_payload__
+      } else {
+        log.notice(item)
+      }
+    }
+
+    return payload
+  }
+
+  // invokeLocalRuby, loosely based on:
+  // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/index.js#L556
+  // invoke.rb, copy/pasted entirely as is:
+  // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/invoke.rb
+  async run(event, context) {
+    const runtime = platform() === 'win32' ? 'ruby.exe' : 'ruby'
+
+    // https://docs.aws.amazon.com/lambda/latest/dg/ruby-context.html
+
+    // https://docs.aws.amazon.com/lambda/latest/dg/ruby-context.html
+    // exclude callbackWaitsForEmptyEventLoop, don't mutate context
+    const { callbackWaitsForEmptyEventLoop, ..._context } = context
+
+    const input = stringify({
+      context: _context,
+      event,
+    })
+
+    // console.log(input)
+
+    const ruby = execa(
+      runtime,
+      [
+        resolve(__dirname, 'invoke.rb'),
+        relative(cwd(), this.#handlerPath),
+        this.#handlerName,
+      ],
+      {
+        env: this.#env,
+        input,
+        // shell: true,
+      },
+    )
+
+    const result = await ruby
+
+    const { stderr, stdout } = result
+
+    if (stderr) {
+      // TODO
+
+      log.notice(stderr)
+    }
+
+    return this.#parsePayload(stdout)
+  }
+}

package/src/lambda/handler-runner/ruby-runner/index.js

@@ -0,0 +1 @@
+export { default } from './RubyRunner.js'

package/src/lambda/handler-runner/worker-thread-runner/WorkerThreadRunner.js

@@ -0,0 +1,70 @@
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { MessageChannel, Worker } from 'node:worker_threads'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const workerThreadHelperPath = resolve(__dirname, './workerThreadHelper.js')
+
+export default class WorkerThreadRunner {
+  #workerThread = null
+
+  constructor(funOptions /* options */, env) {
+    // this._options = options
+
+    const { functionKey, handlerName, handlerPath, timeout } = funOptions
+
+    this.#workerThread = new Worker(workerThreadHelperPath, {
+      // don't pass process.env from the main process!
+      env,
+      workerData: {
+        functionKey,
+        handlerName,
+        handlerPath,
+        timeout,
+      },
+    })
+  }
+
+  // () => Promise<number>
+  cleanup() {
+    // TODO console.log('worker thread cleanup')
+
+    return this.#workerThread.terminate()
+  }
+
+  run(event, context) {
+    return new Promise((res, rej) => {
+      const { port1, port2 } = new MessageChannel()
+
+      port1
+        .on('message', (value) => {
+          if (value instanceof Error) {
+            rej(value)
+            return
+          }
+
+          res(value)
+        })
+        // emitted if the worker thread throws an uncaught exception.
+        // In that case, the worker will be terminated.
+        .on('error', rej)
+        // TODO
+        .on('exit', (code) => {
+          if (code !== 0) {
+            rej(new Error(`Worker stopped with exit code ${code}`))
+          }
+        })
+
+      this.#workerThread.postMessage(
+        {
+          context,
+          event,
+          // port2 is part of the payload, for the other side to answer messages
+          port: port2,
+        },
+        // port2 is also required to be part of the transfer list
+        [port2],
+      )
+    })
+  }
+}

package/src/lambda/handler-runner/worker-thread-runner/index.js

@@ -0,0 +1 @@
+export { default } from './WorkerThreadRunner.js'

package/src/lambda/handler-runner/worker-thread-runner/workerThreadHelper.js

@@ -0,0 +1,29 @@
+import { env } from 'node:process'
+import { parentPort, workerData } from 'node:worker_threads'
+import InProcessRunner from '../in-process-runner/index.js'
+
+const { functionKey, handlerName, handlerPath } = workerData
+
+parentPort.on('message', async (messageData) => {
+  const { context, event, port, timeout } = messageData
+
+  // TODO we could probably cache this in the module scope?
+  const inProcessRunner = new InProcessRunner(
+    functionKey,
+    handlerPath,
+    handlerName,
+    env,
+    timeout,
+  )
+
+  let result
+
+  try {
+    result = await inProcessRunner.run(event, context)
+  } catch (err) {
+    port.postMessage(err)
+  }
+
+  // TODO check serializeability (contains function, symbol etc)
+  port.postMessage(result)
+})

package/src/lambda/index.js

@@ -0,0 +1 @@
+export { default } from './Lambda.js'

package/src/lambda/routes/index.js

@@ -0,0 +1,2 @@
+export { default as invocationsRoute } from './invocations/index.js'
+export { default as invokeAsyncRoute } from './invoke-async/index.js'