@creator.co/wapi 1.2.5 → 1.2.6

package/src/Mailer/Mailer.ts

@@ -4,48 +4,30 @@ import * as Email from 'email-templates'
 import * as nodemailer from 'nodemailer'
 import type * as SESTransport from 'nodemailer/lib/ses-transport'
 
-/**
- * ${1:Description placeholder}
- *
- * @export
- * @class Mailer
- * @typedef {Mailer}
- */
 export default class Mailer {
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
+   * The starting point of a range.
    * @type {string}
    */
   private readonly from: string
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
+   * The default file template for the application.
    * @type {string}
    */
   private readonly templateDefaultFile: string = 'html'
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @readonly
-   * @type {ReturnType<
-   *     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
-   *   >}
+   * The transporter object used for sending emails using the AWS SES service.
+   * @type {ReturnType<typeof nodemailer.createTransport<SESTransport.SentMessageInfo>>}
    */
   private readonly transporter: ReturnType<
     typeof nodemailer.createTransport<SESTransport.SentMessageInfo>
   >
+
   /**
-   * Creates an instance of Mailer.
-   *
-   * @constructor
-   * @param {string} defaultFrom
-   * @param {string} region
+   * Constructs a new instance of the EmailSender class.
+   * @param {string} defaultFrom - The default "from" email address.
+   * @param {string} region - The AWS region to use for sending emails.
+   * @returns None
    */
   constructor(defaultFrom: string, region: string) {
     this.from = defaultFrom
@@ -62,19 +44,14 @@ export default class Mailer {
   }
 
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {(string | Array<string>)} to
-   * @param {string} htmlMessage
-   * @param {string} subject
-   * @param {?(string | Array<string>)} [optionalCC]
-   * @param {?string} [optionalFrom]
-   * @param {?string} [optionalReplyTo]
-   * @param {?any[]} [optionalAttachments]
-   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
-   * @returns {unknown}
+   * Sends a raw email with the specified parameters.
+   * @param {string | Array<string>} to - The recipient(s) of the email.
+   * @param {string} htmlMessage - The HTML content of the email.
+   * @param {string} subject - The subject of the email.
+   * @param {string | Array<string>} [optionalCC] - The optional CC recipient(s) of the email.
+   * @param {string} [optionalFrom] - The optional sender of the email. If not provided, the default sender will be used.
+   * @param {string} [optionalReplyTo] - The optional reply-to address for the email.
+   * @param {any[]} [optionalAttachments] - The optional attachments to include
    */
   public async sendRawEmail(
     to: string | Array<string>,
@@ -112,20 +89,16 @@ export default class Mailer {
     }
     return resp
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @async
-   * @param {(string | Array<string>)} to
-   * @param {(string | Array<string>)} templates
-   * @param {object} data
-   * @param {?(string | Array<string>)} [optionalCC]
-   * @param {?string} [optionalFrom]
-   * @param {?string} [optionalReplyTo]
-   * @param {?any[]} [optionalAttachments]
-   * @param {?Email.NodeMailerTransportOptions} [optionalTransport]
-   * @returns {unknown}
+   * Sends a templated email to the specified recipients.
+   * @param {string | Array<string>} to - The email address(es) of the recipient(s).
+   * @param {string | Array<string>} templates - The template(s) to use for the email.
+   * @param {object} data - The data to be used in the email template.
+   * @param {string | Array<string>} [optionalCC] - The email address(es) to CC.
+   * @param {string} [optionalFrom] - The email address to send the email from.
+   * @param {string} [optionalReplyTo] - The email address to set as the reply-to address.
+   * @param {any[]} [optionalAttachments] - An array
    */
   public async sendTemplatedEmail(
     to: string | Array<string>,
@@ -162,15 +135,14 @@ export default class Mailer {
     }
     return resp
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @public
-   * @param {string} host
-   * @param {number} portNumber
-   * @param {string} user
-   * @param {string} password
-   * @returns {Email.NodeMailerTransportOptions}
+   * Creates a new SMTP transporter for sending emails using NodeMailer.
+   * @param {string} host - The SMTP server host.
+   * @param {number} portNumber - The port number to connect to the SMTP server.
+   * @param {string} user - The username for authentication with the SMTP server.
+   * @param {string} password - The password for authentication with the SMTP server.
+   * @returns {Email.NodeMailerTransportOptions} - The SMTP transporter object.
    */
   public newSMTPTransporter(
     host: string,
@@ -190,15 +162,12 @@ export default class Mailer {
     return smtpTransporter
   }
 
-  /* private */
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @async
-   * @param {(string | Array<string>)} templates
-   * @param {object} data
-   * @returns {Promise<string>}
+   * Chooses a template from the given array of templates or a single template string based on whether it can be rendered with the provided data.
+   * @param {string | Array<string>} templates - The template(s) to choose from.
+   * @param {object} data - The data to be used for rendering the template.
+   * @returns {Promise<string>} - The chosen template.
+   * @throws {Error} - If no template can be rendered with the provided data.
    */
   private async chooseTemplate(templates: string | Array<string>, data: object): Promise<string> {
     if (Array.isArray(templates)) {
@@ -214,14 +183,12 @@ export default class Mailer {
         JSON.stringify(data, null, 2)
     )
   }
+
   /**
-   * ${1:Description placeholder}
-   *
-   * @private
-   * @async
-   * @param {string} template
-   * @param {object} data
-   * @returns {Promise<boolean>}
+   * Checks if a given email template can be rendered with the provided data.
+   * @param {string} template - The name of the email template.
+   * @param {object} data - The data to be used for rendering the template.
+   * @returns {Promise<boolean>} - A promise that resolves to true if the template can be rendered, false otherwise.
    */
   private async canRenderTemplate(template: string, data: object): Promise<boolean> {
     let validRenderResp = null

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()