@ikonintegration/ikapi 4.0.1 → 5.0.0

package/src/Database/DDB/IKDBQueryUpdate.js

@@ -1,221 +0,0 @@
-import IKDBBaseQuery from './IKDBBaseQuery.js';
-import Utils from './../../API/IKUtils.js';
-//
-export default class IKDBQueryUpdate extends IKDBBaseQuery {
-  constructor(indexName) {
-    super(indexName)
-    this.setValues = {};
-    this.removeValues = [];
-    this.incrementValues = {};
-    this.decrementValues = {};
-  }
-  /*public methods*/
-  appendDefaultTrail(userID) {
-    this.appendValue(userID, 'updatedBy');
-    this.appendValue(Date.now(), 'updatedOn');
-  }
-  //return if the value was appended or not
-  appendValue(val, key, prefix) {
-    //check if value is valid
-    if (val != undefined &&
-       ((Object.keys(val).length > 0) ||
-        (!isNaN(val) && val.length != 0) ||
-        (val.length > 0))) {
-      //Check for object conversion
-      val = (prefix != undefined && val.indexOf(prefix) != 0 ? prefix + val : val);
-      //valid
-      this.setValues[key] = val;
-      // console.debug(`Append ${key}@${val}`);
-      return true;
-    } 
-    //remove
-    this.removeValues.push(key);
-    return false;
-  }
-  //return if the value was appended or not
-  incrementValue(val, key, prefix) {
-    //check if value is valid
-    if (val != undefined &&
-      ((Object.keys(val).length > 0) ||
-        (!isNaN(val) && val.length != 0) ||
-        (val.length > 0))) {
-      //Check for object conversion
-      val = (prefix != undefined && val.indexOf(prefix) != 0 ? prefix + val : val);
-      //valid
-      this.incrementValues[key] = val;
-      // console.debug(`Increment ${key}@${val}`);
-      return true;
-    } return false;
-  }
-  //return if the value was appended or not
-  decrementValue(val, key, prefix) {
-    //check if value is valid
-    if (val != undefined &&
-      ((Object.keys(val).length > 0) ||
-        (!isNaN(val) && val.length != 0) ||
-        (val.length > 0))) {
-      //Check for object conversion
-      val = (prefix != undefined && val.indexOf(prefix) != 0 ? prefix + val : val);
-      //valid
-      this.decrementValues[key] = val;
-      // console.debug(`Decrement ${key}@${val}`);
-      return true;
-    } return false;
-  }
-  //dbKey and prefix are optional values
-  appendObjectForKeyValue(source, key, dbKey, prefix) {
-    //Check for optional db key that can differ from input key
-    if (dbKey == undefined || dbKey == null) dbKey = key;
-    //Check if valid, if yes, add, if not, remove
-    if (source[key] != undefined &&
-       ((Object.keys(source[key]).length > 0) ||
-        (!isNaN(source[key]) && source[key].length != 0) ||
-        (source[key].length > 0))) {
-          //Check for object conversion
-          let val = (prefix != undefined && source[key].indexOf(prefix) != 0 ?
-                     prefix + source[key] : source[key]);
-          //valid
-          if (val != undefined) { this.setValues[dbKey]= val; }
-          // console.debug(`Append-ofk ${dbKey}@${val}`);
-      //remove
-    } else this.removeValues.push(dbKey);
-  }
-  //
-  async run(dbManager) {
-    const localConsole = (dbManager.transaction ? dbManager.transaction.logger : console);
-    const resp = await this.rawRun(dbManager);
-    if (resp.Attributes) {
-      const unmarshalled = Utils.decapsulateForDB((Array.isArray(resp.Attributes) ? resp.Attributes : [resp.Attributes]));
-      localConsole.debug('Parsed result: ', unmarshalled);
-      return unmarshalled;
-    } return false;
-  }
-  async rawRun(dbManager) {
-    const localConsole = (dbManager.transaction ? dbManager.transaction.logger : console);
-    let query = this._rawQuery(dbManager.tableName);
-    localConsole.log("Updating item: ", query);
-    let resp = await dbManager.connection.updateItem(query);
-    // localConsole.debug('Raw result: ', resp);
-    this._incrementTrackerStats(resp, dbManager);
-    return resp;
-  }
-
-  /*private methods*/
-  _rawQuery(dbTableName, isTransaction) {
-    return this._buildUpdateQuery(
-            { ...super._rawQuery(dbTableName, isTransaction),
-              ...(isTransaction ? {} : {ReturnValues: "ALL_OLD" /*request all updated values*/ })});
-  }
-  //Builds UpdateExpression
-  _buildUpdateQuery(expression) {
-    // console.debug('Building update query..');
-    //Update ops
-    expression = this.__buildUpdateItems(expression);
-    //Increment ops
-    expression = this.__buildIncrementItems(expression);
-    //Decrement ops
-    expression = this.__buildDecrementItems(expression);
-    //REMOVE ops
-    expression = this.__buildRemoveItems(expression);
-    return expression;
-  }
-  __buildUpdateItems(expression) {
-    if (Object.keys(this.setValues).length > 0) {
-      //check required values
-      if (!expression.UpdateExpression) expression.UpdateExpression = " SET ";
-      else expression.UpdateExpression += " SET ";
-      if (!expression.ExpressionAttributeValues) expression.ExpressionAttributeValues = {};
-      if (!expression.ExpressionAttributeNames) expression.ExpressionAttributeNames = {};
-      //build update expression
-      for (let dbKey of Object.keys(this.setValues)) {
-        let appendingKey = (':' + dbKey);
-        let appendingValueKey = ('#' + dbKey );
-        let val = this.setValues[dbKey];
-        if (val != undefined) {
-          let last = Object.keys(this.setValues).indexOf(dbKey) == (Object.keys(this.setValues).length - 1);
-          //last or first
-          if (last) expression.UpdateExpression += appendingValueKey + ' =' + appendingKey;
-          else expression.UpdateExpression += appendingValueKey + ' =' + appendingKey + ', ';
-          //
-          expression.ExpressionAttributeValues[appendingKey] = Utils.encapsulateForDB(val);
-          expression.ExpressionAttributeNames[appendingValueKey] = dbKey;
-        }
-      }
-    } return expression;
-  }
-  __buildIncrementItems(expression) {
-    if (Object.keys(this.incrementValues).length > 0) {
-      //check required values
-      if (!expression.UpdateExpression) expression.UpdateExpression = " SET ";
-      else if (expression.UpdateExpression.indexOf(' SET ') == -1) expression.UpdateExpression += " SET ";
-      else expression.UpdateExpression += ', ';
-      //
-      if (!expression.ExpressionAttributeValues) expression.ExpressionAttributeValues = {};
-      if (!expression.ExpressionAttributeNames) expression.ExpressionAttributeNames = {};
-      //build update expression
-      for (let dbKey of Object.keys(this.incrementValues)) {
-        let initialKey = ':initial';
-        let appendingKey = (':' + dbKey);
-        let appendingValueKey = ('#' + dbKey);
-        let val = this.incrementValues[dbKey];
-        if (val != undefined) {
-          let last = Object.keys(this.incrementValues).indexOf(dbKey) == (Object.keys(this.incrementValues).length - 1);
-          //last
-          if (last) expression.UpdateExpression += appendingValueKey + ` = if_not_exists(${appendingValueKey}, :initial) + ${appendingKey}`;
-          else expression.UpdateExpression += appendingValueKey + ` = if_not_exists(${appendingValueKey}, :initial) + ${appendingKey}` + ', ';
-          //
-          expression.ExpressionAttributeValues[appendingKey] = Utils.encapsulateForDB(val);
-          expression.ExpressionAttributeValues[initialKey] = Utils.encapsulateForDB(0);
-          expression.ExpressionAttributeNames[appendingValueKey] = dbKey;
-        }
-      }
-    } return expression;
-  }
-  __buildDecrementItems(expression) {
-    if (Object.keys(this.decrementValues).length > 0) {
-      //check required values
-      if (!expression.UpdateExpression) expression.UpdateExpression = " SET ";
-      else if (expression.UpdateExpression.indexOf(' SET ') == -1) expression.UpdateExpression += " SET ";
-      else expression.UpdateExpression += ', ';
-      //
-      if (!expression.ExpressionAttributeValues) expression.ExpressionAttributeValues = {};
-      if (!expression.ExpressionAttributeNames) expression.ExpressionAttributeNames = {};
-      //build update expression
-      for (let dbKey of Object.keys(this.decrementValues)) {
-        let appendingKey = (':' + dbKey);
-        let appendingValueKey = ('#' + dbKey);
-        let val = this.decrementValues[dbKey];
-        if (val != undefined) {
-          let last = Object.keys(this.decrementValues).indexOf(dbKey) == (Object.keys(this.decrementValues).length - 1);
-          //last
-          if (last) expression.UpdateExpression += appendingValueKey + ' =' + appendingValueKey + '-' + appendingKey;
-          else expression.UpdateExpression += appendingValueKey + ' =' + appendingValueKey + '-' + appendingKey + ', ';
-          //
-          expression.ExpressionAttributeValues[appendingKey] = Utils.encapsulateForDB(val);
-          expression.ExpressionAttributeNames[appendingValueKey] = dbKey;
-        }
-      }
-    } return expression;
-  }
-  __buildRemoveItems(expression) {
-    if (this.removeValues != undefined && this.removeValues.length > 0) {
-      //Check for requirements
-      if (!expression.UpdateExpression) expression.UpdateExpression = " REMOVE ";
-      else expression.UpdateExpression += " REMOVE ";
-      //build delete expression
-      for (let dbKey of this.removeValues) {
-        let appendingValueKey = ('#' + dbKey );
-        let last = this.removeValues.indexOf(dbKey) == (this.removeValues.length - 1);
-        //first or last
-        if (last) expression.UpdateExpression += appendingValueKey;
-        else expression.UpdateExpression += appendingValueKey + ', ';
-        //
-        expression.ExpressionAttributeNames[appendingValueKey] = dbKey;
-      }
-    } return expression;
-  }
-  /* tracker support */
-  _incrementTrackerStats(resp, dbManager) {
-    if (resp && resp.ConsumedCapacity && resp.ConsumedCapacity.CapacityUnits) dbManager.stats.writeUnits += parseFloat(resp.ConsumedCapacity.CapacityUnits);
-  }
-}

