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

package/lib/model/modelToJson.js

@@ -0,0 +1,157 @@
+'use strict';
+const { isInternalProp } = require('../utils/internalPropUtils');
+const { mergeQueryProps } = require('./modelQueryProps');
+const { isObject, cloneDeep, isFunction } = require('../utils/objectUtils');
+const EMPTY_ARRAY = [];
+function toJson(model, optIn) {
+    const modelClass = model.constructor;
+    const opt = {
+        virtuals: getVirtuals(optIn),
+        shallow: isShallow(optIn),
+        omit: getOmit(optIn, modelClass),
+        pick: null,
+        omitFromJson: model.$omitFromJson() || null,
+        cloneObjects: modelClass.cloneObjectAttributes,
+    };
+    let json = toExternalJsonImpl(model, opt);
+    json = model.$formatJson(json);
+    return json;
+}
+function toDatabaseJson(model, builder) {
+    const modelClass = model.constructor;
+    const opt = {
+        virtuals: false,
+        shallow: true,
+        omit: modelClass.getRelationNames(),
+        pick: getPick(modelClass),
+        omitFromJson: model.$omitFromDatabaseJson() || null,
+        cloneObjects: modelClass.cloneObjectAttributes,
+    };
+    let json = toDatabaseJsonImpl(model, opt);
+    json = model.$formatDatabaseJson(json);
+    return mergeQueryProps(model, json, opt.omitFromJson, builder);
+}
+function getVirtuals(opt) {
+    if (!opt) {
+        return true;
+    }
+    else if (Array.isArray(opt.virtuals)) {
+        return opt.virtuals;
+    }
+    else {
+        return opt.virtuals !== false;
+    }
+}
+function isShallow(opt) {
+    return !!opt && !!opt.shallow;
+}
+function getOmit(opt, modelClass) {
+    return isShallow(opt) ? modelClass.getRelationNames() : null;
+}
+function getPick(modelClass) {
+    const jsonSchema = modelClass.getJsonSchema();
+    return (jsonSchema && modelClass.pickJsonSchemaProperties && jsonSchema.properties) || null;
+}
+function toExternalJsonImpl(model, opt) {
+    const json = {};
+    const keys = Object.keys(model);
+    const vAttr = getVirtualAttributes(model, opt);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        assignJsonValue(json, key, value, opt);
+    }
+    if (vAttr.length !== 0) {
+        assignVirtualAttributes(json, model, vAttr, opt);
+    }
+    return json;
+}
+function getVirtualAttributes(model, opt) {
+    if (Array.isArray(opt.virtuals)) {
+        return opt.virtuals;
+    }
+    else if (opt.virtuals === true) {
+        return model.constructor.getVirtualAttributes();
+    }
+    else {
+        return EMPTY_ARRAY;
+    }
+}
+function toDatabaseJsonImpl(model, opt) {
+    const json = {};
+    const keys = Object.keys(model);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        assignJsonValue(json, key, value, opt);
+    }
+    return json;
+}
+function assignJsonValue(json, key, value, opt) {
+    const type = typeof value;
+    if (type !== 'function' &&
+        type !== 'undefined' &&
+        !isInternalProp(key) &&
+        !shouldOmit(opt, key) &&
+        shouldPick(opt, key)) {
+        if (isObject(value)) {
+            json[key] = toJsonObject(value, opt);
+        }
+        else {
+            json[key] = value;
+        }
+    }
+}
+function shouldOmit(opt, key) {
+    return ((opt.omit !== null && opt.omit.includes(key)) ||
+        (opt.omitFromJson !== null && opt.omitFromJson.includes(key)));
+}
+function shouldPick(opt, key) {
+    return opt.pick === null || key in opt.pick;
+}
+function assignVirtualAttributes(json, model, vAttr, opt) {
+    for (let i = 0, l = vAttr.length; i < l; ++i) {
+        const key = vAttr[i];
+        let value = model[key];
+        if (isFunction(value)) {
+            value = value.call(model);
+        }
+        assignJsonValue(json, key, value, opt);
+    }
+}
+function toJsonObject(value, opt) {
+    if (Array.isArray(value)) {
+        return toJsonArray(value, opt);
+    }
+    else if (value.$isObjectionModel) {
+        // No branch for $toDatabaseJson here since there is never a need
+        // to have nested models in database rows.
+        return value.$toJson(opt);
+    }
+    else if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    else if (opt.cloneObjects) {
+        return cloneDeep(value);
+    }
+    else {
+        return value;
+    }
+}
+function toJsonArray(value, opt) {
+    const ret = new Array(value.length);
+    for (let i = 0, l = ret.length; i < l; ++i) {
+        const item = value[i];
+        if (isObject(item)) {
+            ret[i] = toJsonObject(item, opt);
+        }
+        else {
+            ret[i] = item;
+        }
+    }
+    return ret;
+}
+module.exports = {
+    toJson,
+    toDatabaseJson,
+};

