@ikonintegration/ikapi 4.0.1 → 5.0.0

package/src/BaseEvent/IKProcess.js

@@ -1,77 +0,0 @@
-//
-import IKGlobals from '../IKGlobals.js';
-import Utils  from "../API/IKUtils.js";
-//Database
-import IKDBDDB from "../Database/DDB/IKDB.js";
-import IKDBPSQL from "../Database/PSQL/IKDB.js";
-//Cache
-import IKCacheRedis from '../Cache/Redis/IKRedis.js';
-//Comps
-import IKLogger from "../Logger/IKLogger.js";
-import IKValidation from '../Validation/IKValidation.js';
-import IKPublisher from '../Publisher/IKPublisher.js';
-import IKExecutionTracker from '../Tracker/IKExecutionTracker.js';
-//
-export default class IKProcess {
-  constructor(config, interval) {
-    this._config = config;
-    this.allowExecutionIdentification = false;
-    this.interval = interval;
-    this.logger = new IKLogger(config.logger, Utils.logLevel());
-    this.publisher = new IKPublisher(config.publisher);
-    this.validator = new IKValidation(config.validation);
-    this.db = this._getDBDriver();
-    this.cache = this._getCacheDriver();
-    if (config.resourcesTracker) this.tracker = new IKExecutionTracker(config.resourcesTracker, null, this.db);
-  }
-
-  //Main interface
-  async execute(executionFunc) {
-    this.logger.debug("Starting main process code");
-    //Tracker
-    if (this.allowExecutionIdentification && this.tracker) this.tracker.resetExecutionTrace();
-    //Connect DB
-    if (this.db) await this.db.connect();
-    //Program loop
-    setInterval( async () => {
-      await this._execute(executionFunc);
-    }, this.interval);
-    //Tracker
-    if (this.allowExecutionIdentification && this.tracker) await this.tracker.trackExecAndDrain();
-  }
-  //Executions
-  async _execute(executionFunc) {
-    let executionFailed = true; //failled til we say no!
-    //safe execution handler
-    try { 
-      //start DB transaction
-      if (this.db) await this.db.beginTransaction();
-      //Execute
-      await executionFunc(this);
-      //Commit DB
-      if (this.db) await this.db.commit();
-      //Tracker
-      if (this.tracker) await this.tracker.quickDrain();
-      //
-      executionFailed = false;
-    } catch (e) { /*EXECUTION FAIL*/
-      this.logger.error('Exception when executing main request code. Rolling back DB!');
-      this.logger.exception(e);
-      //Rollback DB
-      if (this.db) await this.db.rollback();
-    } return executionFailed;
-  }
-  /* DB drivers support */
-  _getDBDriver() {
-    if (this._config.database) {
-      if (this._config.database.type == IKGlobals.DBDrivers.PSQL) return new IKDBPSQL(this._config.database, this);
-      else if (Object.keys(this._config.database).length > 0) return new IKDBDDB(this._config.database, this);
-    } return null;
-  }
-  /* Cache drivers support */
-  _getCacheDriver() {
-    if (this._config.cache) {
-      if (this._config.cache.type == IKGlobals.CacheDrivers.REDIS) return new IKCacheRedis(this._config.cache, this);
-    } return null;
-  }
-}

package/src/BaseEvent/IKTransaction.js