package/src/Database/DDB/_IKDBQueryTransactionalRead.js

@@ -1,46 +0,0 @@
-import IKDBQuery from './IKDBQuery.js';
-import { convertToAttr, marshall, unmarshall } from "@aws-sdk/util-dynamodb";
-//
-export default class IKDBQueryPut extends IKDBQuery {
-  constructor() {
-    super();
-    this.putItems = {};
-  }
-  /*public methods*/
-  //return if the value was appended or not
-  appendValue(source, key, isObject) {
-    //check for optional value
-    if (isObject == undefined) isObject = false;
-    //check if value is valid
-    if (source[key] != undefined &&
-       ((Object.keys(source[key]).length > 0) ||
-        (!isNaN(source[key]) && source[key].length != 0) ||
-        (source[key].length > 0))) {
-      //Check for object conversion
-      let val;
-      if (isObject) val = {"M": marshall(source[key], {removeUndefinedValues: true, convertClassInstanceToMap: true })};
-      else val = convertToAttr(source[key], {removeUndefinedValues: true, convertClassInstanceToMap: true });
-      //valid
-      if (val != undefined) { this.putItems[key]= val; }
-      // console.debug("Apppending key:", key, " val:", val);
-      return true;
-    } return false;
-  }
-  setItems(items) { this.putItems = items; }
-  async run(dbManager) {
-    const localConsole = (dbManager.transaction ? dbManager.transaction.logger : console);
-    const query = this.__rawQuery(dbManager.tableName);
-    localConsole.log('Putting item: ', query);
-    const resp = await dbManager.connection.putItem(query);
-    // localConsole.log('Raw result: ', resp);
-    const unmarshalled = resp.Items.map(unmarshall);
-    localConsole.log('Parsed result: ', unmarshalled);
-    return unmarshalled;
-  }
-
-  /*private methods*/
-  __rawQuery(dbTableName) {
-    return { ...this._rawQuery(dbTableName),
-             Item: this.putItems, ReturnValues: "ALL_NEW" /*request new values added*/ };
-  }
-}

