serverless-offline 8.8.1 → 9.0.0

package/src/lambda/routes/invocations/InvocationsController.js

@@ -0,0 +1,102 @@
+import { log } from '@serverless/utils/log.js'
+
+export default class InvocationsController {
+  #lambda = null
+
+  constructor(lambda) {
+    this.#lambda = lambda
+  }
+
+  async invoke(functionName, invocationType, event, clientContext) {
+    // Reject gracefully if functionName does not exist
+    const functionNames = this.#lambda.listFunctionNames()
+    if (functionNames.length === 0 || !functionNames.includes(functionName)) {
+      log.error(
+        `Attempt to invoke function '${functionName}' failed. Function does not exists.`,
+      )
+      // Conforms to the actual response from AWS Lambda when invoking a non-existent
+      // function. Details on the error are provided in the Payload.Message key
+      return {
+        FunctionError: 'ResourceNotFoundException',
+        Payload: {
+          Message: `Function not found: ${functionName}`,
+          Type: 'User',
+        },
+        StatusCode: 404,
+      }
+    }
+
+    const lambdaFunction = this.#lambda.getByFunctionName(functionName)
+
+    lambdaFunction.setClientContext(clientContext)
+    lambdaFunction.setEvent(event)
+
+    if (invocationType === 'Event') {
+      // don't await result!
+      lambdaFunction.runHandler()
+      return {
+        Payload: '',
+        StatusCode: 202,
+      }
+    }
+
+    if (!invocationType || invocationType === 'RequestResponse') {
+      let result
+
+      try {
+        result = await lambdaFunction.runHandler()
+      } catch (err) {
+        log.error(
+          `Unhandled Lambda Error during invoke of '${functionName}': ${err}`,
+        )
+        // In most circumstances this is the correct error type/structure.
+        // The API returns a StreamingBody with status code of 200
+        // that eventually spits out the error and stack trace.
+        // When the request is synchronous, aws-sdk should buffer
+        // the whole error stream, however this has not been validated.
+        return {
+          Payload: {
+            errorMessage: err.message,
+            errorType: 'Error',
+            trace: err.stack.split('\n'),
+          },
+          StatusCode: 200,
+          UnhandledError: true,
+        }
+        // TODO: Additional pre and post-handler validation can expose
+        // the following error types:
+        // RequestTooLargeException, InvalidParameterValueException,
+        // and whatever response is thrown when the response is too large.
+      }
+
+      // Checking if the result of the Lambda Invoke is a primitive string to wrap it. this is for future post-processing such as Step Functions Tasks
+      if (result) {
+        if (typeof result === 'string') {
+          result = `"${result}"`
+        }
+      }
+
+      // result is actually the Payload.
+      // So return in a standard structure so Hapi can
+      // respond with the correct status codes
+      return {
+        Payload: result,
+        StatusCode: 200,
+      }
+    }
+
+    // TODO FIXME
+    const errMsg = `invocationType: '${invocationType}' not supported by serverless-offline`
+
+    log.error(errMsg)
+
+    return {
+      FunctionError: 'InvalidParameterValueException',
+      Payload: {
+        Message: errMsg,
+        Type: 'User',
+      },
+      StatusCode: 400,
+    }
+  }
+}

package/src/lambda/routes/invocations/index.js

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

package/src/lambda/routes/invocations/invocationsRoute.js

