mythix-orm 1.0.1

package/lib/types/index.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const Type          = require('./type');
+const ConcreteTypes = require('./concrete');
+const VirtualTypes  = require('./virtual');
+const Helpers       = require('./helpers');
+
+const {
+  BigIntType,
+  BlobType,
+  BooleanType,
+  CharType,
+  DateTimeType,
+  DateType,
+  FloatType,
+  ForeignKeyType,
+  IntegerType,
+  StringType,
+  TextType,
+  UUIDV1Type,
+  UUIDV3Type,
+  UUIDV4Type,
+  UUIDV5Type,
+  XIDType,
+  BIGINT,
+  BLOB,
+  BOOLEAN,
+  CHAR,
+  DATE,
+  DATETIME,
+  FLOAT,
+  FOREIGN_KEY,
+  INTEGER,
+  STRING,
+  TEXT,
+  UUIDV1,
+  UUIDV3,
+  UUIDV4,
+  UUIDV5,
+  XID,
+} = ConcreteTypes;
+
+const {
+  ModelType,
+  ModelsType,
+  Model,
+  Models,
+} = VirtualTypes;
+
+module.exports = {
+  DefaultHelpers: Helpers.DefaultHelpers,
+  Type,
+  Helpers,
+
+  // Concrete Types
+  BigIntType,
+  BlobType,
+  BooleanType,
+  CharType,
+  DateTimeType,
+  DateType,
+  FloatType,
+  ForeignKeyType,
+  IntegerType,
+  StringType,
+  TextType,
+  UUIDV1Type,
+  UUIDV3Type,
+  UUIDV4Type,
+  UUIDV5Type,
+  XIDType,
+  BIGINT,
+  BLOB,
+  BOOLEAN,
+  CHAR,
+  DATE,
+  DATETIME,
+  FLOAT,
+  FOREIGN_KEY,
+  INTEGER,
+  STRING,
+  TEXT,
+  UUIDV1,
+  UUIDV3,
+  UUIDV4,
+  UUIDV5,
+  XID,
+
+  // Virtual Types
+  ModelType,
+  ModelsType,
+  Model,
+  Models,
+};

