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

package/lib/model/ModifierNotFoundError.js

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

package/lib/model/RelationDoesNotExistError.js

@@ -0,0 +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;
+    }
+}
+module.exports = {
+    RelationDoesNotExistError,
+};

package/lib/model/ValidationError.js

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

package/lib/model/getModel.js

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

package/lib/model/graph/ModelGraph.js

@@ -0,0 +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;
+        }
+        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,188 @@
+'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,40 @@
+'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,
+};

package/lib/model/graph/ModelGraphNode.js

@@ -0,0 +1,201 @@
+'use strict';
+const { ModelGraphEdge } = require('./ModelGraphEdge');
+const { isNumber } = require('../../utils/objectUtils');
+const NOT_CALCULATED = {};
+class ModelGraphNode {
+    constructor(modelClass, obj) {
+        this.modelClass = modelClass;
+        this.obj = obj;
+        this.edges = [];
+        this.userData = {};
+        this.hasId = obj.$hasId();
+        this.uid = obj[modelClass.uidProp];
+        // These are also included in `edges`. These are simply
+        // shortcuts for commonly used edges.
+        this.refEdges = [];
+        this.parentEdge = null;
+        // These are calculated lazily.
+        this._relationPath = NOT_CALCULATED;
+        this._relationPathKey = NOT_CALCULATED;
+        this._dataPath = NOT_CALCULATED;
+        this._dataPathKey = NOT_CALCULATED;
+        this._idPath = NOT_CALCULATED;
+        this._idPathKey = NOT_CALCULATED;
+    }
+    get isReference() {
+        return this.reference !== undefined;
+    }
+    get isDbReference() {
+        return this.dbReference !== undefined;
+    }
+    get reference() {
+        return this.obj[this.modelClass.uidRefProp];
+    }
+    get dbReference() {
+        return this.obj[this.modelClass.dbRefProp];
+    }
+    get parentNode() {
+        if (this.parentEdge) {
+            return this.parentEdge.ownerNode;
+        }
+        else {
+            return null;
+        }
+    }
+    get indexInRelation() {
+        if (this.parentEdge) {
+            return this.parentEdge.relationIndex;
+        }
+        else {
+            return null;
+        }
+    }
+    get relationName() {
+        if (this.parentEdge) {
+            return this.parentEdge.relation.name;
+        }
+        else {
+            return null;
+        }
+    }
+    get relationPath() {
+        if (this._relationPath === NOT_CALCULATED) {
+            this._relationPath = this._createRelationPath();
+        }
+        return this._relationPath;
+    }
+    get relationPathKey() {
+        if (this._relationPathKey === NOT_CALCULATED) {
+            this._relationPathKey = this._createRelationPathKey();
+        }
+        return this._relationPathKey;
+    }
+    get dataPath() {
+        if (this._dataPath === NOT_CALCULATED) {
+            this._dataPath = this._createDataPath();
+        }
+        return this._dataPath;
+    }
+    get dataPathKey() {
+        if (this._dataPathKey === NOT_CALCULATED) {
+            this._dataPathKey = this._createDataPathKey();
+        }
+        return this._dataPathKey;
+    }
+    get idPath() {
+        if (this._idPath === NOT_CALCULATED) {
+            this._idPath = this._createIdPath();
+        }
+        return this._idPath;
+    }
+    get idPathKey() {
+        if (this._idPathKey === NOT_CALCULATED) {
+            this._idPathKey = this._createIdPathKey();
+        }
+        return this._idPathKey;
+    }
+    /**
+     * If this node is a reference, returns the referred node.
+     */
+    get referencedNode() {
+        for (const edge of this.refEdges) {
+            if (edge.refType === ModelGraphEdge.ReferenceType.Object && edge.isOwnerNode(this)) {
+                return edge.relatedNode;
+            }
+        }
+        return null;
+    }
+    /**
+     * Returns all nodes that are references to this node.
+     */
+    get referencingNodes() {
+        const nodes = [];
+        for (const edge of this.refEdges) {
+            if (edge.refType === ModelGraphEdge.ReferenceType.Object && edge.isRelatedNode(this)) {
+                nodes.push(edge.ownerNode);
+            }
+        }
+        return nodes;
+    }
+    get descendantRelationNodes() {
+        return this._collectDescendantRelationNodes([]);
+    }
+    removeEdge(edge) {
+        // Don't allow removing parent edges for now. It would
+        // cause all kinds of cache invalidation.
+        if (edge === this.parentEdge) {
+            throw new Error('cannot remove parent edge');
+        }
+        this.edges = this.edges.filter((it) => it !== edge);
+        this.refEdges = this.refEdges.filter((it) => it !== edge);
+    }
+    _collectDescendantRelationNodes(nodes) {
+        for (const edge of this.edges) {
+            if (edge.type === ModelGraphEdge.Type.Relation && edge.isOwnerNode(this)) {
+                nodes.push(edge.relatedNode);
+                edge.relatedNode._collectDescendantRelationNodes(nodes);
+            }
+        }
+        return nodes;
+    }
+    _createRelationPath() {
+        if (this.parentNode === null) {
+            return [];
+        }
+        else {
+            return [...this.parentNode.relationPath, this.relationName];
+        }
+    }
+    _createRelationPathKey() {
+        return this.relationPath.join('.');
+    }
+    _createDataPath() {
+        if (this.parentEdge === null) {
+            return [];
+        }
+        else if (this.parentEdge.relation.isOneToOne()) {
+            return [...this.parentNode.dataPath, this.relationName];
+        }
+        else {
+            return [...this.parentNode.dataPath, this.relationName, this.indexInRelation];
+        }
+    }
+    _createDataPathKey() {
+        const dataPathKey = this.dataPath.reduce((key, it) => {
+            if (isNumber(it)) {
+                return `${key}[${it}]`;
+            }
+            else {
+                return key ? `${key}.${it}` : it;
+            }
+        }, '');
+        return dataPathKey ? '.' + dataPathKey : dataPathKey;
+    }
+    _createIdPath() {
+        if (!this.obj.$hasId()) {
+            return null;
+        }
+        if (this.parentEdge === null) {
+            return [this.obj.$idKey()];
+        }
+        else {
+            const path = this.parentNode.idPath;
+            if (path === null) {
+                return null;
+            }
+            return [...path, this.relationName, this.obj.$idKey()];
+        }
+    }
+    _createIdPathKey() {
+        const idPath = this.idPath;
+        if (idPath) {
+            return this.idPath.join('.');
+        }
+        else {
+            return null;
+        }
+    }
+}
+module.exports = {
+    ModelGraphNode,
+};

