@ikonintegration/ikapi 4.0.1 → 5.0.0

package/src/Database/index.ts

@@ -0,0 +1,27 @@
+import { Database } from './Database.js'
+import { DatabaseManager } from './DatabaseManager.js'
+import { DatabaseTransaction } from './DatabaseTransaction.js'
+import { DynamoDatabase } from './integrations/dynamo/DynamoDatabase.js'
+import { KyselyDatabase } from './integrations/kysely/KyselyDatabase.js'
+import { KyselyTransaction } from './integrations/kysely/KyselyTransaction.js'
+import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase.js'
+import { PostgresTransaction } from './integrations/pgsql/PostgresTransaction.js'
+import { DbConfig } from './types.js'
+
+export {
+  // Abstracts
+  DatabaseTransaction,
+  Database,
+  // 'Entrypoints'
+  DatabaseManager,
+  DbConfig,
+  // Postgres
+  PostgresTransaction,
+  PostgresDatabase,
+  // Kysely
+  KyselyTransaction,
+  KyselyDatabase,
+  // Dynamo
+  // DynamoTransaction,
+  DynamoDatabase,
+}

package/src/Database/integrations/dynamo/DynamoDatabase.ts

@@ -0,0 +1,58 @@
+import { Agent } from 'https'
+
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
+import { NodeHttpHandler } from '@smithy/node-http-handler'
+
+import { Database } from '../../Database.js'
+import type { DbConfig } from '../../types.js'
+
+/**
+ * Represents a DynamoDB database connection that extends a generic Database class.
+ * @extends Database<any>
+ */
+export class DynamoDatabase extends Database<any> {
+  /**
+   * A private static property that holds an instance of the DynamoDBClient class.
+   * This property can be used to interact with DynamoDB services.
+   */
+  private static dynamoProvider = DynamoDBClient
+  /**
+   * A readonly property representing the DynamoDB client used to interact with DynamoDB.
+   */
+  public readonly client: DynamoDBClient
+
+  /**
+   * Constructor for creating a new instance of a class that interacts with a DynamoDB database.
+   * @param {DbConfig<'dynamo'>} config - The configuration object for DynamoDB.
+   * @returns None
+   */
+  constructor(config: DbConfig<'dynamo'>) {
+    super(config)
+    this.client = this.providerFactory(config)
+  }
+
+  /**
+   * Override method to handle a transaction asynchronously.
+   * @returns A Promise that resolves to null.
+   */
+  public override async transaction(): Promise<any> {
+    return Promise.resolve(null)
+  }
+
+  /**
+   * Creates a provider for DynamoDB based on the provided configuration.
+   * @param {DbConfig<'dynamo'>} config - The configuration object for DynamoDB.
+   * @returns A DynamoDB provider instance based on the provided configuration.
+   */
+  private providerFactory(config: DbConfig<'dynamo'>) {
+    return new DynamoDatabase.dynamoProvider({
+      region: config.region,
+      maxAttempts: config.maxAttempts || 3,
+      requestHandler: new NodeHttpHandler({
+        connectionTimeout: config.connectionTimeout || 60000,
+        socketTimeout: config.connectionTimeout || 60000,
+        httpsAgent: new Agent({ keepAlive: false, maxSockets: 50, rejectUnauthorized: true }),
+      }),
+    })
+  }
+}

package/src/Database/integrations/kysely/KyselyDatabase.ts

