serverless-offline 8.7.0 → 9.0.0

package/{dist → src}/events/http/parseResources.js

@@ -1,46 +1,39 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parseResources;
-const {
-  entries,
-  fromEntries,
-  keys
-} = Object;
-const APIGATEWAY_INTEGRATION_TYPE_HTTP_PROXY = 'HTTP_PROXY';
-const APIGATEWAY_ROOT_ID = 'RootResourceId';
-const APIGATEWAY_TYPE_METHOD = 'AWS::ApiGateway::Method';
-const APIGATEWAY_TYPE_RESOURCE = 'AWS::ApiGateway::Resource';
+const { entries, fromEntries, keys } = Object
+
+const APIGATEWAY_INTEGRATION_TYPE_HTTP_PROXY = 'HTTP_PROXY'
+const APIGATEWAY_ROOT_ID = 'RootResourceId'
+const APIGATEWAY_TYPE_METHOD = 'AWS::ApiGateway::Method'
+const APIGATEWAY_TYPE_RESOURCE = 'AWS::ApiGateway::Resource'
 
 function getApiGatewayTemplateObjects(resources) {
-  const Resources = resources && resources.Resources;
+  const Resources = resources && resources.Resources
 
   if (!Resources) {
-    return {};
+    return {}
   }
 
-  const methodObjects = [];
-  const pathObjects = [];
+  const methodObjects = []
+  const pathObjects = []
+
   entries(Resources).forEach(([key, value]) => {
-    const resourceObj = value || {};
-    const keyValuePair = [key, resourceObj];
-    const {
-      Type
-    } = resourceObj;
+    const resourceObj = value || {}
+    const keyValuePair = [key, resourceObj]
+
+    const { Type } = resourceObj
 
     if (Type === APIGATEWAY_TYPE_METHOD) {
-      methodObjects.push(keyValuePair);
+      methodObjects.push(keyValuePair)
     } else if (Type === APIGATEWAY_TYPE_RESOURCE) {
-      pathObjects.push(keyValuePair);
+      pathObjects.push(keyValuePair)
     }
-  });
+  })
+
   return {
     methodObjects: fromEntries(methodObjects),
-    pathObjects: fromEntries(pathObjects)
-  };
+    pathObjects: fromEntries(pathObjects),
+  }
 }
+
 /* Example of a Resource Object
  *  "ApiGatewayResourceFavicon": {
  *    "Type": "AWS::ApiGateway::Resource",
@@ -54,52 +47,53 @@ function getApiGatewayTemplateObjects(resources) {
 
 /* Resource Helpers */
 