package/lib/model/inheritModel.js

@@ -0,0 +1,19 @@
+'use strict';
+const cache = new Map();
+function inheritModel(modelClass) {
+    let inherit = cache.get(modelClass.name);
+    if (!inherit) {
+        inherit = createClassInheritor(modelClass.name);
+        cache.set(modelClass.name, inherit);
+    }
+    return inherit(modelClass);
+}
+function createClassInheritor(className) {
+    return new Function('BaseClass', `
+    'use strict';
+    return class ${className} extends BaseClass {}
+  `);
+}
+module.exports = {
+    inheritModel,
+};

package/lib/model/modelBindKnex.js

@@ -0,0 +1,69 @@
+'use strict';
+const { inheritModel } = require('./inheritModel');
+const { staticHiddenProps } = require('./modelUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+function bindKnex(modelClass, knex) {
+    let BoundModelClass = getBoundModelFromCache(modelClass, knex);
+    if (BoundModelClass === null) {
+        BoundModelClass = inheritModel(modelClass);
+        BoundModelClass = copyHiddenProperties(modelClass, BoundModelClass);
+        BoundModelClass.knex(knex);
+        BoundModelClass = putBoundModelToCache(modelClass, BoundModelClass, knex);
+        BoundModelClass = bindRelations(modelClass, BoundModelClass, knex);
+    }
+    return BoundModelClass;
+}
+function getBoundModelFromCache(modelClass, knex) {
+    const cache = getCache(knex);
+    const cacheKey = modelClass.uniqueTag();
+    return cache.get(cacheKey) || null;
+}
+function getCache(knex) {
+    if (!knex.$$objection) {
+        createCache(knex);
+    }
+    return knex.$$objection.boundModels;
+}
+function createCache(knex) {
+    defineNonEnumerableProperty(knex, '$$objection', {
+        boundModels: new Map(),
+    });
+}
+function copyHiddenProperties(modelClass, BoundModelClass) {
+    // Bound classes share the validator of the class they are bound from, which
+    // is copied below. Create it first, so that a class bound to a new knex
+    // instance, like every transaction, doesn't create and compile a validator
+    // of its own.
+    if (!Object.hasOwn(modelClass, '$$validator')) {
+        modelClass.getValidator();
+    }
+    for (const prop of staticHiddenProps) {
+        // $$relations and $$relationArray are handled in separately.
+        if (Object.hasOwn(modelClass, prop) && prop !== '$$relations' && prop !== '$$relationArray') {
+            defineNonEnumerableProperty(BoundModelClass, prop, modelClass[prop]);
+        }
+    }
+    return BoundModelClass;
+}
+function putBoundModelToCache(modelClass, BoundModelClass, knex) {
+    const cache = getCache(knex);
+    const cacheKey = modelClass.uniqueTag();
+    cache.set(cacheKey, BoundModelClass);
+    return BoundModelClass;
+}
+function bindRelations(modelClass, BoundModelClass, knex) {
+    const boundRelations = Object.create(null);
+    const boundRelationArray = [];
+    for (const relationName of modelClass.getRelationNames()) {
+        const relation = modelClass.getRelation(relationName);
+        const boundRelation = relation.bindKnex(knex);
+        boundRelations[relation.name] = boundRelation;
+        boundRelationArray.push(boundRelation);
+    }
+    defineNonEnumerableProperty(BoundModelClass, '$$relations', boundRelations);
+    defineNonEnumerableProperty(BoundModelClass, '$$relationArray', boundRelationArray);
+    return BoundModelClass;
+}
+module.exports = {
+    bindKnex,
+};