@creator.co/wapi 1.2.4 → 1.2.6

package/src/Publisher/Publisher.ts

@@ -6,51 +6,43 @@ import {
 } from '@aws-sdk/client-sns'
 import * as sha1 from 'sha1'
 //reusable client
-// eslint-disable-next-line no-var
 /**
- * ${1:Description placeholder}
- *
- * @type {(SNSClient | null)}
+ * A variable that holds the connection to the SNS client for publishing messages.
+ * @type {SNSClient | null}
  */
-let PUBLISHER_CONN: SNSClient | null = null
 // eslint-disable-next-line no-var
+let PUBLISHER_CONN: SNSClient | null = null
 /**
- * ${1:Description placeholder}
- *
- * @type {(string | null)}
+ * The connection hash for the publisher. It is initially set to null.
+ * @type {string | null}
  */
+// eslint-disable-next-line no-var
 let PUBLISHER_CONN_HASH: string | null = null
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @typedef {PublisherConfig}
+ * Represents the configuration options for a publisher.
+ * @typedef {Object} PublisherConfig
+ * @property {string} [region] - The region where the publisher is located.
  */
 export type PublisherConfig = {
   region?: string
 }
-//
+
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Publisher
- * @typedef {Publisher}
+ * Represents a publisher that can publish messages to an SNS topic.
  */
 export default class Publisher {
   /**
-   * ${1:Description placeholder}
-   *
+   * The region of the object or entity.
    * @private
    * @type {string}
    */
   private region: string
+
   /**
-   * Creates an instance of Publisher.
-   *
-   * @constructor
-   * @param {?PublisherConfig} [config]
+   * Constructs a new instance of the Publisher class.
+   * @param {PublisherConfig} [config] - The configuration object for the Publisher.
+   * @returns None
    */
   constructor(config?: PublisherConfig) {
     if (config && config.region) {
@@ -58,42 +50,41 @@ export default class Publisher {
       // console.debug(`Using region: ${this.region}`);
     }
   }
-  /* Public */
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @async
-   * @param {*} messageObject
-   * @param {string} topic
-   * @param {?object} [additionalProps]
-   * @returns {Promise<PublishCommandOutput>}
+   * Publishes a message on a specified topic.
+   * @param {any} messageObject - The message object to be published.
+   * @param {string} topic - The ARN of the topic to publish the message to.
+   * @param {object} [additionalProps] - Additional properties to include in the publish command.
+   * @returns {Promise<PublishCommandOutput>} - A promise that resolves to the response from the publish command.
    */
   async publishOnTopic(
     messageObject: any,
     topic: string,
     additionalProps?: object
-  ): Promise<PublishCommandOutput> {
-    let resp: null | PublishCommandOutput = null
+  ): Promise<PublishCommandOutput | undefined> {
+    let resp: undefined | PublishCommandOutput = undefined
     try {
-      this._connect()
+      this.connect()
       //Send to SNS
       const params: PublishCommandInput = {
         Message: JSON.stringify(messageObject),
         TopicArn: topic,
         ...(additionalProps ? additionalProps : {}),
       }
-      resp = await PUBLISHER_CONN.send(new PublishCommand(params))
+      resp = await PUBLISHER_CONN?.send(new PublishCommand(params))
     } catch (e) {
       console.error(`Error while publishing into topic ${topic} with error: ${e}`)
     }
     console.debug('Publisher resp', resp)
     return resp
   }
-  /* Private */
+
   /**
-   * ${1:Description placeholder}
+   * Establishes a connection to the SNS client if it does not already exist or if the region has changed.
+   * @returns None
    */
-  _connect() {
+  private connect(): void {
     if ((!PUBLISHER_CONN && !PUBLISHER_CONN_HASH) || PUBLISHER_CONN_HASH != sha1(this.region)) {
       PUBLISHER_CONN = new SNSClient({
         apiVersion: '2010-03-31',

package/src/Server/RouteResolver.ts

@@ -1,37 +1,28 @@
 import { Route, RouterConfig } from './Router'
 
 /**
- * ${1:Description placeholder}
- *
- * @class Routes
- * @typedef {Routes}
+ * Represents a collection of routes that can be added and resolved.
  */
 class Routes {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {?Route}
+   * Represents the current route.
+   * @type {Route | undefined}
    */
   private current?: Route
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {?Routes}
+   * Optional private variable that represents a collection of routes.
+   * @type {Routes | undefined}
    */
   private variable?: Routes
   /**
-   * ${1:Description placeholder}
-   *
+   * An object that maps string keys to Routes.
    * @private
    * @readonly
-   * @type {{ [k: string]: Routes }\}
+   * @type {Object.<string, Routes>}
    */
   private readonly next: { [k: string]: Routes }
   /**
-   * Creates an instance of Routes.
-   *
+   * Initializes a new instance of the class.
    * @constructor
    */
   constructor() {
@@ -39,11 +30,11 @@ class Routes {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {Route} route
-   * @param {string[]} parts
+   * Adds a route to the routing system.
+   * @param {Route} route - The route to add.
+   * @param {string[]} parts - The parts of the route path.
+   * @returns None
+   * @throws {Error} If a duplicate route is detected.
    */
   public addRoute(route: Route, parts: string[]): void {
     const first = parts.shift()
@@ -63,13 +54,11 @@ class Routes {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string[]} parts
-   * @returns {Route}
+   * Resolves a route based on the given parts.
+   * @param {string[]} parts - An array of route parts.
+   * @returns {Route} The resolved route.
    */
-  public resolveRoute(parts: string[]): Route {
+  public resolveRoute(parts: string[]): Route<any, any> | undefined {
     const first = parts.shift()
     if (first) {
       if (first in this.next) {
@@ -82,26 +71,21 @@ class Routes {
 }
 
 /**
- * ${1:Description placeholder}
- *
- * @export
+ * A class that resolves routes based on the provided configuration.
  * @class RouteResolver
- * @typedef {RouteResolver}
  */
 export default class RouteResolver {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @type {{ [method: string]: Routes }\}
+   * An object that maps HTTP methods to their corresponding routes.
+   * @property {object} routes - The routes object.
+   * @property {Routes} routes.method - The routes for the specified HTTP method.
    */
   private routes: { [method: string]: Routes }
 
   /**
-   * Creates an instance of RouteResolver.
-   *
-   * @constructor
-   * @param {RouterConfig} config
+   * Constructs a new instance of the Router class with the given configuration.
+   * @param {RouterConfig} config - The configuration object for the router.
+   * @returns None
    */
   constructor(readonly config: RouterConfig) {
     this.routes = {}
@@ -109,31 +93,26 @@ export default class RouteResolver {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string} method
-   * @param {string} path
-   * @returns {(Route | undefined)}
+   * Resolves a route based on the given HTTP method and path.
+   * @param {string} method - The HTTP method of the request.
+   * @param {string} path - The path of the request.
+   * @returns {Route | undefined} - The resolved route or undefined if no route is found.
    */
   public resolveRoute(method: string, path: string): Route | undefined {
     method = method.toLowerCase()
     const parts = path.split('/').filter(p => p.length)
-
     return this.routes[method]?.resolveRoute(parts)
   }
 
   /**
-   * Description placeholder
-   *
-   * @private
-   * @param {RouterConfig} config
+   * Builds the routes for the router based on the given configuration.
+   * @param {RouterConfig} config - The router configuration object.
+   * @returns None
    */
   private buildRoutes(config: RouterConfig): void {
     for (const route of config.routes) {
       const method = route.method.toLowerCase()
       const parts = route.path.split('/').filter(p => p.length)
-
       this.routes[method] = this.routes[method] || new Routes()
       this.routes[method].addRoute(route, parts)
     }

package/src/Server/Router.ts

@@ -1,3 +1,6 @@
+import { Server as HTTPServer } from 'http'
+
+import * as express from 'express'
 import { z } from 'zod'
 
 import ContainerServer from './lib/ContainerServer'
@@ -6,26 +9,24 @@ import { ResponseErrorType } from '../API/Response'
 import Utils from '../API/Utils'
 import Transaction, { TransactionConfig, TransactionExecution } from '../BaseEvent/Transaction'
 
-// Route
 /**
- * Description placeholder
- *
- * @export
- * @interface Route
- * @typedef {Route}
- * @template [InputType=any]
- * @template [OutputType=any]
+ * Represents a route in an API.
+ * @template InputType - The type of the input data for the route.
+ * @template OutputType - The type of the output data for the route.
+ * @property {string} path - The path of the route.
+ * @property {string} method - The HTTP method of the route.
+ * @property {TransactionExecution<Transaction<InputType, OutputType | ResponseErrorType>, OutputType | ResponseErrorType>} handler - The handler function for the route.
+ * @property {z.ZodObject<any>} [inputSchema] - The input schema for validating the input data.
  */
 export interface Route<InputType = any, OutputType = any> {
   /**
-   * Description placeholder
-   *
-   * @type {string}
+   * Represents a file path as a string.
+   * @param {string} path - The file path.
+   * @returns None
    */
   path: string
   /**
-   * Description placeholder
-   *
+   * Represents the method used in an API request.
    * @type {string}
    */
   method: string
@@ -36,93 +37,113 @@ export interface Route<InputType = any, OutputType = any> {
     - https://github.com/microsoft/TypeScript/issues/10570
   */
   /**
-   * Description placeholder
-   *
-   * @type {TransactionExecution<
-   *     Transaction<InputType, OutputType | ResponseErrorType>,
-   *     OutputType | ResponseErrorType
-   *   >}
+   * Represents a handler for executing a transaction with the given input type and output type.
+   * @param {Transaction<InputType, OutputType | ResponseErrorType>} transaction - The transaction to execute.
+   * @param {OutputType | ResponseErrorType} - The output type or response error type of the transaction.
    */
   handler: TransactionExecution<
     Transaction<InputType, OutputType | ResponseErrorType>,
     OutputType | ResponseErrorType
   >
   /**
+<<<<<<< HEAD
+   * An optional input schema for validating the structure of the input data.
+   * @type {z.ZodObject<any>}
+=======
    * Description placeholder
    *
-   * @type {?z.ZodObject<any>}
+   * @type {?z.ZodObject<any> | z.ZodUnion<any>}
+>>>>>>> 65ffb67 (Improve syntax with tighther eslint, fix lots of test errors, new proxy containerSetupHook and improved validation type)
    */
-  inputSchema?: z.ZodObject<any>
+  inputSchema?: z.ZodObject<any> | z.ZodUnion<any>
 }
 
-// Config
 /**
- * Description placeholder
- *
- * @export
- * @typedef {RouterConfig}
+ * Represents the configuration options for a router.
+ * @typedef {TransactionConfig & {
+ *   routes: Route[]
+ *   port?: number
+ *   timeout?: number
+ *   cors?: {
+ *     origin?: string | string[]
+ *     headers?: string[]
+ *     allowCredentials?: boolean
+ *   }
+ *   healthCheckRoute?: string
+ * }} RouterConfig
+ * @property {Route[]} routes - The routes to be configured in the router.
+ * @property {number} [port] - The port number to listen on. If not specified, a default port will be used.
+ * @property {number} [timeout] - The timeout duration for requests in milliseconds. If not specified, a default timeout will be
  */
 export type RouterConfig = TransactionConfig & {
+  /**
+   * An array of route objects representing the available routes in the application.
+   * @type {Route[]}
+   */
   routes: Route[]
-  // container based configs - otherwise enforced by serverless engine
+  /**
+   * The port number for the server to listen on.
+   * @type {number | undefined}
+   */
   port?: number
+  /**
+   * Optional timeout value in milliseconds.
+   * @type {number | undefined}
+   */
   timeout?: number
+  /**
+   * Configuration options for Cross-Origin Resource Sharing (CORS).
+   * @property {string | string[]} [origin] - The allowed origin(s) for CORS requests.
+   * @property {string[]} [headers] - The allowed headers for CORS requests.
+   * @property {boolean} [allowCredentials] - Whether to allow credentials (cookies, HTTP authentication, and client-side SSL certificates) to be sent in CORS requests.
+   */
   cors?: {
     origin?: string | string[]
     headers?: string[]
     allowCredentials?: boolean
   }
+  /**
+   * The route for the health check endpoint.
+   * @type {string | undefined}
+   */
   healthCheckRoute?: string
+  containerSetupHook?: (server: HTTPServer, app: express.Express) => Promise<void>
 }
 
 /**
- * Description placeholder
- *
- * @export
- * @class Router
- * @typedef {Router}
+ * Represents a router that handles routing logic for a web application.
  */
 export default class Router {
   /**
-   * Description placeholder
-   *
-   * @private
-   * @readonly
-   * @type {RouterConfig}
+   * The configuration object for the router.
    */
   private readonly config: RouterConfig
   /**
-   * Description placeholder
-   *
-   * @private
-   * @readonly
-   * @type {Server}
+   * The private readonly server instance.
    */
   private readonly server: Server
+
   /**
-   * Creates an instance of Router.
-   *
-   * @constructor
-   * @param {RouterConfig} config
+   * Constructs a new instance of the Router class.
+   * @param {RouterConfig} config - The configuration object for the router.
+   * @returns None
    */
   constructor(config: RouterConfig) {
     this.config = config
     this.server = this.isContainer() ? new ContainerServer(config) : new Server(config)
   }
+
   /**
-   * Description placeholder
-   *
-   * @public
-   * @returns {CallableFunction}
+   * Retrieves the export function from the server.
+   * @returns {CallableFunction} The export function from the server.
    */
   public getExport(): CallableFunction {
     return this.server.getExport()
   }
+
   /**
-   * Description placeholder
-   *
-   * @private
-   * @returns {boolean}
+   * Checks if the current element is a container.
+   * @returns {boolean} - True if the element is a container, false otherwise.
    */
   private isContainer(): boolean {
     return Utils.isHybridlessContainer()

package/src/Server/lib/ContainerServer.ts

@@ -3,38 +3,30 @@ import Server from './Server'
 import { RouterConfig } from '../Router'
 
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class ContainerServer
- * @typedef {ContainerServer}
- * @extends {Server}
+ * Represents a server container that extends the Server class and handles serverless events.
  */
 export default class ContainerServer extends Server {
   /**
-   * ${1:Description placeholder}
-   *
-   * @protected
-   * @readonly
+   * The proxy object used for handling requests and responses.
    * @type {Proxy}
+   * @protected
    */
   protected readonly proxy: Proxy
+
   /**
-   * Creates an instance of ContainerServer.
-   *
-   * @constructor
-   * @param {RouterConfig} config
+   * Constructs a new instance of the Router class.
+   * @param {RouterConfig} config - The configuration object for the router.
+   * @returns None
    */
   constructor(config: RouterConfig) {
     super(config)
     this.proxy = new Proxy(config, this.handleServerlessEvent.bind(this))
     this.listenProcessEvents()
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @returns {CallableFunction}
+   * Returns a callable function that can be used to export data.
+   * @returns {CallableFunction} - A callable function that can be used to export data.
    */
   public getExport(): CallableFunction {
     // start server socket
@@ -42,32 +34,28 @@ export default class ContainerServer extends Server {
     // return empty function, we are all done
     return () => {}
   }
-  /* private */
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @returns {*}
+   * Starts the application by loading the proxy.
+   * @returns {Promise<void>} - A promise that resolves when the proxy is loaded.
    */
   public async start() {
     await this.proxy.load()
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {?*} [err]
-   * @returns {*}
+   * Stops the execution of the program and unloads the proxy.
+   * @param {any} [err] - Optional error object to pass to the unload method.
+   * @returns {Promise<void>} - A promise that resolves once the proxy is unloaded.
    */
   public async stop(err?: any) {
     await this.proxy.unload(err)
   }
+
   /**
-   * ${1:Description placeholder}
-   *
+   * Listens for process events and handles them accordingly.
    * @private
+   * @returns None
    */
   private listenProcessEvents() {
     // start process listeners

package/src/Server/lib/Server.ts

@@ -1,5 +1,5 @@
 import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import * as pathToRegexp from 'path-to-regexp'
+import { pathToRegexp } from 'path-to-regexp'
 
 import Request from '../../API/Request'
 import Response from '../../API/Response'
@@ -9,35 +9,26 @@ import { RouterConfig } from '../Router'
 import RouteResolver from '../RouteResolver'
 
 /**
- * ${1:Description placeholder}
- *
- * @export
- * @class Server
- * @typedef {Server}
+ * Represents a server that handles serverless events and routes them to appropriate handlers.
  */
 export default class Server {
   /**
-   * ${1:Description placeholder}
-   *
-   * @protected
+   * The configuration object for the router.
    * @readonly
    * @type {RouterConfig}
    */
   protected readonly config: RouterConfig
   /**
-   * ${1:Description placeholder}
-   *
-   * @protected
-   * @readonly
+   * A protected property that holds a RouteResolver object.
+   * The RouteResolver is responsible for resolving routes and returning the appropriate response.
    * @type {RouteResolver}
    */
   protected readonly routeResolver: RouteResolver
 
   /**
-   * Creates an instance of Server.
-   *
-   * @constructor
-   * @param {RouterConfig} config
+   * Constructs a new instance of the Router class.
+   * @param {RouterConfig} config - The configuration object for the router.
+   * @returns None
    */
   constructor(config: RouterConfig) {
     this.config = config
@@ -45,23 +36,18 @@ export default class Server {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @returns {CallableFunction}
+   * Returns a callable function that is bound to the `handleServerlessEvent` method of the current object.
+   * @returns {CallableFunction} - A callable function that is bound to the `handleServerlessEvent` method.
    */
   public getExport(): CallableFunction {
     return this.handleServerlessEvent.bind(this)
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {APIGatewayProxyEvent} event
-   * @param {Context} context
-   * @returns {*}
+   * Handles a serverless event by executing a transaction and resolving the route based on the event.
+   * @param {APIGatewayProxyEvent} event - The serverless event object.
+   * @param {Context} context - The serverless context object.
+   * @returns None
    */
   public async handleServerlessEvent(event: APIGatewayProxyEvent, context: Context) {
     // init transaction
@@ -86,16 +72,15 @@ export default class Server {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @param {Request<any>} req
-   * @param {string} routePath
+   * Parses the path parameters from the request URL based on the given route path.
+   * @param {Request<any>} req - The request object.
+   * @param {string} routePath - The route path pattern to match against.
+   * @returns None
    */
   private parsePathParams(req: Request<any>, routePath: string) {
     const path = req.getPath()
     const keys = []
     const result = pathToRegexp(routePath, keys).exec(path)
-    req.setFixedPathParams(keys, result)
+    if (result) req.setFixedPathParams(keys, result)
   }
 }