@@ -0,0 +1,99 @@
+import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely'
+import pg from 'pg'
+
+import { KyselyTransaction, KyselyTransactionImpl } from './KyselyTransaction.js'
+import { Database } from '../../Database.js'
+import type { DbBaseConfig, DbConfig } from '../../types.js'
+
+/**
+ * Represents a database connection using the Kysely library with support for transactions.
+ * @template DBSchema - The schema type for the database.
+ */
+export class KyselyDatabase<DBSchema = never> extends Database<KyselyTransaction<DBSchema>> {
+  /**
+   * Represents a PostgreSQL provider for querying data using the PostgresDialect.
+   * @type {PostgresDialect}
+   */
+  private static kyselyPgProvider = PostgresDialect
+  /**
+   * A public static property that provides access to the Kysely class.
+   * This property can be accessed without creating an instance of the class.
+   */
+  private static kyselyProvider = Kysely
+  /**
+   * A static property that represents a connection pool for PostgreSQL database connections.
+   * @type {Pool}
+   */
+  private static pgProvider = pg.Pool
+  /**
+   * Represents a PostgreSQL client using the PostgresDialect.
+   */
+  private readonly pgClient: PostgresDialect
+  /**
+   * Represents a client for querying the database with the specified schema.
+   * @type {Kysely<DBSchema>} client - The client for querying the database.
+   */
+  public readonly client: Kysely<DBSchema>
+  /**
+   * Optional property representing the Postgres dialect for reading in a database client.
+   */
+  private readonly pgReadClient?: PostgresDialect
+  /**
+   * Represents a client for reading from the database.
+   * @type {Kysely<DBSchema> | undefined} - The client for reading from the database.
+   */
+  public readonly readClient?: Kysely<DBSchema>
+
+  /**
+   * Constructor for creating a database connection using the provided configuration.
+   * @param {DbConfig<'kysely'>} config - The configuration object for the database connection.
+   * @returns None
+   */
+  constructor(config: DbConfig<'kysely'>) {
+    super(config)
+    this.pgClient = this.dialectFactory(config)
+    this.client = this.providerFactory(this.pgClient)
+    if (config.readReplica) {
+      this.pgReadClient = this.dialectFactory(config.readReplica)
+      this.readClient = this.providerFactory(this.pgReadClient)
+    }
+  }
+
+  /**
+   * Override method that starts a new transaction using the provided client and read client.
+   * @returns A Promise that resolves to a KyselyTransaction object for the specified database schema.
+   */
+  public override async transaction(): Promise<KyselyTransaction<DBSchema>> {
+    return KyselyTransactionImpl.newTransaction<DBSchema>(this.client, this, this.readClient)
+  }
+
+  /**
+   * Creates a database dialect based on the provided configuration.
+   * @param {DbBaseConfig} config - The configuration object for the database connection.
+   * @returns A database dialect instance based on the provided configuration.
+   */
+  private dialectFactory(config: DbBaseConfig) {
+    return new KyselyDatabase.kyselyPgProvider({
+      pool: new KyselyDatabase.pgProvider({
+        host: config.host,
+        port: config.port,
+        user: config.username,
+        password: config.password,
+        database: config.database,
+        max: config.maxConnections,
+      }),
+    })
+  }
+
+  /**
+   * Creates a provider for interacting with a database using the specified Postgres dialect.
+   * @param {PostgresDialect} dialect - The Postgres dialect to use for the database connection.
+   * @returns A database provider for interacting with the database.
+   */
+  private providerFactory(dialect: PostgresDialect) {
+    return new KyselyDatabase.kyselyProvider<DBSchema>({
+      dialect,
+      plugins: [new CamelCasePlugin()],
+    })
+  }
+}

package/src/Database/integrations/kysely/KyselyTransaction.ts

