@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.0

package/lib/model/ModifierNotFoundError.js

@@ -1,12 +1,10 @@
 'use strict';
-
 class ModifierNotFoundError extends Error {
-  constructor(modifierName) {
-    super(`Unable to determine modify function from provided value: "${modifierName}".`);
-    this.modifierName = modifierName;
-  }
+    constructor(modifierName) {
+        super(`Unable to determine modify function from provided value: "${modifierName}".`);
+        this.modifierName = modifierName;
+    }
 }
-
 module.exports = {
-  ModifierNotFoundError,
+    ModifierNotFoundError,
 };

package/lib/model/NotFoundError.js

@@ -1,23 +1,19 @@
 'use strict';
-
 class NotFoundError extends Error {
-  constructor({ modelClass, data = {}, statusCode = 404, ...rest } = {}) {
-    super(rest.message || 'NotFoundError');
-
-    this.type = 'NotFound';
-    this.name = this.constructor.name;
-    this.data = { ...rest, ...data };
-    this.statusCode = statusCode;
-
-    // Add as non-enumerable in case people are passing instances of
-    // this error directly to `JSON.stringify`.
-    Object.defineProperty(this, 'modelClass', {
-      value: modelClass,
-      enumerable: false,
-    });
-  }
+    constructor({ modelClass, data = {}, statusCode = 404, ...rest } = {}) {
+        super(rest.message || 'NotFoundError');
+        this.type = 'NotFound';
+        this.name = this.constructor.name;
+        this.data = { ...rest, ...data };
+        this.statusCode = statusCode;
+        // Add as non-enumerable in case people are passing instances of
+        // this error directly to `JSON.stringify`.
+        Object.defineProperty(this, 'modelClass', {
+            value: modelClass,
+            enumerable: false,
+        });
+    }
 }
-
 module.exports = {
-  NotFoundError,
+    NotFoundError,
 };

package/lib/model/RelationDoesNotExistError.js

@@ -1,14 +1,11 @@
 'use strict';
-
 class RelationDoesNotExistError extends Error {
-  constructor(relationName) {
-    super(`unknown relation "${relationName}" in a relation expression`);
-
-    this.name = this.constructor.name;
-    this.relationName = relationName;
-  }
+    constructor(relationName) {
+        super(`unknown relation "${relationName}" in a relation expression`);
+        this.name = this.constructor.name;
+        this.relationName = relationName;
+    }
 }
-
 module.exports = {
-  RelationDoesNotExistError,
+    RelationDoesNotExistError,
 };

package/lib/model/ValidationError.js

@@ -1,54 +1,46 @@
 'use strict';
-
 const { asArray, isString } = require('../utils/objectUtils');
-
 const ValidationErrorType = {
-  ModelValidation: 'ModelValidation',
-  RelationExpression: 'RelationExpression',
-  UnallowedRelation: 'UnallowedRelation',
-  InvalidGraph: 'InvalidGraph',
+    ModelValidation: 'ModelValidation',
+    RelationExpression: 'RelationExpression',
+    UnallowedRelation: 'UnallowedRelation',
+    InvalidGraph: 'InvalidGraph',
 };
-
 class ValidationError extends Error {
-  static get Type() {
-    return ValidationErrorType;
-  }
-
-  constructor({ type, message, modelClass, data = {}, statusCode = 400 }) {
-    super(message || errorsToMessage(data));
-
-    this.name = this.constructor.name;
-    this.type = type;
-    this.data = data;
-    this.statusCode = statusCode;
-
-    // Add as non-enumerable in case people are passing instances of
-    // this error directly to `JSON.stringify`.
-    Object.defineProperty(this, 'modelClass', {
-      value: modelClass,
-      enumerable: false,
-    });
-  }
+    static get Type() {
+        return ValidationErrorType;
+    }
+    constructor({ type, message, modelClass, data = {}, statusCode = 400 }) {
+        super(message || errorsToMessage(data));
+        this.name = this.constructor.name;
+        this.type = type;
+        this.data = data;
+        this.statusCode = statusCode;
+        // Add as non-enumerable in case people are passing instances of
+        // this error directly to `JSON.stringify`.
+        Object.defineProperty(this, 'modelClass', {
+            value: modelClass,
+            enumerable: false,
+        });
+    }
 }
