mythix-orm 1.11.3 → 1.11.5

package/lib/connection/connection-base.js

@@ -229,7 +229,7 @@ class ConnectionBase extends EventEmitter {
     }, _options || {});
 
     if (!options.queryGenerator)
-      options.queryGenerator = new QueryGeneratorBase(this);
+      options.queryGenerator = this.createQueryGenerator(options);
 
     Object.defineProperties(this, {
       'dialect': {
@@ -270,6 +270,26 @@ class ConnectionBase extends EventEmitter {
     this.registerModels(options.models);
   }
 
+  /// This method will create the default query generator
+
+  // eslint-disable-next-line no-unused-vars
+  createQueryGenerator(options) {
+    if (this.constructor.DefaultQueryGenerator)
+      return new this.constructor.DefaultQueryGenerator(this);
+
+    return new QueryGeneratorBase(this);
+  }
+
+  stackAssign(obj, ..._args) {
+    let newObj = Object.create(obj || {});
+    let args = _args.filter(Boolean);
+
+    if (args.length > 0)
+      Object.assign(newObj, ...args);
+
+    return newObj;
+  }
+
   /// This method is an internal method that parses
   /// the "lock mode" options passed to a call to
   /// <see>Connection.transaction</see>.

package/lib/connection/literals/average-literal.js

@@ -3,6 +3,10 @@
 const LiteralFieldBase = require('./literal-field-base');
 
 class AverageLiteral extends LiteralFieldBase {
+  static isAggregate() {
+    return true;
+  }
+
   toString(connection, options) {
     if (!connection)
       return `${this.constructor.name} {}`;

package/lib/connection/literals/count-literal.js

@@ -7,6 +7,10 @@ class CountLiteral extends LiteralFieldBase {
     return false;
   }
 
+  static isAggregate() {
+    return true;
+  }
+
   toString(connection, options) {
     if (!connection)
       return `${this.constructor.name} {}`;

package/lib/connection/literals/literal-base.js

@@ -43,6 +43,14 @@ class LiteralBase {
     return (this.isLiteral(value) && value.constructor && value.constructor.name === this.name);
   }
 
+  static isAggregate() {
+    return false;
+  }
+
+  isAggregate() {
+    return this.constructor.isAggregate();
+  }
+
   constructor(literal, options) {
     Object.defineProperties(this, {
       'literal': {
@@ -87,6 +95,9 @@ class LiteralBase {
     if (LiteralBase.isLiteral(definition))
       return definition;
 
+    if (!definition.fieldNames)
+      return definition;
+
     let field = connection.getField(definition.fieldNames[0], definition.modelName);
     if (!field) {
       if (definition.fieldNames[0] && definition.modelName) {
@@ -109,6 +120,10 @@ class LiteralBase {
   toString() {
     return this.literal;
   }
+
+  valueOf() {
+    return this.literal;
+  }
 }
 
 module.exports = LiteralBase;

package/lib/connection/literals/literal-field-base.js

@@ -20,6 +20,8 @@ class LiteralFieldBase extends LiteralBase {
       } catch (error) {
         if (isRequired)
           throw error;
+
+        definition = fullyQualifiedName;
       }
     }
 
@@ -47,6 +49,10 @@ class LiteralFieldBase extends LiteralBase {
 
     return this.definitionToField(connection, this.definition);
   }
+
+  valueOf() {
+    return this.definition;
+  }
 }
 
 module.exports = LiteralFieldBase;

package/lib/connection/literals/max-literal.js

@@ -3,6 +3,10 @@
 const LiteralFieldBase = require('./literal-field-base');
 
 class MaxLiteral extends LiteralFieldBase {
+  static isAggregate() {
+    return true;
+  }
+
   toString(connection, options) {
     if (!connection)
       return `${this.constructor.name} {}`;

package/lib/connection/literals/min-literal.js

@@ -3,6 +3,10 @@
 const LiteralFieldBase = require('./literal-field-base');
 
 class MinLiteral extends LiteralFieldBase {
+  static isAggregate() {
+    return true;
+  }
+
   toString(connection, options) {
     if (!connection)
       return `${this.constructor.name} {}`;

package/lib/connection/literals/sum-literal.js

@@ -3,6 +3,10 @@
 const LiteralFieldBase = require('./literal-field-base');
 
 class SumLiteral extends LiteralFieldBase {
+  static isAggregate() {
+    return true;
+  }
+
   toString(connection, options) {
     if (!connection)
       return `${this.constructor.name} {}`;

package/lib/connection/query-generator-base.d.ts

@@ -1,97 +1,18 @@
 import Field from '../field';
 import { GenericObject } from '../interfaces/common';
-import { ModelClass } from '../model';
 import { QueryEngine } from '../query-engine';
 import ConnectionBase from './connection-base';
 import { AverageLiteral, CountLiteral, DistinctLiteral, FieldLiteral, MaxLiteral, MinLiteral, SumLiteral } from './literals';
 import LiteralBase from './literals/literal-base';
 
-export declare interface GetEscapedFieldNameOptions {
-  fieldNameOnly?: boolean;
-}
-
-export declare interface GetEscapedTableNameNameOptions {
-  tableNamePrefix?: string;
-}
-
-export declare interface GetEscapedColumnNameOptions extends GetEscapedTableNameNameOptions {
-  columnNamePrefix?: string
-  columnNameOnly?: boolean;
-}
-
-export declare interface GetEscapedProjectionNameOptions extends GetEscapedColumnNameOptions, GetEscapedFieldNameOptions {
-  noProjectionAliases?: boolean;
-}
-
-export declare interface GetEscapedModelFieldsOptions extends GetEscapedProjectionNameOptions {
-  asProjection?: boolean;
-  asColumn?: boolean;
-}
-
-export declare interface ProjectedFieldInfo {
-  projectedName: string;
-  Model: ModelClass;
-  modelName: string;
-  Field: Field;
-  fieldName: string;
-  direction: string;
-  fullFieldName: string;
-}
-
-export declare interface JoinTableInfo {
-  operator: string;
-  joinType: string | LiteralBase;
-  rootModelName: string;
-  joinModel: ModelClass;
-  joinModelName: string;
-  leftSideModel: ModelClass;
-  leftSideModelName: string;
-  leftQueryContext: GenericObject;
-  leftSideField: Field;
-  rightSideModel: ModelClass;
-  rightSideModelName: string;
-  rightQueryContext: GenericObject;
-  rightSideField: Field;
-}
-
-export declare interface FieldDirectionInfo {
-  hasDirection: boolean;
-  direction: string;
-  fieldName: string;
-}
-
-export declare interface FieldOrderInfo {
-  Model: ModelClass;
-  Field: Field;
-  direction: string;
-}
-
 declare class QueryGeneratorBase {
   public constructor(connection);
   public stackAssign(obj: GenericObject, ...args: Array<GenericObject>): GenericObject;
   public setOptionsCache(options: GenericObject, keyPath: string, value: any): void;
   public escape(field: Field, value: any, options?: GenericObject): string;
   public escapeID(value: LiteralBase | string, options?: GenericObject): string;
-  public getEscapedFieldName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedFieldNameOptions): string;
-  public getEscapedColumnName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedColumnNameOptions): string;
-  public getEscapedTableName(modelOrField: ModelClass | Field, options?: GetEscapedTableNameNameOptions): string;
-  public getEscapedProjectionName(Model: ModelClass | null | undefined, field: Field, options?: GetEscapedProjectionNameOptions): string;
-  public getEscapedModelFields(Model: ModelClass, options?: GetEscapedModelFieldsOptions): { [key: string]: string };
-  public isFieldIdentifier(value: string): boolean;
-  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: false | undefined): Array<string>;
-  public getProjectedFields(queryEngine: QueryEngine, options?: GenericObject, asMap?: true): Map<string, string>;
-
-  public getJoinTableInfoFromQueryContexts(
-    leftQueryContext: GenericObject,
-    rightQueryContext: GenericObject,
-    joinType: string | LiteralBase,
-    options?: GenericObject
-  ): JoinTableInfo;
-
-  public getFieldDirectionSpecifier(order: LiteralBase): LiteralBase;
-  public getFieldDirectionSpecifier(order: string | Field): FieldDirectionInfo;
 
-  public getQuerySliceFromQueryPart(queryPart: GenericObject): Array<GenericObject>;
+  public _getLiteralAlias(literal: LiteralBase, options?: GenericObject);
   public _averageLiteralToString(literal: AverageLiteral, options?: GenericObject): string;
   public _countLiteralToString(literal: CountLiteral, options?: GenericObject): string;
   public _distinctLiteralToString(literal: DistinctLiteral, options?: GenericObject): string;

package/lib/connection/query-generator-base.js

@@ -1,9 +1,5 @@
 'use strict';
 
-const Nife        = require('nife');
-const Literals    = require('./literals');
-const LiteralBase = Literals.LiteralBase;
-
 /// The base query generator class.
 ///
 /// Alias: QueryGenerator
@@ -19,14 +15,8 @@ class QueryGeneratorBase {
     });
   }
 
-  stackAssign(obj, ..._args) {
-    let newObj = Object.create(obj || {});
-    let args = _args.filter(Boolean);
-
-    if (args.length > 0)
-      Object.assign(newObj, ...args);
-
-    return newObj;
+  stackAssign(obj, ...args) {
+    return this.connection.stackAssign(obj, ...args);
   }
 
   escape(...args) {
@@ -37,331 +27,39 @@ class QueryGeneratorBase {
     return this.connection.escapeID(...args);
   }
 
-  getEscapedFieldName(_Model, field, options) {
-    let isString  = Nife.instanceOf(field, 'string');
-    let fieldName = (isString) ? field : field.fieldName;
-    let Model     = _Model;
-
-    if (!Model && field && !isString)
-      Model = field.Model;
-
-    if (!Model || (options && options.fieldNameOnly === true))
-      return this.escapeID(fieldName);
-    else
-      return `"${field.Model.getModelName()}:${fieldName}"`;
-  }
-
-  getEscapedColumnName(_Model, field, options) {
-    let isString    = Nife.instanceOf(field, 'string');
-    let columnName  = (isString) ? field : (field.columnName || field.fieldName);
-    let Model       = _Model;
-
-    if (!Model && field && !isString)
-      Model = field.Model;
-
-    if (options && options.columnNamePrefix)
-      columnName = `${options.columnNamePrefix}${columnName}`;
-
-    if (!Model || (options && options.columnNameOnly === true))
-      return this.escapeID(columnName);
-    else
-      return `${this.getEscapedTableName(Model)}.${this.escapeID(columnName)}`;
-  }
-
-  getEscapedTableName(_modelOrField, options) {
-    let Model     = (_modelOrField.Model) ? _modelOrField.Model : _modelOrField;
-    let tableName = Model.getTableName(this.connection);
-
-    if (options && options.tableNamePrefix)
-      tableName = `${options.tableNamePrefix}${tableName}`;
-
-    return this.escapeID(tableName);
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  getEscapedProjectionName(Model, field, options) {
-    if (options && options.noProjectionAliases)
-      return this.getEscapedColumnName(Model, field, options);
-    else
-      return `${this.getEscapedColumnName(Model, field, options)} AS ${(options && options.as) ? this.escapeID(options.as) : this.getEscapedFieldName(Model, field, options)}`;
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  getEscapedModelFields(Model, options) {
-    let fields    = {};
-    let modelName = Model.getModelName();
-
-    Model.iterateFields(({ field, fieldName }) => {
-      if (field.type.isVirtual())
-        return;
-
-      let result;
-
-      if (options && options.asProjection)
-        result = this.getEscapedProjectionName(Model, field, options);
-      else if (options && options.asColumn)
-        result = this.getEscapedColumnName(Model, field, options);
-      else
-        result = this.getEscapedFieldName(Model, field, options);
-
-      fields[`${modelName}:${fieldName}`] = result;
-    }, (options && options.fields));
-
-    return fields;
-  }
-
-  isFieldIdentifier(str) {
-    return (/^"[^"]+"."[^"]+"|"\w+:[\w.]+"/i).test(str);
-  }
-
-  getQueryEngineOrder(queryEngine, _options) {
-    let options = _options || {};
-    let context = queryEngine.getOperationContext();
-    let order   = context.order;
-
-    return (order && order.size) ? order : this.connection.getDefaultOrder(context.rootModel, options);
-  }
-
-  getProjectedFields(queryEngine, _options, asMap) {
-    let options               = this.stackAssign(_options || {}, { isProjection: true });
-    let context               = queryEngine.getOperationContext();
-    let queryProjection       = new Map(context.projection);
-    let order                 = this.getQueryEngineOrder(queryEngine, options);
-    let allProjectionFields   = new Map();
-    let allModelsUsedInQuery  = queryEngine.getAllModelsUsedInQuery();
-
-    if (!options.isSubQuery && order && order.size) {
-      let contextOrderSupport = this.connection.isOrderSupportedInContext(options);
-      if (contextOrderSupport) {
-        for (let [ fullyQualifiedFieldName, orderScope ] of order) {
-          if (!queryProjection.has(fullyQualifiedFieldName))
-            queryProjection.set(fullyQualifiedFieldName, orderScope);
-        }
-      }
-    }
-
-    for (let [ fullyQualifiedName, projectedScope ] of queryProjection) {
-      let { value } = projectedScope;
-
-      if (Nife.instanceOf(value, 'string')) {
-        // Raw string is treated as a literal
-        allProjectionFields.set(fullyQualifiedName, value);
-        continue;
-      } else if (LiteralBase.isLiteral(value)) {
-        let result = value.toString(this.connection, options);
-        allProjectionFields.set(result || fullyQualifiedName, result || fullyQualifiedName);
-
-        continue;
-      }
-
-      if (allModelsUsedInQuery.indexOf(value.Model) < 0)
-        continue;
-
-      let escapedFieldName = this.getEscapedProjectionName(value.Model, value, options);
-      allProjectionFields.set(`${value.Model.getModelName()}:${value.fieldName}`, escapedFieldName);
-    }
-
-    if (asMap === true)
-      return allProjectionFields;
-    else
-      return Array.from(allProjectionFields.values());
-  }
-
   // eslint-disable-next-line no-unused-vars
-  getJoinTableInfoFromQueryContexts(leftQueryContext, rightQueryContext, joinType, options) {
-    let rootModel         = leftQueryContext.rootModel;
-    let rootModelName     = rootModel.getModelName();
-    let leftSideModel     = leftQueryContext.Model;
-    let leftSideModelName = leftQueryContext.modelName;
-    if (!leftSideModel)
-      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No model found for left-side of join statement.`);
-
-    let leftSideField = leftQueryContext.Field;
-    if (!leftSideField)
-      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No left-side field found to match on for table join statement.`);
-
-    let isNot               = leftQueryContext.not;
-    let operator            = (isNot) ? leftQueryContext.inverseOperator : leftQueryContext.operator;
-    let rightSideModel      = rightQueryContext.Model;
-    let rightSideModelName  = rightQueryContext.modelName;
-    if (!rightSideModel)
-      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No model found for right-side of join statement.`);
-
-    let rightSideField = rightQueryContext.Field;
-    if (!rightSideField)
-      throw new Error(`${this.constructor.name}::getJoinTableInfoFromQueryEngine: Invalid operation: No right-side field found to match on for table join statement.`);
-
-    let swapJoinRelation    = (rightSideModelName === rootModelName);
-    let joinModel           = (swapJoinRelation) ? leftSideModel : rightSideModel;
-    let joinModelName       = (swapJoinRelation) ? leftSideModelName : rightSideModelName;
-
-    return {
-      operator,
-      joinType,
-      rootModelName,
-
-      joinModel,
-      joinModelName,
-
-      leftSideModel,
-      leftSideModelName,
-      leftQueryContext,
-      leftSideField,
-
-      rightSideModel,
-      rightSideModelName,
-      rightQueryContext,
-      rightSideField,
-    };
-  }
-
-  getFieldDirectionSpecifier(order) {
-    if (!order)
-      return order;
-
-    if (LiteralBase.isLiteral(order))
-      return order;
-
-    // Is this a field?
-    if (order && order.Model && order.fieldName) {
-      return {
-        hasDirection: false,
-        direction:    '+',
-        fieldName:    order.fieldName,
-      };
-    }
-
-    let sign;
-
-    let fieldName = ('' + order).replace(/^[+-]+/, (m) => {
-      sign = m.charAt(0);
-      return '';
-    });
-
-    return {
-      hasDirection: !!sign,
-      direction:    (sign === '-') ? '-' : '+',
-      fieldName,
-    };
-  }
-
-  getQuerySliceFromQueryPart(queryPart) {
-    let operationStack = queryPart.operationStack;
-    let index     = operationStack.indexOf(queryPart);
-
-    return operationStack.slice(index);
-  }
-
-  _getLiteralAlias(literal, options) {
-    let as = (literal.options && literal.options.as) || (options && options.as);
-    if (Nife.isEmpty(as))
-      return '';
-
-    return ` AS ${this.escapeID(as)}`;
-  }
-
   _averageLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    let escapedFieldName;
-
-    if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection, options);
-    else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
-
-    return `AVG(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+    throw new Error(`${this.constructor.name}::_averageLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _countLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    let escapedFieldName;
-
-    if (field) {
-      if (LiteralBase.isLiteral(field))
-        escapedFieldName = field.toString(this.connection, options);
-      else
-        escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
-    } else {
-      escapedFieldName = '*';
-    }
-
-    return `COUNT(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+    throw new Error(`${this.constructor.name}::_countLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _distinctLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    if (!field)
-      return 'DISTINCT';
-
-    if (LiteralBase.isLiteral(field))
-      return `DISTINCT ON(${field.toString(this.connection, this.stackAssign(options, { noProjectionAliases: true }))})`;
-
-    return `DISTINCT ON(${this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options, { noProjectionAliases: true }))})`;
+    throw new Error(`${this.constructor.name}::_distinctLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _fieldLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    if (LiteralBase.isLiteral(field))
-      return field.toString(this.connection, options);
-
-    return this.getEscapedProjectionName(field.Model, field, this.stackAssign(options, { noProjectionAliases: (options && !options.isProjection) }, literal.options));
+    throw new Error(`${this.constructor.name}::_fieldLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _maxLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    let escapedFieldName;
-
-    if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection, options);
-    else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
-
-    return `MAX(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+    throw new Error(`${this.constructor.name}::_maxLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _minLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    let escapedFieldName;
-
-    if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection, options);
-    else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
-
-    return `MIN(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+    throw new Error(`${this.constructor.name}::_minLiteralToString: This operation is not supported for this connection type.`);
   }
 
+  // eslint-disable-next-line no-unused-vars
   _sumLiteralToString(literal, options) {
-    if (!literal || !LiteralBase.isLiteral(literal))
-      return;
-
-    let field = literal.getField(this.connection);
-    let escapedFieldName;
-
-    if (LiteralBase.isLiteral(field))
-      escapedFieldName = field.toString(this.connection, options);
-    else
-      escapedFieldName = this.getEscapedColumnName(field.Model, field, this.stackAssign(options, literal.options));
-
-    return `SUM(${escapedFieldName})${this._getLiteralAlias(literal, options)}`;
+    throw new Error(`${this.constructor.name}::_sumLiteralToString: This operation is not supported for this connection type.`);
   }
 
   // eslint-disable-next-line no-unused-vars

package/lib/model.js

@@ -450,14 +450,16 @@ class Model {
   ///   a connection to your models. This will allow you to provide a
   ///   connection directly when you create the model, which can make
   ///   interacting with the model less tiresome. i.e. `new Model(null, { connection })`.
-  _getConnection(connection) {
+  _getConnection(_connection) {
+    let connection = _connection;
     if (connection)
       return connection;
 
-    if (this._connection)
-      return this._connection;
+    connection = this.constructor._getConnection();
+    if (connection)
+      return connection;
 
-    return this.constructor._getConnection();
+    return this._connection;
   }
 
   static getConnection(_connection) {

package/lib/query-engine/model-scope.js

@@ -353,6 +353,8 @@ class ModelScope extends QueryEngineBase {
       distinctValue = new DistinctLiteral(`${fullyQualifiedName.Model.getModelName()}:${fullyQualifiedName.fieldName}`);
     } else if (LiteralBase.isLiteral(fullyQualifiedName)) {
       distinctValue = new DistinctLiteral(fullyQualifiedName);
+    } else if (!fullyQualifiedName) {
+      distinctValue = null;
     } else {
       throw new TypeError(`QueryEngine::ModelScope::DISTINCT: Invalid value provided [${(fullyQualifiedName) ? fullyQualifiedName.toString() : fullyQualifiedName}]. All values provided must be strings, fields, or literals.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",