@@ -0,0 +1,172 @@
+import { Kysely, Transaction } from 'kysely'
+
+import { KyselyDatabase } from './KyselyDatabase.js'
+import { Database } from '../../Database.js'
+import { DatabaseTransaction } from '../../DatabaseTransaction.js'
+
+/**
+ * Represents a transaction for querying a database with a specific schema.
+ * @typeparam DBSchema - The schema of the database.
+ * @type {KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>}
+ */
+export type KyselyTransaction<DBSchema> = KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export class KyselyTransactionImpl<DBSchema> extends DatabaseTransaction {
+  /**
+   * A readonly property representing a writer for a Kysely object.
+   * @type {Kysely<any>}
+   */
+  public readonly writer: Kysely<any>
+  /**
+   * A readonly property representing a reader of type Kysely<any>.
+   * This property allows reading data of any type using the Kysely interface.
+   */
+  public readonly reader: Kysely<any>
+  /**
+   * A protected property representing a transaction of type any.
+   */
+  protected transaction: Transaction<any>
+  /**
+   * A protected property representing a database instance.
+   * @type {Database<KyselyTransaction<DBSchema>>}
+   */
+  protected database: Database<KyselyTransaction<DBSchema>>
+  /**
+   * A private property that represents a deferred object.
+   * @type {Deferred<any>}
+   */
+  private txWrapper: Deferred<any>
+  /**
+   * Constructs a new instance of the class.
+   * @param {Kysely<DBSchema>} delegate - The delegate object for the database query.
+   * @param {KyselyDatabase<DBSchema>} database - The database object for the query.
+   * @param {Kysely<DBSchema>} [reader] - An optional reader object for the query.
+   * @returns None
+   */
+  private constructor(
+    delegate: Kysely<DBSchema>,
+    database: KyselyDatabase<DBSchema>,
+    reader?: Kysely<DBSchema>
+  ) {
+    super(delegate, database, reader)
+  }
+
+  /**
+   * Creates a new database transaction for the given database schema.
+   * @param {Kysely<DBSchema>} connection - The connection object for the transaction.
+   * @param {KyselyDatabase<DBSchema>} database - The database object for the transaction.
+   * @param {Kysely<DBSchema>} [reader] - An optional reader object for the transaction.
+   * @returns {Promise<KyselyTransaction<DBSchema>>} A promise that resolves to the created transaction.
+   */
+  public static async newTransaction<DBSchema>(
+    connection: Kysely<DBSchema>,
+    database: KyselyDatabase<DBSchema>,
+    reader?: Kysely<DBSchema>
+  ): Promise<KyselyTransaction<DBSchema>> {
+    const tx = new KyselyTransactionImpl<DBSchema>(connection, database, reader)
+    await tx.begin()
+    return DatabaseTransaction.proxyInstance(tx) as any
+  }
+
+  /**
+   * Asynchronously begins a transaction using a writer and resolves the transaction once it is executed.
+   * @returns A Promise that resolves with the transaction object once the transaction is executed.
+   */
+  protected doBegin = async () => {
+    this.txWrapper = new Deferred<any>()
+    return new Promise(resolve => {
+      this.writer
+        .transaction()
+        .execute(async trx => {
+          this.transaction = trx
+          resolve(trx) // resolve with tx
+          return this.txWrapper.promise // wait for wrapper to be solved
+        })
+        .catch(() => {
+          // Don't do anything here. Just swallow the exception.
+        })
+    })
+  }
+
+  /**
+   * Executes the commit operation by resolving the transaction wrapper and returning a resolved Promise.
+   * @returns A Promise that resolves to null.
+   */
+  protected doCommit = () => {
+    this.txWrapper.resolve(null)
+    return Promise.resolve()
+  }
+
+  /**
+   * Performs a rollback operation by rejecting the transaction wrapper with an error.
+   * @returns A resolved Promise after the rollback operation is completed.
+   */
+  protected doRollback = () => {
+    this.txWrapper.reject(new Error('Rollback'))
+    return Promise.resolve()
+  }
+}
+
+/**
+ * Represents a deferred promise that can be resolved or rejected at a later time.
+ * @template T - The type of the value that the promise will resolve to.
+ */
+class Deferred<T> {
+  /**
+   * A private readonly Promise object that resolves to type T.
+   */
+  private readonly _promise: Promise<T>
+  /**
+   * A private property that holds a function to resolve a Promise with a value of type T.
+   * @param {T | PromiseLike<T>} value - The value or promise to be resolved.
+   */
+  private _resolve?: (value: T | PromiseLike<T>) => void
+  /**
+   * A function that can be called to reject a promise with an optional reason.
+   * @param {any} [reason] - An optional reason for rejecting the promise.
+   */
+  private _reject?: (reason?: any) => void
+
+  /**
+   * Constructor for creating a new Promise instance with resolve and reject functions.
+   * @constructor
+   */
+  constructor() {
+    this._promise = new Promise<T>((resolve, reject) => {
+      this._reject = reject
+      this._resolve = resolve
+    })
+  }
+
+  /**
+   * Getter method to retrieve the Promise object.
+   * @returns {Promise<T>} A Promise object of type T.
+   */
+  public get promise(): Promise<T> {
+    return this._promise
+  }
+
+  /**
+   * Resolves the Promise with the given value.
+   * @param {T | PromiseLike<T>} value - The value to resolve the Promise with.
+   * @returns void
+   */
+  public resolve(value: T | PromiseLike<T>): void {
+    if (this._resolve) {
+      this._resolve(value)
+    }
+  }
+
+  /**
+   * Rejects the Promise with the given reason, if the reject function is available.
+   * @param {any} reason - The reason for rejecting the Promise.
+   * @returns void
+   */
+  public reject(reason?: any): void {
+    if (this._reject) {
+      this._reject(reason)
+    }
+  }
+}