-
 function isRoot(resourceId) {
-  return resourceId === APIGATEWAY_ROOT_ID;
+  return resourceId === APIGATEWAY_ROOT_ID
 }
 
 function getPathPart(resourceObj) {
   if (!resourceObj || !resourceObj.Properties) {
-    return undefined;
+    return undefined
   }
 
-  return resourceObj.Properties.PathPart;
+  return resourceObj.Properties.PathPart
 }
 
 function getParentId(resourceObj) {
   if (!resourceObj || !resourceObj.Properties) {
-    return undefined;
+    return undefined
   }
+  const parentIdObj = resourceObj.Properties.ParentId || {}
+
+  const { Ref } = parentIdObj
+  if (Ref) return Ref
+
+  const getAtt = parentIdObj['Fn::GetAtt'] || []
 
-  const parentIdObj = resourceObj.Properties.ParentId || {};
-  const {
-    Ref
-  } = parentIdObj;
-  if (Ref) return Ref;
-  const getAtt = parentIdObj['Fn::GetAtt'] || [];
-  return getAtt[1];
+  return getAtt[1]
 }
 
 function getFullPath(pathObjects, resourceId) {
-  let currentId = resourceId;
-  let currentObj;
-  const arrResourceObjects = [];
+  let currentId = resourceId
+  let currentObj
+  const arrResourceObjects = []
 
   while (currentId && !isRoot(currentId)) {
-    currentObj = pathObjects[currentId];
-    arrResourceObjects.push(currentObj);
-    currentId = getParentId(currentObj);
+    currentObj = pathObjects[currentId]
+    arrResourceObjects.push(currentObj)
+
+    currentId = getParentId(currentObj)
   }
 
-  const arrPath = arrResourceObjects.map(getPathPart).reverse();
+  const arrPath = arrResourceObjects.map(getPathPart).reverse()
 
-  if (arrPath.some(s => !s)) {
-    return undefined;
+  if (arrPath.some((s) => !s)) {
+    return undefined
   }
 
-  return `/${arrPath.join('/')}`;
+  return `/${arrPath.join('/')}`
 }
+
 /* Example of an HTTP Proxy Method Object
  *  "ApiGatewayResourcePublicAnyProxyMethod": {
  *    "Type": "AWS::ApiGateway::Method",
@@ -124,65 +118,66 @@ function getFullPath(pathObjects, resourceId) {
 
 /* Method Helpers */
 
-
 function getResourceId(methodObj) {
   if (!methodObj || !methodObj.Properties) {
-    return undefined;
+    return undefined
   }
-
   if (!methodObj.Properties.ResourceId) {
-    return undefined;
+    return undefined
   }
 
-  return methodObj.Properties.ResourceId.Ref;
+  return methodObj.Properties.ResourceId.Ref
 }
 
 function getHttpMethod(methodObj) {
   if (!methodObj || !methodObj.Properties) {
-    return undefined;
+    return undefined
   }
 
-  return methodObj.Properties.HttpMethod;
+  return methodObj.Properties.HttpMethod
 }
 
 function getIntegrationObj(methodObj) {
   if (!methodObj || !methodObj.Properties) {
-    return undefined;
+    return undefined
   }
 
-  return methodObj.Properties.Integration;
+  return methodObj.Properties.Integration
 }
 
 function constructHapiInterface(pathObjects, methodObjects, methodId) {
   // returns all info necessary so that routes can be added in index.js
-  const methodObj = methodObjects[methodId];
-  const resourceId = getResourceId(methodObj);
-  const Integration = getIntegrationObj(methodObj) || {};
-  const pathResource = getFullPath(pathObjects, resourceId);
-  const method = getHttpMethod(methodObj); // let integrationType;
-
-  let proxyUri;
+  const methodObj = methodObjects[methodId]
+  const resourceId = getResourceId(methodObj)
+  const Integration = getIntegrationObj(methodObj) || {}
+  const pathResource = getFullPath(pathObjects, resourceId)
+  const method = getHttpMethod(methodObj)
+  // let integrationType;
+  let proxyUri
 
   if (!pathResource) {
-    return {};
+    return {}
   }
 
   if (Integration.Type === APIGATEWAY_INTEGRATION_TYPE_HTTP_PROXY) {
-    proxyUri = Integration.Uri;
+    proxyUri = Integration.Uri
   }
 
   return {
     isProxy: !!proxyUri,
     method,
     pathResource,
-    proxyUri
-  };
+    proxyUri,
+  }
 }
 
-function parseResources(resources) {
-  const {
-    methodObjects,
-    pathObjects
-  } = getApiGatewayTemplateObjects(resources);
-  return fromEntries(keys(methodObjects).map(key => [key, constructHapiInterface(pathObjects, methodObjects, key)]));
-}
+export default function parseResources(resources) {
+  const { methodObjects, pathObjects } = getApiGatewayTemplateObjects(resources)
+
+  return fromEntries(
+    keys(methodObjects).map((key) => [
+      key,
+      constructHapiInterface(pathObjects, methodObjects, key),
+    ]),
+  )
+}

package/src/events/http/payloadSchemaValidator.js

@@ -0,0 +1,13 @@
+import { validate } from 'jsonschema'
+
+export default function payloadSchemaValidator(model, body) {
+  const result = validate(body, model)
+
+  if (result.errors.length > 0) {
+    throw new Error(
+      `Request body validation failed: ${result.errors
+        .map((e) => e.message)
+        .join(', ')}`,
+    )
+  }
+}

package/src/events/schedule/Schedule.js

