serverless-offline 8.8.0 → 9.1.0

package/src/utils/checkGoVersion.js

@@ -0,0 +1,16 @@
+import { execa } from 'execa'
+
+export default async function checkGoVersion() {
+  let goVersion
+
+  try {
+    const { stdout } = await execa('go', ['version'])
+    if (stdout.match(/go1.\d+/g)) {
+      goVersion = '1.x'
+    }
+  } catch {
+    // @ignore
+  }
+
+  return goVersion
+}

package/src/utils/createApiKey.js

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto'
+
+export default function createApiKey() {
+  return createHash('md5').digest('hex')
+}

package/src/utils/createUniqueId.js

@@ -0,0 +1,5 @@
+import { randomUUID } from 'node:crypto'
+
+export default function createUniqueId() {
+  return randomUUID()
+}

package/src/utils/detectExecutable.js

@@ -0,0 +1,11 @@
+import { execa } from 'execa'
+
+export default async function detectExecutable(exe, versionFlag = '--version') {
+  try {
+    const { failed } = await execa(exe, [versionFlag])
+
+    return failed === false
+  } catch {
+    return false
+  }
+}

package/{dist → src}/utils/formatToClfTime.js

@@ -1,15 +1,8 @@
-"use strict";
+import { DateTime } from 'luxon'
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = formatToClfTime;
+const { fromMillis } = DateTime
 
-var _luxon = require("luxon");
-
-const {
-  fromMillis
-} = _luxon.DateTime; // CLF -> Common Log Format
+// CLF -> Common Log Format
 // https://httpd.apache.org/docs/1.3/logs.html#common
 // [day/month/year:hour:minute:second zone]
 // day = 2*digit
@@ -19,7 +12,6 @@ const {
 // minute = 2*digit
 // second = 2*digit
 // zone = (`+' | `-') 4*digit
-
-function formatToClfTime(millis) {
-  return fromMillis(millis).toFormat('dd/MMM/yyyy:HH:mm:ss ZZZ');
-}
+export default function formatToClfTime(millis) {
+  return fromMillis(millis).toFormat('dd/MMM/yyyy:HH:mm:ss ZZZ')
+}

package/src/utils/generateHapiPath.js

@@ -0,0 +1,26 @@
+export default function generateHapiPath(path, options, serverless) {
+  // path must start with '/'
+  let hapiPath = path.startsWith('/') ? path : `/${path}`
+
+  if (!options.noPrependStageInUrl) {
+    const stage = options.stage || serverless.service.provider.stage
+    // prepend the stage to path
+    hapiPath = `/${stage}${hapiPath}`
+  }
+
+  if (options.prefix) {
+    hapiPath = `/${options.prefix}${hapiPath}`
+  }
+
+  if (
+    hapiPath !== '/' &&
+    hapiPath.endsWith('/') &&
+    (!options.noStripTrailingSlashInUrl || hapiPath.endsWith('+}/'))
+  ) {
+    hapiPath = hapiPath.slice(0, -1)
+  }
+
+  hapiPath = hapiPath.replace(/\+}/g, '*}')
+
+  return hapiPath
+}

package/src/utils/getHttpApiCorsConfig.js

@@ -0,0 +1,28 @@
+import { log } from '@serverless/utils/log.js'
+
+export default function getHttpApiCorsConfig(httpApiCors) {
+  if (httpApiCors === true) {
+    // default values that should be set by serverless
+    // https://www.serverless.com/framework/docs/providers/aws/events/http-api/
+    const c = {
+      allowedHeaders: [
+        'Authorization',
+        'Content-Type',
+        'X-Amz-Date',
+        'X-Amz-Security-Token',
+        'X-Amz-User-Agent',
+        'X-Api-Key',
+      ],
+      allowedMethods: ['DELETE', 'GET', 'OPTIONS', 'PATCH', 'POST', 'PUT'],
+      allowedOrigins: ['*'],
+    }
+
+    log.debug('Using CORS policy', c)
+
+    return c
+  }
+
+  log.debug('Using CORS policy', httpApiCors)
+
+  return httpApiCors
+}

package/src/utils/index.js