package/src/Database/integrations/pgsql/PostgresDatabase.ts

@@ -0,0 +1,56 @@
+import pg from 'pg'
+
+import { PostgresTransaction, PostgresTransactionImpl } from './PostgresTransaction.js'
+import { Database } from '../../Database.js'
+import type { DbBaseConfig, DbConfig } from '../../types.js'
+
+/**
+ * Represents a Postgres database connection that extends the Database class.
+ * @extends Database<PostgresTransaction>
+ */
+export class PostgresDatabase extends Database<PostgresTransaction> {
+  /**
+   * A public static property that represents a connection pool for a PostgreSQL database.
+   * This property is used to manage and provide connections to the PostgreSQL database.
+   */
+  private static pgProvider = pg.Pool
+  /**
+   * Represents a connection pool to manage multiple client connections to the database.
+   */
+  public readonly client: pg.Pool
+  /**
+   * A private property that represents a connection pool for clients.
+   * @type {Pool | undefined}
+   */
+  public readonly readClient?: pg.Pool
+
+  /**
+   * Constructor for creating a new instance of a database connection using Postgres.
+   * @param {DbConfig<'pg'>} config - The configuration object for the Postgres database.
+   * @returns None
+   */
+  constructor(config: DbConfig<'pg'>) {
+    super(config)
+    this.client = this.providerFactory(config)
+    if (config.readReplica) this.readClient = this.providerFactory(config.readReplica)
+  }
+
+  /**
+   * Creates a new Postgres transaction using the provided client and read client.
+   * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction object.
+   */
+  public override async transaction(): Promise<PostgresTransaction> {
+    return PostgresTransactionImpl.newTransaction(this.client, this, this.readClient)
+  }
+
+  private providerFactory(config: DbBaseConfig) {
+    return new PostgresDatabase.pgProvider({
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      database: config.database,
+      max: config.maxConnections,
+    })
+  }
+}

package/src/Database/integrations/pgsql/PostgresTransaction.ts

@@ -0,0 +1,87 @@
+import * as pg from 'pg'
+
+import { PostgresDatabase } from './PostgresDatabase.js'
+import { Database } from '../../Database.js'
+import { DatabaseTransaction } from '../../DatabaseTransaction.js'
+
+/**
+ * A type alias representing a Postgres transaction. It extends the `PostgresTransactionImpl`
+ * interface and includes the `PoolClient` interface.
+ */
+export type PostgresTransaction = PostgresTransactionImpl & pg.PoolClient
+
+/**
+ * Represents a transaction in a Postgres database.
+ */
+export class PostgresTransactionImpl extends DatabaseTransaction {
+  /**
+   * A Pool object used for writing operations.
+   * @readonly
+   */
+  public readonly writer: pg.Pool
+  /**
+   * A readonly property representing a pool reader.
+   */
+  public readonly reader: pg.Pool
+  /**
+   * Represents a database transaction using a PoolClient.
+   * @type {PoolClient}
+   */
+  protected transaction: pg.PoolClient
+  /**
+   * A protected property representing a database of type Database<PostgresTransaction>.
+   * This property is used to interact with a Postgres database using transactions.
+   */
+  protected database: Database<PostgresTransaction>
+  /**
+   * Constructs a new instance of the class with the provided writer, database, and optional reader.
+   * @param {Pool} writer - The writer pool for database operations.
+   * @param {PostgresDatabase} database - The Postgres database instance.
+   * @param {Pool} [reader] - The reader pool for database operations (optional).
+   */
+  private constructor(writer: pg.Pool, database: PostgresDatabase, reader?: pg.Pool) {
+    super(writer, database, reader)
+  }
+
+  /**
+   * Creates a new database transaction using the provided writer and database instances.
+   * @param {Pool} writer - The writer instance for the transaction.
+   * @param {PostgresDatabase} database - The database instance for the transaction.
+   * @param {Pool} [reader] - Optional reader instance for the transaction.
+   * @returns {Promise<PostgresTransaction>} A promise that resolves to a new PostgresTransaction instance.
+   */
+  public static async newTransaction(
+    writer: pg.Pool,
+    database: PostgresDatabase,
+    reader?: pg.Pool
+  ): Promise<PostgresTransaction> {
+    const tx = new PostgresTransactionImpl(writer, database, reader)
+    await tx.begin() // defaults to opened
+    return DatabaseTransaction.proxyInstance(tx) as any
+  }
+
+  /**
+   * Initiates a transaction by connecting to the writer and executing a 'BEGIN' query.
+   * @returns {Promise<void>} A promise that resolves when the transaction is successfully initiated.
+   */
+  protected doBegin = async () => {
+    this.transaction = await this.writer.connect()
+    return this.transaction.query('BEGIN')
+  }
+
+  /**
+   * Executes a COMMIT query to commit the current transaction.
+   * @returns A Promise that resolves when the COMMIT query is successfully executed.
+   */
+  protected doCommit = () => {
+    return this.transaction.query('COMMIT')
+  }
+
+  /**
+   * Rolls back the current transaction by executing a 'ROLLBACK' query.
+   * @returns A Promise that resolves when the rollback is successful.
+   */
+  protected doRollback = () => {
+    return this.transaction.query('ROLLBACK')
+  }
+}

