mythix-orm 1.0.1

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

@@ -0,0 +1,39 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+class CharType extends Type {
+  static getDisplayName() {
+    return 'CHAR';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    if (!Nife.instanceOf('string') || value.length !== 1)
+      throw new TypeError(`CharType::castToType: Value provided ("${value}") can not be cast into a char. Please provide a string that is one character wide.`);
+
+    return value.charAt(0);
+  }
+
+  isValidValue(value) {
+    return (Nife.instanceOf(value, 'string') && value.length === 1);
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'CHAR';
+  }
+}
+
+module.exports = {
+  CHAR: Type.wrapConstructor(CharType),
+  CharType,
+};

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

@@ -0,0 +1,87 @@
+'use strict';
+
+const Nife          = require('nife');
+const moment        = require('moment');
+const Type          = require('../type');
+const { DATE_NOW }  = require('../helpers/default-helpers');
+
+moment.suppressDeprecationWarnings = true;
+
+class DateType extends Type {
+  static Default = {
+    NOW: DATE_NOW,
+  };
+
+  static getDisplayName() {
+    return 'DATE';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(format) {
+    super(format);
+
+    this.format = format || 'YYYY-MM-DD';
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let dateTime = this.deserialize(value);
+    if (!dateTime.isValid())
+      throw new TypeError(`DateType::castToType: Value provided ("${value}") can not be cast into a date.`);
+
+    return dateTime.startOf('day');
+  }
+
+  isValidValue(value) {
+    return moment(value).isValid();
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'DATE';
+  }
+
+  serialize(value, connection) {
+    if (value == null)
+      return (connection) ? null : value;
+
+    if (connection)
+      return connection.convertDateToDBTime(value);
+
+    if (this.format)
+      return value.format(this.format);
+
+    return value.toISOString();
+  }
+
+  deserialize(_value) {
+    let value = _value;
+    if (value == null)
+      return value;
+
+    if (Nife.instanceOf(value, 'string') && this.format) {
+      value = moment(_value, this.format);
+
+      if (!value.isValid())
+        value = moment(_value);
+    } else {
+      value = moment(value);
+    }
+
+    if (!value.isValid())
+      throw new TypeError(`DateType::deserialize: Value provided ("${_value}") can not be cast into a date.`);
+
+    return value;
+  }
+}
+
+module.exports = {
+  DATE: Type.wrapConstructor(DateType),
+  DateType,
+};

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

@@ -0,0 +1,92 @@
+'use strict';
+
+const Nife              = require('nife');
+const moment            = require('moment');
+const Type              = require('../type');
+const { DATETIME_NOW }  = require('../helpers/default-helpers');
+
+moment.suppressDeprecationWarnings = true;
+
+class DateTimeType extends Type {
+  static Default = {
+    NOW: DATETIME_NOW,
+  };
+
+  static getDisplayName() {
+    return 'DATETIME';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length, format) {
+    super(length, format);
+
+    this.length = length || null;
+    this.format = format;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let dateTime = this.deserialize(value);
+    if (!dateTime.isValid())
+      throw new TypeError(`DateTimeType::castToType: Value provided ("${value}") can not be cast into a date.`);
+
+    return dateTime;
+  }
+
+  isValidValue(value) {
+    return moment(value).isValid();
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'DATETIME';
+  }
+
+  serialize(_value, connection) {
+    let value = _value;
+    if (value == null)
+      return (connection) ? null : value;
+
+    if (!(value instanceof moment))
+      value = this.deserialize(value);
+
+    if (connection)
+      return connection.convertDateToDBTime(value);
+
+    if (this.format)
+      return value.format(this.format);
+
+    return value.toISOString();
+  }
+
+  deserialize(_value) {
+    let value = _value;
+    if (value == null)
+      return value;
+
+    if (Nife.instanceOf(value, 'string') && this.format) {
+      value = moment(_value, this.format);
+
+      if (!value.isValid())
+        value = moment(_value);
+    } else {
+      value = moment(_value);
+    }
+
+    if (!value.isValid())
+      throw new TypeError(`DateType::deserialize: Value provided ("${_value}") can not be cast into a date.`);
+
+    return value;
+  }
+}
+
+module.exports = {
+  DATETIME:   Type.wrapConstructor(DateTimeType),
+  DateTimeType,
+};

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

@@ -0,0 +1,47 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+class FloatType extends Type {
+  static getDisplayName() {
+    return 'FLOAT';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length, precision) {
+    super(length, precision);
+
+    this.length = length;
+    this.precision = precision;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let number = parseFloat(('' + value));
+    if (!isFinite(number))
+      throw new TypeError(`FloatType::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 = {
+  FLOAT: Type.wrapConstructor(FloatType),
+  FloatType,
+};

package/lib/types/concrete/foreign-key-type.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const Nife        = require('nife');
+const Type        = require('../type');
+const ModelUtils  = require('../../utils/model-utils');
+
+class ForeignKeyType extends Type {
+  static isForeignKey() {
+    return true;
+  }
+
+  static getDisplayName() {
+    return 'FOREIGN_KEY';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(_fullyQualifiedName, _options) {
+    if (arguments.length === 0)
+      throw new TypeError('ForeignKeyType::constructor: You must specify a fully qualified field name, or provide complete options.');
+
+    let fullyQualifiedName  = _fullyQualifiedName;
+    let options             = _options || {};
+
+    if (arguments.length === 1) {
+      if (Nife.instanceOf(fullyQualifiedName, 'object'))
+        options = fullyQualifiedName;
+    } else {
+      let def = ModelUtils.parseQualifiedName(fullyQualifiedName);
+      if (Nife.isEmpty(def.modelName))
+        throw new TypeError('ForeignKeyType::constructor: No model found. You must specify a model.');
+
+      options = Object.assign(
+        {},
+        options,
+        {
+          modelName: def.modelName,
+          fieldName: def.fieldNames[0],
+          fullyQualifiedName,
+        },
+      );
+    }
+
+    super(fullyQualifiedName, options);
+
+    this.options = options;
+    this.fullyQualifiedName = fullyQualifiedName;
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    let targetField = this.getTargetField(args.connection);
+    if (!targetField) {
+      let field         = this.getField();
+      let debugFieldStr = '';
+
+      if (field) {
+        let Model = field.Model;
+        if (Model)
+          debugFieldStr = ` "${Model.getModelName()}:${field.fieldName}"`;
+      }
+
+      throw new TypeError(`ForeignKeyType::castToType: Target field not defined${debugFieldStr}.`);
+    }
+
+    return targetField.type.castToType(args);
+  }
+
+  isValidValue(value, options) {
+    let targetField = this.getTargetField(options && options.connection);
+    if (!targetField)
+      throw new TypeError('ForeignKeyType::isValidValue: Target field not defined.');
+
+    return targetField.type.isValidValue(value, options);
+  }
+
+  parseOptionsAndCheckForErrors(SourceModel, sourceField, connection) {
+    let options             = this.options;
+    let fullyQualifiedName  = this.fullyQualifiedName;
+    let Model               = options.Model;
+    let Field               = options.Field;
+    let fieldName           = options.fieldName;
+
+    if (!Model) {
+      if (options.modelName) {
+        Model = connection.getModel(options.modelName);
+      } else {
+        let def = ModelUtils.parseQualifiedName(fullyQualifiedName);
+        Model = connection.getModel(def.modelName);
+
+        if (!fieldName)
+          fieldName = def.fieldNames[0];
+      }
+    }
+
+    if (!Model)
+      throw new TypeError(`ForeignKeyType::parseOptionsAndCheckForErrors: No target model found for field "${SourceModel.getModelName()}:${sourceField.fieldName}". You must specify a model.`);
+
+    if (!Field) {
+      let modelName = Model.getModelName();
+
+      if (options.fieldName) {
+        Field = connection.getField(options.fieldName, modelName);
+      } else {
+        let def = ModelUtils.parseQualifiedName(fullyQualifiedName);
+        Field = connection.getField(def.fieldNames[0], modelName);
+      }
+    }
+
+    if (!Field)
+      throw new TypeError(`ForeignKeyType::parseOptionsAndCheckForErrors: No target field found for "${SourceModel.getModelName()}:${sourceField.fieldName}". You must specify a field.`);
+
+    return {
+      Model,
+      Field,
+    };
+  }
+
+  initialize(connection, self) {
+    if (this.targetModel)
+      return;
+
+    super.initialize(connection, self);
+
+    if (!connection)
+      throw new Error('ForeignKeyType::initialize: A connection is required to use the ForeignKeyType.');
+
+    let {
+      Model,
+      Field,
+    } = this.parseOptionsAndCheckForErrors(this.getModel(), this.getField(), connection);
+
+    Object.defineProperties(this, {
+      'targetModel': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        Model,
+      },
+      'targetField': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        Field,
+      },
+    });
+  }
+
+  getOptions() {
+    return this.options;
+  }
+
+  getTargetModel(connection) {
+    if (connection && !this.targetModel)
+      this.initialize(connection);
+
+    return this.targetModel;
+  }
+
+  getTargetModelName(connection) {
+    let targetModel = this.getTargetModel(connection);
+    return targetModel.getModelName();
+  }
+
+  getTargetField(connection) {
+    if (connection && !this.targetModel)
+      this.initialize(connection);
+
+    return this.targetField;
+  }
+
+  getTargetFieldName(connection) {
+    let targetField = this.getTargetField(connection);
+    if (!targetField)
+      return;
+
+    return targetField.fieldName;
+  }
+
+  toConnectionType(connection, options) {
+    let targetField = this.getTargetField(connection);
+    if (!targetField)
+      return '';
+
+    return targetField.type.toConnectionType(connection, options);
+  }
+
+  toString(...args) {
+    if (args.length === 0)
+      return 'ForeignKeyType {}';
+
+    let targetField = this.getTargetField(...args);
+    if (!targetField)
+      return '';
+
+    return targetField.type.toConnectionType(...args);
+  }
+}
+
+module.exports = {
+  FOREIGN_KEY: Type.wrapConstructor(ForeignKeyType),
+  ForeignKeyType,
+};

package/lib/types/concrete/index.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { BIGINT, BigIntType }          = require('./bigint-type');
+const { BLOB, BlobType }              = require('./blob-type');
+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 { STRING, StringType }          = require('./string-type');
+const { TEXT, TextType }              = require('./text-type');
+const { UUIDV1, UUIDV1Type }          = require('./uuid-v1-type');
+const { UUIDV3, UUIDV3Type }          = require('./uuid-v3-type');
+const { UUIDV4, UUIDV4Type }          = require('./uuid-v4-type');
+const { UUIDV5, UUIDV5Type }          = require('./uuid-v5-type');
+const { XID, XIDType }                = require('./xid-type');
+
+module.exports = {
+  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,
+};

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

@@ -0,0 +1,51 @@
+'use strict';
+
+const Nife                = require('nife');
+const Type                = require('../type');
+const { AUTO_INCREMENT }  = require('../helpers/default-helpers');
+
+class IntegerType extends Type {
+  static Default = {
+    AUTO_INCREMENT,
+  };
+
+  static getDisplayName() {
+    return 'INTEGER';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length) {
+    super(length);
+
+    this.length = length || null;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    let number = parseFloat(('' + value).replace(/[^\d.e-]/g, ''));
+    if (!isFinite(number))
+      throw new TypeError(`IntegerType::castToType: Value provided ("${value}") can not be cast into an integer.`);
+
+    return Math.round(number);
+  }
+
+  isValidValue(value) {
+    return (Nife.instanceOf(value, 'number') && isFinite(value));
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'INTEGER';
+  }
+}
+
+module.exports = {
+  INTEGER: Type.wrapConstructor(IntegerType),
+  IntegerType,
+};

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

@@ -0,0 +1,44 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+const DEFAULT_STRING_LENGTH = 256;
+
+class StringType extends Type {
+  static getDisplayName() {
+    return 'STRING';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length) {
+    super(length);
+
+    this.length = length || DEFAULT_STRING_LENGTH;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    return ('' + value);
+  }
+
+  isValidValue(value) {
+    return Nife.instanceOf(value, 'string');
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : `VARCHAR(${this.length})`;
+  }
+}
+
+module.exports = {
+  STRING: Type.wrapConstructor(StringType),
+  StringType,
+};

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

@@ -0,0 +1,44 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+const DEFAULT_STRING_LENGTH = 65565;
+
+class TextType extends Type {
+  static getDisplayName() {
+    return 'TEXT';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  constructor(length) {
+    super(length);
+
+    this.length = length || DEFAULT_STRING_LENGTH;
+  }
+
+  castToType({ value }) {
+    if (value == null)
+      return value;
+
+    return ('' + value);
+  }
+
+  isValidValue(value) {
+    return Nife.instanceOf(value, 'string');
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : 'TEXT';
+  }
+}
+
+module.exports = {
+  TEXT: Type.wrapConstructor(TextType),
+  TextType,
+};