mythix-orm 1.11.2 → 1.11.4

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,16 @@ 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);
+  }
+
   /// This method is an internal method that parses
   /// the "lock mode" options passed to a call to
   /// <see>Connection.transaction</see>.

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
@@ -37,331 +33,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm",
-  "version": "1.11.2",
+  "version": "1.11.4",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",
@@ -34,18 +34,18 @@
   "homepage": "https://github.com/th317erd/mythix-orm#readme",
   "devDependencies": {
     "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
-    "@types/node": "^18.7.17",
-    "better-sqlite3": "^7.6.2",
+    "@types/node": "^18.11.9",
+    "better-sqlite3": "^8.0.0",
     "colors": "^1.4.0",
     "diff": "^5.1.0",
-    "eslint": "^8.23.1",
-    "jasmine": "^4.4.0",
+    "eslint": "^8.28.0",
+    "jasmine": "^4.5.0",
     "nyc": "^15.1.0"
   },
   "dependencies": {
     "events": "^3.3.0",
-    "inflection": "^1.13.2",
-    "luxon": "^3.0.4",
+    "inflection": "^2.0.0",
+    "luxon": "^3.1.0",
     "nife": "^1.12.1",
     "sqlstring": "^2.3.3",
     "uuid": "^9.0.0",