@@ -0,0 +1,77 @@
+import { Buffer } from 'node:buffer'
+import InvocationsController from './InvocationsController.js'
+
+const { parse } = JSON
+
+// https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html
+export default function invocationsRoute(lambda, options) {
+  const invocationsController = new InvocationsController(lambda)
+
+  return {
+    async handler(request, h) {
+      const {
+        headers,
+        params: { functionName },
+        payload,
+      } = request
+
+      const parsedHeaders = new Headers(headers)
+      const clientContextHeader = parsedHeaders.get('x-amz-client-context')
+      const invocationType = parsedHeaders.get('x-amz-invocation-type')
+
+      // default is undefined
+      let clientContext
+
+      // check client context header was set
+      if (clientContextHeader) {
+        const clientContextBuffer = Buffer.from(clientContextHeader, 'base64')
+        clientContext = parse(clientContextBuffer.toString('utf-8'))
+      }
+
+      // check if payload was set, if not, default event is an empty object
+      const event = payload.length > 0 ? parse(payload.toString('utf-8')) : {}
+
+      const invokeResults = await invocationsController.invoke(
+        functionName,
+        invocationType,
+        event,
+        clientContext,
+      )
+
+      // Return with correct status codes
+      let resultPayload = ''
+      let statusCode = 200
+      let functionError = null
+      if (invokeResults) {
+        const isPayloadDefined = typeof invokeResults.Payload !== 'undefined'
+        resultPayload = isPayloadDefined ? invokeResults.Payload : ''
+        statusCode = invokeResults.StatusCode || 200
+        functionError = invokeResults.FunctionError || null
+      }
+      const response = h.response(resultPayload).code(statusCode)
+      if (functionError) {
+        // AWS Invoke documentation is wrong. The header for error type is
+        // 'x-amzn-ErrorType' in production, not 'X-Amz-Function-Error'
+        response.header('x-amzn-ErrorType', functionError)
+      }
+      if (invokeResults && invokeResults.UnhandledError) {
+        response.header('X-Amz-Function-Error', 'Unhandled')
+      }
+      return response
+    },
+    method: 'POST',
+    options: {
+      cors: options.corsConfig,
+      payload: {
+        // allow: ['binary/octet-stream'],
+        defaultContentType: 'binary/octet-stream',
+        // Set maximum size to 6 MB to match maximum invocation payload size in synchronous responses
+        maxBytes: 1024 * 1024 * 6,
+        // request.payload will be a raw buffer
+        parse: false,
+      },
+      tags: ['api'],
+    },
+    path: '/2015-03-31/functions/{functionName}/invocations',
+  }
+}

package/src/lambda/routes/invoke-async/InvokeAsyncController.js

@@ -0,0 +1,20 @@
+export default class InvokeAsyncController {
+  #lambda = null
+
+  constructor(lambda) {
+    this.#lambda = lambda
+  }
+
+  async invokeAsync(functionName, event) {
+    const lambdaFunction = this.#lambda.getByFunctionName(functionName)
+
+    lambdaFunction.setEvent(event)
+
+    // don't await result!
+    lambdaFunction.runHandler()
+
+    return {
+      StatusCode: 202,
+    }
+  }
+}

package/src/lambda/routes/invoke-async/index.js

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

package/src/lambda/routes/invoke-async/invokeAsyncRoute.js

@@ -0,0 +1,33 @@
+import InvokeAsyncController from './InvokeAsyncController.js'
+
+const { parse } = JSON
+
+// https://docs.aws.amazon.com/lambda/latest/dg/API_InvokeAsync.html
+export default function invokeRoute(lambda, options) {
+  const invokeAsyncController = new InvokeAsyncController(lambda)
+
+  return {
+    handler(request) {
+      const {
+        params: { functionName },
+        payload,
+      } = request
+
+      const event = parse(payload.toString('utf-8'))
+
+      return invokeAsyncController.invokeAsync(functionName, event)
+    },
+    method: 'POST',
+    options: {
+      cors: options.corsConfig,
+      payload: {
+        // allow: ['binary/octet-stream'],
+        defaultContentType: 'binary/octet-stream',
+        // request.payload will be a raw buffer
+        parse: false,
+      },
+      tags: ['api'],
+    },
+    path: '/2014-11-13/functions/{functionName}/invoke-async/',
+  }
+}

package/src/utils/__tests__/createUniqueId.test.js

@@ -0,0 +1,18 @@
+import assert from 'node:assert'
+import createUniqueId from '../createUniqueId.js'
+
+describe('createUniqueId', () => {
+  it('should be unique', () => {
+    const items = 100000
+    const set = new Set(Array.from(Array(items)).map(createUniqueId))
+
+    assert.equal(set.size, items)
+  })
+
+  it('should be a 36 character string', () => {
+    const id = createUniqueId()
+
+    assert.equal(typeof id, 'string')
+    assert.equal(id.length, 36)
+  })
+})

package/src/utils/__tests__/formatToClfTime.test.js

@@ -0,0 +1,14 @@
+import assert from 'node:assert'
+import formatToClfTime from '../formatToClfTime.js'
+
+const { now } = Date
+
+describe('formatToClfTime', () => {
+  it('should return "common log format" formatted time', () => {
+    const millis = now()
+    const result = formatToClfTime(millis)
+
+    // expected: 17/Dec/1995:03:24:00 -0500 (with varying offset)
+    assert.match(result, /([\w:/]+\s[+-]\d{4})/)
+  })
+})