package/src/Database/types.ts

@@ -0,0 +1,85 @@
+import { Database } from './Database.js'
+import { DATABASES } from './DatabaseManager.js'
+import { DynamoDatabase } from './integrations/dynamo/DynamoDatabase.js'
+import { KyselyDatabase } from './integrations/kysely/KyselyDatabase.js'
+import { PostgresDatabase } from './integrations/pgsql/PostgresDatabase.js'
+
+/**
+ * Represents the possible types of databases available in the system.
+ * @typedef {keyof typeof DATABASES} DatabaseType
+ */
+export type DatabaseType = keyof typeof DATABASES
+
+/**
+ * Defines a type for a database class that includes instances for Postgres, and Kysely databases.
+ * @template T - The type of data the KyselyDatabase instance will handle.
+ * @property {new (...args: any[]) => PostgresDatabase} pg - Constructor for PostgresDatabase instances.
+ * @property {new (...args: any[]) => KyselyDatabase<T>} kysely - Constructor for KyselyDatabase instances with type T.
+ */
+export type DatabaseClass<T> = {
+  pg: new (...args: any[]) => PostgresDatabase
+  kysely: new (...args: any[]) => KyselyDatabase<T>
+  dynamo: new (...args: any[]) => DynamoDatabase
+}
+
+/**
+ * Represents a specific implementation type for a database based on the provided DatabaseType.
+ * @param {DatabaseType} Type - The type of database to implement.
+ * @param {T} T - The generic type for the database implementation.
+ * @returns An instance of the specified database class for the given type.
+ */
+export type DatabaseImplType<Type extends DatabaseType, T> = InstanceType<DatabaseClass<T>[Type]>
+
+/**
+ * Defines the type of transaction for a specific database type and schema.
+ * @param {DatabaseType} Type - The type of the database.
+ * @param {DBSchema} DBSchema - The schema of the database.
+ * @returns The transaction type associated with the database type and schema.
+ */
+export type DatabaseTransactionType<Type extends DatabaseType, DBSchema> =
+  DatabaseImplType<Type, DBSchema> extends Database<infer TransactionType> ? TransactionType : never
+
+/**
+ * Defines the configuration options for different types of databases.
+ * @typedef {Object} DbBaseConfig
+ * @property {string} host - The host of the database.
+ * @property {number} port - The port number of the database.
+ * @property {string} username - The username for accessing the database.
+ * @property {string} password - The password for accessing the database.
+ * @property {string} database - The name of the database.
+ * @property {boolean} autoCommit - Flag indicating whether auto-commit is enabled.
+ * @property {number} maxConnections - The maximum number of connections allowed.
+ *
+ * @typedef {Object} DbConfig
+ * @property {string} type - The type of
+ */
+export type DbBaseConfig = {
+  host: string
+  port: number
+  username: string
+  password: string
+  database: string
+  autoCommit: boolean
+  maxConnections: number
+}
+/**
+ * Defines the configuration options for different types of databases.
+ * @template S - The type of database (e.g., 'dynamo', 'pg', 'kysely')
+ * @typedef {Object} DbConfig
+ * @property {DbBaseConfig} DbBaseConfig - The base configuration for the database.
+ * @property {S} type - The type of the database.
+ * @property {DbBaseConfig} [readReplica] - The read replica configuration for '
+ */
+export type DbConfig<S extends DatabaseType> = { type: S } & (S extends 'pg' | 'kysely'
+  ? DbBaseConfig & {
+      readReplica?: DbBaseConfig
+    }
+  : unknown) &
+  (S extends 'dynamo'
+    ? {
+        region: string
+        tableName: string
+        maxAttempts?: number
+        connectionTimeout?: number
+      }
+    : unknown)

