@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/model/ModifierNotFoundError.js

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

package/lib/model/NotFoundError.js

@@ -0,0 +1,23 @@
+'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,
+    });
+  }
+}
+
+module.exports = {
+  NotFoundError,
+};

package/lib/model/RelationDoesNotExistError.js

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

package/lib/model/ValidationError.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { asArray, isString } = require('../utils/objectUtils');
+
+const ValidationErrorType = {
+  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,
+    });
+  }
+}
+
+function errorsToMessage(data) {
+  return Object.keys(data)
+    .reduce((messages, key) => {
+      messages.push(`${key}: ${asArray(data[key]).map(message).join(', ')}`);
+      return messages;
+    }, [])
+    .join(', ');
+}
+
+function message(it) {
+  if (isString(it)) {
+    return it;
+  } else {
+    return it.message;
+  }
+}
+
+module.exports = {
+  ValidationError,
+  ValidationErrorType,
+};

package/lib/model/Validator.js

@@ -0,0 +1,26 @@
+'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);
+  }
+}
+
+module.exports = {
+  Validator,
+};

package/lib/model/getModel.js

@@ -0,0 +1,9 @@
+'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,
+};

package/lib/model/graph/ModelGraph.js

@@ -0,0 +1,80 @@
+'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;
+    }
+
+    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;
+  }
+}
+
+function createNodesByObjectsMap(nodes) {
+  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);
+    }
+  }
+
+  return nodesByIdPathKeys;
+}
+
+module.exports = {
+  ModelGraph,
+};

