mythix-orm 1.0.1

package/lib/types/virtual/models-type.js

@@ -0,0 +1,264 @@
+'use strict';
+
+const Nife                = require('nife');
+const Inflection          = require('inflection');
+const RelationalTypeBase  = require('./relational-type-base');
+const Utils               = require('../../utils');
+
+const NAMED_METHOD = false;
+
+async function destroyRelatedModels(connection, field, type, TargetModel, storedModels, invertMatch, options, operation) {
+  // Destroy all relations not matching stored set
+  let thisMethodName      = type.fieldNameToOperationName(field, operation, NAMED_METHOD);
+  let parentModelName     = this.getModelName();
+  let idMap               = Utils.getPrimaryKeysForModels(connection, TargetModel, storedModels, { includeRelations: true, skipRelations: [ field.Model.getModelName() ] });
+  let { relationalMap }   = await Utils.getRelationalModelStatusForField(connection, this, field);
+  let sortedModelNames    = Nife.subtractFromArray(Utils.sortModelNamesByCreationOrder(connection, Object.keys(relationalMap)), [ parentModelName ]);
+  let targetRelationName  = sortedModelNames[0];
+  let destroyModelNames   = sortedModelNames.slice(1).reverse();
+  let targetIDs           = idMap[targetRelationName];
+  let targetPKFieldName   = TargetModel.getPrimaryKeyFieldName();
+
+  if (destroyModelNames.length === 0) {
+    // No through-table... this is a one-to-many relation.
+    // We can only destroy if the TargetModel has a foreign key
+    // to the parent model.
+
+    // Set destroyModelNames to the first relation.
+    // The following code will ensure they only get
+    // deleted if there is a foreign key relationship
+    // to the parent model.
+    destroyModelNames = [ targetRelationName ];
+  }
+
+  for (let i = 0, il = destroyModelNames.length; i < il; i++) {
+    let modelName = destroyModelNames[i];
+    let ids       = idMap[modelName];
+
+    // If we have no ids for this model, then
+    // there is nothing we can destroy
+    if (Nife.isEmpty(ids))
+      continue;
+
+    let ThisModel             = connection.getModel(modelName);
+    let thisModelPKFieldName  = ThisModel.getPrimaryKeyFieldName();
+    if (!thisModelPKFieldName) {
+      // Not sure how this would happen... since we obviously
+      // have a list of ids already... but let's be safe anyway
+      continue;
+    }
+
+    // We can only destroy models that have a foreign key
+    // to the parent model.
+    let foreignFieldNames = ThisModel.getForeignKeysTargetFieldNames(connection, parentModelName);
+    if (Nife.isEmpty(foreignFieldNames))
+      continue;
+
+    // Create query to destroy related models
+    let query = ThisModel.where(connection)[thisModelPKFieldName];
+    if (invertMatch)
+      query = query.EQ(ids);
+    else
+      query = query.NOT.EQ(ids);
+
+    for (let j = 0, jl = foreignFieldNames.length; j < jl; j++) {
+      let { targetFieldName, sourceFieldName } = foreignFieldNames[j];
+      let parentModelValue = this[targetFieldName];
+
+      // If this value is empty then something is wrong...
+      // so fail early to prevent unwanted data loss
+      if (parentModelValue == null)
+        throw new Error(`${parentModelName}::${thisMethodName}: Field "${parentModelName}.${targetFieldName}" can not be empty for this operation.`);
+
+      query = query.AND[sourceFieldName].EQ(parentModelValue);
+    }
+
+    // If there is a foreign field that points to the target
+    // relation, then also match against those
+    if (targetPKFieldName && Nife.isNotEmpty(targetIDs)) {
+      let targetForeignField = ThisModel.getForeignKeysTargetField(connection, targetRelationName, targetPKFieldName);
+      if (targetForeignField) {
+        if (invertMatch)
+          query = query.AND[modelName][targetForeignField.sourceFieldName].EQ(targetIDs);
+        else
+          query = query.AND[modelName][targetForeignField.sourceFieldName].NOT.EQ(targetIDs);
+      }
+    }
+
+    // Now destroy relations to update set
+    await query.destroy(options);
+  }
+}
+
+// These get injected into the class as
+// addTo{fieldName}, get{fieldName}, etc...
+const TYPE_OPERATIONS = {
+  'queryFor': async function({ field, type }, userQuery, options, ...args) {
+    return await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+  },
+  'addTo': async function({ field }, _models, options) {
+    let models = Nife.toArray(_models).filter(Boolean);
+    if (Nife.isEmpty(models))
+      return [];
+
+    // TODO: Needs to manage unique constraints
+    // for through tables. Even though the model
+    // might be persisted, the through table record
+    // might still be created, which might blow up
+    // if a constraint fails because the records
+    // already exist
+    return this.getConnection(options && options.connection).transaction(async (connection) => {
+      let currentModels = this[field.fieldName];
+      if (Nife.isEmpty(currentModels))
+        currentModels = [];
+
+      let storedModels  = await Utils.createAndSaveAllRelatedModels(connection, this, field, models, options);
+      let allModels     = currentModels.concat(storedModels);
+
+      this[field.fieldName] = allModels;
+
+      return storedModels;
+    }, options);
+  },
+  'get': function({ field, type }, userQuery, options, ...args) {
+    const doGet = async function*() {
+      let query                       = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+      let results                     = query.all(Object.assign({}, options, { stream: true }));
+      let primaryModelRelationalArray = [];
+
+      this[field.fieldName] = primaryModelRelationalArray;
+
+      for await (let item of results) {
+        primaryModelRelationalArray.push(item);
+
+        yield item;
+      }
+    };
+
+    if (options && options.stream === true)
+      return doGet.call(this);
+    else
+      return Utils.collect(doGet.call(this));
+  },
+  'set': async function({ field, type, addTo }, models, options) {
+    return this.getConnection(options && options.connection).transaction(async (connection) => {
+      let TargetModel = type.getTargetModel(connection);
+
+      // Reset relation so we don't end up with
+      // current persisted model instances
+      this[field.fieldName] = [];
+
+      // First, create models in set
+      let storedModels = await addTo.call(this, models, Object.assign({}, options || {}, { connection }));
+
+      await destroyRelatedModels.call(this, connection, field, type, TargetModel, storedModels, false, options, 'set');
+
+      return storedModels;
+    }, options);
+  },
+  'removeFrom': async function({ field, type, get }, _models, _options) {
+    return this.getConnection(_options && _options.connection).transaction(async (connection) => {
+      let { relationalMap, TargetModel } = await Utils.getRelationalModelStatusForField(connection, this, field);
+      let primaryModelName  = this.getModelName();
+      let targetModelName   = TargetModel.getModelName();
+      let models            = Nife.toArray(_models);
+
+      const needsLoad = async () => {
+        let sortedModelNames = Utils.sortModelNamesByCreationOrder(connection, Object.keys(relationalMap));
+
+        for (let i = 0, il = models.length; i < il; i++) {
+          let model = models[i];
+
+          if (!(model instanceof TargetModel))
+            return true;
+
+          if (!model.isPersisted())
+            return true;
+
+          for (let j = 0, jl = sortedModelNames.length; j < jl; j++) {
+            let modelName = sortedModelNames[j];
+            if (modelName === targetModelName || modelName === primaryModelName)
+              continue;
+
+            let relation        = relationalMap[modelName];
+            let ThisModel       = relation.Model;
+            let pluralModelName = ThisModel.getPluralModelName();
+
+            if (!model[pluralModelName])
+              return true;
+
+            let relationSet = model[pluralModelName];
+            if (Nife.isEmpty(relationSet))
+              return true;
+
+            if (!relationSet.every((relatedModel) => relatedModel.isPersisted()))
+              return true;
+          }
+        }
+
+        return false;
+      };
+
+      let options = Object.assign({}, _options || {}, { connection });
+      let storedModels;
+
+      if (await needsLoad()) {
+        let query = Utils.generateQueryFromFilter(connection, TargetModel, models);
+        if (!query)
+          throw new Error(`${this.getModelName()}::${type.fieldNameToOperationName(field, 'removeFrom', NAMED_METHOD)}: Data provided is insufficient to complete operation.`);
+
+        storedModels = await get.call(this, TargetModel.where(connection).AND(query), Object.assign({}, options, { stream: false, includeRelations: true, connection }));
+      } else {
+        storedModels = models;
+      }
+
+      // Destroy target relations to removed
+      // requested models from set
+      await destroyRelatedModels.call(this, connection, field, type, TargetModel, storedModels, true, options, 'removeFrom');
+
+      return storedModels.length;
+    }, _options);
+  },
+  'destroy': async function({ field, type }, userQuery, options, ...args) {
+    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    return await query.destroy(options);
+  },
+  'count': async function({ field, type }, userQuery, options, ...args) {
+    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    return await query.count(null, options);
+  },
+  'has': async function({ count }, userQuery, options, ...args) {
+    let itemCount = await count.call(this, userQuery, options, ...args);
+    return (itemCount > 0);
+  },
+};
+
+class ModelsType extends RelationalTypeBase {
+  static exposeToModel() {
+    return false;
+  }
+
+  isManyRelation() {
+    return true;
+  }
+
+  fieldNameToOperationName(field, operation, rootMethod) {
+    let fieldName = field.pluralName;
+    if (!fieldName)
+      fieldName = Nife.capitalize(Inflection.pluralize(field.fieldName));
+
+    if (rootMethod)
+      return `_${operation}${fieldName}`;
+    else
+      return `${operation}${fieldName}`;
+  }
+
+  initialize(connection, self) {
+    return super.initialize(connection, self, TYPE_OPERATIONS);
+  }
+}
+
+module.exports = {
+  Models: RelationalTypeBase.wrapConstructor(ModelsType),
+  ModelsType,
+};

