mythix-orm 1.0.1

package/lib/types/concrete/uuid-base.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const Nife  = require('nife');
+const Type  = require('../type');
+
+class UUIDBaseType extends Type {
+  constructor(_options) {
+    let options = _options || {};
+
+    super(options);
+
+    Object.defineProperties(this, {
+      'options': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        options,
+      },
+    });
+  }
+
+  getOptions() {
+    if (typeof this.options === 'function')
+      return this.options(this);
+
+    return this.options;
+  }
+
+  getPrefix(_options) {
+    let options = _options || this.getOptions();
+    return options.prefix || '';
+  }
+
+  stripPrefix(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return { prefix: '', id: value };
+
+    let baseLength  = this.getBaseLength();
+    let valueLen    = value.length;
+    if (valueLen > baseLength) {
+      let diff = valueLen - baseLength;
+      return { prefix: value.substring(0, diff), id: value.substring(diff) };
+    }
+
+    return { prefix: '', id: value };
+  }
+
+  addPrefix(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return value;
+
+    let baseLength = this.getBaseLength();
+    if (value > baseLength)
+      return value;
+
+    let { id } = this.stripPrefix(value);
+    return `${this.getPrefix()}${id}`;
+  }
+
+  getBaseLength() {
+    // eslint-disable-next-line no-magic-numbers
+    return 36;
+  }
+
+  getTotalLength() {
+    let prefix = this.getPrefix();
+    return this.getBaseLength() + prefix.length;
+  }
+
+  toString(connection) {
+    return (connection)
+      ? this.toConnectionType(connection)
+      : `VARCHAR(${this.getTotalLength()})`;
+  }
+}
+
+module.exports = UUIDBaseType;

