@ikonintegration/ikapi 5.0.0-alpha1 → 5.0.1-alpha.1

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@ikonintegration/ikapi",
-  "version": "5.0.0-alpha1",
+  "version": "5.0.1-alpha.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "tsc --build",
-    "clean": "tsc --build --clean",
-    "lint-fix": "eslint . --fix",
-    "lint": "eslint .",
-    "docs": "npx typedoc --tsconfig tsconfig.json index.ts src/**/* --includeVersion --entryPointStrategy expand",
-    "test": "npm run test-ts && npm run test-js",
-    "test-ts": "jest --coverage --silent --runInBand --logHeapUsage && cat coverage/coverage.txt",
-    "test-js": "rm -rf ./smoke-tests; tsc -p tsconfig.smoke.json && cd smoke-tests && npm i && NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest --config=./jest.smoke.config.js --coverage --silent --runInBand --logHeapUsage && cat coverage/coverage.txt",
-    "test-dev": "jest --coverage --runInBand && cat coverage/coverage.txt"
+    "build": "task build",
+    "clean": "task clean",
+    "lint-fix": "task lint-fix",
+    "lint": "task lint",
+    "docs": "task docs",
+    "test": "task test",
+    "test-ts": "task test-ts",
+    "test-js": "task test-js",
+    "test-dev": "task test-dev"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.574.0",
-    "@aws-sdk/client-kms": "^3.556.0",
-    "@aws-sdk/client-secrets-manager": "^3.576.0",
-    "@aws-sdk/client-ses": "^3.576.0",
-    "@aws-sdk/client-sns": "^3.576.0",
-    "@aws-sdk/client-ssm": "^3.576.0",
-    "@aws-sdk/credential-provider-node": "^3.576.0",
-    "@aws-sdk/util-dynamodb": "^3.619.0",
-    "@smithy/node-http-handler": "^3.0.0",
+    "@aws-sdk/client-dynamodb": "^3.650.0",
+    "@aws-sdk/client-kms": "^3.650.0",
+    "@aws-sdk/client-secrets-manager": "^3.650.0",
+    "@aws-sdk/client-ses": "^3.650.0",
+    "@aws-sdk/client-sns": "^3.650.0",
+    "@aws-sdk/client-ssm": "^3.650.0",
+    "@aws-sdk/credential-provider-node": "^3.650.0",
+    "@aws-sdk/util-dynamodb": "^3.650.0",
+    "@smithy/node-http-handler": "^3.2.0",
     "@types/email-templates": "^10.0.1",
     "@types/nodemailer": "^6.4.10",
     "@types/object-hash": "^3.0.4",
@@ -36,29 +36,30 @@
     "cuid": "^3.0.0",
     "dotenv": "^16.4.1",
     "email-templates": "^12.0.1",
-    "express": "^4.18.2",
+    "express": "^4.21.0",
     "json-stringify-safe": "^5.0.1",
     "kysely": "^0.27.2",
     "node-cache": "^5.1.2",
     "object-hash": "^3.0.0",
     "parse-duration": "^1.1.0",
-    "path-to-regexp": "^7.1.0",
+    "path-to-regexp": "^8.1.0",
     "pg": "^8.11.3",
-    "redis": "^4.6.13",
+    "redis": "^4.7.0",
     "sha1": "^1.1.1",
     "stack-trace": "0.0.10",
     "zod": "^3.23.4"
   },
   "devDependencies": {
+    "@go-task/cli": "^3.39.0",
     "@jest/globals": "^29.7.0",
-    "@types/aws-lambda": "^8.10.137",
-    "@types/chai": "^4.3.9",
+    "@types/aws-lambda": "^8.10.145",
+    "@types/chai": "^4.3.19",
     "@types/cors": "^2.8.15",
     "@types/express": "^4.17.19",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^29.5.13",
     "@types/node": "^20.12.7",
     "@types/path-to-regexp": "^1.7.0",
-    "@types/pg": "^8.11.5",
+    "@types/pg": "^8.11.9",
     "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^7.7.1",
     "@typescript-eslint/parser": "^7.7.1",
@@ -67,15 +68,15 @@
     "chai": "^4.4.1",
     "eslint": "^8.48.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-import": "^2.30.0",
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-require-extensions": "^0.1.3",
     "jest": "^29.7.0",
     "jest-junit": "^16.0.0",
     "prettier": "^3.2.5",
     "supertest": "^7.0.0",
-    "ts-jest": "^29.1.1",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.1",
-    "typescript": "^5.4.5"
+    "typescript": "^5.6.2"
   }
 }

