mythix-orm 1.10.2 → 1.11.0

package/lib/connection/connection-base.js

@@ -238,7 +238,7 @@ class ConnectionBase extends EventEmitter {
         get:          () => {
           return this.constructor.dialect;
         },
-        set:          () => {
+        set: () => {
         },
       },
       '_models': {
@@ -346,25 +346,6 @@ class ConnectionBase extends EventEmitter {
   ///   are also valid return values (in which case no order will be
   ///   applied to the given operation).
   getDefaultOrder(Model, options) {
-    let order = Model.defaultOrder(options);
-    if (!order)
-      return;
-
-    order = Nife.arrayFlatten(Nife.toArray(order)).filter((value) => {
-      if (!value)
-        return false;
-
-      if (!Nife.instanceOf(value, 'string'))
-        return false;
-
-      return true;
-    });
-
-    if (Nife.isEmpty(order))
-      return;
-
-    let modelName = Model.getModelName();
-    return order.map((value) => ((value.indexOf(':') < 0) ? `${modelName}:${value}` : value));
   }
 
   /// This method is called (and often provided)
@@ -396,6 +377,9 @@ class ConnectionBase extends EventEmitter {
     if (options.isSubQuery) {
       let subQueryOperator = options.subQueryOperator;
       if (subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')
+        return false;
+
+      if (subQueryOperator === 'ANY' || subQueryOperator === 'ALL')
         return true;
 
       return 'PROJECTION_ONLY';

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const ModelUtils = require('../../utils/model-utils');
+const Field = require('../../field');
 
 class LiteralBase {
   static _isMythixLiteral = true;
@@ -31,6 +32,13 @@ class LiteralBase {
     return false;
   }
 
+  isLiteral(value) {
+    if (arguments.length === 0)
+      return true;
+
+    return this.constructor.isLiteral(value);
+  }
+
   static isLiteralType(value) {
     return (this.isLiteral(value) && value.constructor && value.constructor.name === this.name);
   }
@@ -80,8 +88,19 @@ class LiteralBase {
       return definition;
 
     let field = connection.getField(definition.fieldNames[0], definition.modelName);
-    if (!field)
+    if (!field) {
+      if (definition.fieldNames[0] && definition.modelName) {
+        let Model = connection.getModel(definition.modelName);
+        if (Model) {
+          return new Field({
+            fieldName: definition.fieldNames[0],
+            Model,
+          });
+        }
+      }
+
       throw new Error(`${this.constructor.name}::definitionToField: Unable to locate field "${definition.modelName}"."${definition.fieldNames[0]}".`);
+    }
 
     return field;
   }

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

@@ -69,7 +69,6 @@ export declare interface FieldOrderInfo {
 declare class QueryGeneratorBase {
   public constructor(connection);
   public stackAssign(obj: GenericObject, ...args: Array<GenericObject>): GenericObject;
-  public getOptionsCache(options: GenericObject, keyPath: string, initialValue: any): any;
   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;
@@ -77,11 +76,7 @@ declare class QueryGeneratorBase {
   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 getAllModelsUsedInQuery(queryEngine: QueryEngine, options?: GenericObject): Array<ModelClass>;
-  public getProjectionRequiredFields(queryEngine: QueryEngine, options?: GenericObject): Map<string, ProjectedFieldInfo>;
-  public sortedProjectedFields(projectedFields: Array<LiteralBase | string>, options?: GenericObject): Array<LiteralBase | string>;
-  public getProjectionFromQueryEngine(queryEngine: QueryEngine, options?: GenericObject): Array<LiteralBase | string | ProjectedFieldInfo>;
+  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>;
@@ -96,15 +91,6 @@ declare class QueryGeneratorBase {
   public getFieldDirectionSpecifier(order: LiteralBase): LiteralBase;
   public getFieldDirectionSpecifier(order: string | Field): FieldDirectionInfo;
 
-  public getOrderLimitOffset(
-    queryEngine: QueryEngine,
-    options?: GenericObject,
-  ): {
-    limit: number | undefined,
-    offset: number | undefined,
-    order: Array<FieldOrderInfo>,
-  };
-
   public getQuerySliceFromQueryPart(queryPart: GenericObject): Array<GenericObject>;
   public _averageLiteralToString(literal: AverageLiteral, options?: GenericObject): string;
   public _countLiteralToString(literal: CountLiteral, options?: GenericObject): string;