mythix-orm 1.0.1

package/spec/support/models/role-thing-model.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class RoleThing extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'roleID': {
+      type:         Types.FOREIGN_KEY('Role:id', { onDelete: 'CASCADE', onUpdate: 'CASCADE' }),
+      allowNull:    true,
+      index:        true,
+    },
+    'userThing': {
+      type:         Types.Model('UserThing', ({ UserThing, userQuery, self }) => {
+        return UserThing.$.roleThingID.EQ(self.id).MERGE(userQuery);
+      }),
+    },
+    'role': {
+      type:         Types.Model('Role', ({ Role, userQuery, self }) => {
+        return Role.$.id.EQ(self.roleID).MERGE(userQuery);
+      }),
+    },
+    'user': {
+      type:         Types.Model('User', ({ UserThing, User, userQuery, self }) => {
+        return User
+          .$.id
+            .EQ(UserThing.userID)
+          .UserThing.roleThingID
+            .EQ(self.id)
+          .MERGE(userQuery);
+      }),
+    },
+  };
+}
+
+module.exports = RoleThing;

package/spec/support/models/scoped-user-model.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const User = require('./user-model');
+
+class ScopedUser extends User {
+  static fields = User.mergeFields();
+
+  static defaultScope(queryEngine) {
+    return queryEngine.firstName.EQ('Bob');
+  }
+}
+
+module.exports = ScopedUser;

package/spec/support/models/time-model.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class Time extends Model {
+  static fields = {
+    'id': {
+      type:         Types.XID,
+      defaultValue: Types.XID.Default.XID,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'datetime': {
+      type:         Types.DATETIME,
+      defaultValue: Types.DATETIME.Default.NOW,
+      index:        true,
+    },
+    'datetimeLocal': {
+      type:         Types.DATETIME,
+      defaultValue: Types.DATETIME.Default.NOW.LOCAL,
+      index:        true,
+    },
+    'date': {
+      type:         Types.DATE,
+      defaultValue: Types.DATE.Default.NOW,
+      index:        true,
+    },
+    'dateLocal': {
+      type:         Types.DATE,
+      defaultValue: Types.DATE.Default.NOW.LOCAL,
+      index:        true,
+    },
+  };
+}
+
+module.exports = Time;

package/spec/support/models/user-model.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class User extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'firstName': {
+      type:         Types.STRING(64),
+      allowNull:    true,
+      index:        true,
+    },
+    'lastName': {
+      type:         Types.STRING(64),
+      allowNull:    true,
+      index:        true,
+    },
+    'primaryRoleID': {
+      type:         Types.FOREIGN_KEY('Role:id', { onDelete: 'SET NULL', onUpdate: 'SET NULL' }),
+      allowNull:    true,
+    },
+    'roles': {
+      type:         Types.Models('Role', ({ Role, UserRole, userQuery, self }) => {
+        return Role
+          .$.id
+            .EQ(UserRole.$.roleID)
+          .UserRole.userID
+            .EQ(self.id)
+          .MERGE(userQuery);
+      }),
+    },
+    'userRoles': {
+      type:         Types.Models('UserRole', ({ UserRole, userQuery, self }) => {
+        return UserRole.$.userID.EQ(self.id).MERGE(userQuery);
+      }),
+    },
+    'userThing': {
+      type:         Types.Model('UserThing', ({ UserThing, userQuery, self }) => {
+        return UserThing
+          .$.userID
+            .EQ(self.id)
+          .MERGE(userQuery);
+      }),
+    },
+    'userThingRole': {
+      type:         Types.Model('Role', ({ Role, UserThing, RoleThing, userQuery, self }) => {
+        return Role
+          .$.id
+            .EQ(RoleThing.$.roleID)
+          .RoleThing.id
+            .EQ(UserThing.$.roleThingID)
+          .UserThing.userID
+            .EQ(self.id)
+          .MERGE(userQuery);
+      }),
+    },
+    'primaryRole': {
+      type:         Types.Model('Role', ({ Role, userQuery, self }) => {
+        return Role.$.id.EQ(self.primaryRoleID).MERGE(userQuery);
+      }),
+    },
+  };
+}
+
+module.exports = User;

