serverless-offline 8.8.0 → 9.1.0

package/src/events/websocket/lambda-events/WebSocketAuthorizerEvent.js

@@ -0,0 +1,65 @@
+import WebSocketRequestContext from './WebSocketRequestContext.js'
+import {
+  parseHeaders,
+  parseMultiValueHeaders,
+  parseMultiValueQueryStringParameters,
+  parseQueryStringParameters,
+} from '../../../utils/index.js'
+
+export default class WebSocketAuthorizerEvent {
+  #connectionId = null
+
+  #httpsProtocol = null
+
+  #provider = null
+
+  #rawHeaders = null
+
+  #url = null
+
+  #websocketPort = null
+
+  constructor(connectionId, request, provider, options) {
+    const { httpsProtocol, websocketPort } = options
+    const { rawHeaders, url } = request
+
+    this.#connectionId = connectionId
+    this.#httpsProtocol = httpsProtocol
+    this.#rawHeaders = rawHeaders
+    this.#url = url
+    this.#websocketPort = websocketPort
+    this.#provider = provider
+  }
+
+  create() {
+    const headers = parseHeaders(this.#rawHeaders)
+    const multiValueHeaders = parseMultiValueHeaders(this.#rawHeaders)
+    const multiValueQueryStringParameters =
+      parseMultiValueQueryStringParameters(this.#url)
+    const queryStringParameters = parseQueryStringParameters(this.#url)
+
+    const requestContext = new WebSocketRequestContext(
+      'CONNECT',
+      '$connect',
+      this.#connectionId,
+    ).create()
+
+    return {
+      headers,
+      methodArn: `arn:aws:execute-api:${this.#provider.region}:${
+        requestContext.accountId
+      }:${requestContext.apiId}/${requestContext.stage}/${
+        requestContext.routeKey
+      }`,
+      multiValueHeaders,
+      // NOTE: multiValueQueryStringParameters and queryStringParameters
+      // properties are only defined if they have values
+      ...(multiValueQueryStringParameters && {
+        multiValueQueryStringParameters,
+      }),
+      ...(queryStringParameters && { queryStringParameters }),
+      requestContext,
+      type: 'REQUEST',
+    }
+  }
+}

package/src/events/websocket/lambda-events/WebSocketConnectEvent.js

@@ -0,0 +1,68 @@
+import WebSocketRequestContext from './WebSocketRequestContext.js'
+import {
+  parseHeaders,
+  parseMultiValueHeaders,
+  parseMultiValueQueryStringParameters,
+  parseQueryStringParameters,
+} from '../../../utils/index.js'
+
+export default class WebSocketConnectEvent {
+  #connectionId = null
+
+  #httpsProtocol = null
+
+  #rawHeaders = null
+
+  #url = null
+
+  #websocketPort = null
+
+  constructor(connectionId, request, options) {
+    const { httpsProtocol, websocketPort } = options
+    const { rawHeaders, url } = request
+
+    this.#connectionId = connectionId
+    this.#httpsProtocol = httpsProtocol
+    this.#rawHeaders = rawHeaders
+    this.#url = url
+    this.#websocketPort = websocketPort
+  }
+
+  create() {
+    // const headers = {
+    //   Host: 'localhost',
+    //   'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
+    //   'Sec-WebSocket-Key': createUniqueId(),
+    //   'Sec-WebSocket-Version': '13',
+    //   'X-Amzn-Trace-Id': `Root=${createUniqueId()}`,
+    //   'X-Forwarded-For': '127.0.0.1',
+    //   'X-Forwarded-Port': String(this.#websocketPort),
+    //   'X-Forwarded-Proto': `http${this.#httpsProtocol ? 's' : ''}`,
+    // }
+
+    const headers = parseHeaders(this.#rawHeaders)
+    const multiValueHeaders = parseMultiValueHeaders(this.#rawHeaders)
+    const multiValueQueryStringParameters =
+      parseMultiValueQueryStringParameters(this.#url)
+    const queryStringParameters = parseQueryStringParameters(this.#url)
+
+    const requestContext = new WebSocketRequestContext(
+      'CONNECT',
+      '$connect',
+      this.#connectionId,
+    ).create()
+
+    return {
+      headers,
+      isBase64Encoded: false,
+      multiValueHeaders,
+      // NOTE: multiValueQueryStringParameters and queryStringParameters
+      // properties are only defined if they have values
+      ...(multiValueQueryStringParameters && {
+        multiValueQueryStringParameters,
+      }),
+      ...(queryStringParameters && { queryStringParameters }),
+      requestContext,
+    }
+  }
+}

package/src/events/websocket/lambda-events/WebSocketDisconnectEvent.js

@@ -0,0 +1,31 @@
+import WebSocketRequestContext from './WebSocketRequestContext.js'
+import { parseHeaders, parseMultiValueHeaders } from '../../../utils/index.js'
+
+export default class WebSocketDisconnectEvent {
+  #connectionId = null
+
+  constructor(connectionId) {
+    this.#connectionId = connectionId
+  }
+
+  create() {
+    // TODO FIXME not sure where the headers come from
+    const rawHeaders = ['Host', 'localhost', 'x-api-key', '', 'x-restapi', '']
+
+    const headers = parseHeaders(rawHeaders)
+    const multiValueHeaders = parseMultiValueHeaders(rawHeaders)
+
+    const requestContext = new WebSocketRequestContext(
+      'DISCONNECT',
+      '$disconnect',
+      this.#connectionId,
+    ).create()
+
+    return {
+      headers,
+      isBase64Encoded: false,
+      multiValueHeaders,
+      requestContext,
+    }
+  }
+}

package/src/events/websocket/lambda-events/WebSocketEvent.js

@@ -0,0 +1,29 @@
+import WebSocketRequestContext from './WebSocketRequestContext.js'
+
+export default class WebSocketEvent {
+  #connectionId = null
+
+  #payload = null
+
+  #route = null
+
+  constructor(connectionId, route, payload) {
+    this.#connectionId = connectionId
+    this.#payload = payload
+    this.#route = route
+  }
+
+  create() {
+    const requestContext = new WebSocketRequestContext(
+      'MESSAGE',
+      this.#route,
+      this.#connectionId,
+    ).create()
+
+    return {
+      body: this.#payload,
+      isBase64Encoded: false,
+      requestContext,
+    }
+  }
+}

package/src/events/websocket/lambda-events/WebSocketRequestContext.js

@@ -0,0 +1,67 @@
+import { createUniqueId, formatToClfTime } from '../../../utils/index.js'
+
+const { now } = Date
+
+const connectedAt = new Map()
+
+export default class WebSocketRequestContext {
+  #connectedAt = null
+
+  #connectionId = null
+
+  #eventType = null
+
+  #route = null
+
+  constructor(eventType, route, connectionId) {
+    this.#connectionId = connectionId
+    this.#eventType = eventType
+    this.#route = route
+
+    if (eventType === 'CONNECT') {
+      connectedAt.set(connectionId, now())
+    }
+
+    this.#connectedAt = connectedAt.get(connectionId)
+
+    if (eventType === 'DISCONNECT') {
+      connectedAt.delete(connectionId)
+    }
+  }
+
+  create() {
+    const timeEpoch = now()
+
+    const requestContext = {
+      apiId: 'private',
+      connectedAt: this.#connectedAt,
+      connectionId: this.#connectionId,
+      domainName: 'localhost',
+      eventType: this.#eventType,
+      extendedRequestId: createUniqueId(),
+      identity: {
+        accessKey: null,
+        accountId: null,
+        caller: null,
+        cognitoAuthenticationProvider: null,
+        cognitoAuthenticationType: null,
+        cognitoIdentityId: null,
+        cognitoIdentityPoolId: null,
+        principalOrgId: null,
+        sourceIp: '127.0.0.1',
+        user: null,
+        userAgent: null,
+        userArn: null,
+      },
+      messageDirection: 'IN',
+      messageId: createUniqueId(),
+      requestId: createUniqueId(),
+      requestTime: formatToClfTime(timeEpoch),
+      requestTimeEpoch: timeEpoch,
+      routeKey: this.#route,
+      stage: 'local',
+    }
+
+    return requestContext
+  }
+}

package/src/events/websocket/lambda-events/index.js

@@ -0,0 +1,4 @@
+export { default as WebSocketConnectEvent } from './WebSocketConnectEvent.js'
+export { default as WebSocketDisconnectEvent } from './WebSocketDisconnectEvent.js'
+export { default as WebSocketEvent } from './WebSocketEvent.js'
+export { default as WebSocketAuthorizerEvent } from './WebSocketAuthorizerEvent.js'

package/src/index.js

@@ -0,0 +1,12 @@
+// TODO remove with node.js v16.9+ support
+import 'object.hasown/auto'
+
+// install global fetch
+// TODO remove `node-fetch` module and use global built-in with node.js v18+ support
+if (globalThis.fetch === undefined) {
+  const { default: fetch, Headers } = await import('node-fetch')
+  globalThis.fetch = fetch
+  globalThis.Headers = Headers
+}
+
+export { default } from './ServerlessOffline.js'

package/src/lambda/HttpServer.js

@@ -0,0 +1,108 @@
+import { exit } from 'node:process'
+import { Server } from '@hapi/hapi'
+import { log } from '@serverless/utils/log.js'
+import { invocationsRoute, invokeAsyncRoute } from './routes/index.js'
+
+export default class HttpServer {
+  #lambda = null
+
+  #options = null
+
+  #server = null
+
+  constructor(options, lambda) {
+    this.#lambda = lambda
+    this.#options = options
+
+    const { host, lambdaPort } = options
+
+    const serverOptions = {
+      host,
+      port: lambdaPort,
+    }
+
+    this.#server = new Server(serverOptions)
+  }
+
+  async start() {
+    // add routes
+    const invRoute = invocationsRoute(this.#lambda, this.#options)
+    const invAsyncRoute = invokeAsyncRoute(this.#lambda, this.#options)
+
+    this.#server.route([invAsyncRoute, invRoute])
+
+    const { host, httpsProtocol, lambdaPort } = this.#options
+
+    try {
+      await this.#server.start()
+    } catch (err) {
+      log.error(
+        `Unexpected error while starting serverless-offline lambda server on port ${lambdaPort}:`,
+        err,
+      )
+      exit(1)
+    }
+
+    log.notice(
+      `Offline [http for lambda] listening on http${
+        httpsProtocol ? 's' : ''
+      }://${host}:${lambdaPort}`,
+    )
+
+    // Print all the invocation routes to debug
+    const basePath = `http${httpsProtocol ? 's' : ''}://${host}:${lambdaPort}`
+    const funcNamePairs = this.#lambda.listFunctionNamePairs()
+
+    log.notice(
+      [
+        `Function names exposed for local invocation by aws-sdk:`,
+        ...this.#lambda
+          .listFunctionNames()
+          .map(
+            (functionName) =>
+              `           * ${funcNamePairs[functionName]}: ${functionName}`,
+          ),
+      ].join('\n'),
+    )
+    log.debug(
+      [
+        `Lambda Invocation Routes (for AWS SDK or AWS CLI):`,
+        ...this.#lambda
+          .listFunctionNames()
+          .map(
+            (functionName) =>
+              `           * ${
+                invRoute.method
+              } ${basePath}${invRoute.path.replace(
+                '{functionName}',
+                functionName,
+              )}`,
+          ),
+      ].join('\n'),
+    )
+
+    log.debug(
+      [
+        `Lambda Async Invocation Routes (for AWS SDK or AWS CLI):`,
+        ...this.#lambda
+          .listFunctionNames()
+          .map(
+            (functionName) =>
+              `           * ${
+                invAsyncRoute.method
+              } ${basePath}${invAsyncRoute.path.replace(
+                '{functionName}',
+                functionName,
+              )}`,
+          ),
+      ].join('\n'),
+    )
+  }
+
+  // stops the server
+  stop(timeout) {
+    return this.#server.stop({
+      timeout,
+    })
+  }
+}

package/src/lambda/Lambda.js

@@ -0,0 +1,68 @@
+import HttpServer from './HttpServer.js'
+import LambdaFunctionPool from './LambdaFunctionPool.js'
+
+const { assign } = Object
+
+export default class Lambda {
+  #httpServer = null
+
+  #lambdas = new Map()
+
+  #lambdaFunctionNamesKeys = new Map()
+
+  #lambdaFunctionPool = null
+
+  constructor(serverless, options) {
+    this.#httpServer = new HttpServer(options, this)
+    this.#lambdaFunctionPool = new LambdaFunctionPool(serverless, options)
+  }
+
+  #createEvent(functionKey, functionDefinition) {
+    this.#lambdas.set(functionKey, functionDefinition)
+    this.#lambdaFunctionNamesKeys.set(functionDefinition.name, functionKey)
+  }
+
+  create(lambdas) {
+    lambdas.forEach(({ functionKey, functionDefinition }) => {
+      this.#createEvent(functionKey, functionDefinition)
+    })
+  }
+
+  get(functionKey) {
+    const functionDefinition = this.#lambdas.get(functionKey)
+    return this.#lambdaFunctionPool.get(functionKey, functionDefinition)
+  }
+
+  getByFunctionName(functionName) {
+    const functionKey = this.#lambdaFunctionNamesKeys.get(functionName)
+    return this.get(functionKey)
+  }
+
+  listFunctionNames() {
+    const functionNames = Array.from(this.#lambdaFunctionNamesKeys.keys())
+    return functionNames
+  }
+
+  listFunctionNamePairs() {
+    const funcNamePairs = Array.from(this.#lambdaFunctionNamesKeys).reduce(
+      (obj, [key, value]) => assign(obj, { [key]: value }), // Be careful! Maps can have non-String keys; object literals can't.
+      {},
+    )
+    return funcNamePairs
+  }
+
+  start() {
+    this.#lambdaFunctionPool.start()
+
+    return this.#httpServer.start()
+  }
+
+  // stops the server
+  stop(timeout) {
+    return this.#httpServer.stop(timeout)
+  }
+
+  cleanup() {
+    return this.#lambdaFunctionPool.cleanup()
+  }
+}

package/src/lambda/LambdaContext.js

@@ -0,0 +1,33 @@
+// class for creating a LambdaContext
+// http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html
+
+export default class LambdaContext {
+  #context = null
+
+  constructor(functionName, memorySize) {
+    this.#context = {
+      awsRequestId: undefined,
+      callbackWaitsForEmptyEventLoop: true,
+      clientContext: undefined,
+      functionName,
+      functionVersion: '$LATEST',
+      identity: undefined,
+      invokedFunctionArn: `offline_invokedFunctionArn_for_${functionName}`,
+      logGroupName: `offline_logGroupName_for_${functionName}`,
+      logStreamName: `offline_logStreamName_for_${functionName}`,
+      memoryLimitInMB: String(memorySize), // NOTE: string in AWS
+    }
+  }
+
+  setClientContext(clientContext) {
+    this.#context.clientContext = clientContext
+  }
+
+  setRequestId(requestId) {
+    this.#context.awsRequestId = requestId
+  }
+
+  create() {
+    return this.#context
+  }
+}