@@ -0,0 +1,42 @@
+export { default as createApiKey } from './createApiKey.js'
+export { default as createUniqueId } from './createUniqueId.js'
+export { default as detectExecutable } from './detectExecutable.js'
+export { default as formatToClfTime } from './formatToClfTime.js'
+export { default as getHttpApiCorsConfig } from './getHttpApiCorsConfig.js'
+export { default as jsonPath } from './jsonPath.js'
+export { default as lowerCaseKeys } from './lowerCaseKeys.js'
+export { default as parseHeaders } from './parseHeaders.js'
+export { default as parseMultiValueHeaders } from './parseMultiValueHeaders.js'
+export { default as parseMultiValueQueryStringParameters } from './parseMultiValueQueryStringParameters.js'
+export { default as parseQueryStringParameters } from './parseQueryStringParameters.js'
+export { default as splitHandlerPathAndName } from './splitHandlerPathAndName.js'
+export { default as checkDockerDaemon } from './checkDockerDaemon.js'
+export { default as checkGoVersion } from './checkGoVersion.js'
+export { default as generateHapiPath } from './generateHapiPath.js'
+// export { default as baseImage } from './baseImage.js'
+
+const { isArray } = Array
+const { keys } = Object
+
+// Detect the toString encoding from the request headers content-type
+// enhance if further content types need to be non utf8 encoded.
+export function detectEncoding(request) {
+  const contentType = request.headers['content-type']
+
+  return typeof contentType === 'string' &&
+    contentType.includes('multipart/form-data')
+    ? 'binary'
+    : 'utf8'
+}
+
+export function nullIfEmpty(obj) {
+  return obj && (keys(obj).length > 0 ? obj : null)
+}
+
+export function isPlainObject(obj) {
+  return typeof obj === 'object' && !isArray(obj) && obj != null
+}
+
+export function toPlainOrEmptyObject(obj) {
+  return typeof obj === 'object' && !isArray(obj) ? obj : {}
+}

package/src/utils/jsonPath.js

@@ -0,0 +1,13 @@
+import { JSONPath } from 'jsonpath-plus'
+
+export default function jsonPath(json, path) {
+  // NOTE: JSONPath returns undefined if 'json' is e.g. null, undefined, string,
+  // number (anything other than JSON)
+  const [result] =
+    JSONPath({
+      json,
+      path,
+    }) || []
+
+  return result
+}

package/src/utils/logRoutes.js

@@ -0,0 +1,64 @@
+import boxen from 'boxen'
+import chalk from 'chalk'
+
+const { max } = Math
+
+const dodgerblue = chalk.hex('#1e90ff')
+const grey = chalk.hex('#808080')
+const lime = chalk.hex('#00ff00')
+const orange = chalk.hex('#ffa500')
+const peachpuff = chalk.hex('#ffdab9')
+const plum = chalk.hex('#dda0dd')
+const red = chalk.hex('#ff0000')
+const yellow = chalk.hex('#ffff00')
+
+const colorMethodMapping = new Map([
+  ['DELETE', red],
+  ['GET', dodgerblue],
+  // ['HEAD', ...],
+  ['PATCH', orange],
+  ['POST', plum],
+  ['PUT', dodgerblue],
+])
+
+// logs based on:
+// https://github.com/serverless/serverless/blob/master/lib/classes/CLI.js
+
+function logRoute(method, server, path, maxLength, dimPath = false) {
+  const methodColor = colorMethodMapping.get(method) ?? peachpuff
+  const methodFormatted = method.padEnd(maxLength, ' ')
+
+  return `${methodColor(methodFormatted)} ${yellow.dim('|')} ${grey.dim(
+    server,
+  )}${dimPath ? grey.dim(path) : lime(path)}`
+}
+
+function getMaxHttpMethodNameLength(routeInfo) {
+  return max(...routeInfo.map(({ method }) => method.length))
+}
+
+export default function logRoutes(routeInfo) {
+  const boxenOptions = {
+    borderColor: 'yellow',
+    dimBorder: true,
+    margin: 1,
+    padding: 1,
+  }
+  const maxLength = getMaxHttpMethodNameLength(routeInfo)
+
+  // eslint-disable-next-line no-console
+  console.log(
+    boxen(
+      routeInfo
+        .map(
+          ({ method, path, server, invokePath }) =>
+            // eslint-disable-next-line prefer-template
+            logRoute(method, server, path, maxLength) +
+            '\n' +
+            logRoute('POST', server, invokePath, maxLength, true),
+        )
+        .join('\n'),
+      boxenOptions,
+    ),
+  )
+}

package/src/utils/lowerCaseKeys.js

@@ -0,0 +1,6 @@
+const { entries, fromEntries } = Object
+
+// (obj: { [string]: string }): { [Lowercase<string>]: string }
+export default function parseHeaders(obj) {
+  return fromEntries(entries(obj).map(([k, v]) => [k.toLowerCase(), v]))
+}

package/src/utils/parseHeaders.js

