mythix-orm 1.0.1

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

@@ -0,0 +1,83 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('BooleanType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.BooleanType();
+      expect(type.toConnectionType(connection)).toEqual('BOOLEAN');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.BooleanType();
+      expect(type.toConnectionType()).toEqual('BOOLEAN');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.BooleanType();
+      expect(type.toString(connection)).toEqual('BOOLEAN');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.BooleanType();
+      expect(type.toString()).toEqual('BOOLEAN');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.BooleanType();
+    expect(type.toString()).toEqual('BOOLEAN');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.BOOLEAN();
+    expect(type.toString()).toEqual('BOOLEAN');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.BOOLEAN();
+    let value = type.castToType({ value: 1 });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(true);
+
+    value = type.castToType({ value: 0 });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(false);
+
+    value = type.castToType({ value: -1 });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(true);
+
+    value = type.castToType({ value: false });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(false);
+
+    value = type.castToType({ value: true });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(true);
+
+    value = type.castToType({ value: 'false' });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(false);
+
+    value = type.castToType({ value: 'true' });
+    expect(typeof value).toEqual('boolean');
+    expect(value).toEqual(true);
+  });
+});

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

@@ -0,0 +1,85 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const moment = require('moment');
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('DateType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.DateType();
+      expect(type.toConnectionType(connection)).toEqual('DATE');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.DateType();
+      expect(type.toConnectionType()).toEqual('DATE');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.DateType();
+      expect(type.toString(connection)).toEqual('DATE');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.DateType();
+      expect(type.toString()).toEqual('DATE');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.DateType();
+    expect(type.toString()).toEqual('DATE');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.DATE();
+    expect(type.toString()).toEqual('DATE');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.DATE();
+    let value = type.castToType({ value: '2001-01-01' });
+    expect(value).toBeInstanceOf(moment);
+    expect(value.utc(true).toISOString()).toEqual('2001-01-01T00:00:00.000Z');
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+  });
+
+  it('can cast to type with format', () => {
+    let type = Types.DATE('MM.DD.YYYY');
+    let value = type.castToType({ value: '07.23.2022' });
+    expect(value).toBeInstanceOf(moment);
+    expect(value.utc(true).toISOString()).toEqual('2022-07-23T00:00:00.000Z');
+    expect(type.serialize(value)).toEqual('07.23.2022');
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+  });
+
+  it('should throw an error on bad datetime string', () => {
+    let type = Types.DATE();
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new TypeError('DateType::deserialize: Value provided ("derp") can not be cast into a date.'));
+  });
+});

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

@@ -0,0 +1,87 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const moment    = require('moment');
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('DateTimeType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.DateTimeType();
+      expect(type.toConnectionType(connection)).toEqual('DATETIME');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.DateTimeType();
+      expect(type.toConnectionType()).toEqual('DATETIME');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.DateTimeType();
+      expect(type.toString(connection)).toEqual('DATETIME');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.DateTimeType();
+      expect(type.toString()).toEqual('DATETIME');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.DateTimeType();
+    expect(type.toString()).toEqual('DATETIME');
+    expect(type.length).toBe(null);
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.DATETIME(6);
+    expect(type.toString()).toEqual('DATETIME');
+    expect(type.length).toBe(6);
+  });
+
+  it('can cast to type', () => {
+    let type = Types.DATETIME();
+    let value = type.castToType({ value: '2001-01-01' });
+    expect(value).toBeInstanceOf(moment);
+    expect(value.utc(true).toISOString()).toEqual('2001-01-01T00:00:00.000Z');
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+  });
+
+  it('can cast to type with format', () => {
+    let type = Types.DATETIME(null, 'MM.DD.YYYY / HH:mm:ss.SSS');
+    let value = type.castToType({ value: '07.23.2022 / 10:15:45.125' });
+    expect(value).toBeInstanceOf(moment);
+    expect(value.utc(true).toISOString()).toEqual('2022-07-23T10:15:45.125Z');
+    expect(type.serialize(value)).toEqual('07.23.2022 / 10:15:45.125');
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+  });
+
+  it('should throw an error on bad datetime string', () => {
+    let type = Types.DATETIME();
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new TypeError('DateType::deserialize: Value provided ("derp") can not be cast into a date.'));
+  });
+});

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

