serverless-offline 8.8.1 → 9.0.0

package/src/events/http/lambda-events/LambdaProxyIntegrationEvent.js

@@ -0,0 +1,233 @@
+import { Buffer } from 'node:buffer'
+import { env } from 'node:process'
+import { log } from '@serverless/utils/log.js'
+import { decode } from 'jsonwebtoken'
+import {
+  createUniqueId,
+  formatToClfTime,
+  nullIfEmpty,
+  parseHeaders,
+  parseMultiValueHeaders,
+  parseMultiValueQueryStringParameters,
+  parseQueryStringParameters,
+} from '../../../utils/index.js'
+
+const { byteLength } = Buffer
+const { parse } = JSON
+const { assign } = Object
+
+// https://serverless.com/framework/docs/providers/aws/events/apigateway/
+// https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
+// http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-as-simple-proxy-for-lambda.html
+export default class LambdaProxyIntegrationEvent {
+  #additionalRequestContext = null
+
+  #path = null
+
+  #routeKey = null
+
+  #request = null
+
+  #stage = null
+
+  #stageVariables = null
+
+  constructor(
+    request,
+    stage,
+    path,
+    stageVariables,
+    routeKey,
+    additionalRequestContext,
+  ) {
+    this.#additionalRequestContext = additionalRequestContext || {}
+    this.#path = path
+    this.#routeKey = routeKey
+    this.#request = request
+    this.#stage = stage
+    this.#stageVariables = stageVariables
+  }
+
+  create() {
+    const authPrincipalId =
+      this.#request.auth &&
+      this.#request.auth.credentials &&
+      this.#request.auth.credentials.principalId
+
+    const authContext =
+      (this.#request.auth &&
+        this.#request.auth.credentials &&
+        this.#request.auth.credentials.context) ||
+      {}
+
+    let authAuthorizer
+
+    if (env.AUTHORIZER) {
+      try {
+        authAuthorizer = parse(env.AUTHORIZER)
+      } catch {
+        log.error(
+          'Could not parse env.AUTHORIZER, make sure it is correct JSON',
+        )
+      }
+    }
+
+    let body = this.#request.payload
+
+    const { rawHeaders, url } = this.#request.raw.req
+
+    // NOTE FIXME request.raw.req.rawHeaders can only be null for testing (hapi shot inject())
+    const headers = parseHeaders(rawHeaders || []) || {}
+
+    if (headers['sls-offline-authorizer-override']) {
+      try {
+        authAuthorizer = parse(headers['sls-offline-authorizer-override'])
+      } catch {
+        log.error(
+          'Could not parse header sls-offline-authorizer-override, make sure it is correct JSON',
+        )
+      }
+    }
+
+    if (body) {
+      if (typeof body !== 'string') {
+        // this.#request.payload is NOT the same as the rawPayload
+        body = this.#request.rawPayload
+      }
+
+      if (
+        !headers['Content-Length'] &&
+        !headers['content-length'] &&
+        !headers['Content-length'] &&
+        (typeof body === 'string' ||
+          body instanceof Buffer ||
+          body instanceof ArrayBuffer)
+      ) {
+        headers['Content-Length'] = String(byteLength(body))
+      }
+
+      // Set a default Content-Type if not provided.
+      if (
+        !headers['Content-Type'] &&
+        !headers['content-type'] &&
+        !headers['Content-type']
+      ) {
+        headers['Content-Type'] = 'application/json'
+      }
+    } else if (typeof body === 'undefined' || body === '') {
+      body = null
+    }
+
+    // clone own props
+    const pathParams = { ...this.#request.params }
+
+    let token = headers.Authorization || headers.authorization
+
+    if (token && token.split(' ')[0] === 'Bearer') {
+      ;[, token] = token.split(' ')
+    }
+
+    let claims
+    let scopes
+
+    if (token) {
+      try {
+        claims = decode(token) || undefined
+        if (claims && claims.scope) {
+          scopes = claims.scope.split(' ')
+          // In AWS HTTP Api the scope property is removed from the decoded JWT
+          // I'm leaving this property because I'm not sure how all of the authorizers
+          // for AWS REST Api handle JWT.
+          // claims = { ...claims }
+          // delete claims.scope
+        }
+      } catch {
+        // Do nothing
+      }
+    }
+
+    const {
+      headers: _headers,
+      info: { received, remoteAddress },
+      method,
+      route,
+    } = this.#request
+
+    const httpMethod = method.toUpperCase()
+    const requestTime = formatToClfTime(received)
+    const requestTimeEpoch = received
+    const resource = this.#routeKey || route.path.replace(`/${this.#stage}`, '')
+
+    return {
+      body,
+      headers,
+      httpMethod,
+      isBase64Encoded: false, // TODO hook up
+      multiValueHeaders: parseMultiValueHeaders(
+        // NOTE FIXME request.raw.req.rawHeaders can only be null for testing (hapi shot inject())
+        rawHeaders || [],
+      ),
+      multiValueQueryStringParameters:
+        parseMultiValueQueryStringParameters(url),
+      path: this.#path,
+      pathParameters: nullIfEmpty(pathParams),
+      queryStringParameters: parseQueryStringParameters(url),
+      requestContext: {
+        accountId: 'offlineContext_accountId',
+        apiId: 'offlineContext_apiId',
+        authorizer:
+          authAuthorizer ||
+          assign(authContext, {
+            claims,
+            // 'principalId' should have higher priority
+            principalId:
+              authPrincipalId ||
+              env.PRINCIPAL_ID ||
+              'offlineContext_authorizer_principalId', // See #24
+            scopes,
+          }),
+        domainName: 'offlineContext_domainName',
+        domainPrefix: 'offlineContext_domainPrefix',
+        extendedRequestId: createUniqueId(),
+        httpMethod,
+        identity: {
+          accessKey: null,
+          accountId: env.SLS_ACCOUNT_ID || 'offlineContext_accountId',
+          apiKey: env.SLS_API_KEY || 'offlineContext_apiKey',
+          apiKeyId: env.SLS_API_KEY_ID || 'offlineContext_apiKeyId',
+          caller: env.SLS_CALLER || 'offlineContext_caller',
+          cognitoAuthenticationProvider:
+            _headers['cognito-authentication-provider'] ||
+            env.SLS_COGNITO_AUTHENTICATION_PROVIDER ||
+            'offlineContext_cognitoAuthenticationProvider',
+          cognitoAuthenticationType:
+            env.SLS_COGNITO_AUTHENTICATION_TYPE ||
+            'offlineContext_cognitoAuthenticationType',
+          cognitoIdentityId:
+            _headers['cognito-identity-id'] ||
+            env.SLS_COGNITO_IDENTITY_ID ||
+            'offlineContext_cognitoIdentityId',
+          cognitoIdentityPoolId:
+            env.SLS_COGNITO_IDENTITY_POOL_ID ||
+            'offlineContext_cognitoIdentityPoolId',
+          principalOrgId: null,
+          sourceIp: remoteAddress,
+          user: 'offlineContext_user',
+          userAgent: _headers['user-agent'] || '',
+          userArn: 'offlineContext_userArn',
+        },
+        operationName: this.#additionalRequestContext.operationName,
+        path: this.#path,
+        protocol: 'HTTP/1.1',
+        requestId: createUniqueId(),
+        requestTime,
+        requestTimeEpoch,
+        resourceId: 'offlineContext_resourceId',
+        resourcePath: route.path,
+        stage: this.#stage,
+      },
+      resource,
+      stageVariables: this.#stageVariables,
+    }
+  }
+}

package/src/events/http/lambda-events/LambdaProxyIntegrationEventV2.js

@@ -0,0 +1,190 @@
+import { Buffer } from 'node:buffer'
+import { env } from 'node:process'
+import { log } from '@serverless/utils/log.js'
+import { decode } from 'jsonwebtoken'
+import {
+  formatToClfTime,
+  lowerCaseKeys,
+  nullIfEmpty,
+  parseHeaders,
+} from '../../../utils/index.js'
+
+const { isArray } = Array
+const { parse } = JSON
+const { assign, entries, fromEntries } = Object
+
+// https://www.serverless.com/framework/docs/providers/aws/events/http-api/
+// https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+export default class LambdaProxyIntegrationEventV2 {
+  #additionalRequestContext = null
+
+  #routeKey = null
+
+  #request = null
+
+  #stage = null
+
+  #stageVariables = null
+
+  constructor(
+    request,
+    stage,
+    routeKey,
+    stageVariables,
+    additionalRequestContext,
+  ) {
+    this.#additionalRequestContext = additionalRequestContext || {}
+    this.#routeKey = routeKey
+    this.#request = request
+    this.#stage = stage
+    this.#stageVariables = stageVariables
+  }
+
+  create() {
+    const authContext =
+      (this.#request.auth &&
+        this.#request.auth.credentials &&
+        this.#request.auth.credentials.context) ||
+      {}
+
+    let authAuthorizer
+
+    if (env.AUTHORIZER) {
+      try {
+        authAuthorizer = parse(env.AUTHORIZER)
+      } catch {
+        log.error(
+          'Could not parse process.env.AUTHORIZER, make sure it is correct JSON',
+        )
+      }
+    }
+
+    let body = this.#request.payload
+
+    const { rawHeaders } = this.#request.raw.req
+
+    // NOTE FIXME request.raw.req.rawHeaders can only be null for testing (hapi shot inject())
+    const headers = lowerCaseKeys(parseHeaders(rawHeaders || [])) || {}
+
+    if (headers['sls-offline-authorizer-override']) {
+      try {
+        authAuthorizer = parse(headers['sls-offline-authorizer-override'])
+      } catch {
+        log.error(
+          'Could not parse header sls-offline-authorizer-override, make sure it is correct JSON',
+        )
+      }
+    }
+
+    if (body) {
+      if (typeof body !== 'string') {
+        // this.#request.payload is NOT the same as the rawPayload
+        body = this.#request.rawPayload
+      }
+
+      if (
+        !headers['content-length'] &&
+        (typeof body === 'string' ||
+          body instanceof Buffer ||
+          body instanceof ArrayBuffer)
+      ) {
+        headers['content-length'] = String(Buffer.byteLength(body))
+      }
+
+      // Set a default Content-Type if not provided.
+      if (!headers['content-type']) {
+        headers['content-type'] = 'application/json'
+      }
+    } else if (typeof body === 'undefined' || body === '') {
+      body = null
+    }
+
+    // clone own props
+    const pathParams = { ...this.#request.params }
+
+    let token = headers.Authorization || headers.authorization
+
+    if (token && token.split(' ')[0] === 'Bearer') {
+      ;[, token] = token.split(' ')
+    }
+
+    let claims
+    let scopes
+
+    if (token) {
+      try {
+        claims = decode(token) || undefined
+        if (claims && claims.scope) {
+          scopes = claims.scope.split(' ')
+          // In AWS HTTP Api the scope property is removed from the decoded JWT
+          // I'm leaving this property because I'm not sure how all of the authorizers
+          // for AWS REST Api handle JWT.
+          // claims = { ...claims }
+          // delete claims.scope
+        }
+      } catch {
+        // Do nothing
+      }
+    }
+
+    const {
+      headers: _headers,
+      info: { received, remoteAddress },
+      method,
+    } = this.#request
+
+    const httpMethod = method.toUpperCase()
+    const requestTime = formatToClfTime(received)
+    const requestTimeEpoch = received
+
+    const cookies = entries(this.#request.state).flatMap(([key, value]) => {
+      if (isArray(value)) {
+        return value.map((v) => `${key}=${v}`)
+      }
+      return `${key}=${value}`
+    })
+
+    return {
+      body,
+      cookies,
+      headers,
+      isBase64Encoded: false,
+      pathParameters: nullIfEmpty(pathParams),
+      queryStringParameters: this.#request.url.search
+        ? fromEntries(Array.from(this.#request.url.searchParams))
+        : null,
+      rawPath: this.#request.url.pathname,
+      rawQueryString: this.#request.url.searchParams.toString(),
+      requestContext: {
+        accountId: 'offlineContext_accountId',
+        apiId: 'offlineContext_apiId',
+        authorizer:
+          authAuthorizer ||
+          assign(authContext, {
+            jwt: {
+              claims,
+              scopes,
+            },
+          }),
+        domainName: 'offlineContext_domainName',
+        domainPrefix: 'offlineContext_domainPrefix',
+        http: {
+          method: httpMethod,
+          path: this.#request.url.pathname,
+          protocol: 'HTTP/1.1',
+          sourceIp: remoteAddress,
+          userAgent: _headers['user-agent'] || '',
+        },
+        operationName: this.#additionalRequestContext.operationName,
+        requestId: 'offlineContext_resourceId',
+        routeKey: this.#routeKey,
+        stage: this.#stage,
+        time: requestTime,
+        timeEpoch: requestTimeEpoch,
+      },
+      routeKey: this.#routeKey,
+      stageVariables: this.#stageVariables,
+      version: '2.0',
+    }
+  }
+}

package/src/events/http/lambda-events/VelocityContext.js

@@ -0,0 +1,147 @@
+import { Buffer } from 'node:buffer'
+import { env } from 'node:process'
+import jsEscapeString from 'js-string-escape'
+import { decode } from 'jsonwebtoken'
+import {
+  createUniqueId,
+  isPlainObject,
+  jsonPath,
+  parseHeaders,
+} from '../../../utils/index.js'
+
+const { parse, stringify } = JSON
+const { assign, entries, fromEntries } = Object
+
+function escapeJavaScript(x) {
+  if (typeof x === 'string') {
+    return jsEscapeString(x).replace(/\\n/g, '\n') // See #26,
+  }
+
+  if (isPlainObject(x)) {
+    const result = fromEntries(
+      entries(x).map(([key, value]) => [key, jsEscapeString(value)]),
+    )
+
+    return stringify(result) // Is this really how APIG does it?
+  }
+
+  if (typeof x.toString === 'function') {
+    return escapeJavaScript(x.toString())
+  }
+
+  return x
+}
+
+/*
+  Returns a context object that mocks APIG mapping template reference
+  http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
+*/
+export default class VelocityContext {
+  #path = null
+
+  #payload = null
+
+  #request = null
+
+  #stage = null
+
+  constructor(request, stage, payload, path) {
+    this.#path = path
+    this.#payload = payload
+    this.#request = request
+    this.#stage = stage
+  }
+
+  getContext() {
+    const path = (x) => jsonPath(this.#payload, x)
+
+    const authPrincipalId =
+      this.#request.auth &&
+      this.#request.auth.credentials &&
+      this.#request.auth.credentials.principalId
+
+    let authorizer =
+      this.#request.auth &&
+      this.#request.auth.credentials &&
+      this.#request.auth.credentials.authorizer
+
+    // NOTE FIXME request.raw.req.rawHeaders can only be null for testing (hapi shot inject())
+    const headers = parseHeaders(this.#request.raw.req.rawHeaders || [])
+
+    let token = headers && (headers.Authorization || headers.authorization)
+
+    if (token && token.split(' ')[0] === 'Bearer') {
+      ;[, token] = token.split(' ')
+    }
+
+    if (!authorizer) authorizer = {}
+
+    authorizer.principalId =
+      authPrincipalId ||
+      env.PRINCIPAL_ID ||
+      'offlineContext_authorizer_principalId' // See #24
+
+    if (token) {
+      try {
+        const claims = decode(token) || undefined
+        if (claims) {
+          assign(authorizer, { claims })
+        }
+      } catch {
+        // Nothing
+      }
+    }
+
+    return {
+      context: {
+        apiId: 'offlineContext_apiId',
+        authorizer,
+        httpMethod: this.#request.method.toUpperCase(),
+        identity: {
+          accountId: 'offlineContext_accountId',
+          apiKey: 'offlineContext_apiKey',
+          apiKeyId: 'offlineContext_apiKeyId',
+          caller: 'offlineContext_caller',
+          cognitoAuthenticationProvider:
+            'offlineContext_cognitoAuthenticationProvider',
+          cognitoAuthenticationType: 'offlineContext_cognitoAuthenticationType',
+          sourceIp: this.#request.info.remoteAddress,
+          user: 'offlineContext_user',
+          userAgent: this.#request.headers['user-agent'] || '',
+          userArn: 'offlineContext_userArn',
+        },
+        requestId: createUniqueId(),
+        resourceId: 'offlineContext_resourceId',
+        resourcePath: this.#path,
+        stage: this.#stage,
+      },
+      input: {
+        body: this.#payload, // Not a string yet, todo
+        json: (x) => stringify(path(x)),
+        params: (x) =>
+          typeof x === 'string'
+            ? this.#request.params[x] || this.#request.query[x] || headers[x]
+            : {
+                header: headers,
+                path: {
+                  ...this.#request.params,
+                },
+                querystring: {
+                  ...this.#request.query,
+                },
+              },
+        path,
+      },
+      util: {
+        base64Decode: (x) =>
+          Buffer.from(x.toString(), 'base64').toString('binary'),
+        base64Encode: (x) =>
+          Buffer.from(x.toString(), 'binary').toString('base64'),
+        escapeJavaScript,
+        parseJson: parse,
+        urlDecode: (x) => decodeURIComponent(x.replace(/\+/g, ' ')),
+        urlEncode: encodeURI,
+      },
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+export { default as LambdaIntegrationEvent } from './LambdaIntegrationEvent.js'
+export { default as LambdaProxyIntegrationEvent } from './LambdaProxyIntegrationEvent.js'
+export { default as renderVelocityTemplateObject } from './renderVelocityTemplateObject.js'
+export { default as VelocityContext } from './VelocityContext.js'

package/src/events/http/lambda-events/renderVelocityTemplateObject.js

@@ -0,0 +1,93 @@
+import { log } from '@serverless/utils/log.js'
+import velocityjs from 'velocityjs'
+import runInPollutedScope from '../javaHelpers.js'
+import { isPlainObject } from '../../../utils/index.js'
+
+const { parse } = JSON
+const { entries } = Object
+
+function tryToParseJSON(string) {
+  let parsed
+  try {
+    parsed = parse(string)
+  } catch {
+    // nothing! Some things are not meant to be parsed.
+  }
+
+  return parsed || string
+}
+
+function renderVelocityString(velocityString, context) {
+  // runs in a "polluted" (extended) String.prototype replacement scope
+  const renderResult = runInPollutedScope(() =>
+    // This line can throw, but this function does not handle errors
+    // Quick args explanation:
+    // { escape: false } --> otherwise would escape &, < and > chars with html (&amp;, &lt; and &gt;)
+    // render(context, null, true) --> null: no custom macros; true: silent mode, just like APIG
+    new velocityjs.Compile(velocityjs.parse(velocityString), {
+      escape: false,
+    }).render(context, null, true),
+  )
+
+  log.debug('Velocity rendered:', renderResult || 'undefined')
+
+  // Haaaa Velocity... this language sure loves strings a lot
+  switch (renderResult) {
+    case 'undefined':
+      return undefined // But we don't, we want JavaScript types
+
+    case 'null':
+      return null
+
+    case 'true':
+      return true
+
+    case 'false':
+      return false
+
+    default:
+      return tryToParseJSON(renderResult)
+  }
+}
+
+/*
+  Deeply traverses a Serverless-style JSON (Velocity) template
+  When it finds a string, assumes it's Velocity language and renders it.
+*/
+export default function renderVelocityTemplateObject(templateObject, context) {
+  const result = {}
+
+  let toProcess = templateObject
+
+  // In some projects, the template object is a string, let us see if it's JSON
+  if (typeof toProcess === 'string') {
+    toProcess = tryToParseJSON(toProcess)
+  }
+
+  // Let's check again
+  if (isPlainObject(toProcess)) {
+    entries(toProcess).forEach(([key, value]) => {
+      log.debug('Processing key:', key, '- value:', value)
+
+      if (typeof value === 'string') {
+        result[key] = renderVelocityString(value, context)
+        // Go deeper
+      } else if (isPlainObject(value)) {
+        result[key] = renderVelocityTemplateObject(value, context)
+        // This should never happen: value should either be a string or a plain object
+      } else {
+        result[key] = value
+      }
+    })
+    // Still a string? Maybe it's some complex Velocity stuff
+  } else if (typeof toProcess === 'string') {
+    // If the plugin threw here then you should consider reviewing your template or posting an issue.
+    const alternativeResult = tryToParseJSON(
+      renderVelocityString(toProcess, context),
+    )
+
+    return isPlainObject(alternativeResult) ? alternativeResult : result
+  }
+
+  return result
+}