@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/Utils/Utils.test.ts

@@ -0,0 +1,229 @@
+import { expect as c_expect } from 'chai'
+
+import Utils from '../../src/Util/Utils.js'
+
+describe('isHybridlessContainer', () => {
+  test('Simple isHybridlessContainer test', () => {
+    const v = Utils.isHybridlessContainer()
+    c_expect(v).to.be.a('boolean')
+    // this is done, so tests are reliable based on the testing .env
+    c_expect(v).to.be[process.env.HYBRIDLESS_RUNTIME ? 'true' : 'false']
+  })
+})
+
+describe('isValidString', () => {
+  test('Empty string is not valid', () => {
+    const v = Utils.isValidString('')
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.false
+  })
+
+  test('Number is not a valid string', () => {
+    // @ts-ignore
+    const v = Utils.isValidString(12)
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.false
+  })
+
+  test('Simple string is valid', () => {
+    const v = Utils.isValidString('abc')
+    c_expect(v).to.be.a('boolean')
+    c_expect(v).to.be.true
+  })
+})
+
+describe('parseIntNullIfNaN', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseIntNullIfNaN('abc')
+    c_expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseIntNullIfNaN('abc123')
+    c_expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(null)
+    c_expect(v).to.be.null
+  })
+
+  test('Not null if starts with numbers (js behavior)', () => {
+    const v = Utils.parseIntNullIfNaN('123abc')
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
+  })
+
+  test('Not null if numbers', () => {
+    const v = Utils.parseIntNullIfNaN('123')
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
+  })
+
+  test('Not null if number type', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(123)
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
+  })
+})
+
+describe('parseObjectNullIfEmpty', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc')
+    c_expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc123')
+    c_expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseObjectNullIfEmpty(null)
+    c_expect(v).to.be.null
+  })
+
+  test('Null if malformed object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{d: 123}')
+    c_expect(v).to.be.null
+  })
+
+  test('Null if empty object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{}')
+    c_expect(v).to.be.null
+  })
+
+  test('Not null if object with a key', () => {
+    const v = Utils.parseObjectNullIfEmpty('{"d": 123}')
+    c_expect(v).to.be.a('object')
+    c_expect(v?.['d']).to.be.equals(123)
+  })
+})
+
+describe('isValidNumber', () => {
+  test('Not a valid number if only chars', () => {
+    const v = Utils.isValidNumber('abc')
+    c_expect(v).to.be.false
+  })
+
+  test('Not a valid number if only chars and numbers', () => {
+    const v = Utils.isValidNumber('abc123')
+    c_expect(v).to.be.false
+  })
+
+  test('Not a valid number if causes a crash on conversion', () => {
+    // @ts-ignore
+    const v = Utils.isValidNumber({
+      toString: () => {
+        throw new Error('Evil object')
+      },
+    })
+    c_expect(v).to.be.false
+  })
+
+  test('Valid number if numbers and chars after', () => {
+    const v = Utils.isValidNumber('123abc')
+    c_expect(v).to.be.true
+  })
+
+  test('Valid number if numbers', () => {
+    const v = Utils.isValidNumber('123')
+    c_expect(v).to.be.true
+  })
+})
+
+describe('caseInsensitiveObjectForKey', () => {
+  test('Get a key that is lowercase, asking uppercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ abc: 123 }, 'ABC')
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
+  })
+
+  test('Get a key that is uppercase, asking lowercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'abc')
+    c_expect(v).to.be.a('number')
+    c_expect(v).to.be.equals(123)
+  })
+
+  test('Fails gracefully if key is not found', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'asd')
+    c_expect(v).to.be.null
+  })
+
+  test('Fails gracefully for null object', () => {
+    const v = Utils.caseInsensitiveObjectForKey(null, 'abc')
+    c_expect(v).to.be.null
+  })
+
+  test('Fails gracefully for invalid object', () => {
+    const v = Utils.caseInsensitiveObjectForKey('', 'abc')
+    c_expect(v).to.be.null
+  })
+})
+
+describe('ddbMarshall', () => {
+  test('Marshalling of a simple object', () => {
+    const input = { key: 'value' }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key: { S: 'value' } })
+  })
+
+  test('Marshalling of an array', () => {
+    const input = [1, 2, 3]
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ L: [{ N: '1' }, { N: '2' }, { N: '3' }] })
+  })
+
+  test('Marshalling of a nested object', () => {
+    const input = { key: { nestedKey: 'nestedValue' } }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key: { M: { nestedKey: { S: 'nestedValue' } } } })
+  })
+
+  test('Marshalling of a complex object with undefined values', () => {
+    const input = { key1: 'value1', key2: undefined, key3: null }
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ key1: { S: 'value1' }, key3: { NULL: true } })
+  })
+
+  test('Marshalling of a primitive value', () => {
+    const input = 42
+    const output = Utils.ddbMarshall(input)
+    expect(output).toEqual({ N: '42' })
+  })
+})
+
+describe('ddbUnmarshall', () => {
+  test('Unmarshalling of a simple DynamoDB object', () => {
+    const input = { key: { S: 'value' } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key: 'value' })
+  })
+
+  test('Unmarshalling of a DynamoDB array', () => {
+    const input = { array: { L: [{ N: '1' }, { N: '2' }, { N: '3' }] } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output.array).toEqual([1, 2, 3])
+  })
+
+  test('Unmarshalling of a nested DynamoDB object', () => {
+    const input = { key: { M: { nestedKey: { S: 'nestedValue' } } } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key: { nestedKey: 'nestedValue' } })
+  })
+
+  test('Unmarshalling of a complex DynamoDB object with null values', () => {
+    const input = { key1: { S: 'value1' }, key3: { NULL: true } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output).toEqual({ key1: 'value1', key3: null })
+  })
+
+  test('Unmarshalling of a primitive value', () => {
+    const input = { key: { N: '42' } }
+    const output = Utils.ddbUnmarshall(input)
+    expect(output.key).toEqual(42)
+  })
+})