package/src/BaseEvent/DynamoTransaction.ts

@@ -10,6 +10,13 @@ import Response, { ResponseErrorType } from '../API/Response.js'
 import Globals from '../Globals.js'
 import Utils from '../Util/Utils.js'
 
+/**
+ * Interface representing a DynamoDB record with marshalled data.
+ * Extends the DynamoDBRecord interface.
+ * @property {object} Keys - The keys of the record.
+ * @property {object} OldImage - The old image of the record.
+ * @property {object} NewImage - The new image of the record.
+ */
 export interface DynamoDBMarshalledRecord extends DynamoDBRecord {
   marshalled: {
     Keys?: object
@@ -18,6 +25,12 @@ export interface DynamoDBMarshalledRecord extends DynamoDBRecord {
   }
 }
 
+/**
+ * Defines a type for executing a transaction on DynamoDB.
+ * @param {Transaction<null, ResponseInnerType | ResponseErrorType, DynamoDBBatchResponse | null>} transaction - The transaction to execute.
+ * @param {DynamoDBMarshalledRecord} recordContent - The content of the DynamoDB record.
+ * @returns A promise that resolves to a response or a DynamoDB batch response.
+ */
 export type DynamoTransactionExecution<ResponseInnerType> = (
   transaction: Transaction<
     null,
@@ -27,15 +40,41 @@ export type DynamoTransactionExecution<ResponseInnerType> = (
   recordContent: DynamoDBMarshalledRecord
 ) => Promise<Response<ResponseInnerType | ResponseErrorType> | DynamoDBBatchResponse | null>
 
+/**
+ * Represents a DynamoDB transaction handler that processes events from a DynamoDB stream.
+ * @template ResponseInnerType - The inner type of the response.
+ */
 export default class DynamoTransaction<ResponseInnerType> {
+  /**
+   * A boolean flag indicating whether failures are allowed.
+   */
   private readonly allowFailure: boolean
 
+  /**
+   * Readonly property that holds the transaction configuration.
+   */
   private readonly config: TransactionConfig
 
+  /**
+   * The context object that provides information about the current execution context.
+   * @type {Context}
+   */
   private readonly context: Context
 
+  /**
+   * Represents an event from a DynamoDB stream.
+   * @type {DynamoDBStreamEvent}
+   */
   private readonly event: DynamoDBStreamEvent
 
+  /**
+   * Constructor for a TransactionHandler object.
+   * @param {DynamoDBStreamEvent} event - The DynamoDB stream event that triggered the transaction.
+   * @param {Context} context - The AWS Lambda context object.
+   * @param {TransactionConfig} [config] - Optional configuration for the transaction.
+   * @param {boolean} [allowFailure] - Flag to indicate whether to allow transaction failure.
+   * @returns None
+   */
   constructor(
     event: DynamoDBStreamEvent,
     context: Context,
@@ -48,6 +87,12 @@ export default class DynamoTransaction<ResponseInnerType> {
     this.allowFailure = !!allowFailure
   }
 
+  /**
+   * Processes the event execution and returns a response based on the outcome.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The execution object to process.
+   * @returns {Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse>} A promise that resolves to a response object or null.
+   * @throws {Error} If the response code is not within the success range and failure is not allowed.
+   */
   public async processEvent(
     execution: DynamoTransactionExecution<ResponseInnerType>
   ): Promise<Response<ResponseErrorType | null> | null | DynamoDBBatchResponse> {
@@ -63,6 +108,11 @@ export default class DynamoTransaction<ResponseInnerType> {
     return null
   }
 
+  /**
+   * Processes a raw event by executing a transaction on each record in the event.
+   * @param {DynamoTransactionExecution<ResponseInnerType>} execution - The transaction execution function.
+   * @returns {Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse>} A promise that resolves to a response object, null, or a DynamoDB batch response.
+   */
   private async processRawEvent(
     execution: DynamoTransactionExecution<ResponseInnerType>
   ): Promise<Response<ResponseErrorType | any> | null | DynamoDBBatchResponse> {

package/src/BaseEvent/Launchable/ContainerExec.ts

@@ -0,0 +1,96 @@
+import { Context } from 'aws-lambda'
+
+import { LaunchableHandlerType } from './types.js'
+import Response from '../../API/Response.js'
+
+/**
+ * Represents a ContainerExecution class that handles the execution of a launchable handler.
+ * @template Input - The type of input expected by the launchable handler.
+ */
+export default class ContainerExecution<Input> {
+  /**
+   * A private readonly property that holds a handler of LaunchableHandlerType with a given Input type.
+   */
+  private readonly handler: LaunchableHandlerType<Input>
+
+  /**
+   * Constructor for creating an instance of a class with a LaunchableHandlerType input.
+   * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
+   * @returns None
+   */
+  constructor(handler: LaunchableHandlerType<Input>) {
+    this.handler = handler
+  }
+
+  /**
+   * Executes the function asynchronously, invoking the specified inputs and handling the response accordingly.
+   * If the response code is 200, the process exits with code 0; otherwise, it exits with code 1.
+   * @returns None
+   */
+  public async execute() {
+    try {
+      // Invoke
+      const resp = await this.invoke(this.getInputs())
+      // Return
+      console.debug(resp)
+      if (!resp.err && resp.data && resp.data.getCode() == 200) process.exit(0)
+      else process.exit(1)
+    } catch (e) {
+      console.error(e)
+      process.exit(1)
+    }
+  }
+
+  /**
+   * Retrieves inputs from the process arguments and parses them as JSON.
+   * @returns {any} The parsed input object from process arguments.
+   */
+  private getInputs() {
+    let input: any = {}
+    console.debug(process.argv)
+    try {
+      input = JSON.parse(process.argv[2])
+    } catch (e) {
+      console.log('[IKApi Launchable Runtime] - Error while decoding process arguments!', e)
+    }
+    return input
+  }
+
+  /**
+   * Builds a context object for AWS Lambda function.
+   * @param {CallableFunction} callback - The callback function to be executed.
+   * @returns {Context} A context object with AWS Lambda properties.
+   */
+  private buildContext(callback: CallableFunction): Context {
+    return {
+      awsRequestId: `${Date.now()}-${Date.now()}`,
+      callbackWaitsForEmptyEventLoop: true,
+      getRemainingTimeInMillis: () => 0,
+      done: (err, data) => callback(err, data),
+      fail: err => callback(err),
+      succeed: res => callback(null, res),
+    } as any as Context
+  }
+
+  /**
+   * Asynchronously invokes a function with the given input and returns a promise that resolves
+   * with an object containing an error message or data response.
+   * @param {any} input - The input to be passed to the function.
+   * @returns {Promise<{ err?: string; data?: Response<any> }>} A promise that resolves with an object
+   * containing an error message or data response.
+   */
+  private async invoke(input: any) {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise<{ err?: string; data?: Response<any> }>(async (resolve, reject) => {
+      try {
+        const context = this.buildContext((err, data) => {
+          resolve({ err, data })
+        })
+        const resp = await this.handler(input, context)
+        if (resp) resolve({ data: resp })
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+}

package/src/BaseEvent/Launchable/index.ts

@@ -0,0 +1,53 @@
+import ContainerExecution from './ContainerExec.js'
+import { LaunchableHandlerType } from './types.js'
+import Utils from '../../Util/Utils.js'
+
+/**
+ * Represents a Launchable class that can be used to handle launchable items.
+ * @template Input - The type of input expected by the LaunchableHandlerType.
+ */
+export default class Launchable<Input = any> {
+  /**
+   * A private readonly property that holds a handler for launching with a specific input type.
+   * @type {LaunchableHandlerType<Input>}
+   */
+  private readonly handler: LaunchableHandlerType<Input>
+
+  /**
+   * Constructor for creating an instance of a class with a LaunchableHandlerType input.
+   * @param {LaunchableHandlerType<Input>} handler - The handler for the launchable type.
+   * @returns None
+   */
+  constructor(handler: LaunchableHandlerType<Input>) {
+    this.handler = handler
+  }
+
+  /**
+   * Returns the export function based on whether the object is a container or not.
+   * If it is a container, it returns the container export function, otherwise it returns the handler function.
+   * @returns {CallableFunction} The export function to be used.
+   */
+  public getExport(): CallableFunction {
+    return this.isContainer() ? this.getContainerExport() : this.handler
+  }
+
+  /**
+   * Checks if the current element is a container by calling the isHybridlessContainer method from the Utils class.
+   * @returns {boolean} - true if the element is a container, false otherwise.
+   */
+  private isContainer(): boolean {
+    return Utils.isHybridlessContainer()
+  }
+
+  /**
+   * Returns a callable function that executes a ContainerExecution instance and returns a promise.
+   * @returns {CallableFunction} A function that when called, executes a ContainerExecution instance.
+   */
+  private getContainerExport(): CallableFunction {
+    // emulate lambda invocation
+    const ce = new ContainerExecution(this.handler)
+    ce.execute().then(() => {})
+    // return empty function, we are all done
+    return () => {}
+  }
+}

package/src/BaseEvent/Launchable/types.ts

@@ -0,0 +1,15 @@
+import { Context } from 'aws-lambda'
+
+import Response from '../../API/Response.js'
+
+/**
+ * Defines a type for a launchable handler that takes an input event and context,
+ * and returns a promise of a response.
+ * @param {Input} event - The input event for the handler.
+ * @param {Context} context - The context for the handler.
+ * @returns {Promise<Response<any>>} A promise that resolves to a response.
+ */
+export type LaunchableHandlerType<Input> = (
+  event: Input,
+  context: Context
+) => Promise<Response<any>>

package/src/Config/EnvironmentVar.ts

@@ -56,12 +56,7 @@ export default class EnvironmentVar<T> {
    * @param {boolean} [optional] - Indicates whether the environment variable is optional.
    * @param {string} [paramPrefix] - The prefix to be added to the environment variable name.
    */
-  constructor(
-    paramName: string,
-    type: EnvironmentType,
-    optional = true,
-    paramPrefix: string
-  ) {
+  constructor(paramName: string, type: EnvironmentType, optional = true, paramPrefix: string) {
     this.paramName = paramName
     this.type = type
     this.optional = !!optional

package/src/Logger/Logger.ts

@@ -38,7 +38,10 @@ const DEFAULT_LOG_FUNCTION = PURE_CONSOLE.log.bind(PURE_CONSOLE)
  * @type {string[]} blacklist - An array of strings to be converted to lowercase and used as a blacklist.
  * @returns {string[]} - An array of lowercase strings representing the blacklist.
  */
-const blacklist = ['password', 'token', 'accounts'].map(s => s.toLowerCase())
+const blacklist = ['password', 'token', 'accounts', 'rawBody'].map(s => s.toLowerCase())
+
+/* Used to have a clean log */
+const defaultSuppress = ['rawBody'].map(s => s.toLowerCase())
 
 /**
  * Configuration options for the logger.
@@ -107,7 +110,7 @@ export default class Logger {
       ? Array.isArray(this.config.sensitiveFilteringKeywords)
         ? this.config.sensitiveFilteringKeywords
         : blacklist
-      : []
+      : defaultSuppress
     //
     this.setupBindings()
     //

package/src/Server/lib/Server.ts

@@ -103,7 +103,7 @@ export default class Server {
   private parsePathParams(req: Request<any, any, any>, routePath: string) {
     const path = req.getPath()
     const regex = pathToRegexp(routePath)
-    const result = regex.exec(path)
+    const result = regex.regexp.exec(path)
     if (result) req.setFixedPathParams(regex.keys, result)
   }
 }

package/taskfile.yml

@@ -0,0 +1,65 @@
+version: '3'
+
+vars:
+  test_node_options: '--experimental-vm-modules'
+  coverage_file: 'coverage/coverage.txt'
+
+tasks:
+  build:
+    desc: Build the project
+    cmds:
+      - tsc --build
+
+  clean:
+    desc: Clean the build artifacts
+    cmds:
+      - tsc --build --clean
+
+  lint:
+    desc: Run ESLint
+    cmds:
+      - eslint .
+
+  lint-fix:
+    desc: Run ESLint and fix issues
+    cmds:
+      - eslint . --fix
+
+  docs:
+    desc: Generate documentation
+    cmds:
+      - npx typedoc --tsconfig tsconfig.json index.ts src/**/* --includeVersion --entryPointStrategy expand
+
+  test:
+    desc: Run all tests
+    cmds:
+      - task test-ts
+      - task test-js
+
+  test-ts:
+    desc: Run TypeScript tests
+    cmds:
+      - jest --workerIdleMemoryLimit=1024 --coverage --silent --runInBand --logHeapUsage
+      - cat {{.coverage_file}}
+
+  test-js:
+    desc: Run JavaScript smoke tests
+    cmds:
+      - rm -rf ./smoke-tests
+      - tsc -p tsconfig.smoke.json
+      - task test-js-inner
+
+  test-js-inner:
+    desc: Run smoke tests in the smoke-tests directory
+    dir: smoke-tests
+    cmds:
+      - cp -R ../node_modules node_modules
+      - npm i
+      - NODE_OPTIONS="$NODE_OPTIONS {{.test_node_options}}" jest --workerIdleMemoryLimit=1024 --config=./jest.smoke.config.js --coverage --silent --runInBand --logHeapUsage
+      - cat ../{{.coverage_file}}
+
+  test-dev:
+    desc: Run tests in development mode
+    cmds:
+      - jest --coverage --runInBand
+      - cat {{.coverage_file}}

package/tests/Utils/Utils.test.ts

@@ -164,7 +164,6 @@ describe('caseInsensitiveObjectForKey', () => {
   })
 })
 
-
 describe('ddbMarshall', () => {
   test('Marshalling of a simple object', () => {
     const input = { key: 'value' }
@@ -205,7 +204,7 @@ describe('ddbUnmarshall', () => {
   })
 
   test('Unmarshalling of a DynamoDB array', () => {
-    const input = { array: { L: [{ N: '1' }, { N: '2' }, { N: '3' }] }}
+    const input = { array: { L: [{ N: '1' }, { N: '2' }, { N: '3' }] } }
     const output = Utils.ddbUnmarshall(input)
     expect(output.array).toEqual([1, 2, 3])
   })
@@ -223,7 +222,7 @@ describe('ddbUnmarshall', () => {
   })
 
   test('Unmarshalling of a primitive value', () => {
-    const input = { key: { N: '42' }}
+    const input = { key: { N: '42' } }
     const output = Utils.ddbUnmarshall(input)
     expect(output.key).toEqual(42)
   })