@@ -0,0 +1,14 @@
+import unflatten from './unflatten.js'
+
+const { fromEntries } = Object
+
+// (rawHeaders: Array<string>): { [string]: string }
+export default function parseHeaders(rawHeaders) {
+  if (rawHeaders.length === 0) {
+    return null
+  }
+
+  const unflattened = unflatten(rawHeaders, 2)
+
+  return fromEntries(unflattened)
+}

package/src/utils/parseMultiValueHeaders.js

@@ -0,0 +1,27 @@
+import unflatten from './unflatten.js'
+
+const { fromEntries } = Object
+
+// https://aws.amazon.com/blogs/compute/support-for-multi-value-parameters-in-amazon-api-gateway/
+// (rawHeaders: Array<string>): { [string]: Array<string> }
+export default function parseMultiValueHeaders(rawHeaders) {
+  if (rawHeaders.length === 0) {
+    return null
+  }
+
+  const map = new Map()
+  const unflattened = unflatten(rawHeaders, 2)
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [key, value] of unflattened) {
+    const item = map.get(key)
+
+    if (item) {
+      item.push(value)
+    } else {
+      map.set(key, [value])
+    }
+  }
+
+  return fromEntries(map)
+}

package/src/utils/parseMultiValueQueryStringParameters.js

@@ -0,0 +1,31 @@
+import { BASE_URL_PLACEHOLDER } from '../config/index.js'
+
+const { fromEntries } = Object
+
+// https://aws.amazon.com/blogs/compute/support-for-multi-value-parameters-in-amazon-api-gateway/
+// [ [ 'petType', 'dog' ], [ 'petType', 'fish' ] ]
+// => { petType: [ 'dog', 'fish' ] },
+export default function parseMultiValueQueryStringParameters(url) {
+  // dummy placeholder url for the WHATWG URL constructor
+  // https://github.com/nodejs/node/issues/12682
+  const { searchParams } = new URL(url, BASE_URL_PLACEHOLDER)
+
+  if (Array.from(searchParams).length === 0) {
+    return null
+  }
+
+  const map = new Map()
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const [key, value] of searchParams) {
+    const item = map.get(key)
+
+    if (item) {
+      item.push(value)
+    } else {
+      map.set(key, [value])
+    }
+  }
+
+  return fromEntries(map)
+}

package/src/utils/parseQueryStringParameters.js

@@ -0,0 +1,15 @@
+import { BASE_URL_PLACEHOLDER } from '../config/index.js'
+
+const { fromEntries } = Object
+
+export default function parseQueryStringParameters(url) {
+  // dummy placeholder url for the WHATWG URL constructor
+  // https://github.com/nodejs/node/issues/12682
+  const { searchParams } = new URL(url, BASE_URL_PLACEHOLDER)
+
+  if (Array.from(searchParams).length === 0) {
+    return null
+  }
+
+  return fromEntries(searchParams)
+}

package/src/utils/splitHandlerPathAndName.js

@@ -0,0 +1,31 @@
+// some-folder/src.index => some-folder/src
+export default function splitHandlerPathAndName(handler) {
+  // Split handler into method name and path i.e. handler.run
+  // Support Ruby paths with namespace resolution operators e.g.
+  //  ./src/somefolder/source.LambdaFunctions::Handler.process
+  //  prepath: ./src/somefolder/
+  //  postpath: source.LambdaFunctions::Handler.process
+  //  filename: source
+  //  path: ./src/somefolder/source
+  //  name: LambdaFunctions::Handler.process
+  if (handler.match(/::/)) {
+    const prepathDelimiter = handler.lastIndexOf('/')
+    const prepath = handler.substr(0, prepathDelimiter + 1) // include '/' for path
+    const postpath = handler.substr(prepathDelimiter + 1)
+    const nameDelimiter = postpath.indexOf('.')
+    const filename = postpath.substr(0, nameDelimiter)
+    const path = prepath + filename
+    const name = postpath.substr(nameDelimiter + 1)
+
+    return [path, name]
+  }
+
+  // Support nested paths i.e. ./src/somefolder/.handlers/handler.run
+  //  path: ./src/somefoler/.handlers/handler
+  //  name: run
+  const delimiter = handler.lastIndexOf('.')
+  const path = handler.substr(0, delimiter)
+  const name = handler.substr(delimiter + 1)
+
+  return [path, name]
+}

package/src/utils/unflatten.js

@@ -0,0 +1,11 @@
+// [0, 1, 2, 3, 4 ,5] => [[0, 1], [2, 3], [4, 5]]
+export default function unflatten(value, size) {
+  const unflattened = []
+
+  for (let i = 0; i < value.length; i += size) {
+    const slice = value.slice(i, i + size)
+    unflattened.push(slice)
+  }
+
+  return unflattened
+}