-
 function errorsToMessage(data) {
-  return Object.keys(data)
-    .reduce((messages, key) => {
-      messages.push(`${key}: ${asArray(data[key]).map(message).join(', ')}`);
-      return messages;
+    return Object.keys(data)
+        .reduce((messages, key) => {
+        messages.push(`${key}: ${asArray(data[key]).map(message).join(', ')}`);
+        return messages;
     }, [])
-    .join(', ');
+        .join(', ');
 }
-
 function message(it) {
-  if (isString(it)) {
-    return it;
-  } else {
-    return it.message;
-  }
+    if (isString(it)) {
+        return it;
+    }
+    else {
+        return it.message;
+    }
 }
-
 module.exports = {
-  ValidationError,
-  ValidationErrorType,
+    ValidationError,
+    ValidationErrorType,
 };

package/lib/model/Validator.js

@@ -1,26 +1,20 @@
 'use strict';
-
 class Validator {
-  constructor(...args) {
-    this.constructor.init(this, ...args);
-  }
-
-  static init() {}
-
-  beforeValidate({ model, json, options }) {
-    model.$beforeValidate(null, json, options);
-  }
-
-  validate() {
-    /* istanbul ignore next */
-    throw new Error('not implemented');
-  }
-
-  afterValidate({ model, json, options }) {
-    model.$afterValidate(json, options);
-  }
+    constructor(...args) {
+        this.constructor.init(this, ...args);
+    }
+    static init() { }
+    beforeValidate({ model, json, options }) {
+        model.$beforeValidate(null, json, options);
+    }
+    validate() {
+        /* istanbul ignore next */
+        throw new Error('not implemented');
+    }
+    afterValidate({ model, json, options }) {
+        model.$afterValidate(json, options);
+    }
 }
-
 module.exports = {
-  Validator,
+    Validator,
 };

package/lib/model/getModel.js

@@ -1,9 +1,7 @@
 'use strict';
-
 // A small helper method for cached lazy-importing of the Model class.
 let Model;
 const getModel = () => Model || (Model = require('./Model').Model);
-
 module.exports = {
-  getModel,
+    getModel,
 };

package/lib/model/graph/ModelGraph.js

@@ -1,80 +1,60 @@
 'use strict';
-
 const { ModelGraphBuilder } = require('./ModelGraphBuilder');
 const NOT_CALCULATED = {};
-
 class ModelGraph {
-  constructor(nodes, edges) {
-    this.nodes = nodes;
-    this.edges = edges;
-
-    // These are calculated lazily.
-    this._nodesByObjects = NOT_CALCULATED;
-    this._nodesByIdPathKeys = NOT_CALCULATED;
-  }
-
-  static create(rootModelClass, roots) {
-    const builder = ModelGraphBuilder.buildGraph(rootModelClass, roots);
-    return new ModelGraph(builder.nodes, builder.edges);
-  }
-
-  static createEmpty() {
-    return new ModelGraph([], []);
-  }
-
-  get rootObjects() {
-    return this.nodes.filter((node) => !node.parentEdge).map((node) => node.obj);
-  }
-
-  nodeForObject(obj) {
-    if (!obj) {
-      return null;
+    constructor(nodes, edges) {
+        this.nodes = nodes;
+        this.edges = edges;
+        // These are calculated lazily.
+        this._nodesByObjects = NOT_CALCULATED;
+        this._nodesByIdPathKeys = NOT_CALCULATED;
     }
-
-    if (this._nodesByObjects === NOT_CALCULATED) {
-      this._nodesByObjects = createNodesByObjectsMap(this.nodes);
+    static create(rootModelClass, roots) {
+        const builder = ModelGraphBuilder.buildGraph(rootModelClass, roots);
+        return new ModelGraph(builder.nodes, builder.edges);
     }
-
-    return this._nodesByObjects.get(obj) || null;
-  }
-
-  nodeForNode(node) {
-    if (!node) {
-      return null;
+    static createEmpty() {
+        return new ModelGraph([], []);
     }
-
-    if (this._nodesByIdPathKeys === NOT_CALCULATED) {
-      this._nodesByIdPathKeys = createNodesByIdPathKeysMap(this.nodes);
+    get rootObjects() {
+        return this.nodes.filter((node) => !node.parentEdge).map((node) => node.obj);
+    }
+    nodeForObject(obj) {
+        if (!obj) {
+            return null;
+        }
+        if (this._nodesByObjects === NOT_CALCULATED) {
+            this._nodesByObjects = createNodesByObjectsMap(this.nodes);
+        }
+        return this._nodesByObjects.get(obj) || null;
+    }
+    nodeForNode(node) {
+        if (!node) {
+            return null;
+        }
+        if (this._nodesByIdPathKeys === NOT_CALCULATED) {
+            this._nodesByIdPathKeys = createNodesByIdPathKeysMap(this.nodes);
+        }
+        return this._nodesByIdPathKeys.get(node.idPathKey) || null;
     }
-
-    return this._nodesByIdPathKeys.get(node.idPathKey) || null;
-  }
 }
-
 function createNodesByObjectsMap(nodes) {
-  const nodesByObjects = new Map();
-
-  for (const node of nodes) {
-    nodesByObjects.set(node.obj, node);
-  }
-
-  return nodesByObjects;
+    const nodesByObjects = new Map();
+    for (const node of nodes) {
+        nodesByObjects.set(node.obj, node);
+    }
+    return nodesByObjects;
 }
-
 function createNodesByIdPathKeysMap(nodes) {
-  const nodesByIdPathKeys = new Map();
-
-  for (const node of nodes) {
-    const idPathKey = node.idPathKey;
-
-    if (idPathKey !== null) {
-      nodesByIdPathKeys.set(idPathKey, node);
+    const nodesByIdPathKeys = new Map();
+    for (const node of nodes) {
+        const idPathKey = node.idPathKey;
+        if (idPathKey !== null) {
+            nodesByIdPathKeys.set(idPathKey, node);
+        }
     }
-  }
-
-  return nodesByIdPathKeys;
+    return nodesByIdPathKeys;
 }
-
 module.exports = {
-  ModelGraph,
+    ModelGraph,
 };