package/src/Database/PSQL/IKDB.js

@@ -1,41 +0,0 @@
-import PG from 'pg';
-//
-import IKDB from './../Prototype/IKDB.js';
-const { Client  } = PG;
-//
-export default class IKDB_PSQL extends IKDB {
-  constructor(config, transaction) {
-    super(config, transaction)
-    const localConsole = (transaction ? transaction.logger : console);
-    if (config && config.database) { localConsole.debug(`Using database: ${config.database} with config: ${config}`); }
-    this.database = config.database;
-    this.connection = null;
-  }
-  //Overwrites
-  async connect() { return await (await this._getConnection()).connect(); }
-  async cleanup() { return await (await this._getConnection()).end(); }
-  async beginTransaction() { return await (await this._getConnection()).query('START TRANSACTION'); }
-  async commit() { return await (await this._getConnection()).query('COMMIT'); }
-  async rollback() { return await (await this._getConnection()).query('ROLLBACK'); }
-  async runQuery(qry) { return await qry.run(await this._getConnection()); }
-  //tracker support
-  getTrackerStats() { return null; }
-  //Public 
-  async sanitize(val) { return val; }
-
-  /* private */
-  async _getConnection() {
-    if (!this.PSQL_CONN) this.PSQL_CONN = await this._newConnection(this.config);
-    return this.PSQL_CONN;
-  }
-  _newConnection(config) {
-    return new Promise((resolve, reject) => {
-      const conn = new Client({
-        host: config.host, database: config.database,
-        port: config.port, user: config.user,
-        password: config.password, max: 20
-      });
-      resolve(conn);
-    });
-  }
-}