package/lib/types/type.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const { checkDefaultValueFlags }  = require('./helpers/default-helpers');
+
+class Type {
+  static _isMythixFieldType = true;
+
+  static clone = function() {
+    return this;
+  };
+
+  static isTypeClass(value) {
+    if (!value)
+      return false;
+
+    if (value.prototype instanceof Type)
+      return true;
+
+    if (value._isMythixFieldType)
+      return true;
+
+    return false;
+  }
+
+  static isType(value) {
+    if (!value)
+      return false;
+
+    if (value instanceof Type)
+      return true;
+
+    if (value.constructor._isMythixFieldType)
+      return true;
+
+    return false;
+  }
+
+  static instantiateType(_type) {
+    let type = _type;
+    if (!type)
+      throw new TypeError('Type::instantiateType: "type" is required.');
+
+    // Already instantiated?
+    if (Type.isType(type))
+      return type.clone();
+
+    const ThisType = type;
+    return new ThisType();
+  }
+
+  static isVirtual() {
+    return false;
+  }
+
+  static isRelational() {
+    return false;
+  }
+
+  static isForeignKey() {
+    return false;
+  }
+
+  static exposeToModel() {
+    return true;
+  }
+
+  static wrapConstructor(TypeKlass) {
+    let TypeWrapper = function(...args) {
+      return new TypeKlass(...args);
+    };
+
+    const staticPropertiesToCopy = [
+      'Default',
+      '_isMythixFieldType',
+      'clone',
+      'isTypeClass',
+      'isType',
+      'instantiateType',
+      'isVirtual',
+      'isRelational',
+      'isForeignKey',
+      'exposeToModel',
+    ];
+
+    for (let i = 0, il = staticPropertiesToCopy.length; i < il; i++) {
+      let propName  = staticPropertiesToCopy[i];
+      let value     = TypeKlass[propName];
+
+      if (value !== undefined)
+        TypeWrapper[propName] = value;
+    }
+
+    Object.defineProperties(TypeWrapper, {
+      'name': {
+        writable:     false,
+        enumberable:  false,
+        configurable: false,
+        value:        `${TypeKlass.name}Wrapper`,
+      },
+    });
+
+    return TypeWrapper;
+  }
+
+  constructor(...args) {
+    Object.defineProperties(this, {
+      '_args': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        args,
+      },
+      '_Model': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+      '_field': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+      '_modelInstance': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+      '_connection': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        null,
+      },
+      '_initialized': {
+        enumberable:  false,
+        configurable: true,
+        get:          () => {
+          return !!(this._Model && this._field);
+        },
+        set:          () => {},
+      },
+    });
+  }
+
+  clone() {
+    let Type        = this.constructor;
+    let newInstance = new Type(...this._args);
+
+    newInstance._Model = this._Model;
+    newInstance._field = this._field;
+    newInstance._modelInstance = this._modelInstance;
+
+    return newInstance;
+  }
+
+  isVirtual() {
+    return this.constructor.isVirtual.call(this.constructor);
+  }
+
+  isRelational() {
+    return this.constructor.isRelational.call(this.constructor);
+  }
+
+  isForeignKey() {
+    return this.constructor.isForeignKey.call(this.constructor);
+  }
+
+  exposeToModel() {
+    return this.constructor.exposeToModel.call(this.constructor);
+  }
+
+  isRemote() {
+    let field = this.getField();
+    if (!field)
+      throw new Error(`${this.constructor.name}::isRemote: Error, the model type must be initialized before you call "isRemote".`);
+
+    if (field.remote === true)
+      return true;
+
+    return checkDefaultValueFlags(field.defaultValue, [ 'remote' ]);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  isValidValue(value) {
+    return true;
+  }
+
+  getField() {
+    return this._field;
+  }
+
+  setField(field) {
+    this._field = field;
+  }
+
+  getModel() {
+    let Model = this._Model;
+    if (!Model) {
+      let field = this.getField();
+      if (!field)
+        return;
+
+      Model = field.Model;
+      if (!Model)
+        return;
+
+      this._Model = Model;
+    }
+
+    return Model;
+  }
+
+  setModel(Model) {
+    this._Model = Model;
+  }
+
+  castToType({ value }) {
+    return value;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  initialize(connection, self) {
+  }
+
+  serialize(value) {
+    return value;
+  }
+
+  deserialize(value) {
+    return value;
+  }
+
+  toConnectionType(connection, options) {
+    if (!connection)
+      return this.toString();
+
+    return connection.typeToString(this, options);
+  }
+}
+
+module.exports = Type;

package/lib/types/virtual/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// One to one relationships
+const { ModelType, Model } = require('./model-type');
+
+// One to many, or many to many relationships
+const { ModelsType, Models } = require('./models-type');
+
+module.exports = {
+  ModelType,
+  ModelsType,
+  Model,
+  Models,
+};

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

@@ -0,0 +1,141 @@
+'use strict';
+
+const Nife                = require('nife');
+const RelationalTypeBase  = require('./relational-type-base');
+const ModelUtils          = require('../../utils/model-utils');
+
+// These get injected into the class as
+// create{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);
+  },
+  'create': async function({ field, type, get }, model, options) {
+    if (!model)
+      return false;
+
+    let result = await this.getConnection(options && options.connection).transaction(async (connection) => {
+      let TargetModel = type.getTargetModel(connection);
+
+      // Why are we fetching on get? Because this
+      // could be a complex relationship, and there
+      // might already be something that exists.
+      // TODO: Likely a good area for performance
+      // improvements... we can likely detect if
+      // the relationship is too complex to guess
+      // or not.
+      let fetchedModel  = await get.call(this, TargetModel.where(connection).LIMIT(1), options);
+      if (fetchedModel && fetchedModel instanceof TargetModel) {
+        fetchedModel.setAttributes(model, true);
+        if (fetchedModel.isDirty())
+          await fetchedModel.save(options);
+
+        return fetchedModel;
+      }
+
+      let storedModels  = await ModelUtils.createAndSaveAllRelatedModels(connection, this, field, [ model ], options);
+      let resultModel   = storedModels[0];
+
+      // Update this model to reflect the update
+      ModelUtils.setRelationalValues(connection, this.getModel(), this, resultModel.getModel(), resultModel);
+
+      return resultModel;
+    }, options);
+
+    // Save needs to go outside of the transaction
+    // otherwise some DBs will violate foreign key
+    // constraints
+    if (this.isDirty())
+      await this.save(options);
+
+    return result;
+  },
+  'get': async function({ field, type }, userQuery, options, ...args) {
+    let query = await type.prepareQuery({ connection: null, self: this, field, userQuery, options }, args);
+    return await query.first(null, options);
+  },
+  'update': async function({ fullMethodName, field, type, create }, attributes, _options, ...args) {
+    let options = _options || {};
+
+    let result = await this.getConnection(options.connection).transaction(async (connection) => {
+      let query = await type.prepareQuery({ connection, self: this, field, options }, args);
+      let model = await query.first(null, options);
+
+      if (!model) {
+        if (options.force === true)
+          return await create.call(this, attributes, options);
+
+        throw new Error(`${field.Model.getModelName}::${fullMethodName}: Model not found to update. You can pass "{ force: true }" to the options to force a creation instead.`);
+      }
+
+      model.setAttributes(attributes, true);
+      if (!model.isDirty())
+        return model;
+
+      let [ storedModel ] = await connection.update(model.getModel(), [ model ], options);
+
+      // Update this model to reflect the update
+      ModelUtils.setRelationalValues(connection, this.getModel(), this, storedModel.getModel(), storedModel);
+
+      return storedModel;
+    }, options);
+
+    // Save needs to go outside of the transaction
+    // otherwise some DBs will violate foreign key
+    // constraints
+    if (this.isDirty())
+      await this.save(options);
+
+    return result;
+  },
+  'destroy': async function({ field, type }, options, ...args) {
+    let result = await this.getConnection(options && options.connection).transaction(async (connection) => {
+      let query = await type.prepareQuery({ connection, self: this, field, options }, args);
+      let model = await query.first(options);
+
+      if (!model)
+        return false;
+
+      await connection.destroy(model.getModel(), [ model ], options);
+
+      // Update this model to reflect the deletion
+      ModelUtils.setRelationalValues(connection, this.getModel(), this, model.getModel());
+
+      return true;
+    }, options);
+
+    // Save needs to go outside of the transaction
+    // otherwise some DBs will violate foreign key
+    // constraints
+    if (this.isDirty())
+      await this.save(options);
+
+    return result;
+  },
+  'exists': async function({ field, type }, options, ...args) {
+    let query = await type.prepareQuery({ connection: null, self: this, field, options }, args);
+    return await query.exists(options);
+  },
+};
+
+class ModelType extends RelationalTypeBase {
+  isManyRelation() {
+    return false;
+  }
+
+  fieldNameToOperationName(field, operation, rootMethod) {
+    if (rootMethod)
+      return `_${operation}${Nife.capitalize(field.fieldName)}`;
+    else
+      return `${operation}${Nife.capitalize(field.fieldName)}`;
+  }
+
+  initialize(connection, self) {
+    return super.initialize(connection, self, TYPE_OPERATIONS);
+  }
+}
+
+module.exports = {
+  Model: RelationalTypeBase.wrapConstructor(ModelType),
+  ModelType,
+};