@@ -1,139 +0,0 @@
-//
-import IKGlobals from '../IKGlobals.js';
-import Utils  from "../API/IKUtils.js";
-//Database
-import IKDBDDB from "../Database/DDB/IKDB.js";
-import IKDBPSQL from "../Database/PSQL/IKDB.js";
-//Cache
-import IKCacheRedis from '../Cache/Redis/IKRedis.js';
-//Comps
-import IKLogger from "../Logger/IKLogger.js";
-import IKValidation from '../Validation/IKValidation.js';
-import IKPublisher from '../Publisher/IKPublisher.js';
-import IKExecutionTracker from '../Tracker/IKExecutionTracker.js';
-//Request
-import IKRequest from '../API/IKRequest.js';
-import IKResponse, { IKBadRequestResponseWithRollback } from '../API/IKResponse.js';
-
-//
-export default class IKTransaction {
-  constructor(event, context, config, _isBatch, _retrowErrors) {
-    this._event = event;
-    this._context = context;
-    this._config = config;
-    //response behaviour flags
-    this._syncReturn = _isBatch;
-    this._retrowErrors = _retrowErrors; /* retrow internal errors */
-    this._resp = null;
-      //When set, this will be called with the response context right before calling the context suceed/fail - useful for IOing the resp for example.
-    this.responseProxy = null;
-    //
-    this.logger = new IKLogger(config.logger, Utils.logLevel(), (context.awsRequestId ? context.awsRequestId : (event.requestContext ? event.requestContext.requestId : 'unknown')));
-    this.request = new IKRequest(this._event, this._context, this);
-    this.publisher = new IKPublisher(config.publisher);
-    this.validator = new IKValidation(config.validation);
-    this.db = this._getDBDriver();
-    if (config.resourcesTracker) this.tracker = new IKExecutionTracker(config.resourcesTracker, context, this.db);
-    this.cache = this._getCacheDriver();
-  }
-
-  //Main interface
-  async execute(executionFunc) {
-    await this._executeLoggerFlush(async ()=>{
-      await this._executeDBTransactions(async ()=>{
-        return await this._execute(executionFunc);
-      });
-    });
-    if (this._syncReturn) return this._resp;
-  }
-  //Executions
-  async _execute(executionFunc) {
-    let executionFailed = true; //failled til we say no!
-    //safe execution handler
-    try { //Execute
-      this.logger.debug("Starting main request code");
-      this._resp = await executionFunc(this);
-      //Tracker after successful execution (before succeeding the context, which will cause things to die)
-      if (this.tracker) await this.tracker.trackExecAndDrain();
-      //Answer client
-      if (this._resp && this._resp instanceof IKResponse) {
-        await this._resp.build(this._context, this, this._syncReturn);
-        executionFailed = !!(this._resp.getBody() && this._resp.getBody().rollback);
-      } else if (this._syncReturn && this._resp) { //sync return can return other than ikresponse
-        this.logger.log("Sync return with different response object:");
-        this.logger.debug(this._resp);
-        executionFailed = false;
-      } else {
-        this._resp = this._getErrorResponse(IKGlobals.ErrorResponseInvalidServerResponse, IKGlobals.ErrorCode_APIError)
-        await this._resp.build(this._context, this, this._syncReturn);
-        this.logger.error("Invalid response object from main request code.");
-      }
-    } catch (e) { /*EXECUTION FAIL*/
-      this.logger.error('Exception when executing main request code.');
-      this.logger.exception(e);
-      //retrow?
-      if (this._retrowErrors) throw e;
-      //envelope exception?
-      if (executionFailed) {
-        this._resp = this._getErrorResponse(IKGlobals.ErrorResponseUnhandledError, IKGlobals.ErrorCode_APIError);
-        await this._resp.build(this._context, this, this._syncReturn);
-      }
-    } return executionFailed;
-  }
-  async _executeDBTransactions(safeExecution) {
-    try {
-      //start DB
-      if (this.db) await this.db.connect();
-      //start transaction
-      if (this.db) await this.db.beginTransaction();
-      //
-      let executionFailed = await safeExecution();
-      //Commit if not failed, rollback if failed
-      if (!executionFailed) {
-        if (this.db) await this.db.commit();
-      } else {
-        this.logger.log("Rolling back DB transactions. Main code failed!");
-        if (this.db) await this.db.rollback();
-      }
-      //Cleanup DB after execution
-      if (this.db) await this.db.cleanup();
-    } catch (e) {
-      this.logger.error('Exception when executing DB transactions.');
-      this.logger.log(e.stack);
-      //retrow?
-      if (this._retrowErrors) throw e;
-    }
-  }
-  async _executeLoggerFlush(safeExecution) {
-    try {
-      await safeExecution();
-      await this.logger.flushLogs();
-      //Tracker (if not tracked yet -- exception case)
-      if (this.tracker) await this.tracker.trackExecAndDrain();
-    } catch (e) {
-      this.logger.error('Exception when flushing logs.');
-      this.logger.exception(e);
-      //retrow?
-      if (this._retrowErrors) throw e;
-    } finally {
-      this.logger.debug("Transaction ended");
-    }
-  }
-  /* DB drivers support */
-  _getDBDriver() {
-    if (this._config.database) {
-      if (this._config.database.type == IKGlobals.DBDrivers.PSQL) return new IKDBPSQL(this._config.database, this);
-      else if (Object.keys(this._config.database).length > 0) return new IKDBDDB(this._config.database, this);
-    } return null;
-  }
-  /* Cache drivers support */
-  _getCacheDriver() {
-    if (this._config.cache) {
-      if (this._config.cache.type == IKGlobals.CacheDrivers.REDIS) return new IKCacheRedis(this._config.cache, this);
-    } return null;
-  }
-  /* Response support */
-  _getErrorResponse(error, code) {
-    return IKBadRequestResponseWithRollback(error, code);
-  }
-}