package/tests/Validation/Validator.test.ts

@@ -0,0 +1,82 @@
+import { expect } from 'chai'
+import { z } from 'zod'
+
+import Response from '../../src/API/Response.js'
+import Globals from '../../src/Globals.js'
+import Validator from '../../src/Validation/Validator.js'
+import { ViewSchema } from '../Test.utils.js'
+
+function expectFullFailure(validationResult, c = 4) {
+  expect(validationResult).to.be.an.instanceof(Response)
+  if (validationResult instanceof Response) {
+    expect(validationResult.getBody()).is.not.null
+    expect(validationResult.getBody()).to.have.property('err', Globals.ErrorResponseValidationFail)
+    expect(validationResult.getBody()).to.have.property('errCode', Globals.ErrorCode_InvalidInput)
+    expect(validationResult.getBody()).to.have.property('validationFailure')
+    expect(validationResult.getBody()['validationFailure']).to.have.lengthOf(c)
+    expect(validationResult.getCode()).is.equals(400)
+  }
+}
+
+describe('Validates unsuccessfully', () => {
+  test('Fails to validate async', () => {
+    const validationResult = Validator.validateSchema(async () => {}, ViewSchema)
+    expectFullFailure(validationResult, 1)
+  })
+
+  test('Fails to validate null', () => {
+    const validationResult = Validator.validateSchema(null, ViewSchema)
+    expectFullFailure(validationResult, 1)
+  })
+
+  test('Fails to validate empty string', () => {
+    const validationResult = Validator.validateSchema('', ViewSchema)
+    expectFullFailure(validationResult, 1)
+  })
+
+  test('Fails to validate empty object', () => {
+    const validationResult = Validator.validateSchema({}, ViewSchema)
+    expectFullFailure(validationResult)
+  })
+
+  test('Fails to validate object with wrong keys', () => {
+    const validationResult = Validator.validateSchema({ name: 'Joe' }, ViewSchema)
+    expectFullFailure(validationResult)
+  })
+
+  test('Fails to validate object with wrong key types', () => {
+    const validationResult = Validator.validateSchema({ id: 123 }, ViewSchema)
+    expectFullFailure(validationResult)
+    if (validationResult instanceof Response) {
+      console.log(validationResult.getBody()['validationFailure'])
+      expect(
+        validationResult.getBody()['validationFailure'].filter(f => {
+          return f.message == 'Expected string, received number'
+        })
+      ).to.have.lengthOf(1)
+    }
+  })
+})
+
+describe('Validates successfully', () => {
+  test('Succeeds to validate', () => {
+    const validationResult = Validator.validateSchema(
+      {
+        id: '123',
+        content: '123',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      ViewSchema
+    )
+    expect(validationResult).to.not.be.an.instanceof(Response)
+    expect(validationResult).to.be.true
+  })
+  test('Succeeds to validate null schema', () => {
+    const validationResult = Validator.validateSchema(null, ViewSchema.or(z.null()))
+    expect(validationResult).to.not.be.an.instanceof(Response)
+    expect(validationResult).to.be.true
+  })
+})
+
+export {}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "exclude": ["**/*.test.*", "**/__mocks__/*", "**/__tests__/*", "**/tests/*", "./dist/**/*", "./smoke-tests/**/*", "./jest*", "./node_modules"],
+  "include": ["./**/*", "./package.json", "./package-lock.json"],
+  "compilerOptions": {
+    "lib": [
+      "es5",
+      "es6",
+      "dom"
+    ],
+    "module": "esnext",
+    "target": "es6",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "noImplicitAny": false,
+    "noEmitOnError": true,
+    "removeComments": false,
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "declaration": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noErrorTruncation": true
+  }
+}