package/src/Globals.ts

@@ -0,0 +1,103 @@
+import dotenv from 'dotenv'
+
+import Utils from './Util/Utils.js'
+
+// important for dev env to load .env file
+dotenv.config()
+
+/**
+ * Class containing global constants and configurations for the application.
+ */
+export default class Globals {
+  /**
+   * A constant string representing an error message for input validation failure.
+   */
+  public static ErrorResponseValidationFail = 'Input validation failed: ' //400
+  /**
+   * A constant string representing an error response for an invalid server response.
+   */
+  public static ErrorResponseInvalidServerResponse = 'No valid response, this is a system error.' //400
+  /**
+   * The error message for an unhandled error when processing a request.
+   */
+  public static ErrorResponseUnhandledError = 'Unhandled error when processing request.' //400
+  /**
+   * A static string representing an error response when there are no records to be processed.
+   */
+  public static ErrorResponseNoRecords = 'No events to be processed.' //400
+  /**
+   * Represents an error code for a missing parameter.
+   * @type {string}
+   */
+  public static ErrorCode_MissingParam = 'MISSING_PARAM'
+  /**
+   * Represents an error code for invalid input.
+   * @type {string}
+   */
+  public static ErrorCode_InvalidInput = 'INVALID_INPUT'
+  /**
+   * Represents an error code for an API error.
+   * @type {string}
+   */
+  public static ErrorCode_APIError = 'API_ERROR'
+  /**
+   * Represents the error code for when there are no records found.
+   * @type {string}
+   */
+  public static ErrorCode_NoRecords = 'EMPTY_EVENT'
+
+  /**
+   * Retrieves the default port number for HTTP listeners.
+   * The port number is obtained from the environment variable "PORT" and parsed as an integer.
+   * If the environment variable is not set or cannot be parsed as an integer, the default port number 9000 is used.
+   * @returns {number} - The default port number for HTTP listeners.
+   */
+  public static Listener_HTTP_DefaultPort = Utils.parseIntNullIfNaN(process.env.PORT) || 9000
+  /**
+   * The default host for the HTTP listener.
+   */
+  public static Listener_HTTP_DefaultHost = 'localhost'
+  /**
+   * The HTTP proxy route listener for all routes.
+   * @type {string}
+   */
+  public static Listener_HTTP_ProxyRoute = '*'
+  /**
+   * Retrieves the default timeout value for HTTP listeners.
+   * @returns {number} The default timeout value in milliseconds.
+   */
+  public static Listener_HTTP_DefaultTimeout = Utils.parseIntNullIfNaN(process.env.TIMEOUT) || 30000
+  /**
+   * The default health check route for the HTTP listener.
+   * @type {string}
+   */
+  public static Listener_HTTP_DefaultHealthCheckRoute = process.env.HEALTH_ROUTE || '/health'
+
+  /**
+   * The response message for an exception that occurred during request execution in the Proxy.
+   */
+  public static Resp_MSG_EXCEPTION = '[Proxy]: Exception during request execution!'
+  /**
+   * The response code for an exception that occurred during execution.
+   */
+  public static Resp_CODE_EXCEPTION = 'EXEC_EXCEPTION'
+  /**
+   * The HTTP response status code for an exception scenario.
+   */
+  public static Resp_STATUSCODE_EXCEPTION = 502
+
+  /**
+   * The error message for an invalid response from the server.
+   */
+  public static Resp_MSG_INVALIDRESP = '[Proxy]: Invalid response from server!'
+  /**
+   * Represents the response code for an invalid response.
+   */
+  public static Resp_CODE_INVALIDRESP = 'EMPTY_RESPONSE'
+  /**
+   * The HTTP response status code for an invalid response.
+   * @type {number}
+   * @default 400
+   */
+  public static Resp_STATUSCODE_INVALIDRESP = 400
+}