Function logWarnings has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  async logWarnings(results) {
    const warningResults = await this.run('SHOW WARNINGS');
    const warningMessage = `MySQL Warnings (${this.connection.uuid || 'default'}): `;
    const messages = [];
    for (const _warningRow of warningResults) {

• Read up
  Read up

Function _checkValidJsonStatement has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  _checkValidJsonStatement(stmt) {
    if (typeof stmt !== 'string') {
      return false;
    }

• Read up
  Read up

Function delete has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  async delete(instance, tableName, identifier, options) {
    const cascades = [];
    const sql = this.queryGenerator.deleteQuery(tableName, identifier, {}, instance.constructor);

    options = { ...options };

• Read up
  Read up

Function rawSelect has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  async rawSelect(tableName, options, attributeSelector, Model) {
    options = Utils.cloneDeep(options);
    options = _.defaults(options, {
      raw: true,
      plain: true,

• Read up
  Read up

Function formatError has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  formatError(err) {
    switch (err.code) {
      case 'SQLITE_CONSTRAINT': {
        if (err.message.includes('FOREIGN KEY constraint failed')) {
          return new sequelizeErrors.ForeignKeyConstraintError({

• Read up
  Read up

Function _paranoidClause has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

  static _paranoidClause(model, options = {}) {
    // Apply on each include
    // This should be handled before handling where conditions because of logic with returns
    // otherwise this code will never run on includes of a already conditionable where
    if (options.include) {

• Read up
  Read up

Function getQueryOrders has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  getQueryOrders(options, model, subQuery) {
    const mainQueryOrder = [];
    const subQueryOrder = [];

    if (Array.isArray(options.order)) {

Function _conformInclude has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  static _conformInclude(include, self) {
    if (include) {
      let model;

      if (include._pseudo) return include;

Function _checkValidJsonStatement has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  _checkValidJsonStatement(stmt) {
    if (typeof stmt !== 'string') {
      return false;
    }

Function parseConstraintsFromSql has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  parseConstraintsFromSql(sql) {
    let constraints = sql.split('CONSTRAINT ');
    let referenceTableName, referenceTableKeys, updateAction, deleteAction;
    constraints.splice(0, 1);
    constraints = constraints.map(constraintSql => {

Function includeAttributes has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      const includeAttributes = include.attributes.map(attr => {
        let attrAs = attr;
        let verbatim = false;

        if (Array.isArray(attr) && attr.length === 2) {

Function dropSchema has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  dropSchema(schema) {
    // Mimics Postgres CASCADE, will drop objects belonging to the schema
    const quotedSchema = wrapSingleQuote(schema);
    return [
      'IF EXISTS (SELECT schema_name',

Function describeTableQuery has 36 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  describeTableQuery(tableName, schema) {
    let sql = [
      'SELECT',
      "c.COLUMN_NAME AS 'Name',",
      "c.DATA_TYPE AS 'Type',",

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

Open

  log(...args) {
    let options;

    const last = _.last(args);

• Read up
  Read up

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

Open

  handleSequelizeMethod(smth, tableName, factory, options, prepend) {
    if (smth instanceof Utils.Json) {
      // Parse nested object
      if (smth.conditions) {
        const conditions = this.parseConditionObject(smth.conditions).map(

• Read up
  Read up

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

Open

  getUniqueConstraintErrorMessage(field) {
    let message = field ? `${field} must be unique` : 'Must be unique';

    if (field && this.model) {
      for (const key of Object.keys(this.model.uniqueKeys)) {

• Read up
  Read up

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

Open

function stringify(data) {
  if (data === null) return null;

  if (!Array.isArray(data)) throw new Error('range must be an array');
  if (!data.length) return 'empty';

• Read up
  Read up

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

Open

  validate(value, field, options) {
    if (this.typeValidation && field.type.validate && value) {
      try {
        if (options.isList && Array.isArray(value)) {
          for (const item of value) {

• Read up
  Read up

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

Open

  updateQuery(tableName, attrValueHash, where, options, attributes) {
    options = options || {};
    _.defaults(options, this.options);

    attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, options.omitNull, options);

• Read up
  Read up

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

Open

  static async upsert(values, options) {
    options = {
      hooks: true,
      returning: true,
      validate: true,

• Read up
  Read up