package/lib/types/virtual/relational-type-base.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const Nife            = require('nife');
+const Type            = require('../type');
+const Utils           = require('../../utils');
+const { QueryEngine } = require('../../query-engine');
+
+const NAMED_METHOD  = false;
+const ROOT_METHOD   = true;
+
+class RelationalTypeBase extends Type {
+  static isVirtual() {
+    return true;
+  }
+
+  static isRelational() {
+    return true;
+  }
+
+  // Model types work by specifying a "target"
+  // and a "value provider" (source).
+  // These are fully qualified names, meaning
+  // they also point to the model as well as the field.
+  // If no model is specified, then it always defaults to
+  // "this" model. If no field is specified, then it always
+  // defaults to "this PK" of the model.
+  // Mythix ORM will recursively walk all models and fields
+  // defined until it has the full relationships between
+  // all fields.
+  constructor(_targetModelName, queryFactory, _options) {
+    let options = _options || {};
+
+    super(_targetModelName, queryFactory, options);
+
+    let targetModelName = _targetModelName;
+    if (!targetModelName || !(Nife.instanceOf(targetModelName, 'string') || targetModelName._isMythixModel))
+      throw new TypeError(`${this.constructor.name}::constructor: First argument is required to be a model or a model name.`);
+
+    if (targetModelName._isMythixModel)
+      targetModelName = targetModelName.getModelName();
+
+    Object.defineProperties(this, {
+      'targetModelName': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        targetModelName,
+      },
+      'queryFactory': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        queryFactory,
+      },
+      'options': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        options,
+      },
+    });
+  }
+
+  getOptions() {
+    return this.options;
+  }
+
+  initialize(connection, self, methods) {
+    if (typeof this.queryFactory !== 'function') {
+      let debugScope = '';
+
+      let Model = this.getModel();
+      let Field = this.getField();
+
+      if (Model || Field) {
+        let modelName = (Model) ? Model.getModelName() : '<UnknownModel>';
+        let fieldName = (Field) ? Field.fieldName : '<UnknownField>';
+
+        debugScope = `"${modelName}:${fieldName}" `;
+      }
+
+      throw new TypeError(`${this.constructor.name}::initialize: ${debugScope}Bad relation arguments. Expected a method that returns a query.`);
+    }
+
+    super.initialize(connection, self);
+
+    if (!connection)
+      throw new Error(`${this.constructor.name}::initialize: A connection is required to use the ModelType.`);
+
+    let field           = this.getField();
+    let context         = {};
+    let binding         = Object.create(context);
+    let operationNames  = Object.keys(methods);
+
+    for (let i = 0, il = operationNames.length; i < il; i++) {
+      let operation       = operationNames[i];
+      let method          = methods[operation];
+      let methodName      = this.fieldNameToOperationName(field, operation, NAMED_METHOD);
+      let fullMethodName  = this.fieldNameToOperationName(field, operation, ROOT_METHOD);
+
+      context[operation] = function(...args) {
+        return this[methodName].apply(this, args);
+      };
+
+      context[`_${operation}`] = function(...args) {
+        return this[fullMethodName].apply(this, args);
+      };
+
+      Object.assign(binding, { methodName, fullMethodName, field, type: this });
+
+      Utils.injectModelMethod(self, method.bind(self, binding), methodName, fullMethodName);
+    }
+  }
+
+  async walkQueryRelations(connection, callback, context, ...args) {
+    const isAlreadyVisited = (leftContext, rightContext) => {
+      // Model can't be related to itself
+      if (leftContext.modelName === rightContext.modelName)
+        return true;
+
+      let firstKey  = `${leftContext.modelName}:${leftContext.fieldName}<->${rightContext.modelName}:${rightContext.fieldName}`;
+      let secondKey = `${rightContext.modelName}:${rightContext.fieldName}<->${leftContext.modelName}:${leftContext.fieldName}`;
+      if (alreadyVisited.has(firstKey))
+        return true;
+
+      if (alreadyVisited.has(secondKey))
+        return true;
+
+      alreadyVisited.add(firstKey);
+      alreadyVisited.add(secondKey);
+
+      return false;
+    };
+
+    const prepareSourceAndTarget = (leftContext, rightContext) => {
+      const voidFieldForNonRelational = (info) => {
+        let { target, source } = info;
+
+        if (target.field.type.isRelational() && !source.field.type.isRelational()) {
+          source.field = null;
+          source.fieldName = null;
+        }
+
+        if (!target.field.type.isRelational() && source.field.type.isRelational()) {
+          target.field = null;
+          target.fieldName = null;
+        }
+
+        return info;
+      };
+
+      let target = {
+        Model:      leftContext.Model,
+        modelName:  leftContext.modelName,
+        field:      leftContext.Field,
+        fieldName:  leftContext.fieldName,
+      };
+
+      let source = {
+        Model:      rightContext.Model,
+        modelName:  rightContext.modelName,
+        field:      rightContext.Field,
+        fieldName:  rightContext.fieldName,
+      };
+
+      // The primary model is always the target
+      // so swap the order if it is currently
+      // marked as the source
+      let swapRelation = (source.modelName === primaryModelName);
+
+      return voidFieldForNonRelational({
+        PrimaryModel,
+        TargetModel,
+        TargetField,
+        target: (swapRelation) ? source : target,
+        source: (swapRelation) ? target : source,
+      });
+    };
+
+    let PrimaryModel      = (context.self && context.self.getModel());
+    let primaryModelName  = PrimaryModel.getModelName();
+    let query             = await this.prepareQuery(Object.assign({ connection }, context), args);
+    let queryParts        = query._getRawQuery();
+    let queryContext      = (queryParts[queryParts.length - 1] || {});
+    let TargetModel       = queryContext.rootModel;
+    let TargetField       = queryContext.rootField;
+    let alreadyVisited    = new Set();
+
+    for (let i = 0, il = queryParts.length; i < il; i++) {
+      let leftQueryContext = queryParts[i];
+
+      if (!(Object.prototype.hasOwnProperty.call(leftQueryContext, 'condition') && leftQueryContext.condition))
+        continue;
+
+      let conditionValue    = leftQueryContext.value;
+      let rightQueryContext = null;
+
+      if (QueryEngine.isQuery(conditionValue)) {
+        rightQueryContext = conditionValue._getRawQueryContext();
+        if (rightQueryContext.condition)
+          continue;
+      } else {
+        continue;
+      }
+
+      if (isAlreadyVisited(leftQueryContext, rightQueryContext))
+        continue;
+
+      callback(prepareSourceAndTarget(leftQueryContext, rightQueryContext));
+
+      if (leftQueryContext.Field.type.isForeignKey()) {
+        let fkField         = leftQueryContext.Field.type;
+        let targetModel     = fkField.getTargetModel(connection);
+        let targetModelName = fkField.getTargetModelName(connection);
+        let targetField     = fkField.getTargetField(connection);
+        let targetFieldName = fkField.getTargetFieldName(connection);
+        let fkContext       = {
+          Model:      targetModel,
+          modelName:  targetModelName,
+          field:      targetField,
+          fieldName:  targetFieldName,
+        };
+
+        if (!isAlreadyVisited(fkContext, rightQueryContext))
+          callback(prepareSourceAndTarget(fkContext, rightQueryContext));
+      }
+
+      if (rightQueryContext.Field.type.isForeignKey()) {
+        let fkField         = rightQueryContext.Field.type;
+        let targetModel     = fkField.getTargetModel(connection);
+        let targetModelName = fkField.getTargetModelName(connection);
+        let targetField     = fkField.getTargetField(connection);
+        let targetFieldName = fkField.getTargetFieldName(connection);
+        let fkContext       = {
+          Model:      targetModel,
+          modelName:  targetModelName,
+          field:      targetField,
+          fieldName:  targetFieldName,
+        };
+
+        if (!isAlreadyVisited(leftQueryContext, fkContext))
+          callback(prepareSourceAndTarget(leftQueryContext, fkContext));
+      }
+    }
+
+    if (TargetField.type.isRelational() && TargetField.type.isManyRelation())
+      return query;
+
+    if (context.field.type.isRelational() && context.field.type.isManyRelation())
+      return query;
+
+    // Here the source and target are swapped
+    // because the target will be the primary model
+    // and the source (target model) is where we will
+    // be copying field values from
+    let targetModelName = TargetModel.getModelName();
+    let source      = {
+      Model:      TargetModel,
+      modelName:  targetModelName,
+      Field:      TargetField,
+      fieldName:  TargetField.fieldName,
+    };
+    let target    = {
+      Model:      PrimaryModel,
+      modelName:  PrimaryModel.getModelName(),
+      Field:      context.field,
+      fieldName:  context.field.fieldName,
+    };
+
+    if (!isAlreadyVisited(source, target))
+      callback(prepareSourceAndTarget(source, target));
+
+    return query;
+  }
+
+  getTargetModel(_connection) {
+    let connection    = _connection || this.getModel().getConnection();
+    return connection.getModel(this.targetModelName);
+  }
+
+  async prepareQuery({ connection: _connection, self, field, options: _options, userQuery: _userQuery }, args) {
+    let options       = _options || {};
+    let queryFactory  = this.queryFactory;
+    let connection    = _connection || self.getConnection(options.connection);
+    let userQuery     = _userQuery;
+    let TargetModel   = this.getTargetModel(connection);
+
+    if (!QueryEngine.isQuery(userQuery) && Nife.instanceOf(userQuery, 'array', 'object', 'map', 'set'))
+      userQuery = Utils.generateQueryFromFilter(connection, TargetModel, userQuery);
+
+    let rootQuery     = await queryFactory.call(
+      self,
+      Object.assign(
+        {
+          userQuery:  userQuery || undefined,
+          type:       this,
+          self,
+          connection,
+          field,
+        },
+        connection.getModels() || {},
+      ),
+      ...(args || []),
+    );
+
+    if (!QueryEngine.isQuery(rootQuery)) {
+      // eslint-disable-next-line no-magic-numbers
+      throw new Error(`${this.constructor.name}::prepareQuery: Query factory is required to return a query. Got "${('' + rootQuery).slice(0, 1000)}" instead.`);
+    }
+
+    return rootQuery.AND[TargetModel.getModelName()];
+  }
+
+  toConnectionType() {
+    throw new Error(`${this.constructor.name}::toConnectionType: Can not convert relational types to DB types.`);
+  }
+
+  toString() {
+    return `${this.constructor.name} {}`;
+  }
+}
+
+module.exports = RelationalTypeBase;