package/tsconfig.smoke.json

@@ -0,0 +1,26 @@
+{
+  "exclude": ["./dist/**/*", "./smoke-tests/**/*", "./node_modules", "./**/Logger.test.*"],
+  "include": ["./**/*", "./package.json", "./package-lock.json"],
+  "compilerOptions": {
+    "lib": [
+      "es5",
+      "es6",
+      "dom"
+    ],
+    "module": "esnext",
+    "target": "es6",
+    "moduleResolution": "node",
+    "noImplicitAny": false,
+    "noEmitOnError": true,
+    "removeComments": false,
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "outDir": "smoke-tests",
+    "declaration": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noErrorTruncation": true
+  }
+}

package/index.js

@@ -1,88 +0,0 @@
-//Set defaults
-import Bluebird from "bluebird";
-global.Promise = Bluebird;
-//Base Events
-import IKTransaction from "./src/BaseEvent/IKTransaction.js";
-import IKProcess from "./src/BaseEvent/IKProcess.js";
-//Extra Events
-import IKRouter from "./src/IKRouter.js";
-import IKEventProcessor from "./src/IKEventProcessor.js";
-import IKDynamoStream from "./src/IKDynamoStream.js";
-import IKStepTransaction from "./src/IKStepTransaction.js";
-//Extra components
-import IKMailer from "./src/Mailer/IKMailer.js";
-import IKValidation from "./src/Validation/IKValidation.js";
-//Responses
-import * as IKResponse from "./src/API/IKResponse.js";
-//Helpers
-import Utils from "./src/API/IKUtils.js";
-//Cache
-//Redis
-import IKRedis from "./src/Cache/Redis/IKRedis.js";
-//Database
-//PSQL
-import IKDBPSQLQuery from "./src/Database/PSQL/IKDBBaseQuery.js";
-//DDB
-import IKDBQueryScan from "./src/Database/DDB/IKDBQueryScan.js";
-import IKDBQueryGet from "./src/Database/DDB/IKDBQueryGet.js";
-import IKDBQueryPut from "./src/Database/DDB/IKDBQueryPut.js";
-import IKDBQueryUpdate from "./src/Database/DDB/IKDBQueryUpdate.js";
-import IKDBQueryDelete from "./src/Database/DDB/IKDBQueryDelete.js";
-import IKDBQueryBatchWrite from "./src/Database/DDB/IKDBQueryBatchWrite.js";
-import IKDBQueryBatchGet from "./src/Database/DDB/IKDBQueryBatchGet.js";
-import IKDBQueryTransactionalWrite from "./src/Database/DDB/IKDBQueryTransactionalWrite.js";
-import { IKDBExpressionOperator } from "./src/Database/DDB/IKDBBaseExpression.js";
-//
-export default {
-  //Base Events
-  IKTransaction,
-  IKProcess,
-  //Extra Events
-  IKRouter,
-  IKEventProcessor,
-  IKDynamoStream,
-  IKStepTransaction,
-  //Extra components
-  IKMailer,
-  IKValidation,
-  //Responses
-  IKResponse: IKResponse.default,
-  IKBadRequestResponse: IKResponse.IKBadRequestResponse,
-  IKUnauthorizedResponse: IKResponse.IKUnauthorizedResponse,
-  IKMissingParamResponse: IKResponse.IKMissingParamResponse,
-  IKMissingQueryResponse: IKResponse.IKMissingQueryResponse,
-  IKSuccessResponse: IKResponse.IKSuccessResponse,
-  IKSuccessStreamResponse: IKResponse.IKSuccessStreamResponse,
-  IKSuccessNoContentResponse: IKResponse.IKSuccessNoContentResponse,
-  IKBadRequestResponseWithRollback: IKResponse.IKBadRequestResponseWithRollback,
-  IKStepFunctionResponse: IKResponse.IKStepFunctionResponse,
-  IKSimpleResponse: IKResponse.IKSimpleResponse,
-  //Helpers
-  Utils,
-  //Cache
-  //Redis
-  IKRedis,
-  //Database
-  //PSQL
-  IKDBPSQLQuery,
-  //DDB
-  IKDBDDBQueryScan: IKDBQueryScan,
-  IKDBDDBQueryGet: IKDBQueryGet,
-  IKDBDDBQueryPut: IKDBQueryPut,
-  IKDBDDBQueryUpdate: IKDBQueryUpdate,
-  IKDBDDBQueryDelete: IKDBQueryDelete,
-  IKDBDDBQueryBatchWrite: IKDBQueryBatchWrite,
-  IKDBDDBQueryBatchGet: IKDBQueryBatchGet,
-  IKDBDDBQueryTransactionalWrite: IKDBQueryTransactionalWrite,
-  IKDBDDBExpressionOperator: IKDBExpressionOperator,
-  //Legacy
-  IKDBQueryScan,
-  IKDBQueryGet,
-  IKDBQueryPut,
-  IKDBQueryUpdate,
-  IKDBQueryDelete,
-  IKDBQueryBatchWrite,
-  IKDBQueryBatchGet,
-  IKDBQueryTransactionalWrite,
-  IKDBExpressionOperator,
-};