package/src/Database/PSQL/IKDBBaseQuery.js

@@ -1,26 +0,0 @@
-import IKDBBaseQuery from './../Prototype/IKDBBaseQuery.js';
-//
-export default class IKDBPSQLBaseQuery extends IKDBBaseQuery {
-  constructor(query, params) {
-    super();
-    this.query = query;
-    this.params = params;
-  }
-  async run(connection) {
-    try {
-      const resp = await this.rawRun(this.query, this.params, connection);
-      return {error: null, data: resp};
-    } catch (e) {
-      const localConsole = (connection.transaction ? connection.transaction.logger : console);
-      localConsole.error('Query Error:',e);
-      return {error: e.toString().replace('Error:','').replace('Error:',''), data: []};
-    }
-  }
-  async rawRun(query, params, connection) {
-    const localConsole = (connection.transaction ? connection.transaction.logger : console);
-    localConsole.debug('Querying: ', query, params);
-    const resp = await connection.query(query, params)
-    // console.debug('Raw result: ', resp);
-    return resp;
-  }
-}

package/src/Database/Prototype/IKDB.js

@@ -1,21 +0,0 @@
-export default class IKDB {
-  constructor(config, transaction) {
-    this.config = config;
-    this.transaction = transaction;
-    this.connection = null;
-  }
-
-  async connect() { }
-
-  //Transaction support
-  beginTransaction() {  }
-  commit() { }
-  rollback() { }
-  cleanup() { }
-
-  //main interface
-  async runQuery(qry) { return await qry.run(this); }
-
-  //tracker support
-  getTrackerStats() { return null; }
-}

package/src/Database/Prototype/IKDBBaseQuery.js

@@ -1,14 +0,0 @@
-import Utils from "./../../API/IKUtils.js";
-//
-export default class IKDBBaseQuery {
-  constructor() {}
-  //Utils
-  newUID() { return Utils.newUID(); }
-
-  //Inheritance support
-  _rawQuery() { return { }; }
-  async run(dbManager) { 
-    const localConsole = (dbManager.transaction ? dbManager.transaction.logger : console);
-    localConsole.error("Run query is not implemented on base classes. Skipping it.");
-  }
-}

package/src/IKDynamoStream.js

