mythix-orm 1.8.3 → 1.11.0

package/lib/field.js

@@ -118,8 +118,8 @@
 ///    If `true`, then this field will be indexed in the database.
 ///    If an array is provided, then it must be an array containing
 ///    other field names to combine with this field to create a combined
-///    index. For example: `index: [ true, 'firstName', 'lastName', [ 'firstName', 'lastName' ] ]`
-///    would create four indexes: `true` means index this field, `firstName` would create
+///    index. For example: `index: [ true, 'firstName', 'lastName', [ 'firstName', 'lastName' ] ]` would create four indexes:
+///    `true` means index this field, `firstName` would create
 ///    the combination index `this_field_first_name`, `lastName` would create the
 ///    combination index `this_field_last_name`, and `[ 'firstName', 'lastName ]` would
 ///    create the combination index `this_field_first_name_last_name`.
@@ -234,6 +234,13 @@ class Field {
     return false;
   }
 
+  isField(value) {
+    if (arguments.length === 0)
+      return true;
+
+    return this.constructor.isField(value);
+  }
+
   /// Construct a Field.
   ///
   /// This method will create a new instance of <see>Field</see>.

package/lib/model.d.ts

@@ -42,6 +42,21 @@ export declare interface IterateFieldsContext {
 
 export declare type IterateFieldsCallback = (context: IterateFieldsContext) => any;
 
+export declare interface FinalizeQueryContext {
+  type: 'create' | 'read' | 'update' | 'delete';
+  query: QueryEngine;
+  queryDepth: number;
+  connection: ConnectionBase;
+  Model: Model;
+  modelName: string;
+  operationIndex: number;
+  operation: GenericObject;
+  operations: Array<GenericObject>;
+  parent: GenericObject | null;
+  contextKey: string | null;
+  options: GenericObject | null;
+}
+
 export declare class Model {
   declare public static fields: LooseFields | undefined;
   declare public static _sortedFields: Array<Field> | null;
@@ -83,6 +98,8 @@ export declare class Model {
   public static defaultScope(query: QueryEngine): QueryEngine;
   public defaultScope(query: QueryEngine): QueryEngine;
 
+  public static finalizeQuery(context: FinalizeQueryContext): Promise<QueryEngine>;
+
   public static getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
   public getQueryEngine(connection?: ConnectionBase, options?: GenericObject): QueryEngine;
 
@@ -153,8 +170,6 @@ export declare class Model {
   public static getConcreteFieldCount(): number;
   public getConcreteFieldCount(): number;
 
-  public static defaultOrder(options?: GenericObject): Array<string>;
-
   public static getWhereWithConnection(options?: { connection: ConnectionBase }): QueryEngine;
   public getWhereWithConnection(options?: { connection: ConnectionBase }): QueryEngine;
 

package/lib/model.js

@@ -104,8 +104,8 @@ function bindStaticWhereToModelClass(ModelClass) {
   };
 
   Object.defineProperties(ModelClass, {
-    'where':  whereProp,
-    '$':      whereProp,
+    'where': whereProp,
+    '$':     whereProp,
   });
 }
 
@@ -557,7 +557,7 @@ class Model {
       get:          () => {
         return ModelClass.getQueryEngine(ModelClass._getConnection() || connection);
       },
-      set:          () => {},
+      set: () => {},
     };
 
     Object.defineProperties(ModelClass, {
@@ -567,8 +567,8 @@ class Model {
         configurable: true,
         value:        connection,
       },
-      'where':  whereProp,
-      '$':      whereProp,
+      'where': whereProp,
+      '$':     whereProp,
     });
 
     return ModelClass;
@@ -637,14 +637,16 @@ class Model {
 
   /// One can apply a "default scope" to any model simply
   /// by providing this static method on the model. By
-  /// default it will simply return the <see name="derp">QueryEngine</see>
+  /// default it will simply return the <see>QueryEngine</see>
   /// instance (a query) that it was provided.
   ///
   /// The way this works is simple. The caller provides the
   /// query as the first and only argument. The user, by
   /// overloading this method can then easily modify this
   /// provided query, changing the "default scope" whenever
-  /// the model is used for queries. For example, let's say
+  /// the model is used for queries. This can be used to set
+  /// a default order for a model, or to set default conditions
+  /// to apply to any query for the model. For example, let's say
   /// you have a User model, and by default, you only want
   /// to query against Users that have their `active` column
   /// set to `true`. In order to do this, you could easily
@@ -656,7 +658,7 @@ class Model {
   ///     static defaultScope(baseQuery) {
   ///       // `baseQuery` is equal to `User.where`
   ///       // without a default scope.
-  ///       return baseQuery.active.EQ(true);
+  ///       return baseQuery.active.EQ(true).ORDER.ASC('User:createdAt');
   ///     }
   ///   }
   ///
@@ -673,6 +675,11 @@ class Model {
     return this.constructor.defaultScope(queryEngine);
   }
 
+  // eslint-disable-next-line no-unused-vars
+  static finalizeQuery({ type, query, queryDepth, operationIndex, operation, operations, parent, contextKey, options }) {
+    return query;
+  }
+
   /// This method is called any time a `Model.where` or
   /// `Model.$` property is accessed. It returns a query,
   /// based off this model class (as the root model).
@@ -1602,37 +1609,6 @@ class Model {
     return this.constructor.getConcreteFieldCount();
   }
 
-  /// Specify the default SELECT "ORDER" for the model.
-  /// This method will be called if no "ORDER" was specified
-  /// for any given query. This method should return an
-  /// Array of fully qualified field names. The `options`
-  /// argument is the current options for the specific
-  /// query being operated on.
-  ///
-  /// Note:
-  ///   Internally, Mythix ORM will call `this.connection.defaultOrder(options)`,
-  ///   which--if not overloaded--will simply call this method from the
-  ///   model itself.
-  ///
-  /// Note:
-  ///   A "fully qualified field name" in Mythix ORM means
-  ///   a full field definition, including the model name.
-  ///   An example of a fully qualified field name might be
-  ///   `"User:id"`. The model name is separated from the field
-  ///   name by a colon `:`. A short hand, *not fully qualified
-  ///   field name* example would be simply `"id"`. Since this
-  ///   contains no model prefix, this is "short hand", and is
-  ///   **not** a fully qualified field name.
-  ///
-  /// Return: Array<string> | null
-  ///   An array of fully qualified field names to specify the ORDER.
-  ///   Prefix a field name with `+` to specify ASCending order, i.e.
-  ///   `[ "+User:id" ]`. Prefix the field name with `-` to specify
-  ///   DESCending order, i.e. `[ "-User:id" ]`.
-  // eslint-disable-next-line no-unused-vars
-  static defaultOrder(options) {
-  }
-
   /// This method is called anytime a `Model.where` or `Model.$`
   /// attribute is accessed. It will provide the instantiated
   /// <see>QueryEngine</see> with the connection specified (if any).
@@ -1700,14 +1676,18 @@ class Model {
   ///   Return the number of models stored in the database for this model type.
   ///
   /// Arguments:
+  ///   field?: string | Field
+  ///     A fully qualified field name, or a `Field` instance. If supplied, this is the
+  ///     column in the table that will be counted (i.e. `COUNT(column)`). If not supplied,
+  ///     then a `COUNT(*)` type operation will be carried out.
   ///   options?: object
   ///     An "options" object to pass off to the underlying <see>Connection</see> methods.
   ///     If a `connection` key is specified in this object, then that will be used
   ///     as the connection for the operation. This can be important if for example
   ///     you are calling this from a `transaction`, in which case you most certainly
   ///     would want to provide the `connection` for the transaction.
-  static count(options) {
-    return this.getWhereWithConnection(options).count(null, options);
+  static count(field, options) {
+    return this.getWhereWithConnection(options).count(field, options);
   }
 
   /// Fetch all models from the database for this model type.
@@ -1890,7 +1870,7 @@ class Model {
       get:          () => {
         return this.constructor.where(this._getConnection());
       },
-      set:          () => {},
+      set: () => {},
     };
 
     Object.defineProperties(this, {
@@ -1960,10 +1940,10 @@ class Model {
         get:          () => {
           return this._getDirtyFields();
         },
-        set:          () => {},
+        set: () => {},
       },
-      'where':        whereProp,
-      '$':            whereProp,
+      'where': whereProp,
+      '$':     whereProp,
     });
 
     this._constructor(data);
@@ -2032,12 +2012,12 @@ class Model {
   _constructField(fieldName, field) {
     Object.defineProperties(this, {
       [fieldName]: {
-        enumerable:   false,
+        enumerable:   true,
         configurable: true,
         get:          () => {
           return this._getFieldValue(fieldName, field);
         },
-        set:          (value) => {
+        set: (value) => {
           this._setFieldValue(fieldName, field, value);
         },
       },
@@ -2082,9 +2062,12 @@ class Model {
   _initializeModelData(_data) {
     let dirtyFieldData  = this._dirtyFieldData;
     let data            = _data || {};
+    let fieldNames      = new Set();
 
     // First initialize field values from data
     this.iterateFields(({ field, fieldName }) => {
+      fieldNames.add(fieldName);
+
       if (!field.type.exposeToModel())
         return;
 
@@ -2104,6 +2087,15 @@ class Model {
       let fieldValue = (data) ? data[fieldName] : undefined;
       this._initializeFieldData(fieldName, field, fieldValue, data);
     });
+
+    let keys = Object.keys(data);
+    for (let i = 0, il = keys.length; i < il; i++) {
+      let key = keys[i];
+      if (fieldNames.has(key))
+        continue;
+
+      this[key] = data[key];
+    }
   }
 
   /// This casts a field value to its type,
@@ -2129,9 +2121,9 @@ class Model {
       return value;
 
     return type.castToType({
-      connection:     this.getConnection(),
-      Model:          this.getModel(),
-      self:           this,
+      connection: this.getConnection(),
+      Model:      this.getModel(),
+      self:       this,
       field,
       value,
     });
@@ -2189,10 +2181,10 @@ class Model {
 
       if (shouldRunDefaultValueOnInitialize()) {
         defaultValue = defaultValue({
-          model:              this,
-          self:               this,
-          connection:         this.getConnection(),
-          _initial:           true,
+          model:      this,
+          self:       this,
+          connection: this.getConnection(),
+          _initial:   true,
           field,
           fieldName,
           fieldValue,
@@ -2218,8 +2210,8 @@ class Model {
     }
 
     field.type.onSetFieldValue({
-      self:   this,
-      value:  initialValue,
+      self:  this,
+      value: initialValue,
       field,
       fieldName,
     });
@@ -2322,8 +2314,8 @@ class Model {
 
       // Does the type itself report that we are dirty?
       let value = field.type.isDirty({
-        self:   this,
-        value:  this.getDataValue(fieldName),
+        self:  this,
+        value: this.getDataValue(fieldName),
         field,
         fieldName,
         connection,
@@ -2422,10 +2414,10 @@ class Model {
 
     if (typeof field.get === 'function') {
       return field.get.call(this, {
-        model:  this,
-        self:   this,
-        set:    this.setDataValue.bind(this, fieldName),
-        get:    this.getDataValue.bind(this, fieldName),
+        model: this,
+        self:  this,
+        set:   this.setDataValue.bind(this, fieldName),
+        get:   this.getDataValue.bind(this, fieldName),
         value,
         field,
         fieldName,
@@ -2468,10 +2460,10 @@ class Model {
   _setFieldValue(fieldName, field, value) {
     if (typeof field.set === 'function') {
       field.set.call(this, {
-        model:  this,
-        self:   this,
-        set:    this.setDataValue.bind(this, fieldName),
-        get:    this.getDataValue.bind(this, fieldName),
+        model: this,
+        self:  this,
+        set:   this.setDataValue.bind(this, fieldName),
+        get:   this.getDataValue.bind(this, fieldName),
         value,
         field,
         fieldName,
@@ -2670,8 +2662,8 @@ class Model {
     let newValue = this._castFieldValue(field, value);
 
     field.type.onSetFieldValue({
-      self:   this,
-      value:  newValue,
+      self:  this,
+      value: newValue,
       field,
       fieldName,
     });
@@ -2810,9 +2802,9 @@ class Model {
       return false;
 
     return pkField.type.isValidValue(pkValue, {
-      connection:     this.getConnection(),
-      Model:          this.getModel(),
-      self:           this,
+      connection: this.getConnection(),
+      Model:      this.getModel(),
+      self:       this,
     });
   }
 

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

@@ -9,24 +9,57 @@ function addOperatorToQuery(name, inverseName, value, extraOptions) {
     throw new Error(`QueryEngine::addOperatorToQuery: ${name}(${value}) makes no sense...`);
 
   let conditionalParams = {
-    condition:        true,
-    operator:         name,
-    inverseOperator:  inverseName,
-    value:            this._fetchOperatorValue(value),
-    hasCondition:     true,
+    condition:       true,
+    operator:        name,
+    queryProp:       name,
+    queryExtraArgs:  (extraOptions) ? [ extraOptions ] : [],
+    inverseOperator: inverseName,
+    value:           this._fetchOperatorValue(value),
+    hasCondition:    true,
   };
 
   if (extraOptions)
     conditionalParams = Object.assign(conditionalParams, extraOptions);
 
-  this._addToQuery(conditionalParams);
+  this._pushOperationOntoStack(conditionalParams);
 
   return this._fetchScope('model');
 }
 
+function wrapAnyAll(func) {
+  const checkQueryProjection = (_query, subType) => {
+    let query         = _query;
+    let queryContext  = (QueryEngineBase.isQuery(query)) ? query.getOperationContext() : null;
+    if (!queryContext || !queryContext.hasCondition)
+      throw new Error(`QueryEngine::FieldScope::${subType}: Provided value must be a query with conditions.`);
+
+    if (!queryContext.projection) {
+      let Model   = queryContext.Model;
+      let pkField = Model.getPrimaryKeyField();
+
+      if (pkField)
+        query = query.clone().PROJECT(pkField);
+      else
+        throw new Error(`QueryEngine::FieldScope::${subType}: Provided query must have only a single field projected.`);
+    }
+
+    return query;
+  };
+
+  func.ANY = (_query) => {
+    return func.call(this, checkQueryProjection(_query, 'ANY'), { subType: 'ANY' });
+  };
+
+  func.ALL = (_query) => {
+    return func.call(this, checkQueryProjection(_query, 'ANY'), { subType: 'ALL' });
+  };
+
+  return func;
+}
+
 class FieldScope extends QueryEngineBase {
   NOT = ProxyClass.autoCall(function() {
-    this._addToQuery({ logical: true, operator: 'NOT', not: !this.currentContext.not });
+    this._pushOperationOntoStack({ logical: true, operator: 'NOT', queryProp: 'NOT', not: !this.currentContext.not });
     return this[ProxyClass.PROXY];
   });
 
@@ -65,29 +98,29 @@ class FieldScope extends QueryEngineBase {
     return value;
   }
 
-  EQ(value) {
-    return addOperatorToQuery.call(this, 'EQ', 'NEQ', value);
-  }
+  EQ = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'EQ', 'NEQ', value, options);
+  });
 
-  NEQ(value) {
-    return addOperatorToQuery.call(this, 'NEQ', 'EQ', value);
-  }
+  NEQ = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'NEQ', 'EQ', value, options);
+  });
 
-  GT(value) {
-    return addOperatorToQuery.call(this, 'GT', 'LTE', value);
-  }
+  GT = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'GT', 'LTE', value, options);
+  });
 
-  GTE(value) {
-    return addOperatorToQuery.call(this, 'GTE', 'LT', value);
-  }
+  GTE = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'GTE', 'LT', value, options);
+  });
 
-  LT(value) {
-    return addOperatorToQuery.call(this, 'LT', 'GTE', value);
-  }
+  LT = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'LT', 'GTE', value, options);
+  });
 
-  LTE(value) {
-    return addOperatorToQuery.call(this, 'LTE', 'GT', value);
-  }
+  LTE = wrapAnyAll.call(this, (value, options) => {
+    return addOperatorToQuery.call(this, 'LTE', 'GT', value, options);
+  });
 
   LIKE(value, options) {
     let caseSensitive = ((options && options.caseSensitive) === true);