@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/.github/workflows/npmpublish.yml

@@ -1,22 +1,14 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
-
-name: Node.js Package
-
+name: NPM Publish
 on:
-  release:
-    types: [created]
+  push: 
+    branches: [ "main" ]
 
 jobs:
-  publish-npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --access='public'
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+  Publish:
+    uses: Creator-co/tool-github-workflows/.github/workflows/npmpublish.yml@main2
+    secrets: inherit
+    with:
+      disablieSASTFailure: false
+      disableLintFailure: false
+      disableUTestFailure: false
+      NODE_VERSION: "16.x"

package/.github/workflows/prs.yml

@@ -0,0 +1,13 @@
+name: PR Checks
+on:
+  pull_request:
+    branches:
+      - master
+      - main
+
+jobs:
+  Checks:
+    uses: Creator-co/tool-github-workflows/.github/workflows/prs-check.yml@main2
+    secrets: inherit
+    with:
+      NODE_VERSION: "16.x"

package/jest.config.ts

@@ -0,0 +1,39 @@
+import type { Config } from "@jest/types"
+/* eslint-env node */
+const config: Config.InitialOptions = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  reporters: [
+    "default",
+    [
+      "jest-junit",
+      {
+        outputDirectory: "coverage",
+        outputName: "jest-junit.xml",
+        ancestorSeparator: " › ",
+        uniqueOutputName: "false",
+        suiteNameTemplate: "{filepath}",
+        classNameTemplate: "{classname}",
+        titleTemplate: "{title}",
+      },
+    ],
+  ],
+  coverageReporters: [
+    "clover",
+    "json",
+    "lcov",
+    "text",
+    ["text", { file: "coverage.txt" }],
+    "json-summary",
+  ],
+  collectCoverageFrom: ["src/**/*.(t|j)s"],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+}
+export default config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creator.co/wapi",
-  "version": "1.2.1-beta6",
+  "version": "1.2.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,10 @@
   "scripts": {
     "build": "npm run lint && tsc --build",
     "clean": "tsc --build --clean",
-    "lint": "eslint . --ext .ts --fix"
+    "lint-fix": "eslint . --ext .ts --fix",
+    "lint": "eslint . --ext .ts",
+    "test": "jest --coverage --silent --runInBand",
+    "test-dev": "jest --coverage --runInBand"
   },
   "author": "",
   "license": "ISC",
@@ -33,21 +36,29 @@
     "parse-duration": "^1.1.0",
     "sha1": "^1.1.1",
     "stack-trace": "0.0.10",
-    "unflatten": "^1.0.4",
     "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.119",
     "@types/express": "^4.17.19",
+    "@types/jest": "^29.5.6",
     "@types/jsonwebtoken": "^9.0.3",
     "@types/node": "^20.5.7",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
     "aws-lambda": "^1.0.7",
+    "aws-sdk-client-mock": "^3.0.0",
+    "chai": "^4.3.10",
     "eslint": "^8.48.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-prettier": "^5.0.0",
-    "prettier": "^3.0.3"
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "prettier": "^3.0.3",
+    "supertest": "^6.3.3",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
   }
 }

package/src/API/Request.ts

@@ -2,28 +2,74 @@ import type { Context, APIGatewayEvent } from "aws-lambda"
 
 import Utils from "./Utils"
 import Logger from "../Logger/Logger"
-//
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Request
+ * @typedef {Request}
+ * @template InputType
+ */
 export default class Request<InputType> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {APIGatewayEvent}
+   */
   private requestEvent: APIGatewayEvent
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {Context}
+   */
   private context: Context
+  /**
+   * Creates an instance of Request.
+   *
+   * @constructor
+   * @param {APIGatewayEvent} requestEvent
+   * @param {Context} context
+   * @param {Logger} logger
+   */
   constructor(requestEvent: APIGatewayEvent, context: Context, logger: Logger) {
     this.requestEvent = requestEvent
     this.context = context
     logger.debug("Request info:", JSON.stringify(requestEvent))
     logger.debug("Request context:", JSON.stringify(context))
   }
-  //query
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} paramName
+   * @returns {boolean}
+   */
   public containsQueryParam(paramName: string): boolean {
     const val = this.getQueryParam(paramName)
     return !!val && (Utils.isValidString(val) || Utils.isValidNumber(val))
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} paramName
+   * @returns {(string | null)}
+   */
   public getQueryParam(paramName: string): string | null {
     return Utils.caseInsensitiveObjectForKey(
       this.requestEvent.queryStringParameters,
       paramName,
     )
   }
