mythix-orm 1.4.6 → 1.5.1

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

@@ -68,8 +68,9 @@ class QueryEngine extends QueryEngineBase {
     if (!QueryEngine.isQuery(queryEngine) && Nife.instanceOf(queryEngine, 'array', 'object', 'map', 'set'))
       queryEngine = Utils.generateQueryFromFilter(this.getConnection(), thisQueryContext.rootModel, queryEngine);
 
-    let sourceQuery   = queryEngine._getRawQuery();
-    let currentModel  = thisQueryContext.Model;
+    let sourceQuery           = queryEngine._getRawQuery();
+    let currentModel          = thisQueryContext.Model;
+    let skipLogicalOperators  = true;
 
     for (let i = 0, il = sourceQuery.length; i < il; i++) {
       let queryPart     = sourceQuery[i];
@@ -88,12 +89,29 @@ class QueryEngine extends QueryEngineBase {
         'rootModelName',
       ]);
 
-      // Skip unneeded duplicate model entries
-      if (mergeContext.operator === 'MODEL') {
-        if (mergeContext.Model === currentModel)
+      // For merges, we want to skip the first logical operators
+      // found before any other operation.
+      // This is because one might do a: Model.where.OR.MERGE(Model.AND.field.EQ()).
+      // This query, once merged, would be: Model.where.OR.Model.AND.field.EQ(),
+      // which is not what we want... instead we want: Model.where.OR.Model.field.EQ().
+      // Since the result we want here is OR merge, not AND merge
+      // we skip the first "AND" we encounter, leaving the "OR" as
+      // the current logical operator.
+      if (skipLogicalOperators && Object.prototype.hasOwnProperty.call(mergeContext, 'logical') && mergeContext.logical) {
+        if (mergeContext.value == null && (mergeContext.operator === 'AND' || mergeContext.operator === 'OR'))
           continue;
+      }
+
+      if (Object.prototype.hasOwnProperty.call(mergeContext, 'operator')) {
+        // Skip unneeded duplicate model entries
+        if (mergeContext.operator === 'MODEL') {
+          if (mergeContext.Model === currentModel)
+            continue;
 
-        currentModel = mergeContext.Model;
+          currentModel = mergeContext.Model;
+        } else if (mergeContext.operator !== 'FIELD') {
+          skipLogicalOperators = false;
+        }
       }
 
       this._addToQuery(Object.assign({

package/lib/types/concrete/date-type.js

@@ -26,11 +26,11 @@ class DateType extends Type {
     this.format = format || 'YYYY-MM-DD';
   }
 
-  castToType({ value }) {
+  castToType({ value, connection }) {
     if (value == null)
       return value;
 
-    let dateTime = this.deserialize(value);
+    let dateTime = this.deserialize(value, connection);
     if (!dateTime.isValid())
       throw new TypeError(`DateType::castToType: Value provided ("${value}") can not be cast into a date.`);
 
@@ -60,7 +60,8 @@ class DateType extends Type {
     return value.toISOString();
   }
 
-  deserialize(_value) {
+  // eslint-disable-next-line no-unused-vars
+  deserialize(_value, connection) {
     let value = _value;
     if (value == null)
       return value;

package/lib/types/concrete/datetime-type.js

@@ -27,11 +27,11 @@ class DateTimeType extends Type {
     this.format = format;
   }
 
-  castToType({ value }) {
+  castToType({ value, connection }) {
     if (value == null)
       return value;
 
-    let dateTime = this.deserialize(value);
+    let dateTime = this.deserialize(value, connection);
     if (!dateTime.isValid())
       throw new TypeError(`DateTimeType::castToType: Value provided ("${value}") can not be cast into a date.`);
 
@@ -65,7 +65,8 @@ class DateTimeType extends Type {
     return value.toISOString();
   }
 
-  deserialize(_value) {
+  // eslint-disable-next-line no-unused-vars
+  deserialize(_value, connection) {
     let value = _value;
     if (value == null)
       return value;

package/lib/types/concrete/index.js

@@ -6,9 +6,11 @@ const { BOOLEAN, BooleanType }        = require('./boolean-type');
 const { CHAR, CharType }              = require('./char-type');
 const { DATE, DateType }              = require('./date-type');
 const { DATETIME, DateTimeType }      = require('./datetime-type');
-const { FLOAT, FloatType }            = require('./float-type');
 const { FOREIGN_KEY, ForeignKeyType } = require('./foreign-key-type');
 const { INTEGER, IntegerType }        = require('./integer-type');
+const { NUMERIC, NumericType }        = require('./numeric-type');
+const { REAL, RealType }              = require('./real-type');
+const { SERIALIZED, SerializedType }  = require('./serialized-type');
 const { STRING, StringType }          = require('./string-type');
 const { TEXT, TextType }              = require('./text-type');
 const { UUIDV1, UUIDV1Type }          = require('./uuid-v1-type');
@@ -24,9 +26,11 @@ module.exports = {
   CharType,
   DateTimeType,
   DateType,
-  FloatType,
+  NumericType,
+  RealType,
   ForeignKeyType,
   IntegerType,
+  SerializedType,
   StringType,
   TextType,
   UUIDV1Type,
@@ -40,9 +44,11 @@ module.exports = {
   CHAR,
   DATE,
   DATETIME,
-  FLOAT,
+  NUMERIC,
+  REAL,
   FOREIGN_KEY,
   INTEGER,
+  SERIALIZED,
   STRING,
   TEXT,
   UUIDV1,

package/lib/types/concrete/{float-type.js → numeric-type.js}

@@ -3,20 +3,23 @@
 const Nife  = require('nife');
 const Type  = require('../type');
 
-class FloatType extends Type {
+const DEFAULT_TOTAL_DIGITS    = 20;
+const DEFAULT_DECIMAL_PLACES  = 6;
+
+class NumericType extends Type {
   static getDisplayName() {
-    return 'FLOAT';
+    return 'NUMERIC';
   }
 
   getDisplayName() {
     return this.constructor.getDisplayName();
   }
 
-  constructor(length, precision) {
-    super(length, precision);
+  constructor(precision, scale) {
+    super(precision, scale);
 
-    this.length = length;
-    this.precision = precision;
+    this.precision = precision || DEFAULT_TOTAL_DIGITS;
+    this.scale = scale || DEFAULT_DECIMAL_PLACES;
   }
 
   castToType({ value }) {
@@ -37,11 +40,11 @@ class FloatType extends Type {
   toString(connection) {
     return (connection)
       ? this.toConnectionType(connection)
-      : 'FLOAT';
+      : 'NUMERIC';
   }
 }
 
 module.exports = {
-  FLOAT: Type.wrapConstructor(FloatType),
-  FloatType,
+  NUMERIC: Type.wrapConstructor(NumericType),
+  NumericType,
 };

package/lib/types/concrete/real-type.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+class RealType extends Type {
+  static getDisplayName() {
+    return 'REAL';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length, scale) {
+    super(length, scale);
+
+    this.length = length;
+    this.scale = scale;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let number = parseFloat(('' + value));
+    if (!isFinite(number))
+      throw new TypeError(`RealType::castToType: Value provided ("${value}") can not be cast into an floating point number.`);
+
+    return number;
+  }
+
+  isValidValue(value) {
+    return (Nife.instanceOf(value, 'number') && isFinite(value));
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'FLOAT';
+  }
+}
+
+module.exports = {
+  REAL: Type.wrapConstructor(RealType),
+  RealType,
+};

package/lib/types/concrete/serialized-type.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const Type = require('../type');
+
+class SerializedType extends Type {
+  static getDisplayName() {
+    return 'SERIALIZED';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(_options) {
+    let options = _options;
+    if (Type.isTypeClass(options) || Type.isType(options))
+      options = { type: options };
+
+    options = {
+      serialize:    ({ value }) => {
+        if (value == null)
+          return value;
+
+        return JSON.stringify(value);
+      },
+      deserialize:  ({ value }) => {
+        if (value == null)
+          return value;
+
+        return JSON.parse(value);
+      },
+      ...(options || {}),
+    };
+
+    if (!options.type)
+      throw new TypeError('SerializedType::constructor: "type" must be specified on the "options" for this type. "type" defines the storage type for this field. i.e. Types.SERIALIZED({ type: Types.STRING(1024) })');
+
+    super(options);
+
+    options.type = Type.instantiateType(options.type);
+
+    Object.defineProperties(this, {
+      'options': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        options,
+      },
+    });
+  }
+
+  getOptions() {
+    return this.options;
+  }
+
+  initialize(connection, self) {
+    let options = this.getOptions();
+    options.type.initialize(connection, self);
+  }
+
+  castToType({ value, connection }) {
+    return this.deserialize(value, connection);
+  }
+
+  onSetFieldValue({ value, fieldName, self }) {
+    // we make a copy here
+    // so that when the value is modified
+    // we can detect the changes later
+    let clonedValue = this.deserialize(this.serialize(value, self.getConnection() || {}));
+    self._typeData[fieldName] = clonedValue;
+  }
+
+  isDirty(context) {
+    let options = this.getOptions();
+    if (typeof options.isDirty === 'function')
+      return options.isDirty.call(this, context);
+
+    let { value, fieldName, self, connection } = context;
+    let currentValue = self._typeData[fieldName];
+    if (value == null && currentValue == null)
+      return;
+
+    if (this.serialize(value, connection) !== this.serialize(currentValue, connection))
+      return value;
+  }
+
+  isValidValue() {
+    return true;
+  }
+
+  serialize(value, connection) {
+    if (!connection)
+      return value;
+
+    let options   = this.getOptions();
+    let innerType = options.type;
+
+    if (value != null && innerType.isValidValue(value))
+      return value;
+
+    return options.serialize({ value, connection });
+  }
+
+  deserialize(value, connection) {
+    let options   = this.getOptions();
+    let innerType = options.type;
+
+    if (value != null && !innerType.isValidValue(value))
+      return value;
+
+    return options.deserialize({ value, connection });
+  }
+
+  toString(connection) {
+    let options   = this.getOptions();
+    let innerType = options.type;
+    return innerType.toString(connection);
+  }
+
+  toConnectionType(connection, options) {
+    let typeOptions = this.getOptions();
+    let innerType   = typeOptions.type;
+
+    if (!connection)
+      return innerType.toString();
+
+    return connection.typeToString(innerType, options);
+  }
+}
+
+module.exports = {
+  SERIALIZED: Type.wrapConstructor(SerializedType),
+  SerializedType,
+};

package/lib/types/index.js

@@ -12,9 +12,11 @@ const {
   CharType,
   DateTimeType,
   DateType,
-  FloatType,
+  NumericType,
+  RealType,
   ForeignKeyType,
   IntegerType,
+  SerializedType,
   StringType,
   TextType,
   UUIDV1Type,
@@ -28,9 +30,11 @@ const {
   CHAR,
   DATE,
   DATETIME,
-  FLOAT,
+  NUMERIC,
+  REAL,
   FOREIGN_KEY,
   INTEGER,
+  SERIALIZED,
   STRING,
   TEXT,
   UUIDV1,
@@ -59,9 +63,11 @@ module.exports = {
   CharType,
   DateTimeType,
   DateType,
-  FloatType,
+  NumericType,
+  RealType,
   ForeignKeyType,
   IntegerType,
+  SerializedType,
   StringType,
   TextType,
   UUIDV1Type,
@@ -75,9 +81,11 @@ module.exports = {
   CHAR,
   DATE,
   DATETIME,
-  FLOAT,
+  NUMERIC,
+  REAL,
   FOREIGN_KEY,
   INTEGER,
+  SERIALIZED,
   STRING,
   TEXT,
   UUIDV1,

package/lib/types/type.js

@@ -229,6 +229,12 @@ class Type {
   initialize(connection, self) {
   }
 
+  isDirty() {
+  }
+
+  onSetFieldValue() {
+  }
+
   serialize(value) {
     return value;
   }

package/lib/utils/model-utils.js

@@ -81,32 +81,52 @@ function fieldToFullyQualifiedName(field, Model) {
   return `${def.modelName}:${def.fieldNames[0]}`;
 }
 
-function sortModelNamesByDependencyOrder(connection, modelNames, dependencyHelper) {
-  let modelOrderMap = {};
-  for (let i = 0, il = modelNames.length; i < il; i++) {
-    let modelName           = modelNames[i];
-    let Model               = connection.getModel(modelName);
-    let dependentModelNames = dependencyHelper(Model, modelName);
+function sortModelNamesByDependencyOrder(connection, _modelNames, dependencyHelper) {
+  const recursiveAdd = (modelName, _depth) => {
+    if (modelNames.indexOf(modelName) < 0)
+      return;
 
-    modelOrderMap[modelName] = dependentModelNames;
-  }
+    let depth = _depth || 0;
 
-  let sortedModelNames = modelNames.sort((a, b) => {
-    if (a === b)
-      return 0;
+    // eslint-disable-next-line no-magic-numbers
+    if (depth > 10)
+      throw new Error(`ModelUtils::sortModelNamesByDependencyOrder: Cyclic dependency detected with model "${modelName}".`);
 
-    let orderA = modelOrderMap[a];
-    let orderB = modelOrderMap[b];
+    if (finalOrder.has(modelName))
+      return;
 
-    if (orderA.indexOf(b) >= 0)
-      return 1;
+    let dependentModelNames = modelOrderMap[modelName];
+    if (dependentModelNames == null) {
+      let Model = connection.getModel(modelName);
+      dependentModelNames = modelOrderMap[modelName] = (dependencyHelper(Model, modelName) || []);
+    }
 
-    if (orderB.indexOf(a) >= 0)
-      return -1;
+    if (dependentModelNames.length === 0) {
+      finalOrder.set(modelName, dependentModelNames);
+      return;
+    }
 
-    return Math.sign(orderA.length - orderB.length);
-  });
+    for (let j = 0, jl = dependentModelNames.length; j < jl; j++) {
+      let dependentModelName = dependentModelNames[j];
+      recursiveAdd(dependentModelName, depth + 1);
+    }
+
+    finalOrder.set(modelName, dependentModelNames);
+  };
+
+  let modelOrderMap = {};
+  let modelNames    = Nife.toArray(_modelNames).slice().sort();
+  let finalOrder    = new Map();
+
+  for (let i = 0, il = modelNames.length; i < il; i++) {
+    let modelName = modelNames[i];
+    if (!modelName)
+      continue;
+
+    recursiveAdd(modelName);
+  }
 
+  let sortedModelNames = Array.from(finalOrder.keys());
   return sortedModelNames;
 }
 

package/lib/utils/query-utils.js

@@ -60,13 +60,13 @@ const FILTER_OPERATORS = {
   '<>': (Model, fieldName, query, value) => {
     return query.AND(Model.where[fieldName].LT(value[0]).OR[fieldName].GT(value[1]));
   },
-  // Like (TODO: Mythix ORM needs to support this)
+  // Like
   '*':  (Model, fieldName, query, value) => {
-    return query.EQ(value);
+    return query.LIKE(value);
   },
-  // NOT Like (TODO: Mythix ORM needs to support this)
+  // NOT Like
   '!*': (Model, fieldName, query, value) => {
-    return query.EQ(value);
+    return query.NOT_LIKE(value);
   },
 };
 

package/package.json

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