@@ -0,0 +1,71 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('FloatType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.FloatType();
+      expect(type.toConnectionType(connection)).toEqual('FLOAT');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.FloatType();
+      expect(type.toConnectionType()).toEqual('FLOAT');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.FloatType();
+      expect(type.toString(connection)).toEqual('FLOAT');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.FloatType();
+      expect(type.toString()).toEqual('FLOAT');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.FloatType();
+    expect(type.toString()).toEqual('FLOAT');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.FLOAT();
+    expect(type.toString()).toEqual('FLOAT');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.FLOAT();
+    let value = type.castToType({ value: '1234' });
+    expect(typeof value).toEqual('number');
+    expect(value).toEqual(1234);
+
+    value = type.castToType({ value: '-1234.6' });
+    expect(typeof value).toEqual('number');
+    expect(value).toEqual(-1234.6);
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new TypeError('FloatType::castToType: Value provided ("derp") can not be cast into an floating point number.'));
+  });
+});

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

@@ -0,0 +1,64 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const Model = require('../../../lib/model');
+const {
+  Types,
+  ConnectionBase,
+} = require('../../../lib');
+
+describe('ForeignKeyType', () => {
+  let connection;
+  let FKModel;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     Object.assign({}, require('../../support/models'), {
+        FKModel: class FKModel extends Model {
+          static fields = {
+            'id': {
+              type:         Types.UUIDV4,
+              defaultValue: Types.UUIDV4.Default.UUIDV4,
+              allowNull:    false,
+              primaryKey:   true,
+            },
+            'userID': {
+              type:       Types.FOREIGN_KEY('User:id'),
+              allowNull:  true,
+            },
+          };
+        },
+      }),
+    });
+
+    let models = connection.getModels();
+
+    FKModel = models.FKModel;
+  });
+
+  describe('toString', () => {
+    it('should be empty if a connection is provided', () => {
+      let type = FKModel.fields.userID.type;
+      expect(type.toString(connection)).toEqual('VARCHAR(36)');
+    });
+
+    it('should display field type without any arguments', () => {
+      let type = FKModel.fields.userID.type;
+      expect(type.toString()).toEqual('ForeignKeyType {}');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.ForeignKeyType('User:id');
+    expect(type.toString()).toEqual('ForeignKeyType {}');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.FOREIGN_KEY('User:id');
+    expect(type.toString()).toEqual('ForeignKeyType {}');
+  });
+});

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

@@ -0,0 +1,71 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('IntegerType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.IntegerType();
+      expect(type.toConnectionType(connection)).toEqual('INTEGER');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.IntegerType();
+      expect(type.toConnectionType()).toEqual('INTEGER');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.IntegerType();
+      expect(type.toString(connection)).toEqual('INTEGER');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.IntegerType();
+      expect(type.toString()).toEqual('INTEGER');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.IntegerType();
+    expect(type.toString()).toEqual('INTEGER');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.INTEGER();
+    expect(type.toString()).toEqual('INTEGER');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.INTEGER();
+    let value = type.castToType({ value: '1234' });
+    expect(typeof value).toEqual('number');
+    expect(value).toEqual(1234);
+
+    value = type.castToType({ value: '-1234.6' });
+    expect(typeof value).toEqual('number');
+    expect(value).toEqual(-1235);
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new TypeError('IntegerType::castToType: Value provided ("derp") can not be cast into an integer.'));
+  });
+});

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