-  //header
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} headerName
+   * @returns {(string | null)}
+   */
   public getHeader(headerName: string): string | null {
     return Utils.caseInsensitiveObjectForKey(
       this.requestEvent.headers,
@@ -31,24 +77,49 @@ export default class Request<InputType> {
     )
   }
   //context params
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} cxtParam
+   * @returns {(any | null)}
+   */
   public getContextParam(cxtParam: string): any | null {
     return Utils.caseInsensitiveObjectForKey(
       this.requestEvent.requestContext,
       cxtParam,
     )
   }
-  //path param
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} paramName
+   * @returns {boolean}
+   */
   public containsPathParam(paramName: string): boolean {
     const val = this.getPathParam(paramName)
     return !!val && (Utils.isValidString(val) || Utils.isValidNumber(val))
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} paramName
+   * @returns {(string | null)}
+   */
   public getPathParam(paramName: string): string | null {
     return Utils.caseInsensitiveObjectForKey(
       this.requestEvent.pathParameters,
       paramName,
     )
   }
-  //body
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {InputType}
+   */
   public getBody(): InputType {
     let b: any = null
     try {
@@ -60,33 +131,72 @@ export default class Request<InputType> {
     }
     return b
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {string}
+   */
   public getPath(): string {
     return this.requestEvent.path
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {string}
+   */
   public getMethod(): string {
     return this.requestEvent.httpMethod
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {(object | null)}
+   */
   public getPathParams(): object | null {
     return this.requestEvent.pathParameters
   }
-
-  //Shortcuts
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {(string | null)}
+   */
   public getAuthorizationHeader(): string | null {
     return this.getHeader("Authorization")
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {string}
+   */
   public getRequestID(): string {
     if (this.context.awsRequestId) return this.context.awsRequestId
     return this.requestEvent.requestContext
       ? this.requestEvent.requestContext.requestId
       : "unknown"
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {string}
+   */
   public getOriginIP(): string {
     const origin = this.getContextParam("identity")?.sourceIp
     const hOrigin = this.getHeader("X-Forwarded-For")
-    return origin ? origin : hOrigin ? hOrigin : "unknow"
+    return origin ? origin : hOrigin ? hOrigin : "unknown"
   }
-
-  //ugly fix
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {any[]} keys
+   * @param {any[]} result
+   */
   public setFixedPathParams(keys: any[], result: any[]): void {
     this.requestEvent.pathParameters = {}
     keys.forEach(

package/src/API/Response.ts

@@ -3,29 +3,121 @@ import type { Context } from "aws-lambda"
 import Transaction from "../BaseEvent/Transaction"
 import Globals from "../Globals"
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @class CustomError
+ * @typedef {CustomError}
+ * @extends {Error}
+ */
 class CustomError extends Error {
+  /**
+   * Creates an instance of CustomError.
+   *
+   * @constructor
+   * @param {*} body
+   */
   constructor(body: any) {
-    const msg = body && body.message ? body.message : "Unknown error!"
-    super(msg)
-    this.name = body && body.error ? body.error : "UnknownError"
+    super(body.message || "Unknown error!")
+    this.name = body.error || "UnknownError"
   }
 }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @typedef {ResponseErrorType}
+ */
 export type ResponseErrorType = {
   err: string
   errCode?: string
 }
 //
+/**
+ * ${1:Description placeholder}
+ *
+ * @export
+ * @class Response
+ * @typedef {Response}
+ * @template [BodyType=null]
+ */
 export default class Response<BodyType = null> {
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {number}
+   */
   private _statusCode: number
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {*}
+   */
   private _body: any
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {boolean}
+   */
   private _isPipingOut: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @type {object}
+   */
   private _headers: object
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly shouldStream: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly rawBody: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly throwOnErrors: boolean
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @readonly
+   * @type {boolean}
+   */
   public readonly disableTransactionID: boolean
   //
+  /**
+   * Creates an instance of Response.
+   *
+   * @constructor
+   * @param {number} statusCode
+   * @param {BodyType} body
+   * @param {?(| {
+   *           shouldStream?: boolean
+   *           rawBody?: boolean
+   *           throwOnErrors?: boolean
+   *           disableTransactionID?: boolean
+   *         }
+   *       | undefined)\} [optBehaviour]
+   */
   constructor(
     statusCode: number,
     body: BodyType,
@@ -54,18 +146,54 @@ export default class Response<BodyType = null> {
     this.throwOnErrors = !!optBehaviour?.throwOnErrors
     this.disableTransactionID = !!optBehaviour?.disableTransactionID
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {number}
+   */
   public getCode(): number {
     return this._statusCode
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @returns {BodyType}
+   */
   public getBody(): BodyType {
     return this._body
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} key
+   * @param {*} value
+   */
   public appendIntoBody(key: string, value: any): void {
     this._body[key] = value
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @param {string} key
+   * @param {*} value
+   */
   public appendHeader(key: string, value: any): void {
     this._headers[key] = value
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @async
+   * @param {Context} context
+   * @param {Transaction<any, any, any>} transaction
+   * @param {boolean} _optDoNotCallContext
+   * @returns {Promise<void>}
+   */
   public async build(
     context: Context,
     transaction: Transaction<any, any, any>,
@@ -98,9 +226,14 @@ export default class Response<BodyType = null> {
     //Batch does not succeed directly just on upper transaction (which will should be a batch)
     if (!_optDoNotCallContext) context.succeed(b)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {Context} context
+   */
   private _pipe(context: Context): void {
     //Check if not streaming
-    if (this._isPipingOut) return
     this._isPipingOut = true
     //build response
     const b = {
@@ -111,6 +244,13 @@ export default class Response<BodyType = null> {
     //log response and respond to context
     context.succeed(b)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @private
+   * @param {Context} context
+   * @param {Transaction<null, BodyType>} transaction
+   */
   private _rawContext(
     context: Context,
     transaction: Transaction<null, BodyType>,
@@ -126,6 +266,14 @@ export default class Response<BodyType = null> {
   }
 
   /* Shortcuts */
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} paramName
+   * @returns {Response<ResponseErrorType>}
+   */
   public static MissingParamResponse(
     paramName: string,
   ): Response<ResponseErrorType> {
@@ -135,6 +283,14 @@ export default class Response<BodyType = null> {
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} paramName
+   * @returns {Response<ResponseErrorType>}
+   */
   public static MissingQueryResponse(
     paramName: string,
   ): Response<ResponseErrorType> {
@@ -144,6 +300,16 @@ export default class Response<BodyType = null> {
       errCode: Globals.ErrorCode_MissingParam,
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {?string} [msg]
+   * @param {?string} [errCode]
+   * @param {?*} [optBody]
+   * @returns {Response<ResponseErrorType>}
+   */
   public static BadRequestResponse(
     msg?: string,
     errCode?: string,
@@ -156,9 +322,19 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} msg
+   * @param {?string} [errCode]
+   * @param {?*} [optBody]
+   * @returns {Response<ResponseErrorType>}
+   */
   public static BadRequestResponseWithRollback(
     msg: string,
-    errCode: string,
+    errCode?: string,
     optBody?: any,
   ): Response<ResponseErrorType> {
     console.warn(`Bad request - ${msg}`)
@@ -169,9 +345,18 @@ export default class Response<BodyType = null> {
       ...(optBody || {}),
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} msg
+   * @param {?string} [errCode]
+   * @returns {Response<ResponseErrorType>}
+   */
   public static UnauthorizedResponse(
     msg: string,
-    errCode: string,
+    errCode?: string,
   ): Response<ResponseErrorType> {
     console.warn(`Denying request - ${msg}`)
     return new Response<ResponseErrorType>(401, {
@@ -179,28 +364,71 @@ export default class Response<BodyType = null> {
       ...(errCode ? { errCode: errCode } : {}),
     })
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @template BodyType
+   * @param {BodyType} body
+   * @returns {Response<BodyType>}
+   */
   public static SuccessResponse<BodyType>(body: BodyType): Response<BodyType> {
     return new Response<BodyType>(200, (body ? body : {}) as BodyType)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {string} url
+   * @returns {Response<null>}
+   */
   public static RedirectResponse(url: string): Response<null> {
     const resp = new Response<null>(302, null)
     resp.appendHeader("Location", url)
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @returns {Response<null>}
+   */
   public static SuccessNoContentResponse(): Response<null> {
     return new Response<null>(204, null)
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @param {*} stream
+   * @param {string} contentType
+   * @returns {Response}
+   */
   public static SuccessStreamResponse(
     stream: any,
     contentType: string,
   ): Response {
-    const resp = new Response(200, stream ? stream : {}, {
+    const resp = new Response(200, stream, {
       shouldStream: true,
     })
     resp.appendHeader("Connection", "keep-alive")
-    if (contentType) resp.appendHeader("Content-type", contentType)
+    if (contentType) resp.appendHeader("Content-Type", contentType)
     return resp
   }
+  /**
+   * ${1:Description placeholder}
+   *
+   * @public
+   * @static
+   * @template BodyType
+   * @param {BodyType} body
+   * @param {?number} [optionalCode]
+   * @returns {Response<BodyType>}
+   */
   public static SimpleResponse<BodyType>(
     body: BodyType,
     optionalCode?: number,