mythix-orm 1.0.1

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

@@ -0,0 +1,325 @@
+'use strict';
+
+const ProxyClass = require('../proxy-class');
+
+let uuid = 1;
+
+function generateID() {
+  return uuid++;
+}
+
+class QueryEngineBase extends ProxyClass {
+  static generateID() {
+    return uuid++;
+  }
+
+  static isQueryContext(value) {
+    return !!(value && value.isQueryContext);
+  }
+
+  static isQuery(value) {
+    if (!value)
+      return false;
+
+    if (value instanceof QueryEngineBase)
+      return true;
+
+    if (value._isQueryEngine)
+      return true;
+
+    if (typeof value._getRawQueryContext === 'function')
+      return true;
+
+    return false;
+  }
+
+  static queryContextType(queryContext) {
+    let contextParams = {
+      hasCondition: false,
+      hasField:     false,
+      hasModel:     false,
+    };
+
+    if (!queryContext)
+      return contextParams;
+
+    if (queryContext.condition)
+      contextParams.hasCondition = true;
+
+    if (queryContext.fieldName)
+      contextParams.hasField = true;
+
+    if (queryContext.Model)
+      contextParams.hasModel = true;
+
+    return contextParams;
+  }
+
+  getModelScopeClass() {
+    return this.getQueryEngineScope().getModelScopeClass();
+  }
+
+  getFieldScopeClass() {
+    return this.getQueryEngineScope().getFieldScopeClass();
+  }
+
+  _inheritContext(context, name, ...args) {
+    let newContext = Object.assign(
+      Object.create(context),
+      { value: undefined },
+      ...args,
+      {
+        contextID: generateID(),
+      },
+    );
+
+    if (name) {
+      newContext[`${name}Context`] = newContext;
+      newContext['currentScopeName'] = name;
+    }
+
+    return newContext;
+  }
+
+  _fetchScope(...scopeNames) {
+    let context = this._getRawQueryContext();
+
+    for (let i = 0, il = scopeNames.length; i < il; i++) {
+      let scopeName = scopeNames[i];
+      if (scopeName === 'queryEngine') {
+        return this._newQueryEngineScope();
+      } else if (scopeName === 'model') {
+        let Model = context.Model;
+        if (!Model)
+          continue;
+
+        return this._newModelScope(Model);
+      } else if (scopeName === 'field') {
+        let Field = context.Field;
+        if (!Field)
+          continue;
+
+        return this._newFieldScope(context.Field);
+      }
+    }
+
+    return this;
+  }
+
+  _newQueryEngineScope() {
+    const QueryEngine = this.getQueryEngineClass();
+    let context       = this.currentContext;
+    let newContext    = this._inheritContext(context, 'queryEngine');
+    let newScope      = new QueryEngine(newContext);
+
+    return newScope;
+  }
+
+  _newModelScope(Model) {
+    let ModelScopeClass = this.getModelScopeClass();
+    let modelName       = Model.getModelName();
+    let context         = this.currentContext;
+    let extra           = {};
+
+    if (!context.rootModel) {
+      extra.rootModelName = modelName;
+      extra.rootModel = Model;
+    }
+
+    // Ensure that the specified model
+    // is the same dialect as the query
+    let modelConnection = Model._getConnection();
+    let dialect;
+
+    if (modelConnection) {
+      dialect = modelConnection.dialect;
+      if (context.dialect && context.dialect !== dialect)
+        throw new Error(`QueryEngine: Model "${Model.getModelName()}" is on a different connection dialect than the current query dialect of "${context.dialect}". You can not match different connection dialects in the same query.`);
+    }
+
+    if (!dialect) {
+      let connection = this.getConnection();
+      if (connection)
+        dialect = connection.dialect;
+    }
+
+    let newContext  = this._inheritContext(context, 'model', { operator: 'MODEL', Model, modelName, dialect }, extra);
+    let newScope    = new ModelScopeClass(newContext);
+
+    // We shouldn't add this scope if this is
+    // already the current model of the scope
+    if (context.Model !== Model)
+      context.queryRoot.push(newContext);
+
+    // But we always need to return the scope
+    // for the proxy to work properly
+    return newScope;
+  }
+
+  _newFieldScope(Field) {
+    let fieldName       = Field.fieldName;
+    let context         = this.currentContext;
+    let FieldScopeClass = this.getFieldScopeClass();
+    let extra           = {};
+
+    if (!context.rootField) {
+      extra.rootFieldName = fieldName;
+      extra.rootField = Field;
+    }
+
+    let newContext  = this._inheritContext(context, 'field', { operator: 'FIELD', fieldName, Field }, extra);
+    let newScope    = new FieldScopeClass(newContext);
+
+    // We shouldn't add this scope if this is
+    // already the current field of the scope
+    if (context.Field !== Field)
+      context.queryRoot.push(newContext);
+
+    // But we always need to return the scope
+    // for the proxy to work properly
+    return newScope;
+  }
+
+  constructor(context) {
+    super();
+
+    this._isQueryEngine = true;
+
+    if (!context)
+      throw new TypeError('QueryEngineBase::constructor: "context" required.');
+
+    if (!context.rootContext) {
+      context._isQueryEngine = true;
+      context.rootContext = context;
+    }
+
+    if (!context.queryRoot)
+      context.queryRoot = [];
+
+    if (!('and' in context))
+      context.and = true;
+
+    if (!('or' in context))
+      context.or = false;
+
+    // console.log(`Creating new ${this.constructor.name} scope: `, context, Object.getPrototypeOf(context));
+
+    let queryRoot = context.queryRoot;
+    Object.defineProperties(this, {
+      queryRoot: {
+        writable:     false,
+        enumberable:  false,
+        configurable: true,
+        value:        queryRoot,
+      },
+      currentContext: {
+        enumberable:  false,
+        configurable: true,
+        get:          () => {
+          let currentContext = queryRoot[queryRoot.length - 1];
+          return currentContext || context;
+        },
+        set:          () => {},
+      },
+    });
+  }
+
+  _getTopContextID() {
+    return this.currentContext.contextID;
+  }
+
+  _getRawQueryContext() {
+    return this.currentContext;
+  }
+
+  _getRawQuery() {
+    return this.currentContext.queryRoot;
+  }
+
+  _isLastPartControl() {
+    let queryParts  = this._getRawQuery();
+    let lastPart    = queryParts[queryParts.length - 1];
+
+    if (Object.prototype.hasOwnProperty.call(lastPart, 'control') && lastPart.control === true)
+      return true;
+
+    return false;
+  }
+
+  _isLastPartCondition() {
+    let queryParts  = this._getRawQuery();
+    let lastPart    = queryParts[queryParts.length - 1];
+
+    if (Object.prototype.hasOwnProperty.call(lastPart, 'condition') && lastPart.condition === true)
+      return true;
+
+    return false;
+  }
+
+  _debugQuery() {
+    let query = this._getRawQuery();
+    for (let i = 0, il = query.length; i < il; i++) {
+      let queryPart = query[i];
+      let operator  = queryPart.operator;
+
+      if (operator === 'MODEL')
+        console.log(`MODEL -> ${queryPart.Model.getModelName()}`);
+      else if (operator === 'FIELD')
+        console.log(`FIELD -> ${queryPart.Field.fieldName}`);
+      else
+        console.log(`${operator} -> ${queryPart.value}`);
+    }
+
+  }
+
+  _addToQuery(queryPart, _context) {
+    let context   = _context || this._getRawQueryContext();
+    let queryRoot = context.queryRoot;
+
+    queryRoot.push(
+      this._inheritContext(
+        context,
+        null,
+        queryPart,
+      ),
+    );
+  }
+
+  getConnection() {
+    return this.currentContext.connection;
+  }
+
+  getModel(modelName) {
+    let connection  = this.getConnection();
+    let Model       = (connection && connection.getModel(modelName));
+
+    if (!Model) {
+      let models = this.currentContext.models;
+      if (models)
+        Model = models[modelName];
+    }
+
+    return Model;
+  }
+
+  getQueryEngineScope() {
+    return this.currentContext.queryEngineScope;
+  }
+
+  getQueryEngineClass() {
+    return this.currentContext.queryEngineScope.constructor;
+  }
+
+  clone() {
+    const Klass           = this.constructor;
+    let context           = this._getRawQueryContext();
+    let queryRootCopy     = this._getRawQuery().slice();
+    let newContext        = Object.assign(Object.create(context), { queryRoot: queryRootCopy });
+
+    queryRootCopy.push(newContext);
+
+    return new Klass(newContext);
+  }
+}
+
+module.exports = QueryEngineBase;

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