@@ -0,0 +1,131 @@
+// based on:
+// https://github.com/ajmath/serverless-offline-scheduler
+
+import { log } from '@serverless/utils/log.js'
+import nodeSchedule from 'node-schedule'
+import ScheduleEvent from './ScheduleEvent.js'
+import ScheduleEventDefinition from './ScheduleEventDefinition.js'
+
+const CRON_LENGTH_WITH_YEAR = 6
+
+const { stringify } = JSON
+
+export default class Schedule {
+  #lambda = null
+
+  #region = null
+
+  constructor(lambda, region) {
+    this.#lambda = lambda
+    this.#region = region
+  }
+
+  #scheduleEvent(functionKey, scheduleEvent) {
+    const { enabled, input, rate } = scheduleEvent
+
+    if (!enabled) {
+      log.notice(`Scheduling [${functionKey}] cron: disabled`)
+
+      return
+    }
+
+    // Convert string rate to array to support Serverless v2.57.0 and lower.
+    let rates = rate
+    if (typeof rate === 'string') {
+      rates = [rate]
+    }
+
+    rates.forEach((entry) => {
+      const cron = this.#convertExpressionToCron(entry)
+
+      log.notice(
+        `Scheduling [${functionKey}] cron: [${cron}] input: ${stringify(
+          input,
+        )}`,
+      )
+
+      nodeSchedule.scheduleJob(cron, async () => {
+        try {
+          const lambdaFunction = this.#lambda.get(functionKey)
+
+          const event = input ?? new ScheduleEvent(this.#region)
+          lambdaFunction.setEvent(event)
+
+          /* const result = */ await lambdaFunction.runHandler()
+
+          log.notice(
+            `Successfully invoked scheduled function: [${functionKey}]`,
+          )
+        } catch (err) {
+          log.error(
+            `Failed to execute scheduled function: [${functionKey}] Error: ${err}`,
+          )
+        }
+      })
+    })
+  }
+
+  #convertCronSyntax(cronString) {
+    if (cronString.split(' ').length < CRON_LENGTH_WITH_YEAR) {
+      return cronString
+    }
+
+    return cronString.replace(/\s\S+$/, '')
+  }
+
+  #convertRateToCron(rate) {
+    const [number, unit] = rate.split(' ')
+
+    switch (unit) {
+      case 'minute':
+      case 'minutes':
+        return `*/${number} * * * *`
+
+      case 'hour':
+      case 'hours':
+        return `0 */${number} * * *`
+
+      case 'day':
+      case 'days':
+        return `0 0 */${number} * *`
+
+      default:
+        log.error(`scheduler: Invalid rate syntax '${rate}', will not schedule`)
+
+        return null
+    }
+  }
+
+  #convertExpressionToCron(scheduleEvent) {
+    const params = scheduleEvent
+      .replace('rate(', '')
+      .replace('cron(', '')
+      .replace(')', '')
+
+    if (scheduleEvent.startsWith('cron(')) {
+      return this.#convertCronSyntax(params)
+    }
+
+    if (scheduleEvent.startsWith('rate(')) {
+      return this.#convertRateToCron(params)
+    }
+
+    log.error('scheduler: invalid, schedule syntax')
+
+    return undefined
+  }
+
+  #create(functionKey, rawScheduleEventDefinition) {
+    const scheduleEvent = new ScheduleEventDefinition(
+      rawScheduleEventDefinition,
+    )
+
+    this.#scheduleEvent(functionKey, scheduleEvent)
+  }
+
+  create(events) {
+    events.forEach(({ functionKey, schedule }) => {
+      this.#create(functionKey, schedule)
+    })
+  }
+}

package/src/events/schedule/ScheduleEvent.js

@@ -0,0 +1,18 @@
+import { createUniqueId } from '../../utils/index.js'
+
+export default class ScheduleEvent {
+  constructor(region) {
+    // format of aws displaying the time, e.g.: 2020-02-09T14:13:57Z
+    const time = new Date().toISOString().replace(/\.(.*)(?=Z)/g, '')
+
+    this.account = createUniqueId()
+    this.detail = {}
+    this['detail-type'] = 'Scheduled Event'
+    this.id = createUniqueId()
+    this.region = region
+    this.resources = []
+    this.source = 'aws.events'
+    this.time = time
+    this.version = '0'
+  }
+}

