Function findAll has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.

Open

function findAll(conditions: Condition | String = 'all', returnFields=[]) {
  /* return all objects that meet the conditions 
    conditions is single object with property where whose value is further
    an object with key => value pair of the properties of the object to find
  */

• Read up
  Read up

Function checkDatatype has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.

Open

  checkDatatype: (schema: object, modelToCreate: object) => {
    // Return datatype fields that fail validation and a message
    const allowedFields = Object.keys(schema);
    let datatypeValidationMessage = '';
    const datatypeField = allowedFields.find(field => {

• Read up
  Read up

Function update has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

function update(propsToUpdate: any, conditions: Condition, returnFields=[]) {
  /* 
    propsToUpdate contain the new properties to replace the old ones
    this method should be called on the particular object to update.
    which means that before call update you must use the finder methods to 

• Read up
  Read up

File functs.ts has 322 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import { Condition, IMapping } from '../interfaces';

const functObj = {
  confirmPropMatch: (model: IMapping, conditions: Condition) => {
    const whereConditions: IMapping = conditions.where;

Function create has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.

Open

function create(modelToCreate: object, returnFields=[]) {
  const result = new Promise((resolve, reject) => {
    if (!modelToCreate)
      reject({ message: 'Expected an object to create at position 1' });

• Read up
  Read up

Function bulkCreate has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

function bulkCreate(modelsToCreate: any, returnFields: Array<any>=[]) {
  // create a new model
  let createdModels: Array<object> = [];
  const failingObj: Array<object> = [];
  const useDB = this.using_db;

• Read up
  Read up

Function updateQuery has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

function updateQuery(modelName: string, conditions: Condition, newProps: object, returnFields: Array<any>=[]) {
  if (typeof newProps !== 'object' || typeof conditions !== 'object') {
    return { message: 'type error! expecting an object' };
  }

• Read up
  Read up

Function createModel has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

function createModel(modelToCreate: any, returnFields: Array<any>, resolve: Function, reject: Function) {
  const singleModel = this.singleModel;
  const uniqueKeys = this.uniqueKeys;
  const schema = this.schema;
  const model = this.model;

• Read up
  Read up

Function getQuery has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

function getQuery(modelName: string, conditions: Condition | any, returnFields: Array<any>=[]) {
  const typeOfCondition = (typeof conditions);
  const { schema } = this;
  if (typeOfCondition !== 'string' && typeOfCondition !== 'object' && typeOfCondition !== 'number') {
    return { message: 'type error!' };

• Read up
  Read up

Function DataModela has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

var DataModela = /** @class */ (function () {
    function DataModela(modelName, schema, options) {
        var _this = this;
        if (schema === void 0) { schema = {}; }
        this.allowedFields = [];

• Read up
  Read up

Function confirmPropMatch has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

  confirmPropMatch: (model: IMapping, conditions: Condition) => {
    const whereConditions: IMapping = conditions.where;
    const groupConditions = conditions.groups ? conditions.groups : null;
    const props = Object.keys(whereConditions);
    const matchType = conditions.type ? conditions.type : 'and';

• Read up
  Read up

Function findById has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

function findById(id: number | string, returnFields=[]) {
  const result = new Promise((resolve, reject) => {
    if (!id) reject({ message: 'Expected argument 1 to be id of model to search' });
    if (!Array.isArray(returnFields))
      reject({ message: 'Expected an array of fields to return' });

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              if (field === 'createdAt' || field === 'updatedAt') {
                // This field will be supplied at creation time if not provided
                return false;
              }

Consider simplifying this complex logical expression.

Open

    if ((!checkAll && !checkObjType) ||
       (!checkAll && !checkWhere) ||
       (checkWhere && !checkWhereKeys)) {
        if (checkLimit) {
          // pass if limit is provided

Function createModelWithDB has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

function createModelWithDB(this: any, 
  modelToCreate: any,
  returnFields: Array<any>,
  resolve: Function,
  reject: Function

Function find has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

function find(condition: Condition, returnFields=[]) {
  /* return a single object that meet the condition
    condition is single object with property where whose value is further
    an object with key => value pair of the properties of the object to find
  */

• Read up
  Read up

Avoid too many return statements within this function.

Open

          return true;

Avoid too many return statements within this function.

Open

        return false

Avoid too many return statements within this function.

Open

              return true;

Avoid too many return statements within this function.

Open

          return false;