@@ -0,0 +1,212 @@
+'use strict';
+
+const Nife            = require('nife');
+const ProxyClass      = require('../proxy-class');
+const QueryEngineBase = require('./query-engine-base');
+const ModelScope      = require('./model-scope');
+const FieldScope      = require('./field-scope');
+const Utils           = require('../utils');
+
+class QueryEngine extends QueryEngineBase {
+  getModelScopeClass() {
+    return ModelScope;
+  }
+
+  getFieldScopeClass() {
+    return FieldScope;
+  }
+
+  constructor(_context) {
+    let context = Object.assign(
+      Object.create(_context || {}),
+      {
+        currentScopeName: 'queryEngine',
+        isQueryContext:   true,
+        contextID:        QueryEngineBase.generateID(),
+      },
+    );
+
+    super(context);
+
+    context.queryEngineScope = this;
+  }
+
+  Model(modelName) {
+    let model = this.getModel(modelName);
+    if (!model)
+      throw new Error(`QueryEngine::Model: Requested model "${modelName}" not found.`);
+
+    return this._newModelScope(model);
+  }
+
+  unscoped(context) {
+    let QueryEngineClass  = this.constructor;
+    let currentContext    = context || this.currentContext;
+    let queryEngine       = new QueryEngineClass({
+      connection: currentContext.connection,
+    });
+
+    if (currentContext.rootModelName)
+      queryEngine = queryEngine[currentContext.rootModelName];
+
+    return queryEngine;
+  }
+
+  toString(...args) {
+    if (args.length === 0)
+      return `${this.constructor.name} {}`;
+
+    let connection      = args[0];
+    let queryGenerator  = connection.getQueryGenerator();
+
+    return queryGenerator.generateSelectStatement(this, args[1]);
+  }
+
+  toSQL(options) {
+    let connection = this.getConnection();
+    return this.toString(connection, options);
+  }
+
+  MERGE(_queryEngine) {
+    let queryEngine = _queryEngine;
+    if (!queryEngine)
+      return this;
+
+    let thisQueryContext = this._getRawQueryContext();
+    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;
+
+    for (let i = 0, il = sourceQuery.length; i < il; i++) {
+      let queryPart     = sourceQuery[i];
+      let mergeContext  = Utils.objectAssignSpecial(queryPart, null, [
+        // Skip the following keys
+        // as they are provided by the
+        // parent queryEngine
+        'connection',
+        'contextID',
+        'fieldContext',
+        'isQueryContext',
+        'modelContext',
+        'queryEngineScope',
+        'queryRoot',
+        'rootContext',
+        'rootModel',
+        'rootModelName',
+      ]);
+
+      // Skip unneeded duplicate model entries
+      if (mergeContext.operator === 'MODEL') {
+        if (mergeContext.Model === currentModel)
+          continue;
+
+        currentModel = mergeContext.Model;
+      }
+
+      this._addToQuery(Object.assign({
+        Model:      queryPart.Model,
+        modelName:  queryPart.modelName,
+        Field:      queryPart.Field,
+        fieldName:  queryPart.fieldName,
+      }, mergeContext));
+    }
+
+    return this;
+  }
+
+  all(options) {
+    let connection = this.getConnection(options && options.connection);
+
+    if (options && options.stream)
+      return connection.select(this, options);
+    else
+      return Utils.collect(connection.select(this, options));
+  }
+
+  async first(_limit, options) {
+    let limit       = (_limit == null) ? 1 : _limit;
+    let connection  = this.getConnection(options && options.connection);
+    let query       = this.clone().LIMIT(limit);
+
+    let result = await Utils.collect(connection.select(query, options));
+    return (_limit == null) ? result[0] : result;
+  }
+
+  async last(_limit, options) {
+    let limit       = (_limit == null) ? 1 : _limit;
+    let connection  = this.getConnection(options && options.connection);
+    let query       = this.clone().LIMIT(limit);
+
+    let result = await Utils.collect(connection.select(query, Object.assign({}, options || {}, { reverseOrder: true })));
+    return (_limit == null) ? result[0] : result.reverse();
+  }
+
+  async update(attributes, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.updateAll(this, attributes, options);
+  }
+
+  async destroy(options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.destroy(this, options);
+  }
+
+  async average(field, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.average(this, field, options);
+  }
+
+  async count(field, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.count(this, field, options);
+  }
+
+  async min(field, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.min(this, field, options);
+  }
+
+  async max(field, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.max(this, field, options);
+  }
+
+  async sum(field, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.sum(this, field, options);
+  }
+
+  async pluck(fields, options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.pluck(this, fields, options);
+  }
+
+  async exists(options) {
+    let connection = this.getConnection(options && options.connection);
+    return await connection.exists(this, options);
+  }
+
+  [ProxyClass.MISSING](target, prop) {
+    if (prop === 'debug') {
+      this.currentContext.rootContext.debug = true;
+      return this._fetchScope('model', 'queryEngine');
+    }
+
+    let model = this.getModel(prop);
+    if (model) {
+      return this._newModelScope(model).__call(function(...args) {
+        let fieldName = args.find((arg) => (arg && arg.constructor && !arg.constructor._isMythixConnection));
+        if (!fieldName)
+          return this;
+
+        return this.Field(fieldName);
+      });
+    }
+
+    return this[prop];
+  }
+}
+
+module.exports = QueryEngine;

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const Nife                = require('nife');
+const Type                = require('../type');
+const { AUTO_INCREMENT }  = require('../helpers/default-helpers');
+
+class BigIntType extends Type {
+  static Default = {
+    AUTO_INCREMENT,
+  };
+
+  static getDisplayName() {
+    return 'BIGINT';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length, _options) {
+    let options = _options || {};
+
+    super(length, options);
+
+    this.length = length || null;
+
+    Object.defineProperties(this, {
+      '_options': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        options,
+      },
+    });
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let castValue = BigInt(value);
+    if (this._options.strict === true)
+      return castValue;
+
+    return Number(castValue).valueOf();
+  }
+
+  isValidValue(value) {
+    return (Nife.instanceOf(value, 'number', 'bigint') && isFinite(value));
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : `BIGINT${(this.length != null) ? `(${this.length})` : ''}`;
+  }
+}
+
+module.exports = {
+  BIGINT: Type.wrapConstructor(BigIntType),
+  BigIntType,
+};

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

@@ -0,0 +1,46 @@
+'use strict';
+
+/* global Buffer */
+
+const Type = require('../type');
+
+class BlobType extends Type {
+  static getDisplayName() {
+    return 'BLOB';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length) {
+    super(length);
+
+    this.length = length || null;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    if (!Buffer.isBuffer(value))
+      throw new TypeError(`BlobType::castToType: Value provided ("${value}") can not be cast into a Buffer. Please provide a Buffer directly.`);
+
+    return value;
+  }
+
+  isValidValue(value) {
+    return Buffer.isBuffer(value);
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'BLOB';
+  }
+}
+
+module.exports = {
+  BLOB: Type.wrapConstructor(BlobType),
+  BlobType,
+};

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

@@ -0,0 +1,41 @@
+'use strict';
+
+const Type = require('../type');
+
+class BooleanType extends Type {
+  static getDisplayName() {
+    return 'BOOLEAN';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    if (value === 'true')
+      return true;
+
+    if (value === 'false')
+      return false;
+
+    return !!value;
+  }
+
+  isValidValue(value) {
+    return (value === true || value === false);
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'BOOLEAN';
+  }
+}
+
+module.exports = {
+  BOOLEAN: Type.wrapConstructor(BooleanType),
+  BooleanType,
+};