package/lib/model/modelUtils.js

@@ -0,0 +1,40 @@
+'use strict';
+const hiddenProps = ['$$queryProps'];
+const staticHiddenProps = [
+    '$$knex',
+    '$$validator',
+    '$$jsonSchema',
+    '$$colToProp',
+    '$$propToCol',
+    '$$relationMappings',
+    '$$relations',
+    '$$relationNames',
+    '$$jsonAttributes',
+    '$$columnNameMappers',
+    '$$tableMetadata',
+    '$$readOnlyAttributes',
+    '$$idRelationProperty',
+    '$$virtualAttributes',
+];
+function defineNonEnumerableProperty(obj, prop, value) {
+    Object.defineProperty(obj, prop, {
+        enumerable: false,
+        writable: true,
+        configurable: true,
+        value,
+    });
+}
+function keyByProps(models, props) {
+    const map = new Map();
+    for (let i = 0, l = models.length; i < l; ++i) {
+        const model = models[i];
+        map.set(model.$propKey(props), model);
+    }
+    return map;
+}
+module.exports = {
+    hiddenProps,
+    staticHiddenProps,
+    defineNonEnumerableProperty,
+    keyByProps,
+};

package/lib/model/modelValidate.js

@@ -0,0 +1,40 @@
+'use strict';
+const { clone } = require('./modelClone');
+function validate(model, json, options = {}) {
+    json = json || model;
+    const inputJson = json;
+    const validatingModelInstance = inputJson && inputJson.$isObjectionModel;
+    if (options.skipValidation) {
+        return json;
+    }
+    if (validatingModelInstance) {
+        // Strip away relations and other internal stuff.
+        // TODO 1: This should use `json.$toJson()` since we always validate the input representation!
+        // TODO 2: This should also keep the relations in the object because some validators may
+        //         depend on the relations.
+        json = clone(json, true, true);
+        // We can mutate `json` now that we took a copy of it.
+        options = Object.assign({}, options, { mutable: true });
+    }
+    const modelClass = model.constructor;
+    const validator = modelClass.getValidator();
+    const args = {
+        options,
+        model,
+        json,
+        ctx: Object.create(null),
+    };
+    validator.beforeValidate(args);
+    json = validator.validate(args);
+    validator.afterValidate(args);
+    if (validatingModelInstance) {
+        // If we cloned `json`, we need to copy the possible default values.
+        return inputJson.$set(json);
+    }
+    else {
+        return json;
+    }
+}
+module.exports = {
+    validate,
+};

package/lib/model/modelValues.js