package/src/utils/__tests__/generateHapiPath.test.js

@@ -0,0 +1,46 @@
+import assert from 'node:assert'
+import generateHapiPath from '../generateHapiPath.js'
+
+const serverless = {
+  service: {
+    provider: {
+      stage: 'dev',
+    },
+  },
+}
+
+describe('generateHapiPath', () => {
+  it('should generate url starting with a slash', () => {
+    const options = {}
+    const result = generateHapiPath('users', options, serverless)
+    assert.equal(result[0], '/')
+  })
+
+  it('should generate url with the stage prepended', () => {
+    const options = {}
+    const result = generateHapiPath('users', options, serverless)
+    assert.equal(result, '/dev/users')
+  })
+
+  describe('when a prefix option is set', () => {
+    it('the url should add the prefix', () => {
+      const options = { prefix: 'some-prefix' }
+      const result = generateHapiPath('users', options, serverless)
+      assert.equal(result, '/some-prefix/dev/users')
+    })
+  })
+
+  describe('when the noPrependStageInUrl option is set', () => {
+    it('the url should omit the stage', () => {
+      const options = { noPrependStageInUrl: true }
+      const result = generateHapiPath('users', options, serverless)
+      assert.equal(result, '/users')
+    })
+  })
+
+  it('the stage from options should override stage from serverless config', () => {
+    const options = { stage: 'prod' }
+    const result = generateHapiPath('users', options, serverless)
+    assert.equal(result, '/prod/users')
+  })
+})

package/src/utils/__tests__/lowerCaseKeys.test.js

@@ -0,0 +1,30 @@
+import assert from 'node:assert'
+import lowerCaseKeys from '../lowerCaseKeys.js'
+
+describe('lowerCaseKeys', () => {
+  it('should handle empty object', () => {
+    const result = lowerCaseKeys({})
+    assert.deepEqual(result, {})
+  })
+
+  it('should handle object with one key', () => {
+    const result = lowerCaseKeys({ 'Some-Key': 'value' })
+    assert.deepEqual(result, { 'some-key': 'value' })
+  })
+
+  it('should handle object with multiple keys', () => {
+    const result = lowerCaseKeys({
+      'already-lowercase': 'cool',
+      'Another-Key': 'anotherValue',
+      'lOts-OF-CAPitaLs': 'ButThisIsNotTouched',
+      'Some-Key': 'value',
+    })
+
+    assert.deepEqual(result, {
+      'already-lowercase': 'cool',
+      'another-key': 'anotherValue',
+      'lots-of-capitals': 'ButThisIsNotTouched',
+      'some-key': 'value',
+    })
+  })
+})

package/src/utils/__tests__/parseHeaders.test.js

@@ -0,0 +1,13 @@
+import assert from 'node:assert'
+// uses the same tests as parseMultiValueHeaders
+import tests from './parseMultiValueHeaders.test.js'
+import parseHeaders from '../parseHeaders.js'
+
+describe('parseQueryStringParameters', () => {
+  tests.forEach(({ description, expected, param }) => {
+    it(`should return ${description}`, () => {
+      const result = parseHeaders(param)
+      assert.deepEqual(result, expected)
+    })
+  })
+})

package/src/utils/__tests__/parseMultiValueHeaders.test.js

@@ -0,0 +1,24 @@
+import assert from 'node:assert'
+import parseMultiValueHeaders from '../parseMultiValueHeaders.js'
+
+// TODO need more tests
+const tests = [
+  {
+    description: 'no parameter (empty array)',
+    expected: null,
+    expectedMulti: null,
+    param: [],
+  },
+]
+
+describe('parseMultiValueHeaders', () => {
+  tests.forEach(({ description, expectedMulti, param }) => {
+    it(`should return ${description}`, () => {
+      const resultMulti = parseMultiValueHeaders(param)
+      assert.deepEqual(resultMulti, expectedMulti)
+    })
+  })
+})
+
+// export tests for parseHeaders
+export default tests

package/src/utils/__tests__/parseMultiValueQueryStringParameters.test.js