@@ -1,42 +0,0 @@
-import IKTransaction from './BaseEvent/IKTransaction.js';
-import IKResponse, { IKBadRequestResponse, IKSuccessResponse } from './API/IKResponse.js';
-import IKGlobals from './IKGlobals.js';
-import Utils from "./API/IKUtils.js";
-//
-export default class IKDynamoStream {
-  constructor(event, context, config) {
-    this.event = event;
-    this.context = context;
-    this.apiConfig = config;
-  }
-  async processEvent(execution) {
-    const resp = await this._processRawEvent(execution);
-    if (resp && resp.getCode() != 200) throw new Error(JSON.stringify(resp.body));
-    else if (resp) return resp;
-  }
-  async _processRawEvent(execution) {
-    if (this.event.Records && this.event.Records.length > 0) { //safe check for empty events?
-      //init transaction for all records
-      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*batch processing*/)).execute(async (transaction) => {
-        //for each available event
-        for (let eventRecord of this.event.Records) {
-          //Prepare parsed record
-          const parsedRecord = {
-            ...eventRecord,
-            ...(eventRecord.dynamodb.Keys ? {Keys: Utils.decapsulateForDB(eventRecord.dynamodb.Keys)} : {}),
-            ...(eventRecord.dynamodb.OldImage ? {OldImage: Utils.decapsulateForDB(eventRecord.dynamodb.OldImage)} : {}),
-            ...(eventRecord.dynamodb.NewImage ? {NewImage: Utils.decapsulateForDB(eventRecord.dynamodb.NewImage)} : {}),
-            //...(eventRecord.OldImage ? Utils.decapsulateForDB(eventRecord.OldImage) : {}),
-          };
-          //Call execution
-          let resp = await execution(transaction, parsedRecord);
-          if (resp.getCode() != 200 && resp.getCode() != 204) { //if execution failed, respond and mark as answered
-            return resp;
-          }
-        }
-        //not errored and loop ended - succeeded
-        return IKSuccessResponse();
-      });
-    } else return IKBadRequestResponse(IKGlobals.ErrorResponseNoRecords, IKGlobals.ErrorCode_NoRecords); //no event to be processed?
-  }
-}

package/src/IKEventProcessor.js

@@ -1,42 +0,0 @@
-import IKTransaction from './BaseEvent/IKTransaction.js';
-import IKResponse, { IKBadRequestResponse, IKSuccessResponse } from './API/IKResponse.js';
-import IKGlobals from './IKGlobals.js';
-//
-export default class IKEventProcessor {
-  constructor(event, context, config, respondWithFailures) {
-    this.event = event;
-    this.context = context;
-    this.apiConfig = config;
-    this._respondWithFailures = respondWithFailures;
-  }
-  async processEvent(execution, doNotDecodeMessage) {
-    const resp = await this._processRawEvent(execution, doNotDecodeMessage);
-    if (!this._respondWithFailures && resp && !(resp.getCode() >= 200 && resp.getCode() < 300)) throw new Error(JSON.stringify(resp.getBody()));
-    else if (resp) return resp;
-  }
-  async _processRawEvent(execution, doNotDecodeMessage) {
-    if (this.event.Records && this.event.Records.length > 0) { //safe check for empty events?
-      //init transaction for all records
-      return await (new IKTransaction(this.event, this.context, this.apiConfig, true /*batch processing*/)).execute(async (transaction) => {
-        //Map records with decoded message when required
-        const decodedRecords = this.event.Records.map((eventRecord) => (doNotDecodeMessage ? eventRecord.body : JSON.parse(eventRecord.body)));
-        
-        //for each available event
-        const failureIDs = [];
-        for (let eventRecord of decodedRecords) {
-          //Call execution
-          let resp = await execution(transaction, eventRecord);
-          //check for failure
-          if (!(resp.getCode() >= 200 && resp.getCode() < 300)) {
-            //response with failures or fail hard at first
-            if (this._respondWithFailures) failureIDs.push(eventRecord.messageId);
-            else return resp;
-          }
-        }
-        //not errored and loop ended - succeeded (might have failures)
-        if (this._respondWithFailures) return { batchItemFailures: failureIDs.map((id) => ({ itemIdentifier: id })) };
-        return IKSuccessResponse();
-      });
-    } else return IKBadRequestResponse(IKGlobals.ErrorResponseNoRecords, IKGlobals.ErrorCode_NoRecords); //no event to be processed?
-  }
-}