@@ -0,0 +1,91 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('StringType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.StringType();
+      expect(type.toConnectionType(connection)).toEqual('VARCHAR(256)');
+    });
+
+    it('can convert to connection type when connection is defined with length', () => {
+      let type = new Types.StringType(64);
+      expect(type.toConnectionType(connection)).toEqual('VARCHAR(64)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.StringType();
+      expect(type.toConnectionType()).toEqual('VARCHAR(256)');
+    });
+
+    it('can convert to connection type when connection is undefined with length', () => {
+      let type = new Types.StringType(64);
+      expect(type.toConnectionType()).toEqual('VARCHAR(64)');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.StringType();
+      expect(type.toString(connection)).toEqual('VARCHAR(256)');
+    });
+
+    it('can convert to connection type when connection is defined with length', () => {
+      let type = new Types.StringType(64);
+      expect(type.toString(connection)).toEqual('VARCHAR(64)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.StringType();
+      expect(type.toString()).toEqual('VARCHAR(256)');
+    });
+
+    it('can convert to connection type when connection is undefined with length', () => {
+      let type = new Types.StringType(64);
+      expect(type.toString()).toEqual('VARCHAR(64)');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.StringType(123);
+    expect(type.toString()).toEqual('VARCHAR(123)');
+    expect(type.length).toBe(123);
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.STRING(123);
+    expect(type.toString()).toEqual('VARCHAR(123)');
+    expect(type.length).toBe(123);
+  });
+
+  it('can cast to type', () => {
+    let type = Types.STRING(123);
+    let value = type.castToType({ value: 123 });
+    expect(typeof value).toEqual('string');
+    expect(value).toEqual('123');
+
+    value = type.castToType({ value: {} });
+    expect(typeof value).toEqual('string');
+    expect(value).toEqual('[object Object]');
+
+    value = type.castToType({ value: undefined });
+    expect(value).toBe(undefined);
+
+    value = type.castToType({ value: null });
+    expect(value).toBe(null);
+  });
+});

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

@@ -0,0 +1,73 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+const { UUID_REGEXP }           = require('../../support/test-helpers');
+
+describe('UUIDV1Type', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.UUIDV1Type();
+      expect(type.toConnectionType(connection)).toEqual('VARCHAR(36)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.UUIDV1Type();
+      expect(type.toConnectionType()).toEqual('VARCHAR(36)');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.UUIDV1Type();
+      expect(type.toString(connection)).toEqual('VARCHAR(36)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.UUIDV1Type();
+      expect(type.toString()).toEqual('VARCHAR(36)');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.UUIDV1Type();
+    expect(type.toString()).toEqual('VARCHAR(36)');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.UUIDV1();
+    expect(type.toString()).toEqual('VARCHAR(36)');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.UUIDV1({
+      node:     [ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab ],
+      clockseq: 0x1234,
+      msecs:    new Date('2011-11-01').getTime(),
+      nsecs:    5678,
+      random:   new Array(16),
+    });
+
+    expect(() => type.castToType({ value: '1234' })).toThrow(new TypeError('UUIDV1Type::castToType: Provided value "1234" is not a valid UUID.'));
+
+    let uuid = Types.UUIDV1.Default.UUIDV1({ field: { type } });
+
+    expect(uuid).toMatch(UUID_REGEXP);
+    expect(type.castToType({ value: uuid })).toEqual(uuid);
+
+    expect(type.castToType({ value: undefined })).toBe(undefined);
+    expect(type.castToType({ value: null })).toBe(null);
+  });
+});

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

@@ -0,0 +1,65 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+const { UUID_REGEXP }           = require('../../support/test-helpers');
+
+describe('UUIDV4Type', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.UUIDV4Type();
+      expect(type.toConnectionType(connection)).toEqual('VARCHAR(36)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.UUIDV4Type();
+      expect(type.toConnectionType()).toEqual('VARCHAR(36)');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection type when connection is defined', () => {
+      let type = new Types.UUIDV4Type();
+      expect(type.toString(connection)).toEqual('VARCHAR(36)');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.UUIDV4Type();
+      expect(type.toString()).toEqual('VARCHAR(36)');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.UUIDV4Type();
+    expect(type.toString()).toEqual('VARCHAR(36)');
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.UUIDV4();
+    expect(type.toString()).toEqual('VARCHAR(36)');
+  });
+
+  it('can cast to type', () => {
+    let type = Types.UUIDV4();
+    expect(() => type.castToType({ value: '1234' })).toThrow(new TypeError('UUIDV4Type::castToType: Provided value "1234" is not a valid UUID.'));
+
+    let uuid = Types.UUIDV4.Default.UUIDV4({ field: { type } });
+    expect(uuid).toMatch(UUID_REGEXP);
+    expect(type.castToType({ value: uuid })).toEqual(uuid);
+
+    expect(type.castToType({ value: undefined })).toBe(undefined);
+    expect(type.castToType({ value: null })).toBe(null);
+  });
+});