package/src/Cache/Prototype/IKCache.js

@@ -1,17 +0,0 @@
-export default class IKCache {
-  constructor(config, transaction) {
-    this.config = config;
-    this.transaction = transaction;
-    this.connection = null;
-  }
-  /* Public */
-  async get(key) { }
-  async set(key, value) { }
-  async del(key) {  }
-  async keys(pattern) { }
-  async mget(key) { }
-  async mset(key, value) { }
-  async mdel(key) { }
-  /* Private */
-  async _connect() { }
-}

package/src/Cache/Redis/IKRedis.js

@@ -1,148 +0,0 @@
-import IKCache from '../Prototype/IKCache.js';
-export default class IKCache_Redis extends IKCache {
-  constructor(config, transaction) {
-    super(config, transaction);
-    //
-    this.awaitingConnectionQueue = null;
-    //
-    const localConsole = (transaction ? transaction.logger : console);
-    if (config && config.host) { localConsole.debug(`Using cache: REDIS on host: ${config.host}`); }
-  }
-  /* Public */
-  async get(key) {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.get(key, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async set(key, value) {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.set(key, value, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async del(key) {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.del(key, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async keys(pattern) {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.keys(pattern, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async mget() {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.mget(...arguments, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async mset() {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.mset(...arguments, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  async mdel() {
-    return new Promise(async (resolve, reject) => {
-      await this._connect();
-      this.connection.del(...arguments, (err, reply) => {
-        if (err) reject(err);
-        else (resolve(reply));
-      });
-    });
-  }
-  /* Private */
-  async _isRedisClientAvailable() {
-    let response = true;
-    try { const test = await import('redis'); } 
-    catch (e) { response = false; }
-    return response;
-  }
-  async _isRedisClientV4() {
-    let isV4 = false;
-    try {
-      const test = await import('redis');
-      isV4 = !!test.createCluster; 
-    } 
-    catch (e) { }
-    return isV4;
-  }
-  async _connect() {
-    //No connection, but waiting connection queue is valid? wait until other promise
-    //fulfill this promire
-    if (!this.connection && this.awaitingConnectionQueue) {
-      return new Promise((resolve) => this.awaitingConnectionQueue.push(resolve));
-    } else if (this.connection) return this.connection; //already connected
-
-    //Check if redis client is available
-    if (!(await this._isRedisClientAvailable())) throw new Error('Redis client is not available! Please, run "npm i -S redis".');
-
-    //Prepare
-    const localConsole = (this.transaction ? this.transaction.logger : console);
-    this.awaitingConnectionQueue = [];
-    localConsole.debug("Starting remote cache connection");
-    
-    //Instantiate client and initiate connection
-    return new Promise(async (resolve, reject) => {
-      const redis = await import("redis");
-      const isV4 = await this._isRedisClientV4();
-      //
-      const connection = redis.createClient({
-        ...(isV4 ? {
-          username: this.config.user, 
-          socket: { 
-            ...(this.config.enableTLS ? { tls: true } : {}), host: this.config.host,
-            connectTimeout: 10000, reconnectStrategy: (retries) => retries <= 2 ? 1000 : new Error('Redis max connection attempts reached!')
-          }
-        } : {
-          host: this.config.host, user: this.config.user,
-          ...(this.config.enableTLS ? { tls: {} } /* https://docs.upstash.com/howto/connectwithtls */ : {})
-        }),
-        password: this.config.password, 
-      });
-      //redis v4 & v3 compatibility
-      if (connection && connection.connect) await connection.connect();
-      //
-      const connectedHandler = () => {
-        this.connection = connection;
-        if (this.awaitingConnectionQueue) this.awaitingConnectionQueue.forEach((resolve) => resolve());
-        this.awaitingConnectionQueue = null;
-        resolve();
-      }
-      //reached here on v4, everything is connected
-      if (isV4) {
-        connectedHandler();
-        return;
-      } 
-      //v3 <=
-      connection.on('connect', connectedHandler);
-      connection.on('error', (err) => {
-        localConsole.error(err);
-        if (this.awaitingConnectionQueue) this.awaitingConnectionQueue.forEach((resolve) => resolve()); //fulfill, error will be thrown
-        this.awaitingConnectionQueue = null;
-        reject(err);
-      });
-    });
-  }
-}

package/src/Database/DDB/IKDB.js

@@ -1,56 +0,0 @@
-import { DynamoDB } from "@aws-sdk/client-dynamodb";
-import { NodeHttpHandler } from "@aws-sdk/node-http-handler";
-import Utils from "./../../API/IKUtils.js";
-import sha1 from 'sha1';
-//
-import IKGlobals from './../../IKGlobals.js';
-import IKDB from './../Prototype/IKDB.js';
-//
-import { Agent } from "https";
-//reusable connection
-var DDB_CONN = null;
-var DDB_CONN_HASH = null;
-//
-export default class IKDB_DDB extends IKDB {
-  constructor(config, transaction) {
-    super(config, transaction);
-    this.tableName = config.tableName;
-    this.region = config.region;
-    this.stats = { readUnits: 0, writeUnits: 0 };
-    //
-    // const localConsole = (transaction ? transaction.logger : console);
-    // if (config && this.tableName) { localConsole.debug(`Using table: ${this.tableName} on region: ${this.region}`); }
-  }
-
-  async connect() {
-    const localConsole = (this.transaction ? this.transaction.logger : console);
-    //Reusability logic
-    if (!((!DDB_CONN && !DDB_CONN_HASH) || DDB_CONN_HASH != sha1(this.region))) {
-      localConsole.debug("Reusing database connection");
-      this.connection = DDB_CONN;
-      return;
-    }
-    //setup db
-    if (Utils.isOffline()) {
-      localConsole.debug("Starting offline database connection");
-      this.connection = new DynamoDB(IKGlobals.DynamoDBLocalConfig);
-    } else {
-      // localConsole.debug("Starting remote database connection");
-      //initialize connection
-      this.connection = new DynamoDB({ 
-        region: this.region, maxAttempts: IKGlobals.DDBMaxAttempts,
-        requestHandler: new NodeHttpHandler({
-          connectionTimeout: IKGlobals.DDBHttpTimeout, socketTimeout: IKGlobals.DDBHttpTimeout,
-          httpsAgent: new Agent({ keepAlive: false, maxSockets: 50, rejectUnauthorized: true }),
-        })
-      });
-      //Reusable logic
-      DDB_CONN = this.connection;
-      DDB_CONN_HASH = sha1(this.region);
-    }
-  }
-  getTrackerStats() {
-    if (!(this.stats.readUnits > 0 || this.stats.writeUnits > 0)) return null;
-    return { tableName: this.tableName, ...this.stats };
-  }
-}

package/src/Database/DDB/IKDBBaseExpression.js

@@ -1,130 +0,0 @@
-import Utils from './../../API/IKUtils.js';
-//
-export default class IKDBBaseExpression  {
-  constructor() {
-    this.values = [];
-    this.operator = IKDBExpressionOperator.AND;
-    this.counter = 0;
-  }
-  /*public methods*/
-  appendOperator(key, val, cond) {
-    const aKey = this._anonimizeKeyValue(key);
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `${keyName} ${cond} ${aKey}`, values: [val], appendKeys: [aKey],
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendBetween(key, val1, val2) {
-    const aKey = this._anonimizeKeyValue(key);
-    const aKey2 = this._anonimizeKeyValue(key);
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `(${keyName} BETWEEN ${aKey} AND ${aKey2})`, values: [val1, val2], appendKeys: [aKey, aKey2],
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendBeginsWith(key, val) {
-    const aKey = this._anonimizeKeyValue(key);
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `begins_with(${keyName}, ${aKey})`, values: [val], appendKeys: [aKey],
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendAttributeType(key, val) {
-    const aKey = this._anonimizeKeyValue(key);
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `attribute_type(${keyName}, ${aKey})`, values: [val], appendKeys: [aKey],
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendContains(key, val) {
-    const aKey = this._anonimizeKeyValue(key);
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `contains(${keyName}, ${aKey})`, values: [val], appendKeys: [aKey],
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendExists(key) {
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `attribute_exists(${keyName})`, anonimizedNames: { [keyName]: key } });
-  }
-  appendNotExists(key) {
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `attribute_not_exists(${keyName})`, anonimizedNames: { [keyName]: key } });
-  }
-  appendIN(key, values) {
-    let aKeys = values.map((val)=>this._anonimizeKeyValue(val));
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `(${keyName} IN (${aKeys.toString()}))`, values: values, appendKeys: aKeys,
-                      anonimizedNames: { [keyName]: key }});
-  }
-  appendNotIN(key, values) {
-    let aKeys = values.map((val)=>this._anonimizeKeyValue(val));
-    const keyName = this._anonimizeKeyName(key);
-    this.values.push({exp: `NOT (${keyName} IN (${aKeys.toString()}))`, values: values, appendKeys: aKeys,
-                      anonimizedNames: { [keyName]: key }});
-  }
-  _anonimizeKeyValue(_key) {
-    this.counter++;
-    return (':' + _key.replace(/[:-]/g, '') + this.counter);
-  }
-  _anonimizeKeyName(_key) {
-    this.counter++;
-    return ('#' + _key.replace(/[:-]/g, '') + this.counter);
-  }
-  //Groups
-  startGroupping() { this.values.push({startGroupping: true}); }
-  endGroupping() { this.values.push({endGroupping: true}); }
-  addSeparator(val) { this.values.push({exp: ` ${val} `}); }
-  //Builds items and exp (if set)
-  buildExpression() {
-    const exp = this.__buildExpressionOnQuery();
-    // if (exp && Object.keys(exp).length > 0) console.debug('Building query expression..', exp);
-    return exp;
-  }
-  __buildExpressionOnQuery() {
-    let expression = {};
-    if (this.values.length > 0) {
-      //Check required values
-      if (!expression.items) expression.items = {};
-      if (!expression.names) expression.names = {};
-      //build conditional expression
-      let condition = '';
-      let groupping = false;
-      let keyCount = 0;
-      for (let addObj of this.values) {
-        if (condition != '' && !groupping) condition += ` ${this.operator} `;
-        //Check for include types
-        if (addObj.startGroupping) {
-          condition += `(`;
-          groupping = true;
-        } else if (addObj.endGroupping) {
-          condition += `)`;
-          groupping = false;
-        } else if (addObj.values) { //multi value expressions
-          condition += `${addObj.exp}`;
-          let i = 0;
-          for (let val of addObj.values) {
-            expression.items[`${addObj.appendKeys[i]}`] = Utils.encapsulateForDB(val);
-            i++;
-          }
-        } else if (addObj.exp) { //pure expressions
-          condition += `${addObj.exp}`;
-        }
-        //Check for key anonimization
-        if (addObj.anonimizedNames) {
-          for (let aKeyName of Object.keys(addObj.anonimizedNames)) {
-            expression.names[aKeyName] = addObj.anonimizedNames[aKeyName];
-          }
-        }
-      } expression.exp = condition;
-    } return expression;
-  }
-}
-//
-export const IKDBExpressionOperator = {
-  EQUAL: '=',
-  NOT_EQUAL: '<>',
-  LESS_THAN: '<',
-  LESS_EQUAL_THAN: '<=',
-  GREATER_THAN: '>',
-  GREATER_EQUAL_THAN: '>=',
-  GREATE_EQUAL_THAN: '>=', //typo compatiblity :/ 
-  NOT: 'NOT',
-  AND: 'AND',
-  OR: 'OR'
-};