@@ -0,0 +1,113 @@
+'use strict';
+const { isObject } = require('../utils/objectUtils');
+// Property keys needs to be prefixed with a non-numeric character so that
+// they are not considered indexes when used as object keys.
+const PROP_KEY_PREFIX = 'k_';
+function values(model, args) {
+    switch (args.length) {
+        case 1:
+            return values1(model, args);
+        case 2:
+            return values2(model, args);
+        case 3:
+            return values3(model, args);
+        default:
+            return valuesN(model, args);
+    }
+}
+function propKey(model, props) {
+    switch (props.length) {
+        case 1:
+            return propKey1(model, props);
+        case 2:
+            return propKey2(model, props);
+        case 3:
+            return propKey3(model, props);
+        default:
+            return propKeyN(model, props);
+    }
+}
+function hasProps(model, props) {
+    for (let i = 0; i < props.length; ++i) {
+        const value = model[props[i]];
+        if (isNullOrUndefined(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+function values1(model, args) {
+    return [model[args[0]]];
+}
+function values2(model, args) {
+    return [model[args[0]], model[args[1]]];
+}
+function values3(model, args) {
+    return [model[args[0]], model[args[1]], model[args[2]]];
+}
+function valuesN(model, args) {
+    const ret = new Array(args.length);
+    for (let i = 0, l = args.length; i < l; ++i) {
+        ret[i] = model[args[i]];
+    }
+    return ret;
+}
+function propKey1(model, props) {
+    return PROP_KEY_PREFIX + propToStr(model[props[0]]);
+}
+function propKey2(model, props) {
+    return PROP_KEY_PREFIX + propToStr(model[props[0]]) + ',' + propToStr(model[props[1]]);
+}
+function propKey3(model, props) {
+    return (PROP_KEY_PREFIX +
+        propToStr(model[props[0]]) +
+        ',' +
+        propToStr(model[props[1]]) +
+        ',' +
+        propToStr(model[props[2]]));
+}
+function propKeyN(model, props) {
+    let key = PROP_KEY_PREFIX;
+    for (let i = 0, l = props.length; i < l; ++i) {
+        key += propToStr(model[props[i]]);
+        if (i < l - 1) {
+            key += ',';
+        }
+    }
+    return key;
+}
+function propToStr(value) {
+    // Ids are almost always numbers or strings.
+    const type = typeof value;
+    if (type === 'string') {
+        return value;
+    }
+    else if (type === 'number') {
+        return `${value}`;
+    }
+    else if (value === null) {
+        return 'null';
+    }
+    else if (value === undefined) {
+        return 'undefined';
+    }
+    else if (Buffer.isBuffer(value)) {
+        return value.toString('hex');
+    }
+    else if (isObject(value)) {
+        return JSON.stringify(value);
+    }
+    else {
+        return `${value}`;
+    }
+}
+function isNullOrUndefined(val) {
+    return val === null || val === undefined;
+}
+module.exports = {
+    PROP_KEY_PREFIX,
+    propToStr,
+    values,
+    hasProps,
+    propKey,
+};

package/lib/model/modelVisitor.js

@@ -0,0 +1,34 @@
+'use strict';
+function visitModels(models, modelClass, visitor) {
+    doVisit(models, modelClass, null, null, visitor);
+}
+function doVisit(models, modelClass, parent, rel, visitor) {
+    if (Array.isArray(models)) {
+        visitMany(models, modelClass, parent, rel, visitor);
+    }
+    else if (models) {
+        visitOne(models, modelClass, parent, rel, visitor);
+    }
+}
+function visitMany(models, modelClass, parent, rel, visitor) {
+    for (let i = 0, l = models.length; i < l; ++i) {
+        visitOne(models[i], modelClass, parent, rel, visitor);
+    }
+}
+function visitOne(model, modelClass, parent, rel, visitor) {
+    if (model) {
+        visitor(model, modelClass, parent, rel);
+    }
+    const relationNames = modelClass.getRelationNames();
+    for (let i = 0, l = relationNames.length; i < l; ++i) {
+        const relationName = relationNames[i];
+        const relatedObj = model[relationName];
+        if (relatedObj) {
+            const relation = modelClass.getRelation(relationName);
+            doVisit(relatedObj, relation.relatedModelClass, model, relation, visitor);
+        }
+    }
+}
+module.exports = {
+    visitModels,
+};

package/lib/objection.js

@@ -0,0 +1,89 @@
+'use strict';
+const { DBError, UniqueViolationError, NotNullViolationError, ForeignKeyViolationError, ConstraintViolationError, CheckViolationError, DataError, } = require('db-errors');
+const { Model: NativeModel } = require('./model/Model');
+const { QueryBuilder: NativeQueryBuilder } = require('./queryBuilder/QueryBuilder');
+const { QueryBuilderBase } = require('./queryBuilder/QueryBuilderBase');
+const { QueryBuilderOperation } = require('./queryBuilder/operations/QueryBuilderOperation');
+const { RelationExpression } = require('./queryBuilder/RelationExpression');
+const { ValidationError } = require('./model/ValidationError');
+const { NotFoundError } = require('./model/NotFoundError');
+const { AjvValidator: NativeAjvValidator } = require('./model/AjvValidator');
+const { Validator: NativeValidator } = require('./model/Validator');
+const { Relation } = require('./relations/Relation');
+const { HasOneRelation } = require('./relations/hasOne/HasOneRelation');
+const { HasManyRelation } = require('./relations/hasMany/HasManyRelation');
+const { BelongsToOneRelation } = require('./relations/belongsToOne/BelongsToOneRelation');
+const { HasOneThroughRelation } = require('./relations/hasOneThrough/HasOneThroughRelation');
+const { ManyToManyRelation } = require('./relations/manyToMany/ManyToManyRelation');
+const { transaction } = require('./transaction');
+const { initialize } = require('./initialize');
+const { snakeCaseMappers, knexSnakeCaseMappers, knexIdentifierMapping, } = require('./utils/identifierMapping');
+const { compose, mixin } = require('./utils/mixin');
+const { ref } = require('./queryBuilder/ReferenceBuilder');
+const { val } = require('./queryBuilder/ValueBuilder');
+const { raw } = require('./queryBuilder/RawBuilder');
+const { fn } = require('./queryBuilder/FunctionBuilder');
+const { inherit } = require('./utils/classUtils');
+// We need to wrap the classes, that people can inherit, with ES5 classes
+// so that babel is able to use ES5 inheritance. sigh... Maybe people
+// should stop transpiling node apps to ES5 in the year 2019? Node 6
+// with full class support was released three years ago.
+function Model() {
+    // Nothing to do here.
+}
+function QueryBuilder(...args) {
+    NativeQueryBuilder.init(this, ...args);
+}
+function Validator(...args) {
+    NativeValidator.init(this, ...args);
+}
+function AjvValidator(...args) {
+    NativeAjvValidator.init(this, ...args);
+}
+// Returns the relation mappings as is. This only exists for typescript: it
+// preserves the exact types of the mappings (like the names of `extra`
+// columns) so that the relation types can be inferred from them.
+function defineRelations(relationMappings) {
+    return relationMappings;
+}
+inherit(Model, NativeModel);
+inherit(QueryBuilder, NativeQueryBuilder);
+inherit(Validator, NativeValidator);
+inherit(AjvValidator, NativeAjvValidator);
+Model.QueryBuilder = QueryBuilder;
+module.exports = {
+    Model,
+    QueryBuilder,
+    QueryBuilderBase,
+    QueryBuilderOperation,
+    RelationExpression,
+    ValidationError,
+    NotFoundError,
+    AjvValidator,
+    Validator,
+    Relation,
+    HasOneRelation,
+    HasManyRelation,
+    BelongsToOneRelation,
+    HasOneThroughRelation,
+    ManyToManyRelation,
+    transaction,
+    initialize,
+    compose,
+    mixin,
+    defineRelations,
+    ref,
+    val,
+    raw,
+    fn,
+    snakeCaseMappers,
+    knexSnakeCaseMappers,
+    knexIdentifierMapping,
+    DBError,
+    UniqueViolationError,
+    NotNullViolationError,
+    ForeignKeyViolationError,
+    ConstraintViolationError,
+    CheckViolationError,
+    DataError,
+};