package/src/API/IKRequest.js

@@ -1,52 +0,0 @@
-/** Ikon Integration DynamoDB wrapper**/
-import Utils from "./IKUtils.js";
-//
-export default class IKRequest {
-  constructor(request, context, transaction) {
-    this.requestEvent = request;
-    this.transaction = transaction;
-    this.context = context;
-    this.transaction.logger.debug("Request info:", JSON.stringify(request));
-    this.transaction.logger.debug("Request context:", JSON.stringify(context));
-  }
-  //query
-  containsQueryParam(paramName) {
-    const val = this.getQueryParam(paramName);
-    return (Utils.isValidString(val) || Utils.isValidNumber(val));
-  }
-  getQueryParam(paramName) { return Utils.caseInsensitiveObjectForKey(this.requestEvent.queryStringParameters, paramName); }
-  //header
-  getHeader(headerName) { return Utils.caseInsensitiveObjectForKey(this.requestEvent.headers, headerName); }
-  //context params
-  getContextParam(cxtParam) { return Utils.caseInsensitiveObjectForKey(this.requestEvent.requestContext, cxtParam); }
-  //path param
-  containsPathParam(paramName) {
-    const val = this.getPathParam(paramName);
-    return (Utils.isValidString(val) || Utils.isValidNumber(val));
-  }
-  getPathParam(paramName) { return Utils.caseInsensitiveObjectForKey(this.requestEvent.pathParameters, paramName); }
-  //body
-  getBody() { 
-    let b = null;
-    try {
-      b = this.requestEvent.body;
-      if (typeof b === 'string' || b instanceof String) b = JSON.parse(b);
-    } catch (e) {}
-    return b;
-  }
-  getPath() { return this.requestEvent.path; }
-  getMethod() { return this.requestEvent.httpMethod; }
-  getPathParams() { return this.requestEvent.pathParameters; }
-
-  //Shortcuts
-  getAuthorizationHeader() { return this.getHeader('Authorization'); }
-  getRequestID() {
-    if (this.context.awsRequestId) return this.context.awsRequestId;
-    return (this.requestEvent.requestContext ? this.requestEvent.requestContext.requestId : 'unknown');
-  }
-  getOriginIP() {
-    const origin = this.getContextParam('identity').sourceIp;
-    const hOrigin = this.getHeader('X-Forwarded-For');
-    return (origin ? origin : (hOrigin ? hOrigin : 'unknow'));
-  }
- }