package/lib/utils/index.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const MiscUtils   = require('./misc-utils');
+const ModelUtils  = require('./model-utils');
+const QueryUtils  = require('./query-utils');
+
+const {
+  collect,
+  copyStaticProps,
+  objectAssignSpecial,
+  iterateStaticProps,
+} = MiscUtils;
+
+const {
+  assignRelatedModels,
+  buildQueryFromModelsAttributes,
+  constructModelsForCreationFromOriginField,
+  createAndSaveAllRelatedModels,
+  fieldToFullyQualifiedName,
+  getPrimaryKeysForModels,
+  getRelationalModelStatusForField,
+  injectModelMethod,
+  isUUID,
+  parseQualifiedName,
+  sanitizeFieldString,
+  setRelationalValues,
+  sortModelNamesByCreationOrder,
+  sortModelNamesByDependencyOrder,
+} = ModelUtils;
+
+const {
+  parseFilterFieldAndOperator,
+  generateQueryFromFilter,
+} = QueryUtils;
+
+module.exports = {
+  MiscUtils,
+  ModelUtils,
+
+  // MiscUtils
+  collect,
+  copyStaticProps,
+  objectAssignSpecial,
+  iterateStaticProps,
+
+  // ModelUtils
+  assignRelatedModels,
+  buildQueryFromModelsAttributes,
+  constructModelsForCreationFromOriginField,
+  createAndSaveAllRelatedModels,
+  fieldToFullyQualifiedName,
+  getPrimaryKeysForModels,
+  getRelationalModelStatusForField,
+  injectModelMethod,
+  isUUID,
+  parseQualifiedName,
+  sanitizeFieldString,
+  setRelationalValues,
+  sortModelNamesByCreationOrder,
+  sortModelNamesByDependencyOrder,
+
+  // QueryUtils
+  parseFilterFieldAndOperator,
+  generateQueryFromFilter,
+};