@@ -0,0 +1,159 @@
+import assert from 'node:assert'
+import parseMultiValueQueryStringParameters from '../parseMultiValueQueryStringParameters.js'
+
+const tests = [
+  {
+    description: 'no parameter (empty string)',
+    expected: null,
+    expectedMulti: null,
+    param: '',
+  },
+
+  {
+    description: 'string parameter',
+    expected: { foo: 'bar' },
+    expectedMulti: { foo: ['bar'] },
+    param: 'foo=bar',
+  },
+
+  {
+    description: 'number parameter (no type casting)',
+    expected: { foo: '1' },
+    expectedMulti: { foo: ['1'] },
+    param: 'foo=1',
+  },
+
+  {
+    description: 'boolean parameter (no type casting)',
+    expected: { foo: 'true' },
+    expectedMulti: { foo: ['true'] },
+    param: 'foo=true',
+  },
+
+  {
+    description: 'multiple parameters',
+    expected: { bar: 'test2', foo: 'test1' },
+    expectedMulti: { bar: ['test2'], foo: ['test1'] },
+    param: 'foo=test1&bar=test2',
+  },
+
+  {
+    description: 'multiple parameters, same keys',
+    expected: { foo: 'foobar' },
+    expectedMulti: { foo: ['test', 'foobar'] },
+    param: 'foo=test&foo=foobar',
+  },
+
+  {
+    description: 'multiple parameters, same keys, different casing',
+    expected: { foo: 'test', FOO: 'FOOBAR' },
+    expectedMulti: { foo: ['test'], FOO: ['FOOBAR'] },
+    param: 'foo=test&FOO=FOOBAR',
+  },
+
+  {
+    description: 'multiple parameters, same keys, same values',
+    expected: { foo: 'test' },
+    expectedMulti: { foo: ['test', 'test'] },
+    param: 'foo=test&foo=test',
+  },
+
+  {
+    description: 'no value',
+    expected: { foo: '' },
+    expectedMulti: { foo: [''] },
+    param: 'foo',
+  },
+
+  {
+    description: 'no value with =',
+    expected: { foo: '' },
+    expectedMulti: { foo: [''] },
+    param: 'foo=',
+  },
+
+  {
+    description: 'no value with &',
+    expected: { foo: '' },
+    expectedMulti: { foo: [''] },
+    param: 'foo&',
+  },
+
+  {
+    description: 'no value with = and &',
+    expected: { foo: '' },
+    expectedMulti: { foo: [''] },
+    param: 'foo=&',
+  },
+
+  {
+    description: 'value is whitespace',
+    expected: { foo: ' ' },
+    expectedMulti: { foo: [' '] },
+    param: 'foo=%20',
+  },
+
+  {
+    description: 'key and value have whitespace',
+    expected: { ' foo ': ' test ' },
+    expectedMulti: { ' foo ': [' test '] },
+    param: '%20foo%20=%20test%20',
+  },
+
+  {
+    description: 'unicode',
+    expected: { Σ: '😋' },
+    expectedMulti: { Σ: ['😋'] },
+    param: 'Σ=😋',
+  },
+
+  {
+    description: 'encoded', // encodeURIComponent
+    expected: { '?=/&:': '?=/&:' },
+    expectedMulti: { '?=/&:': ['?=/&:'] },
+    param: '%3F%3D%2F%26%3A=%3F%3D%2F%26%3A',
+  },
+
+  {
+    description: 'end of line',
+    expected: { '\n': '\n' },
+    expectedMulti: { '\n': ['\n'] },
+    param: '%0A=%0A',
+  },
+
+  // silly test section:
+  {
+    description: 'silly I.',
+    expected: { test: '?' },
+    expectedMulti: { test: ['?'] },
+    param: 'test=?',
+  },
+
+  {
+    description: 'silly II.',
+    expected: { test: '/' },
+    expectedMulti: { test: ['/'] },
+    param: 'test=/',
+  },
+
+  {
+    description: 'silly III.',
+    expected: { test: '=' },
+    expectedMulti: { test: ['='] },
+    param: 'test==',
+  },
+]
+
+describe('parseMultiValueQueryStringParameters', () => {
+  tests.forEach(({ description, expectedMulti, param }) => {
+    const url = `foo?${param}`
+
+    it(`should return ${description}`, () => {
+      const resultMulti = parseMultiValueQueryStringParameters(url)
+      assert.deepEqual(resultMulti, expectedMulti)
+    })
+  })
+})
+
+// export tests for parseQueryStringParameters
+export default tests