package/src/API/IKResponse.js

@@ -1,119 +0,0 @@
-import IKGlobals from '../IKGlobals.js';
-//
-export default class IKResponse {
-  constructor(statusCode, body) {
-    this._statusCode = statusCode;
-    this._body = body;
-    //
-    this._streamingOut = false; //internal -- flag to indicate streaming out has started and avoid double stream call
-    //indeally it should be moved to initialization method as we dont' want them to be changed on the go and also give the false impression of getters with the current naming pattern
-    this._isStream = false; //
-    this._contextRawBody = false;
-    this._throwOnErrors = false;
-    this.disableTransactionID = false;
-    //
-    this._headers = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Credentials": true,
-      "Content-Type": "application/json"
-    };
-  }
-  getCode() { return this._statusCode; }
-  getBody() { return this._body; }
-  appendIntoBody(key, value) { this._body[key] = value; }
-  appendHeader(key, value) { this._headers[key] = value; }
-  async build(context, transaction, doNotSucceed) {
-    //Stream support
-    if (this._streamingOut) return;
-    if (this._isStream) return this._pipe(context);
-    
-    //append default fields
-    if (transaction.request.getRequestID() && this._body && !this.disableTransactionID) this.appendIntoBody('transactionID', transaction.request.getRequestID()); //append transaction ID
-    //Raw response support
-    if (this._contextRawBody) return this.rawContext(context, transaction);
-
-    //build response
-    let b = {
-      statusCode: this._statusCode, headers: this._headers,
-      ...(this._body ? { body: JSON.stringify(this._body) } : {}),
-    };
-    //log response and respond to context
-    transaction.logger.debug(b)
-    //Check for transaction response proxy
-    if (transaction.responseProxy) await transaction.responseProxy(b);
-    //Batch does not succeed directly just on upper transaction (which will should be a batch)
-    if (!doNotSucceed) context.succeed(b);
-  }
-  _pipe(context) {
-    //Check if not streaming
-    if (this._streamingOut) return;
-    this._streamingOut = true;
-    //build response
-    let b = { statusCode: this._statusCode, body: this._body, headers: this._headers };
-    //log response and respond to context
-    context.succeed(b);
-  }
-  rawContext(context, transaction) {
-    //log response and respond to context
-    transaction.logger.debug(this._body)
-    if (this.getCode() <= 200 && this.getCode() <= 299) context.succeed(this._body);
-    else {
-      //
-      function CustomError(body) {
-        this.name = body && body.error ? body.error : 'UnknownError';
-        this.message = body && body.message ? body.message : 'Unknown error!';
-      }
-      CustomError.prototype = new Error();
-      //
-      if (!this._throwOnErrors) context.fail(new CustomError(this._body));
-      else throw (new CustomError(this._body));
-    }
-  }
-}
-
-
-/* Shortcuts */
-export function IKMissingParamResponse(paramName) {
-  console.warn(`Invalid request - Path parameter ${paramName} is missing.`);
-  return (new IKResponse(400, { err: `Invalid request. Path parameter ${paramName} is missing.`, errCode: IKGlobals.ErrorCode_MissingParam }));
-}
-export function IKMissingQueryResponse(paramName) {
-  console.warn(`Invalid request - Query parameter ${paramName} is missing.`);
-  return (new IKResponse(400, { err: `Invalid request. Query parameter ${paramName} is missing.`, errCode: IKGlobals.ErrorCode_MissingParam }));
-}
-export function IKBadRequestResponse(msg, errCode, optBody) {
-  console.warn(`Bad request - ${msg}`);
-  return (new IKResponse(400, { err: msg, ...(errCode ? { errCode: errCode } : {}), ...(optBody || {}) }));
-}
-export function IKBadRequestResponseWithRollback(msg, errCode, optBody) {
-  console.warn(`Bad request - ${msg}`);
-  return (new IKResponse(400, { err: msg, rollback: true, ...(errCode ? { errCode: errCode } : {}), ...(optBody || {}) }));
-}
-export function IKUnauthorizedResponse(msg, errCode) {
-  console.warn(`Denying request - ${msg}`);
-  return (new IKResponse(401, { err: msg, ...(errCode ? { errCode: errCode } : {}) }));
-}
-export function IKSuccessResponse(msg) { return (new IKResponse(200, (msg ? msg : {}))); }
-export function IKRedirectResponse(url) { 
-  const resp = new IKResponse(302);
-  resp.appendHeader('Location', url);
-  return resp;
-}
-export function IKSuccessNoContentResponse() { return (new IKResponse(204, null)); }
-export function IKSuccessStreamResponse(stream, contentType) {
-  const resp = new IKResponse(200, (stream ? stream : {}));
-  resp._isStream = true;
-  resp.appendHeader('Connection', 'keep-alive');
-  if (contentType) resp.appendHeader('Content-type', contentType);
-  return resp;
-}
-export function IKStepFunctionResponse(body, optionalCode) {
-  const resp = new IKResponse(optionalCode || 200, body);
-  resp._contextRawBody = true;
-  resp._throwOnErrors = true;
-  return resp;
-}
-export function IKSimpleResponse(body, optionalCode) {
-  const resp = new IKResponse(optionalCode || 200, body);
-  return resp;
-}