package/spec/support/models/user-role-model.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class UserRole extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'roleID': {
+      type:         Types.FOREIGN_KEY('Role:id', { onDelete: 'CASCADE', onUpdate: 'CASCADE' }),
+      allowNull:    false,
+      index:        true,
+    },
+    'userID': {
+      type:         Types.FOREIGN_KEY('User:id', { onDelete: 'CASCADE', onUpdate: 'CASCADE' }),
+      allowNull:    false,
+      index:        true,
+    },
+    'role': {
+      type:         Types.Model('Role', ({ Role, userQuery, self }) => {
+        return Role.$.id.EQ(self.roleID).MERGE(userQuery);
+      }),
+    },
+    'user': {
+      type:         Types.Model('User', ({ User, userQuery, self }) => {
+        return User.$.id.EQ(self.userID).MERGE(userQuery);
+      }),
+    },
+  };
+}
+
+module.exports = UserRole;

package/spec/support/models/user-thing-model.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class UserThing extends Model {
+  static fields = {
+    'id': {
+      type:         Types.UUIDV4,
+      defaultValue: Types.UUIDV4.Default.UUIDV4,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'userID': {
+      type:         Types.FOREIGN_KEY('User:id', { onDelete: 'CASCADE', onUpdate: 'CASCADE' }),
+      allowNull:    false,
+      index:        true,
+    },
+    'roleThingID': {
+      type:         Types.FOREIGN_KEY('RoleThing:id', { onDelete: 'CASCADE', onUpdate: 'CASCADE' }),
+      allowNull:    false,
+      index:        true,
+    },
+    'roleThing': {
+      type:         Types.Model('RoleThing', ({ RoleThing, userQuery, self }) => {
+        return RoleThing.$.id.EQ(self.roleThingID).MERGE(userQuery);
+      }),
+    },
+    'role': {
+      type:         Types.Model('Role', ({ Role, RoleThing, userQuery, self }) => {
+        return Role
+          .$.id
+            .EQ(RoleThing.$.roleID)
+          .RoleThing.id
+            .EQ(self.roleThingID)
+          .MERGE(userQuery);
+      }),
+    },
+    'user': {
+      type:         Types.Model('User', ({ User, userQuery, self }) => {
+        return User.$.id.EQ(self.userID).MERGE(userQuery);
+      }),
+    },
+  };
+}
+
+module.exports = UserThing;

package/spec/support/models/validation-test-model.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { Model, Types } = require('../../../lib');
+
+class ValidationTest extends Model {
+  static fields = {
+    'id': {
+      type:         Types.XID,
+      defaultValue: Types.XID.Default.XID,
+      allowNull:    false,
+      primaryKey:   true,
+    },
+    'number': {
+      type:         Types.STRING,
+      index:        true,
+      validate:     async (value) => {
+        if (!(/^\d+$/).test(value))
+          throw new Error('Number expected');
+      },
+    },
+    'boolean': {
+      type:         Types.STRING,
+      index:        true,
+      validate:     async (value) => {
+        if (!(/^(true|false)$/).test(value))
+          throw new Error('Boolean expected');
+      },
+    },
+    'date': {
+      type:         Types.STRING,
+      index:        true,
+      validate:     async (value) => {
+        if (!(/^\d{4}-\d{2}-\d{2}$/).test(value))
+          throw new Error('Invalid date');
+      },
+    },
+  };
+}
+
+module.exports = ValidationTest;

package/spec/support/snapshots.js

@@ -0,0 +1,293 @@
+'use strict';
+
+const jsDiff        = require('diff');
+const colors        = require('colors/safe');
+const Path          = require('path');
+const FileSystem    = require('fs');
+
+const MAX_FILE_NAME_LENGTH = 100;
+
+function showDiff(fileName, c1, c2) {
+  jsDiff.createPatch(fileName, c1 || '', c2 || '').replace(/.*/g, function(m) {
+    if (!m)
+      return;
+
+    let c = m.charAt(0);
+    let out = m;
+
+    if (c === '-')
+      console.log(colors.red(out));
+    else if (c === '+')
+      console.log(colors.green(out));
+    else
+      console.log(out);
+  });
+}
+
+function serialize(value) {
+  if (value == null)
+    return ('' + value);
+
+  if (typeof value === 'boolean' || value instanceof Boolean)
+    return ('' + value);
+
+  if (typeof value === 'number' || value instanceof Number)
+    return ('' + value);
+
+  if (typeof value === 'bigint')
+    return `BigInt(${value})`;
+
+  if (typeof value === 'string' || value instanceof String)
+    return `"${value.replace(/"/g, '\\"')}"`;
+
+  return JSON.stringify(value, undefined, 2);
+}
+
+const specFileCache = {};
+const callCountCache = {};
+
+function getSnapshotNameAndPath() {
+  const getFileName = (stackLine) => {
+    let fileName;
+
+    stackLine.replace(/\(([^(]+):\d+:\d+\)$/, (_, str) => {
+      fileName = str;
+    });
+
+    return fileName;
+  };
+
+  const getLineNumber = (stackLine) => {
+    let number;
+
+    stackLine.replace(/(\d+):\d+\)$/, (_, numStr) => {
+      number = parseInt(numStr, 10);
+    });
+
+    return number;
+  };
+
+  const getBacktraceFile = () => {
+    const matchesPatterns = (patterns, fileName) => {
+      for (let i = 0, il = patterns.length; i < il; i++) {
+        let pattern = patterns[i];
+        if (pattern.test(fileName))
+          return true;
+      }
+
+      return false;
+    };
+
+    let specFilePatterns  = [ /-spec\.js/ ];
+    let stack             = (new Error()).stack.split(/\s+at\s+/g).slice(1).map((part) => part.trim());
+    let file;
+
+    for (let i = 0, il = stack.length; i < il; i++) {
+      let stackLine = stack[i];
+      let fileName  = getFileName(stackLine);
+      if (!matchesPatterns(specFilePatterns, fileName))
+        continue;
+
+      let lineNumber = getLineNumber(stackLine);
+
+      if (!file) {
+        file = {
+          lineNumbers: [ lineNumber ],
+          fileName,
+        };
+      } else {
+        file.lineNumbers.push(lineNumber);
+      }
+    }
+
+    return file;
+  };
+
+  const getSpecFileStructure = (fileName) => {
+    if (specFileCache[fileName])
+      return specFileCache[fileName];
+
+    let contents = FileSystem.readFileSync(fileName, 'utf8');
+    let lines = contents.split(/\n/g);
+
+    lines = lines.map((line, lineIndex) => {
+      let specName;
+      let indentAmount;
+
+      line.replace(/([\s\t]*)f?(?:describe|it)\s*\(\s*(['"])((?:\\.|.)*?)\2/, (m, indent, q, name) => {
+        specName = name.replace(/\\(.)/g, '$1');
+        indentAmount = indent.replace(/\t/g, '  ').length;
+      });
+
+      if (!specName)
+        return;
+
+      return { specName, indentAmount, lineNumber: lineIndex + 1 };
+    }).filter(Boolean);
+
+    let nodes = [];
+    let currentChildren = nodes;
+    let previousNode;
+    let parent = null;
+
+    for (let i = 0, il = lines.length; i < il; i++) {
+      let line = lines[i];
+      let { specName, indentAmount, lineNumber } = line;
+
+      if (previousNode) {
+        if (previousNode.indentAmount < indentAmount) {
+          parent = previousNode;
+          currentChildren = previousNode.children;
+        } else if (previousNode.indentAmount > indentAmount) {
+          parent = previousNode.parent;
+          while (parent && parent.indentAmount >= indentAmount)
+            parent = parent.parent;
+
+          currentChildren = (parent) ? parent.children : nodes;
+        }
+      }
+
+      let node = { parent, indentAmount, name: specName, lineNumber, children: [] };
+      currentChildren.push(node);
+
+      previousNode = node;
+    }
+
+    specFileCache[fileName] = nodes;
+
+    return nodes;
+  };
+
+  const findCorrectNode = (nodes, lineNumber, parentNode) => {
+    const findChildNode = (nodes, lineNumber) => {
+      for (let i = 0, il = nodes.length; i < il; i++) {
+        let node = nodes[i];
+        let childNode = findCorrectNode(node.children, lineNumber, node);
+        if (childNode)
+          return childNode;
+      }
+    };
+
+    const findLargerNode = (nodes, lineNumber) => {
+      for (let i = 0, il = nodes.length; i < il; i++) {
+        let node = nodes[i];
+        if (node.lineNumber > lineNumber)
+          return i;
+      }
+
+      return -1;
+    };
+
+    let childNode = findChildNode(nodes, lineNumber);
+    if (childNode) {
+      while (childNode.lineNumber > lineNumber)
+        childNode = childNode.parent;
+
+      return childNode;
+    }
+
+    let largerNodeIndex = findLargerNode(nodes, lineNumber);
+    if (largerNodeIndex <= 0)
+      return (largerNodeIndex === 0) ? parentNode : undefined;
+
+    return nodes[largerNodeIndex - 1];
+  };
+
+  const getLastNode = (nodes) => {
+    if (!nodes.length)
+      return;
+
+    let lastNode = nodes[nodes.length - 1];
+    if (lastNode.children.length > 0)
+      return getLastNode(lastNode.children);
+
+    return lastNode;
+  };
+
+  const getNodePath = (_node) => {
+    if (!_node)
+      return;
+
+    let node = _node;
+    let path = [ node.name ];
+
+    while (node && node.parent) {
+      node = node.parent;
+      path.push(node.name);
+    }
+
+    return path.reverse().join('/');
+  };
+
+  const getCorrectNodePath = (nodes, lineNumbers) => {
+    let nodePaths = lineNumbers.map((lineNumber) => {
+      let node = findCorrectNode(nodes, lineNumber);
+      if (!node)
+        node = getLastNode(nodes);
+
+      return getNodePath(node);
+    }).filter(Boolean);
+
+    let nodePath = nodePaths.sort((a, b) => {
+      if (a.length === b.length)
+        return 0;
+
+      return (a.length < b.length) ? 1 : -1;
+    })[0];
+
+    let callCount = callCountCache[nodePath];
+    if (!callCount)
+      callCount = 0;
+
+    callCount++;
+    callCountCache[nodePath] = callCount;
+
+    nodePath = nodePath.replace(/[^\w/]+/g, '_').replace(/\//g, '-');
+    if (nodePath.length > MAX_FILE_NAME_LENGTH) {
+      nodePath = nodePath.substring(0, MAX_FILE_NAME_LENGTH);
+      nodePath = nodePath.replace(/^[^0-9a-zA-Z]+/, '').replace(/[^0-9a-zA-Z]+$/, '');
+    }
+
+    // eslint-disable-next-line no-magic-numbers
+    return (`${nodePath}-${('' + callCount).padStart(3, '0')}.snapshot`);
+  };
+
+  const getSnapshotDetails = () => {
+    let { fileName, lineNumbers } = getBacktraceFile();
+    let nodes = getSpecFileStructure(fileName);
+    let name  = getCorrectNodePath(nodes, lineNumbers);
+
+    return { path: Path.dirname(fileName), name };
+  };
+
+  let structure = getSnapshotDetails();
+  return structure;
+}
+
+function matchesSnapshot(value) {
+  let { name, path }  = getSnapshotNameAndPath();
+  let snapshotPath    = Path.join(path, '__snapshots__');
+  let fullPath        = Path.join(snapshotPath, name);
+
+  try {
+    FileSystem.mkdirSync(snapshotPath);
+  } catch (error) {
+    if (error.code !== 'EEXIST')
+      throw error;
+  }
+
+  let serializedValue = serialize(value);
+  if (!FileSystem.existsSync(fullPath))
+    FileSystem.writeFileSync(fullPath, serializedValue, 'utf8');
+
+  let storedValue = FileSystem.readFileSync(fullPath, 'utf8');
+
+  if (storedValue !== serializedValue) {
+    showDiff(fullPath, storedValue, serializedValue);
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = matchesSnapshot;

package/spec/support/test-helpers.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const UUID_REGEXP         = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const XID_REGEXP          = /^[0-9abcdefghjkmnpqrstvwxyz]{20}$/;
+const ISO8601_TIME_REGEXP = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/;
+const ISO8601_DATE_REGEXP = /\d{4}-\d{2}-\d{2}T00:00:00.000Z/;
+
+module.exports = {
+  UUID_REGEXP,
+  XID_REGEXP,
+  ISO8601_TIME_REGEXP,
+  ISO8601_DATE_REGEXP,
+};

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

@@ -0,0 +1,84 @@
+/* eslint-disable no-magic-numbers */
+
+'use strict';
+
+/* global describe, it, expect, beforeAll */
+
+const { Types, ConnectionBase } = require('../../../lib');
+
+describe('BigIntType', () => {
+  let connection;
+
+  beforeAll(async () => {
+    connection = new ConnectionBase({
+      bindModels: false,
+      models:     require('../../support/models'),
+    });
+  });
+
+  describe('toConnectionType', () => {
+    it('can convert to connection is defined', () => {
+      let type = new Types.BigIntType();
+      expect(type.toConnectionType(connection)).toEqual('BIGINT');
+    });
+
+    it('can convert to connection type when connection is undefined', () => {
+      let type = new Types.BigIntType(6);
+      expect(type.toConnectionType()).toEqual('BIGINT(6)');
+    });
+  });
+
+  describe('toString', () => {
+    it('can convert to connection is defined', () => {
+      let type = new Types.BigIntType();
+      expect(type.toString(connection)).toEqual('BIGINT');
+    });
+
+    it('can convert to connection type when connection undefined', () => {
+      let type = new Types.BigIntType(6);
+      expect(type.toString()).toEqual('BIGINT(6)');
+    });
+  });
+
+  it('can construct from class', () => {
+    let type = new Types.BigIntType();
+    expect(type.toString()).toEqual('BIGINT');
+    expect(type.length).toBe(null);
+  });
+
+  it('can construct from class with length', () => {
+    let type = new Types.BigIntType(11);
+    expect(type.toString()).toEqual('BIGINT(11)');
+    expect(type.length).toEqual(11);
+  });
+
+  it('can construct from type helper', () => {
+    let type = Types.BIGINT();
+    expect(type.toString()).toEqual('BIGINT');
+    expect(type.length).toBe(null);
+  });
+
+  it('can construct from type helper with length', () => {
+    let type = Types.BIGINT(11);
+    expect(type.toString()).toEqual('BIGINT(11)');
+    expect(type.length).toEqual(11);
+  });
+
+  it('can cast to type', () => {
+    let type = Types.BIGINT();
+    let value = type.castToType({ value: '1234' });
+    expect(typeof value).toEqual('number');
+    expect(value).toEqual(1234);
+
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new SyntaxError('Cannot convert derp to a BigInt'));
+  });
+
+  it('can cast to type (strict)', () => {
+    let type = Types.BIGINT(null, { strict: true });
+    let value = type.castToType({ value: '1234' });
+    expect(typeof value).toEqual('bigint');
+    expect(value).toEqual(BigInt(1234));
+
+    expect(() => type.castToType({ value: 'derp' })).toThrow(new SyntaxError('Cannot convert derp to a BigInt'));
+  });
+});