package/lib/types/concrete/uuid-v1-type.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const Nife                  = require('nife');
+const UUID                  = require('uuid');
+const UUIDBaseType          = require('./uuid-base');
+const { defaultValueFlags } = require('../helpers/default-helpers');
+
+let CALLABLE_PROP_NAMES = [ 'node', 'clockseq', 'msecs', 'nsecs', 'random', 'buffer', 'offset' ];
+
+class UUIDV1Type extends UUIDBaseType {
+  static Default = {
+    UUIDV1: defaultValueFlags(function(context) {
+      let field     = context.field;
+      let type      = field.type;
+      let options   = type.getOptions();
+      let uuidArgs  = type.getArgsForUUID(options);
+
+      // Will throw an error if something is wrong
+      type.validateOptions(uuidArgs);
+
+      let prefix = options.prefix || '';
+      return `${prefix}${UUID.v1(...uuidArgs)}`;
+    }),
+  };
+
+  static getDisplayName() {
+    return 'UUIDV1';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  getArgsForUUID(options) {
+    let uuidOptions = {};
+
+    for (let i = 0, il = CALLABLE_PROP_NAMES.length; i < il; i++) {
+      let propName  = CALLABLE_PROP_NAMES[i];
+      let value     = options[propName];
+
+      if (typeof value === 'function')
+        value = value(this);
+
+      if (value !== undefined)
+        uuidOptions[propName] = value;
+    }
+
+    let args = [];
+    if (Nife.isNotEmpty(uuidOptions))
+      args.push(uuidOptions);
+
+    if (uuidOptions.buffer) {
+      args.push(uuidOptions.buffer);
+      args.push(uuidOptions.offset || 0);
+    }
+
+    return args;
+  }
+
+  validateOptions(uuidArgs) {
+    let uuidOptions = uuidArgs[0];
+
+    if (Nife.isEmpty(uuidOptions))
+      throw new Error('UUIDV1Type::Default::UUIDV1: "options" argument is required for the specified type. Try "type: Types.UUIDV1({ ...options })" for your type instead.');
+
+    if (uuidOptions.clockseq == null)
+      throw new Error('UUIDV1Type::Default::UUIDV1: "options.clockseq" option is required for the specified type. Try "type: Types.UUIDV1({ clockseq: Function | Number })" for your type instead.');
+
+    if (uuidOptions.rng == null && uuidOptions.random == null)
+      throw new Error('UUIDV1Type::Default::UUIDV1: One of "options.rng" or "option.random" options are required for the specified type. Try "type: Types.UUIDV1({ rng: () => Array[16] })" or "type: Types.UUIDV1({ random: Function | Array[16] })" for your type instead.');
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    if (!this.isValidValue(value, args))
+      throw new TypeError(`UUIDV1Type::castToType: Provided value "${value}" is not a valid UUID.`);
+
+    return this.addPrefix(value);
+  }
+
+  isValidValue(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return false;
+
+    let { id } = this.stripPrefix(value);
+    if (!id)
+      return false;
+
+    return UUID.validate(id);
+  }
+}
+
+module.exports = {
+  UUIDV1: UUIDBaseType.wrapConstructor(UUIDV1Type),
+  UUIDV1Type,
+};

package/lib/types/concrete/uuid-v3-type.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const Nife                  = require('nife');
+const UUID                  = require('uuid');
+const UUIDBaseType          = require('./uuid-base');
+const { defaultValueFlags } = require('../helpers/default-helpers');
+
+let CALLABLE_PROP_NAMES = [ 'name', 'namespace', 'buffer', 'offset' ];
+
+class UUIDV3Type extends UUIDBaseType {
+  static Default = {
+    UUIDV3: defaultValueFlags(function(context) {
+      let field     = context.field;
+      let type      = field.type;
+      let options   = type.getOptions();
+      let uuidArgs  = type.getArgsForUUID(options);
+
+      // Will throw an error if something is wrong
+      type.validateOptions(uuidArgs);
+
+      let prefix = options.prefix || '';
+      return `${prefix}${UUID.v3(...uuidArgs)}`;
+    }),
+  };
+
+  static getDisplayName() {
+    return 'UUIDV3';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  getArgsForUUID(options) {
+    let uuidOptions = {};
+
+    for (let i = 0, il = CALLABLE_PROP_NAMES.length; i < il; i++) {
+      let propName  = CALLABLE_PROP_NAMES[i];
+      let value     = options[propName];
+
+      if (typeof value === 'function')
+        value = value(this);
+
+      if (value !== undefined)
+        uuidOptions[propName] = value;
+    }
+
+    let args = [];
+    if (Nife.isNotEmpty(uuidOptions.name))
+      args.push(uuidOptions.name);
+
+    if (Nife.isNotEmpty(uuidOptions.namespace))
+      args.push(uuidOptions.namespace);
+
+    if (uuidOptions.buffer) {
+      if (args.length < 1)
+        args.push(null);
+
+      if (args.length < 2)
+        args.push(null);
+
+      args.push(uuidOptions.buffer);
+      args.push(uuidOptions.offset || 0);
+    }
+
+    return args;
+  }
+
+  validateOptions(uuidArgs) {
+    let [ name, namespace ] = uuidArgs;
+
+    if (Nife.isEmpty(this.options))
+      throw new Error('UUIDV3Type::Default::UUIDV3: "options" argument is required for the specified type. Try "type: Types.UUIDV3({ ...options })" for your type instead.');
+
+    if (Nife.isEmpty(name))
+      throw new Error('UUIDV3Type::Default::UUIDV3: "options.name" option is required for the specified type. Try "type: Types.UUIDV3({ name: Function | String | Array })" for your type instead.');
+
+    if (Nife.isEmpty(namespace))
+      throw new Error('UUIDV3Type::Default::UUIDV3: "options.namespace" option is required for the specified type. Try "type: Types.UUIDV3({ namespace: Function | String | Array[16] })" for your type instead.');
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    if (!this.isValidValue(value, args))
+      throw new TypeError(`UUIDV3Type::castToType: Provided value "${value}" is not a valid UUID.`);
+
+    return this.addPrefix(value);
+  }
+
+  isValidValue(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return false;
+
+    let { id } = this.stripPrefix(value);
+    if (!id)
+      return false;
+
+    return UUID.validate(id);
+  }
+}
+
+module.exports = {
+  UUIDV3: UUIDBaseType.wrapConstructor(UUIDV3Type),
+  UUIDV3Type,
+};

package/lib/types/concrete/uuid-v4-type.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const Nife                  = require('nife');
+const UUID                  = require('uuid');
+const UUIDBaseType          = require('./uuid-base');
+const { defaultValueFlags } = require('../helpers/default-helpers');
+
+let CALLABLE_PROP_NAMES = [ 'random', 'buffer', 'offset' ];
+
+class UUIDV4Type extends UUIDBaseType {
+  static Default = {
+    UUIDV4: defaultValueFlags(function(context) {
+      let field     = context.field;
+      let type      = field.type;
+      let options   = type.getOptions();
+      let uuidArgs  = type.getArgsForUUID(options);
+
+      // Will throw an error if something is wrong
+      type.validateOptions(uuidArgs);
+
+      let prefix = options.prefix || '';
+      return `${prefix}${UUID.v4(...uuidArgs)}`;
+    }),
+  };
+
+  static getDisplayName() {
+    return 'UUIDV4';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  getArgsForUUID(options) {
+    let uuidOptions = {};
+
+    for (let i = 0, il = CALLABLE_PROP_NAMES.length; i < il; i++) {
+      let propName  = CALLABLE_PROP_NAMES[i];
+      let value     = options[propName];
+
+      if (typeof value === 'function')
+        value = value(this);
+
+      if (value !== undefined)
+        uuidOptions[propName] = value;
+    }
+
+    let args = [];
+    if (Nife.isNotEmpty(uuidOptions))
+      args.push(uuidOptions);
+
+    if (uuidOptions.buffer) {
+      args.push(uuidOptions.buffer);
+      args.push(uuidOptions.offset || 0);
+    }
+
+    return args;
+  }
+
+  validateOptions() {
+    // No validation required for V4
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    if (!this.isValidValue(value, args))
+      throw new TypeError(`UUIDV4Type::castToType: Provided value "${value}" is not a valid UUID.`);
+
+    return this.addPrefix(value);
+  }
+
+  isValidValue(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return false;
+
+    let { id } = this.stripPrefix(value);
+    if (!id)
+      return false;
+
+    return UUID.validate(id);
+  }
+}
+
+module.exports = {
+  UUIDV4: UUIDBaseType.wrapConstructor(UUIDV4Type),
+  UUIDV4Type,
+};

package/lib/types/concrete/uuid-v5-type.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const Nife                  = require('nife');
+const UUID                  = require('uuid');
+const UUIDBaseType          = require('./uuid-base');
+const { defaultValueFlags } = require('../helpers/default-helpers');
+
+let CALLABLE_PROP_NAMES = [ 'name', 'namespace', 'buffer', 'offset' ];
+
+class UUIDV5Type extends UUIDBaseType {
+  static Default = {
+    UUIDV5: defaultValueFlags(function(context) {
+      let field     = context.field;
+      let type      = field.type;
+      let options   = type.getOptions();
+      let uuidArgs  = type.getArgsForUUID(options);
+
+      // Will throw an error if something is wrong
+      type.validateOptions(uuidArgs);
+
+      let prefix = options.prefix || '';
+      return `${prefix}${UUID.v5(...uuidArgs)}`;
+    }),
+  };
+
+  static getDisplayName() {
+    return 'UUIDV5';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  getArgsForUUID(options) {
+    let uuidOptions = {};
+
+    for (let i = 0, il = CALLABLE_PROP_NAMES.length; i < il; i++) {
+      let propName  = CALLABLE_PROP_NAMES[i];
+      let value     = options[propName];
+
+      if (typeof value === 'function')
+        value = value(this);
+
+      if (value !== undefined)
+        uuidOptions[propName] = value;
+    }
+
+    let args = [];
+    if (Nife.isNotEmpty(uuidOptions.name))
+      args.push(uuidOptions.name);
+
+    if (Nife.isNotEmpty(uuidOptions.namespace))
+      args.push(uuidOptions.namespace);
+
+    if (uuidOptions.buffer) {
+      if (args.length < 1)
+        args.push(null);
+
+      if (args.length < 2)
+        args.push(null);
+
+      args.push(uuidOptions.buffer);
+      args.push(uuidOptions.offset || 0);
+    }
+
+    return args;
+  }
+
+  validateOptions(uuidArgs) {
+    let [ name, namespace ] = uuidArgs;
+
+    if (Nife.isEmpty(this.options))
+      throw new Error('UUIDV5Type::Default::UUIDV5: "options" argument is required for the specified type. Try "type: Types.UUIDV5({ ...options })" for your type instead.');
+
+    if (Nife.isEmpty(name))
+      throw new Error('UUIDV5Type::Default::UUIDV5: "options.name" option is required for the specified type. Try "type: Types.UUIDV5({ name: Function | String | Array })" for your type instead.');
+
+    if (Nife.isEmpty(namespace))
+      throw new Error('UUIDV5Type::Default::UUIDV5: "options.namespace" option is required for the specified type. Try "type: Types.UUIDV5({ namespace: Function | String | Array[16] })" for your type instead.');
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    if (!this.isValidValue(value, args))
+      throw new TypeError(`UUIDV5Type::castToType: Provided value "${value}" is not a valid UUID.`);
+
+    return this.addPrefix(value);
+  }
+
+  isValidValue(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return false;
+
+    let { id } = this.stripPrefix(value);
+    if (!id)
+      return false;
+
+    return UUID.validate(id);
+  }
+}
+
+module.exports = {
+  UUIDV5: UUIDBaseType.wrapConstructor(UUIDV5Type),
+  UUIDV5Type,
+};

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

@@ -0,0 +1,58 @@
+'use strict';
+
+const Nife                  = require('nife');
+const XID                   = require('xid-js');
+const UUIDBaseType          = require('./uuid-base');
+const { defaultValueFlags } = require('../helpers/default-helpers');
+
+class XIDType extends UUIDBaseType {
+  static Default = {
+    XID: defaultValueFlags(function(context) {
+      let field   = context.field;
+      let type    = field.type;
+      let prefix  = type.getPrefix();
+
+      return `${prefix}${XID.next()}`;
+    }),
+  };
+
+  static getDisplayName() {
+    return 'XID';
+  }
+
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
+
+  castToType(args) {
+    let { value } = args;
+    if (value == null)
+      return value;
+
+    if (!this.isValidValue(value, args))
+      throw new TypeError(`XIDType::castToType: Provided value "${value}" is not a valid XID.`);
+
+    return this.addPrefix(value);
+  }
+
+  isValidValue(value) {
+    if (!Nife.instanceOf(value, 'string'))
+      return false;
+
+    let { id } = this.stripPrefix(value);
+    if (!id)
+      return false;
+
+    return (/^[0-9abcdefghjkmnpqrstvwxyz]{20}$/).test(id);
+  }
+
+  getBaseLength() {
+    // eslint-disable-next-line no-magic-numbers
+    return 20;
+  }
+}
+
+module.exports = {
+  XID: UUIDBaseType.wrapConstructor(XIDType),
+  XIDType,
+};

package/lib/types/helpers/default-helpers.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const FLAG_ON_INITIALIZE  = 0x01;
+const FLAG_ON_INSERT      = 0x02;
+const FLAG_ON_UPDATE      = 0x04;
+const FLAG_ON_STORE       = FLAG_ON_INSERT | FLAG_ON_UPDATE;
+const FLAG_LITERAL        = 0x08;
+const FLAG_REMOTE         = 0x10;
+
+function defaultValueFlags(func, _flagsObj) {
+  let flags = FLAG_ON_INITIALIZE;
+  let flagsObj = _flagsObj || {};
+
+  if (flagsObj.onInsert === true)
+    flags |= FLAG_ON_INSERT;
+
+  if (flagsObj.onUpdate === true)
+    flags |= FLAG_ON_UPDATE;
+
+  if (flagsObj.onStore === true)
+    flags |= FLAG_ON_STORE;
+
+  if (flagsObj.literal === true)
+    flags |= FLAG_LITERAL;
+
+  if (flagsObj.remote === true)
+    flags |= FLAG_REMOTE;
+
+  if (flagsObj.remote === true || flagsObj.onInitialize === false)
+    flags = flags & ~FLAG_ON_INITIALIZE;
+  else if (flags > 1)
+    flags = flags & ~FLAG_ON_INITIALIZE;
+
+  func.mythixFlags = flags;
+
+  return func;
+}
+
+function getDefaultValueFlags(func) {
+  if (!func)
+    return 0;
+
+  return func.mythixFlags || 0;
+}
+
+function checkDefaultValueFlags(func, checkFlags) {
+  if (!checkFlags || !checkFlags.length || !func)
+    return false;
+
+  let flags = getDefaultValueFlags(func);
+  for (let i = 0, il = checkFlags.length; i < il; i++) {
+    let flag = checkFlags[i];
+
+    if ((flag === 'onInitialize' || flag === FLAG_ON_INITIALIZE) && !(flags & FLAG_ON_INITIALIZE))
+      return false;
+
+    if ((flag === 'onInsert' || flag === FLAG_ON_INSERT) && !(flags & FLAG_ON_INSERT))
+      return false;
+
+    if ((flag === 'onUpdate' || flag === FLAG_ON_UPDATE) && !(flags & FLAG_ON_UPDATE))
+      return false;
+
+    if ((flag === 'onStore' || flag === FLAG_ON_STORE) && (flags & FLAG_ON_STORE) !== FLAG_ON_STORE)
+      return false;
+
+    if ((flag === 'literal' || flag === FLAG_LITERAL) && !(flags & FLAG_LITERAL))
+      return false;
+
+    if ((flag === 'remote' || flag === FLAG_REMOTE) && !(flags & FLAG_REMOTE))
+      return false;
+  }
+
+  return true;
+}
+
+function generatePermutations(func, flags) {
+  const masterFunc = defaultValueFlags(func, flags);
+
+  masterFunc.UPDATE = defaultValueFlags(function(...args) {
+    return func.apply(this, args);
+  }, Object.assign({}, flags, { onUpdate: true }));
+
+  masterFunc.INSERT = defaultValueFlags(function(...args) {
+    return func.apply(this, args);
+  }, Object.assign({}, flags, { onInsert: true }));
+
+  masterFunc.ALWAYS = defaultValueFlags(function(...args) {
+    return func.apply(this, args);
+  }, Object.assign({}, flags, { onStore: true }));
+
+  return masterFunc;
+}
+
+const AUTO_INCREMENT = defaultValueFlags(function(context) {
+  return context.connection.getDefaultFieldValue('AUTO_INCREMENT', context);
+}, { literal: true, remote: true });
+
+const DATETIME_NOW = generatePermutations(function(context) {
+  return context.connection.getDefaultFieldValue('DATETIME_NOW', context);
+}, { literal: true, remote: true });
+
+const DATE_NOW = generatePermutations(function(context) {
+  return context.connection.getDefaultFieldValue('DATE_NOW', context);
+}, { literal: true, remote: true });
+
+DATETIME_NOW.LOCAL = generatePermutations(function(context) {
+  return context.connection.getDefaultFieldValue('DATETIME_NOW_LOCAL', context);
+});
+
+DATE_NOW.LOCAL = generatePermutations(function(context) {
+  return context.connection.getDefaultFieldValue('DATE_NOW_LOCAL', context);
+});
+
+module.exports = {
+  FLAG_ON_INITIALIZE,
+  FLAG_ON_INSERT,
+  FLAG_ON_UPDATE,
+  FLAG_ON_STORE,
+  FLAG_LITERAL,
+  FLAG_REMOTE,
+  defaultValueFlags,
+  getDefaultValueFlags,
+  checkDefaultValueFlags,
+  AUTO_INCREMENT,
+  DATETIME_NOW,
+  DATE_NOW,
+};

package/lib/types/helpers/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const DefaultHelpers = require('./default-helpers');
+
+const {
+  FLAG_ON_INITIALIZE,
+  FLAG_ON_INSERT,
+  FLAG_ON_UPDATE,
+  FLAG_ON_STORE,
+  FLAG_LITERAL,
+  FLAG_REMOTE,
+  defaultValueFlags,
+  getDefaultValueFlags,
+  checkDefaultValueFlags,
+  AUTO_INCREMENT,
+  DATETIME_NOW,
+  DATE_NOW,
+} = DefaultHelpers;
+
+module.exports = {
+  DefaultHelpers,
+
+  FLAG_ON_INITIALIZE,
+  FLAG_ON_INSERT,
+  FLAG_ON_UPDATE,
+  FLAG_ON_STORE,
+  FLAG_LITERAL,
+  FLAG_REMOTE,
+  defaultValueFlags,
+  getDefaultValueFlags,
+  checkDefaultValueFlags,
+  AUTO_INCREMENT,
+  DATETIME_NOW,
+  DATE_NOW,
+};