mythix-orm 1.8.3 → 1.11.0

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

@@ -81,6 +81,7 @@ declare class ConnectionBase extends EventEmitter {
   public getOptions(): ConnectionBaseOptions;
   public isStarted(): boolean;
   public toQueryEngine(queryEngineLike: any): QueryEngine | undefined;
+  public finalizeQuery(operation: string, query: QueryEngine, options: GenericObject): Promise<QueryEngine>
   public registerModel<T = ModelClass>(Model: T, options?: GenericObject): T;
   public registerModels(models: Models | Array<ModelClass>, options?: GenericObject): Models | undefined;
   public getContextValue(key: any, defaultValue?: any): any;

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';
@@ -489,6 +473,73 @@ class ConnectionBase extends EventEmitter {
     return queryEngine;
   }
 
+  async finalizeQuery(crudOperation, queryEngine, options) {
+    if (!QueryEngine.isQuery(queryEngine))
+      return queryEngine;
+
+    const finalizeQueryForModel = async (query, parent, contextKey, depth) => {
+      let operations = query.getOperationStack();
+
+      // Has query already been finalized?
+      let lastOperation = operations[operations.length - 1];
+      if (lastOperation && Object.prototype.hasOwnProperty.call(lastOperation, '_queryFinalized') && lastOperation._queryFinalized)
+        return query;
+
+      let newQuery              = query.clone();
+      let alreadyVisitedModels  = new Set();
+
+      for (let i = 0, il = operations.length; i < il; i++) {
+        let operation = operations[i];
+        if (!Object.prototype.hasOwnProperty.call(operation, 'modelName'))
+          continue;
+
+        let modelName = operation.modelName;
+        if (alreadyVisitedModels.has(modelName))
+          continue;
+
+        alreadyVisitedModels.add(modelName);
+
+        let Model = operation.Model;
+        if (typeof Model.finalizeQuery !== 'function')
+          continue;
+
+        newQuery = await Model.finalizeQuery({
+          type:           crudOperation,
+          query:          newQuery,
+          queryDepth:     depth,
+          operationIndex: i,
+          connection:     this,
+          Model,
+          modelName,
+          operation,
+          operations,
+          parent,
+          contextKey,
+          options,
+        });
+
+        if (parent && contextKey)
+          parent[contextKey] = newQuery;
+      }
+
+      // Mark as finalized
+      newQuery.getOperationContext()._queryFinalized = true;
+
+      return newQuery;
+    };
+
+    let promises = [];
+
+    queryEngine.walk((query, parent, contextKey, depth) => {
+      promises.push(finalizeQueryForModel(query, parent, contextKey, depth));
+    });
+
+    if (promises.length > 0)
+      await Promise.all(promises);
+
+    return await finalizeQueryForModel(queryEngine, null, null, 0);
+  }
+
   /// Register the provided model class.
   ///
   /// This will register the provided model class with this

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;