package/src/API/IKUtils.js

@@ -1,51 +0,0 @@
-
-import KSUID from 'ksuid';
-import { convertToAttr, marshall, unmarshall } from "@aws-sdk/util-dynamodb";
-//
-export default class IKUtils {}
-IKUtils.isOffline = function() { return process.env.IS_OFFLINE; }
-IKUtils.isHybridlessContainer = function() { return process.env.HYBRIDLESS_RUNTIME; }
-IKUtils.logLevel = function() { return process.env.LOG_LEVEL; }
-
-//formatting
-IKUtils.toDoubleDigit = function(str) { return String("0" + str).slice(-2); }
-IKUtils.isValidString = function(string) { return (string && string.length > 0 && !Array.isArray(string)); }
-IKUtils.isValidNumber = function(number) {
-  let validNumb = NaN;
-  try { validNumb = parseInt(number + ""); }
-  catch (e) { }
-  return !isNaN(validNumb) && !Array.isArray(number);
-}
-//
-IKUtils.caseInsensitiveObjectForKey = function(obj, key) {
-  if (!obj) return null;
-  const insensitiveKey = Object.keys(obj).find(k => k.toLowerCase() === key.toLowerCase());
-  if (insensitiveKey && insensitiveKey != '') return obj[insensitiveKey];
-  return null;
-}
-IKUtils.caseInsensitiveSetObjectForKey = function(obj, key, value) {
-  if (!obj) return null;
-  const insensitiveKey = Object.keys(obj).find(k => k.toLowerCase() === key.toLowerCase());
-  if (insensitiveKey && insensitiveKey != '') obj[insensitiveKey] = value;
-}
-//DB
-IKUtils.encapsulateForDB = function(item) {
-  if (Array.isArray(item)) return {L: item.map(_i => IKUtils.encapsulateForDB(_i))};
-  else if (typeof item === 'object' && isNaN(parseInt(item))) {
-    return {M: marshall(item, {removeUndefinedValues: true, convertClassInstanceToMap: true })};
-  } else return convertToAttr(item, {removeUndefinedValues: true, convertClassInstanceToMap: true });
-}
-IKUtils.decapsulateForDB = function(item) {
-  if (!item && item !== false) return null;
-  if (Array.isArray(item)) {
-    return item.map(_item => IKUtils.decapsulateForDB(_item));
-  } else if (typeof item === 'object') {
-    return unmarshall(item, {removeUndefinedValues: true, convertClassInstanceToMap: true });
-  } return item;
-}
-//Threads
-IKUtils.sleep = async function(delay) {
-  return new Promise((resolve) => setTimeout(resolve, delay));
-}
-//DB
-IKUtils.newUID = function() { return KSUID.randomSync().string; }