package/src/events/schedule/ScheduleEventDefinition.js

@@ -0,0 +1,21 @@
+const { assign } = Object
+
+export default class ScheduleEventDefinition {
+  constructor(rawHttpEventDefinition) {
+    let enabled
+    let rate
+    let rest
+
+    if (typeof rawHttpEventDefinition === 'string') {
+      rate = rawHttpEventDefinition
+    } else {
+      ;({ rate, enabled, ...rest } = rawHttpEventDefinition)
+    }
+
+    // enabled: true (default)
+    this.enabled = enabled == null ? true : enabled
+    this.rate = rate
+
+    assign(this, rest)
+  }
+}

package/src/events/schedule/index.js

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

package/src/events/websocket/HttpServer.js

@@ -0,0 +1,69 @@
+import { exit } from 'node:process'
+import { Server } from '@hapi/hapi'
+import { log } from '@serverless/utils/log.js'
+import { catchAllRoute, connectionsRoutes } from './http-routes/index.js'
+
+export default class HttpServer {
+  #options = null
+
+  #server = null
+
+  #webSocketClients = null
+
+  constructor(options, webSocketClients) {
+    this.#options = options
+    this.#webSocketClients = webSocketClients
+
+    const { host, websocketPort } = options
+
+    const serverOptions = {
+      host,
+      port: websocketPort,
+      router: {
+        // allows for paths with trailing slashes to be the same as without
+        // e.g. : /my-path is the same as /my-path/
+        stripTrailingSlash: true,
+      },
+    }
+
+    this.#server = new Server(serverOptions)
+  }
+
+  async start() {
+    // add routes
+    const routes = [
+      ...connectionsRoutes(this.#webSocketClients),
+      catchAllRoute(),
+    ]
+    this.#server.route(routes)
+
+    const { host, httpsProtocol, websocketPort } = this.#options
+
+    try {
+      await this.#server.start()
+    } catch (err) {
+      log.error(
+        `Unexpected error while starting serverless-offline websocket server on port ${websocketPort}:`,
+        err,
+      )
+      exit(1)
+    }
+
+    log.notice(
+      `Offline [http for websocket] listening on http${
+        httpsProtocol ? 's' : ''
+      }://${host}:${websocketPort}`,
+    )
+  }
+
+  // stops the server
+  stop(timeout) {
+    return this.#server.stop({
+      timeout,
+    })
+  }
+
+  get server() {
+    return this.#server.listener
+  }
+}

package/src/events/websocket/WebSocket.js

@@ -0,0 +1,52 @@
+import HttpServer from './HttpServer.js'
+import WebSocketEventDefinition from './WebSocketEventDefinition.js'
+import WebSocketClients from './WebSocketClients.js'
+import WebSocketServer from './WebSocketServer.js'
+
+export default class WebSocket {
+  #httpServer = null
+
+  #webSocketServer = null
+
+  constructor(serverless, options, lambda) {
+    const webSocketClients = new WebSocketClients(serverless, options, lambda)
+
+    this.#httpServer = new HttpServer(options, webSocketClients)
+
+    // share server
+    this.#webSocketServer = new WebSocketServer(
+      options,
+      webSocketClients,
+      this.#httpServer.server,
+    )
+  }
+
+  start() {
+    return Promise.all([
+      this.#httpServer.start(),
+      this.#webSocketServer.start(),
+    ])
+  }
+
+  // stops the server
+  stop(timeout) {
+    return Promise.all([
+      this.#httpServer.stop(timeout),
+      this.#webSocketServer.stop(),
+    ])
+  }
+
+  #createEvent(functionKey, rawWebSocketEventDefinition) {
+    const webSocketEvent = new WebSocketEventDefinition(
+      rawWebSocketEventDefinition,
+    )
+
+    this.#webSocketServer.addRoute(functionKey, webSocketEvent)
+  }
+
+  create(events) {
+    events.forEach(({ functionKey, websocket }) => {
+      this.#createEvent(functionKey, websocket)
+    })
+  }
+}