package/lib/model/graph/ModelGraphBuilder.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const { isObject, isString, asArray, asSingle } = require('../../utils/objectUtils');
+const { ValidationErrorType } = require('../../model/ValidationError');
+const { ModelGraphNode } = require('./ModelGraphNode');
+const { ModelGraphEdge } = require('./ModelGraphEdge');
+
+class ModelGraphBuilder {
+  constructor() {
+    this.nodes = [];
+    this.edges = [];
+  }
+
+  static buildGraph(rootModelClass, roots) {
+    const builder = new this();
+    builder._buildGraph(rootModelClass, roots);
+
+    return builder;
+  }
+
+  _buildGraph(rootModelClass, roots) {
+    if (roots) {
+      if (Array.isArray(roots)) {
+        this._buildNodes(rootModelClass, roots);
+      } else if (isObject(roots)) {
+        this._buildNode(rootModelClass, roots);
+      } else {
+        throw createNotModelError(rootModelClass, roots);
+      }
+    }
+
+    this._buildReferences();
+  }
+
+  _buildNodes(modelClass, objs, parentNode = null, relation = null) {
+    objs = asArray(objs);
+
+    objs.forEach((obj, index) => {
+      this._buildNode(modelClass, obj, parentNode, relation, index);
+    });
+  }
+
+  _buildNode(modelClass, obj, parentNode = null, relation = null, index = null) {
+    obj = asSingle(obj);
+
+    if (!isObject(obj) || !obj.$isObjectionModel) {
+      throw createNotModelError(modelClass, obj);
+    }
+
+    const node = new ModelGraphNode(modelClass, obj);
+    this.nodes.push(node);
+
+    if (parentNode) {
+      const edge = new ModelGraphEdge(
+        ModelGraphEdge.Type.Relation,
+        parentNode,
+        node,
+        relation,
+        index,
+      );
+
+      node.parentEdge = edge;
+      this._addEdge(parentNode, node, edge);
+    }
+
+    this._buildRelationNodes(node);
+  }
+
+  _buildRelationNodes(node) {
+    for (const relationName of node.modelClass.getRelationNames()) {
+      const relatedObjects = node.obj[relationName];
+
+      if (!relatedObjects) {
+        continue;
+      }
+
+      const relation = node.modelClass.getRelation(relationName);
+
+      if (relation.isOneToOne()) {
+        this._buildNode(relation.relatedModelClass, relatedObjects, node, relation);
+      } else {
+        this._buildNodes(relation.relatedModelClass, relatedObjects, node, relation);
+      }
+    }
+  }
+
+  _buildReferences() {
+    const nodesByUid = this._nodesByUid();
+
+    this._buildObjectReferences(nodesByUid);
+    this._buildPropertyReferences(nodesByUid);
+  }
+
+  _nodesByUid() {
+    const nodesByUid = new Map();
+
+    for (const node of this.nodes) {
+      const uid = node.uid;
+
+      if (uid === undefined) {
+        continue;
+      }
+
+      nodesByUid.set(uid, node);
+    }
+
+    return nodesByUid;
+  }
+
+  _buildObjectReferences(nodesByUid) {
+    for (const node of this.nodes) {
+      const ref = node.reference;
+
+      if (ref === undefined) {
+        continue;
+      }
+
+      const refNode = nodesByUid.get(ref);
+
+      if (!refNode) {
+        throw createReferenceNotFoundError(ref);
+      }
+
+      const edge = new ModelGraphEdge(ModelGraphEdge.Type.Reference, node, refNode);
+      edge.refType = ModelGraphEdge.ReferenceType.Object;
+
+      this._addEdge(node, refNode, edge);
+    }
+  }
+
+  _buildPropertyReferences(nodesByUid) {
+    for (const node of this.nodes) {
+      forEachPropertyReference(node.obj, ({ path, refMatch, ref, refPath }) => {
+        const refNode = nodesByUid.get(ref);
+
+        if (!refNode) {
+          throw createReferenceNotFoundError(ref);
+        }
+
+        const edge = new ModelGraphEdge(ModelGraphEdge.Type.Reference, node, refNode);
+
+        edge.refType = ModelGraphEdge.ReferenceType.Property;
+        edge.refMatch = refMatch;
+        edge.refOwnerDataPath = path.slice();
+        edge.refRelatedDataPath = refPath;
+
+        this._addEdge(node, refNode, edge);
+      });
+    }
+  }
+
+  _addEdge(ownerNode, relatedNode, edge) {
+    this.edges.push(edge);
+
+    ownerNode.edges.push(edge);
+    relatedNode.edges.push(edge);
+
+    if (edge.type === ModelGraphEdge.Type.Reference) {
+      ownerNode.refEdges.push(edge);
+      relatedNode.refEdges.push(edge);
+    }
+  }
+}
+
+function forEachPropertyReference(obj, callback) {
+  const modelClass = obj.constructor;
+  const relationNames = modelClass.getRelationNames();
+
+  for (const prop of Object.keys(obj)) {
+    if (relationNames.includes(prop)) {
+      continue;
+    }
+
+    visitStrings(obj[prop], [prop], (str, path) => {
+      forEachMatch(modelClass.propRefRegex, str, (match) => {
+        const [refMatch, ref, refPath] = match;
+        callback({ path, refMatch, ref, refPath: refPath.trim().split('.') });
+      });
+    });
+  }
+}
+
+function visitStrings(value, path, visit) {
+  if (Array.isArray(value)) {
+    visitStringsInArray(value, path, visit);
+  } else if (isObject(value) && !Buffer.isBuffer(value)) {
+    visitStringsInObject(value, path, visit);
+  } else if (isString(value)) {
+    visit(value, path);
+  }
+}
+
+function visitStringsInArray(value, path, visit) {
+  for (let i = 0; i < value.length; ++i) {
+    path.push(i);
+    visitStrings(value[i], path, visit);
+    path.pop();
+  }
+}
+
+function visitStringsInObject(value, path, visit) {
+  for (const prop of Object.keys(value)) {
+    path.push(prop);
+    visitStrings(value[prop], path, visit);
+    path.pop();
+  }
+}
+
+function forEachMatch(regex, str, cb) {
+  let matchResult = regex.exec(str);
+
+  while (matchResult) {
+    cb(matchResult);
+    matchResult = regex.exec(str);
+  }
+}
+
+function createReferenceNotFoundError(ref) {
+  return new Error(
+    [
+      `could not resolve reference ${ref} in a graph.`,
+      `If you are sure the #id exist in the same graph,`,
+      `this may be due to a limitation that a subgraph under a related item`,
+      `cannot reference an item in a subgraph under another related item.`,
+      `If you run into this limitation, please open an issue in objection github.`,
+    ].join(' '),
+  );
+}
+
+function createNotModelError(modelClass, value) {
+  throw modelClass.createValidationError({
+    type: ValidationErrorType.InvalidGraph,
+    message: `expected value "${value}" to be an instance of ${modelClass.name}`,
+  });
+}
+
+module.exports = {
+  ModelGraphBuilder,
+  createNotModelError,
+  forEachPropertyReference,
+};

package/lib/model/graph/ModelGraphEdge.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const Type = {
+  Relation: 'Relation',
+  Reference: 'Reference',
+};
+
+const ReferenceType = {
+  Object: 'Object',
+  Property: 'Property',
+};
+
+class ModelGraphEdge {
+  constructor(type, ownerNode, relatedNode, relation = null, relationIndex = null) {
+    this.type = type;
+
+    this.ownerNode = ownerNode;
+    this.relatedNode = relatedNode;
+    this.relation = relation;
+    this.relationIndex = relationIndex;
+
+    this.refType = null;
+    this.refMatch = null;
+
+    this.refOwnerDataPath = null;
+    this.refRelatedDataPath = null;
+  }
+
+  static get Type() {
+    return Type;
+  }
+
+  static get ReferenceType() {
+    return ReferenceType;
+  }
+
+  getOtherNode(node) {
+    return this.isOwnerNode(node) ? this.relatedNode : this.ownerNode;
+  }
+
+  isOwnerNode(node) {
+    return node === this.ownerNode;
+  }
+
+  isRelatedNode(node) {
+    return node === this.relatedNode;
+  }
+}
+
+module.exports = {
+  ModelGraphEdge,
+};