package/src/IKGlobals.js

@@ -1,24 +0,0 @@
-export default class IKGlobals {}
-IKGlobals.DBDrivers = {
-  DynamoDB: 'DDB',
-  PSQL: 'PSQL'
-};
-IKGlobals.CacheDrivers = {
-  REDIS: 'REDIS'
-};
-//DDB Client 
-IKGlobals.DDBHttpTimeout = 15000;
-IKGlobals.DDBMaxAttempts = 3;
-//Error messages
-IKGlobals.ErrorResponseValidationFail = 'Input validation failed: '; //400
-IKGlobals.ErrorResponseInvalidServerResponse = 'No valid response, this is a system error.'; //400
-IKGlobals.ErrorResponseUnhandledError = 'Unhandled error when processing request.'; //400
-IKGlobals.ErrorResponseNoRecords = 'No events to be processed.'; //400
-//Development Configs
-IKGlobals.DynamoDBLocalConfig = {region: "localhost", endpoint: "http://localhost:8000", accessKeyId: 'DEFAULT_ACCESS_KEY', secretAccessKey: 'DEFAULT_SECRET'};
-
-//Error Codes
-IKGlobals.ErrorCode_MissingParam = 'MISSING_PARAM';
-IKGlobals.ErrorCode_InvalidInput = 'INVALID_INPUT';
-IKGlobals.ErrorCode_APIError = 'API_ERROR';
-IKGlobals.ErrorCode_NoRecords = 'EMPTY_EVENT';

package/src/IKRouter.js

@@ -1,47 +0,0 @@
-//Components
-import IKTransaction from './BaseEvent/IKTransaction.js';
-import IKResponse, { IKBadRequestResponse } from './API/IKResponse.js';
-//
-import { pathToRegexp } from 'path-to-regexp';
-//
-export default class IKRouter {
-  constructor(routes, config) {
-    this.routes = routes;
-    this.config = config;
-  }
-
-  //Main handler
-  async handleEvent(event, context) {
-    //init transaction
-    await (new IKTransaction(event, context, this.config)).execute(async transaction => {
-      //get path and tries to match an defined route with existing request
-      const path = transaction.request.getPath();
-      for (let route of this.routes) {
-        //Check for possible paths
-        const resp = this._routeMatches(route.route, route.method, transaction, route.handler);
-        if (resp) {
-          transaction.logger.log("Router accepted route:", route)
-          return await resp(transaction);
-        }
-      }
-      //No route found :/
-      return new IKResponse(404, {err: 'Route not found!'});
-    });
-  }
-  //Helper function to match route and return handler if matches
-  _routeMatches(exp, method, transaction, handler) {
-    const path = transaction.request.getPath();
-    let keys = [];
-    const result = pathToRegexp(exp, keys).exec(path);
-    if (result) {
-      const reqMethod = transaction.request.getMethod();
-      if (reqMethod.toLowerCase() == method.toLowerCase()) {
-        //Fix path params on proxy
-        transaction.request.requestEvent.pathParameters = {};
-        keys.forEach((key, index) => transaction.request.requestEvent.pathParameters[key.name] = result[index + 1]);
-        //
-        return handler;
-      }
-    }
-  }
-}

package/src/IKStepTransaction.js

@@ -1,14 +0,0 @@
-//
-import IKTransaction from './BaseEvent/IKTransaction.js';
-import { IKStepFunctionResponse } from './API/IKResponse.js';
-//
-export default class IKStepTransaction extends IKTransaction {
-  constructor(event, context, config) {
-    super(event, context, config, false, true /* retrowErrors */);
-  }
-  /* Response support */
-  _getErrorResponse(error, code) {
-    return IKStepFunctionResponse({ err: error, errCode: code }, 400);
-  }
-}
-