package/src/utils/__tests__/parseQueryStringParameters.test.js

@@ -0,0 +1,15 @@
+import assert from 'node:assert'
+// uses the same tests as parseMultiValueQueryStringParameters
+import tests from './parseMultiValueQueryStringParameters.test.js'
+import parseQueryStringParameters from '../parseQueryStringParameters.js'
+
+describe('parseQueryStringParameters', () => {
+  tests.forEach(({ description, expected, param }) => {
+    const url = `/foo?${param}`
+
+    it(`should return ${description}`, () => {
+      const result = parseQueryStringParameters(url)
+      assert.deepEqual(result, expected)
+    })
+  })
+})

package/src/utils/__tests__/splitHandlerPathAndName.test.js

@@ -0,0 +1,54 @@
+import assert from 'node:assert'
+import splitHandlerPathAndName from '../splitHandlerPathAndName.js'
+
+const tests = [
+  {
+    description: 'ruby handler with namespace resolution operator ::',
+    expected: ['./src/somefolder/source', 'LambdaFunctions::Handler.process'],
+    handler: './src/somefolder/source.LambdaFunctions::Handler.process',
+  },
+  {
+    description: 'ruby handler with multiple namespace resolution operators ::',
+    expected: [
+      './src/somefolder/source',
+      'Functions::LambdaFunctions::Handler.process',
+    ],
+    handler:
+      './src/somefolder/source.Functions::LambdaFunctions::Handler.process',
+  },
+  {
+    description: 'ruby handler with namespace resolution operator ::, unnested',
+    expected: ['source', 'LambdaFunctions::Handler.process'],
+    handler: 'source.LambdaFunctions::Handler.process',
+  },
+  {
+    description:
+      'ruby handler with multiple namespace resolution operators ::, unnested',
+    expected: ['./source', 'Functions::LambdaFunctions::Handler.process'],
+    handler: './source.Functions::LambdaFunctions::Handler.process',
+  },
+  {
+    description: 'ruby handler from kernel',
+    expected: ['./src/somefolder/function', 'handler'],
+    handler: './src/somefolder/function.handler',
+  },
+  {
+    description: 'generic handler',
+    expected: ['./src/somefolder/.handlers/handler', 'run'],
+    handler: './src/somefolder/.handlers/handler.run',
+  },
+  {
+    description: 'generic handler, unnested',
+    expected: ['handler', 'run'],
+    handler: 'handler.run',
+  },
+]
+
+describe('splitHandlerPathAndName', () => {
+  tests.forEach(({ description, expected, handler }) => {
+    it(`should split ${description}`, () => {
+      const result = splitHandlerPathAndName(handler)
+      assert.deepEqual(result, expected)
+    })
+  })
+})

package/src/utils/__tests__/unflatten.test.js

@@ -0,0 +1,32 @@
+import assert from 'node:assert'
+import unflatten from '../unflatten.js'
+
+describe('unflatten', () => {
+  it('should work with empty array parameter', () => {
+    const value = []
+    const out = unflatten(value, 2)
+    const expected = []
+
+    assert.deepEqual(out, expected)
+  })
+
+  it('should work with single pair parameter', () => {
+    const value = ['a', 1]
+    const out = unflatten(value, 2)
+    const expected = [['a', 1]]
+
+    assert.deepEqual(out, expected)
+  })
+
+  it('should work with multiple pair parameters', () => {
+    const value = ['a', 1, 'b', 2, 'c', 3]
+    const out = unflatten(value, 2)
+    const expected = [
+      ['a', 1],
+      ['b', 2],
+      ['c', 3],
+    ]
+
+    assert.deepEqual(out, expected)
+  })
+})

package/src/utils/checkDockerDaemon.js

@@ -0,0 +1,19 @@
+import { execa } from 'execa'
+
+export default async function checkDockerDaemon() {
+  let dockerServerOS
+
+  try {
+    ;({ stdout: dockerServerOS } = await execa('docker', [
+      'version',
+      '--format',
+      '{{.Server.Os}}',
+    ]))
+  } catch {
+    throw new Error('The docker daemon is not running.')
+  }
+
+  if (dockerServerOS !== 'linux') {
+    throw new Error('Please switch docker daemon to linux mode.')
+  }
+}