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

package/lib/model/modelClone.js

@@ -0,0 +1,102 @@
+'use strict';
+const { isObject, cloneDeep } = require('../utils/objectUtils');
+const { hiddenProps } = require('./modelUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isInternalProp } = require('../utils/internalPropUtils');
+function clone(model, shallow, stripInternal) {
+    let clone = null;
+    const omitFromJson = model.$omitFromJson();
+    const omitFromDatabaseJson = model.$omitFromDatabaseJson();
+    if (!shallow && !stripInternal) {
+        clone = cloneSimple(model);
+    }
+    else {
+        clone = cloneWithOpt(model, shallow, stripInternal);
+    }
+    if (omitFromJson) {
+        clone.$omitFromJson(omitFromJson);
+    }
+    if (omitFromDatabaseJson) {
+        clone.$omitFromDatabaseJson(omitFromDatabaseJson);
+    }
+    clone = copyHiddenProps(model, clone);
+    return clone;
+}
+function cloneSimple(model) {
+    const clone = new model.constructor();
+    const keys = Object.keys(model);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        if (isObject(value)) {
+            clone[key] = cloneObject(value);
+        }
+        else {
+            clone[key] = value;
+        }
+    }
+    return clone;
+}
+function cloneWithOpt(model, shallow, stripInternal) {
+    const clone = new model.constructor();
+    const keys = Object.keys(model);
+    const relationNames = model.constructor.getRelationNames();
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        if (shallow && relationNames.includes(key)) {
+            // The constructor may have given default values for relations.
+            delete clone[key];
+            continue;
+        }
+        if (stripInternal && isInternalProp(key)) {
+            continue;
+        }
+        if (isObject(value)) {
+            clone[key] = cloneObject(value);
+        }
+        else {
+            clone[key] = value;
+        }
+    }
+    return clone;
+}
+function cloneObject(value) {
+    if (Array.isArray(value)) {
+        return cloneArray(value);
+    }
+    else if (value.$isObjectionModel) {
+        return clone(value, false, false);
+    }
+    else if (Buffer.isBuffer(value)) {
+        return Buffer.from(value);
+    }
+    else {
+        return cloneDeep(value);
+    }
+}
+function cloneArray(value) {
+    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] = cloneObject(item);
+        }
+        else {
+            ret[i] = item;
+        }
+    }
+    return ret;
+}
+function copyHiddenProps(model, clone) {
+    for (let i = 0, l = hiddenProps.length; i < l; ++i) {
+        const prop = hiddenProps[i];
+        if (Object.hasOwn(model, prop)) {
+            defineNonEnumerableProperty(clone, prop, model[prop]);
+        }
+    }
+    return clone;
+}
+module.exports = {
+    clone,
+};

package/lib/model/modelColPropMap.js

@@ -0,0 +1,24 @@
+'use strict';
+const { difference } = require('../utils/objectUtils');
+function columnNameToPropertyName(modelClass, columnName) {
+    const model = new modelClass();
+    const addedProps = Object.keys(model.$parseDatabaseJson({}));
+    const row = {};
+    row[columnName] = null;
+    const props = Object.keys(model.$parseDatabaseJson(row));
+    const propertyName = difference(props, addedProps)[0];
+    return propertyName || columnName;
+}
+function propertyNameToColumnName(modelClass, propertyName) {
+    const model = new modelClass();
+    const addedCols = Object.keys(model.$formatDatabaseJson({}));
+    const obj = {};
+    obj[propertyName] = null;
+    const cols = Object.keys(model.$formatDatabaseJson(obj));
+    const columnName = difference(cols, addedCols)[0];
+    return columnName || propertyName;
+}
+module.exports = {
+    columnNameToPropertyName,
+    propertyNameToColumnName,
+};

package/lib/model/modelConcurrency.js

@@ -0,0 +1,24 @@
+'use strict';
+const { isMsSql } = require('../utils/knexUtils');
+const DEFAULT_CONCURRENCY = 4;
+let defaultGetConcurrency = null;
+// Called by Model.js with Model.getConcurrency.
+function setDefaultGetConcurrency(getConcurrency) {
+    defaultGetConcurrency = getConcurrency;
+}
+// The concurrency of the queries that only read, like the queries of
+// `withGraphFetched()`. By default `getConcurrency()` is 1 on MySQL, because
+// concurrent graph updates and deletes deadlock there, but reads don't. The
+// concurrency a model sets with `concurrency` or `getConcurrency()` is used as
+// is.
+function getReadConcurrency(modelClass, knex) {
+    if (modelClass.concurrency !== null || modelClass.getConcurrency !== defaultGetConcurrency) {
+        return modelClass.getConcurrency(knex);
+    }
+    // The mssql driver can't run concurrent queries.
+    return knex && isMsSql(knex) ? 1 : DEFAULT_CONCURRENCY;
+}
+module.exports = {
+    setDefaultGetConcurrency,
+    getReadConcurrency,
+};

package/lib/model/modelId.js

@@ -0,0 +1,57 @@
+'use strict';
+function getSetId(model, maybeId) {
+    if (maybeId !== undefined) {
+        return setId(model, maybeId);
+    }
+    else {
+        return getId(model);
+    }
+}
+function hasId(model) {
+    return model.$hasProps(model.constructor.getIdPropertyArray());
+}
+function setId(model, id) {
+    const idProp = model.constructor.getIdProperty();
+    const isCompositeId = Array.isArray(idProp);
+    if (Array.isArray(id)) {
+        if (isCompositeId) {
+            if (id.length !== idProp.length) {
+                throw new Error('trying to set an invalid identifier for a model');
+            }
+            for (let i = 0; i < id.length; ++i) {
+                model[idProp[i]] = id[i];
+            }
+        }
+        else {
+            if (id.length !== 1) {
+                throw new Error('trying to set an invalid identifier for a model');
+            }
+            model[idProp] = id[0];
+        }
+    }
+    else {
+        if (isCompositeId) {
+            if (idProp.length > 1) {
+                throw new Error('trying to set an invalid identifier for a model');
+            }
+            model[idProp[0]] = id;
+        }
+        else {
+            model[idProp] = id;
+        }
+    }
+}
+function getId(model) {
+    const idProp = model.constructor.getIdProperty();
+    const isCompositeId = Array.isArray(idProp);
+    if (isCompositeId) {
+        return model.$values(idProp);
+    }
+    else {
+        return model[idProp];
+    }
+}
+module.exports = {
+    getSetId,
+    hasId,
+};

package/lib/model/modelJsonAttributes.js

@@ -0,0 +1,72 @@
+'use strict';
+const { asArray, isObject, flatten, isString } = require('../utils/objectUtils');
+function parseJsonAttributes(json, modelClass) {
+    const jsonAttr = modelClass.getJsonAttributes();
+    if (jsonAttr.length) {
+        // JSON attributes may be returned as strings depending on the database and
+        // the database client. Convert them to objects here.
+        for (let i = 0, l = jsonAttr.length; i < l; ++i) {
+            const attr = jsonAttr[i];
+            const value = json[attr];
+            if (isString(value)) {
+                const parsed = tryParseJson(value);
+                // tryParseJson returns undefined if parsing failed.
+                if (parsed !== undefined) {
+                    json[attr] = parsed;
+                }
+            }
+        }
+    }
+    return json;
+}
+function formatJsonAttributes(json, modelClass) {
+    const jsonAttr = modelClass.getJsonAttributes();
+    if (jsonAttr.length) {
+        // All database clients want JSON columns as strings. Do the conversion here.
+        for (let i = 0, l = jsonAttr.length; i < l; ++i) {
+            const attr = jsonAttr[i];
+            const value = json[attr];
+            if (value != null) {
+                json[attr] = JSON.stringify(value);
+            }
+        }
+    }
+    return json;
+}
+function getJsonAttributes(modelClass) {
+    let jsonAttributes = modelClass.jsonAttributes;
+    if (Array.isArray(jsonAttributes)) {
+        return jsonAttributes;
+    }
+    jsonAttributes = [];
+    if (modelClass.getJsonSchema()) {
+        const props = modelClass.getJsonSchema().properties || {};
+        for (const propName of Object.keys(props)) {
+            const prop = props[propName];
+            let types = asArray(prop.type).filter((it) => !!it);
+            if (types.length === 0 && Array.isArray(prop.anyOf)) {
+                types = flatten(prop.anyOf.map((it) => it.type));
+            }
+            if (types.length === 0 && Array.isArray(prop.oneOf)) {
+                types = flatten(prop.oneOf.map((it) => it.type));
+            }
+            if (types.indexOf('object') !== -1 || types.indexOf('array') !== -1) {
+                jsonAttributes.push(propName);
+            }
+        }
+    }
+    return jsonAttributes;
+}
+function tryParseJson(maybeJsonStr) {
+    try {
+        return JSON.parse(maybeJsonStr);
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+module.exports = {
+    parseJsonAttributes,
+    formatJsonAttributes,
+    getJsonAttributes,
+};

package/lib/model/modelParseRelations.js

@@ -0,0 +1,83 @@
+'use strict';
+const { isObject } = require('../utils/objectUtils');
+function parseRelationsIntoModelInstances(model, json, options = {}) {
+    const relationNames = model.constructor.getRelationNames();
+    if (!options.cache && !hasRelation(json, relationNames)) {
+        // Nothing to parse. The cache would only be used for the relations.
+        return model;
+    }
+    if (!options.cache) {
+        options = Object.assign({}, options, {
+            cache: new Map(),
+        });
+    }
+    options.cache.set(json, model);
+    for (const relationName of relationNames) {
+        const relationJson = json[relationName];
+        if (relationJson !== undefined) {
+            const relation = model.constructor.getRelation(relationName);
+            const relationModel = parseRelation(relationJson, relation, options);
+            if (relationModel !== relationJson) {
+                model[relation.name] = relationModel;
+            }
+        }
+    }
+    return model;
+}
+function hasRelation(json, relationNames) {
+    for (let i = 0, l = relationNames.length; i < l; ++i) {
+        if (json[relationNames[i]] !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseRelation(json, relation, options) {
+    if (Array.isArray(json)) {
+        return parseRelationArray(json, relation, options);
+    }
+    else if (json) {
+        return parseRelationObject(json, relation, options);
+    }
+    else {
+        return null;
+    }
+}
+function parseRelationArray(json, relation, options) {
+    const models = new Array(json.length);
+    let didChange = false;
+    for (let i = 0, l = json.length; i < l; ++i) {
+        const model = parseRelationObject(json[i], relation, options);
+        if (model !== json[i]) {
+            didChange = true;
+        }
+        models[i] = model;
+    }
+    if (didChange) {
+        return models;
+    }
+    else {
+        return json;
+    }
+}
+function parseRelationObject(json, relation, options) {
+    if (isObject(json)) {
+        const modelClass = relation.relatedModelClass;
+        let model = options.cache.get(json);
+        if (model === undefined) {
+            if (json instanceof modelClass) {
+                model = parseRelationsIntoModelInstances(json, json, options);
+            }
+            else {
+                model = modelClass.fromJson(json, options);
+            }
+        }
+        return model;
+    }
+    else {
+        return json;
+    }
+}
+module.exports = {
+    parseRelationsIntoModelInstances,
+};

package/lib/model/modelQueryProps.js

@@ -0,0 +1,116 @@
+'use strict';
+const { isObject, isFunction } = require('../utils/objectUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isKnexRaw, isKnexQueryBuilder } = require('../utils/knexUtils');
+const QUERY_PROPS_PROPERTY = '$$queryProps';
+// Removes query properties from `json` and stores them into a hidden property
+// inside `model` so that they can be later merged back to `json`.
+function splitQueryProps(model, json) {
+    const keys = Object.keys(json);
+    if (hasQueryProps(json, keys)) {
+        const queryProps = {};
+        const modelProps = {};
+        for (let i = 0, l = keys.length; i < l; ++i) {
+            const key = keys[i];
+            const value = json[key];
+            if (isQueryProp(value)) {
+                queryProps[key] = value;
+            }
+            else {
+                modelProps[key] = value;
+            }
+        }
+        defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, queryProps);
+        return modelProps;
+    }
+    else {
+        return json;
+    }
+}
+function hasQueryProps(json, keys) {
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        if (isQueryProp(json[keys[i]])) {
+            return true;
+        }
+    }
+    return false;
+}
+function isQueryProp(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    return (isKnexQueryBuilder(value) ||
+        isKnexRaw(value) ||
+        isKnexRawConvertable(value) ||
+        value.isObjectionQueryBuilderBase);
+}
+// Merges and converts `model`'s query properties into `json`.
+function mergeQueryProps(model, json, omitProps, builder) {
+    json = convertExistingQueryProps(json, builder);
+    json = convertAndMergeHiddenQueryProps(model, json, omitProps, builder);
+    return json;
+}
+// Converts the query properties in `json` to knex raw instances.
+// `json` may have query properties even though we removed them.
+// For example they may have been added in lifecycle hooks.
+function convertExistingQueryProps(json, builder) {
+    const keys = Object.keys(json);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = json[key];
+        if (isQueryProp(value)) {
+            json[key] = queryPropToKnexRaw(value, builder);
+        }
+    }
+    return json;
+}
+// Converts and merges the query props that were split from the model
+// and stored into QUERY_PROPS_PROPERTY.
+function convertAndMergeHiddenQueryProps(model, json, omitProps, builder) {
+    const queryProps = model[QUERY_PROPS_PROPERTY];
+    if (!queryProps) {
+        // The model has no query properties.
+        return json;
+    }
+    const modelClass = model.constructor;
+    const keys = Object.keys(queryProps);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        if (!omitProps || !omitProps.includes(key)) {
+            const queryProp = queryPropToKnexRaw(queryProps[key], builder);
+            json[modelClass.propertyNameToColumnName(key)] = queryProp;
+        }
+    }
+    return json;
+}
+// Converts a query property into a knex `raw` instance.
+function queryPropToKnexRaw(queryProp, builder) {
+    if (!queryProp) {
+        return queryProp;
+    }
+    if (queryProp.isObjectionQueryBuilderBase) {
+        return buildObjectionQueryBuilder(queryProp, builder);
+    }
+    else if (isKnexRawConvertable(queryProp)) {
+        return buildKnexRawConvertable(queryProp, builder);
+    }
+    else {
+        return queryProp;
+    }
+}
+function buildObjectionQueryBuilder(builder, parentBuilder) {
+    return builder.subqueryOf(parentBuilder).toKnexQuery();
+}
+function buildKnexRawConvertable(convertable, builder) {
+    if (!builder) {
+        throw new Error('toDatabaseJson called without a query builder instance for a model with query properties');
+    }
+    return convertable.toKnexRaw(builder);
+}
+function isKnexRawConvertable(queryProp) {
+    return isFunction(queryProp.toKnexRaw);
+}
+module.exports = {
+    splitQueryProps,
+    mergeQueryProps,
+};

package/lib/model/modelSet.js

@@ -0,0 +1,116 @@
+'use strict';
+const { isInternalProp } = require('../utils/internalPropUtils');
+const { splitQueryProps } = require('./modelQueryProps');
+const { isFunction, isString, isPlainObject } = require('../utils/objectUtils');
+const { parseRelationsIntoModelInstances } = require('./modelParseRelations');
+function setJson(model, json, options) {
+    json = json || {};
+    options = options || {};
+    if (Object.prototype.toString.call(json) !== '[object Object]') {
+        throw new Error('You should only pass objects to $setJson method. ' +
+            '$setJson method was given an invalid value ' +
+            json);
+    }
+    if (!json.$isObjectionModel) {
+        // json can contain "query properties" like `raw` instances, query builders etc.
+        // We take them out of `json` and store them to a hidden property $$queryProps
+        // in the model instance for later use.
+        json = splitQueryProps(model, json);
+    }
+    json = model.$parseJson(json, options);
+    json = model.$validate(json, options);
+    model.$set(json);
+    if (!options.skipParseRelations) {
+        parseRelationsIntoModelInstances(model, json, options);
+    }
+    return model;
+}
+function setDatabaseJson(model, json) {
+    json = model.$parseDatabaseJson(json);
+    if (json) {
+        const keys = Object.keys(json);
+        for (let i = 0, l = keys.length; i < l; ++i) {
+            const key = keys[i];
+            model[key] = json[key];
+        }
+    }
+    return model;
+}
+function setFast(model, obj) {
+    if (obj) {
+        // Don't try to set read-only properties. They can easily get here
+        // through `fromJson` when parsing an object that was previously
+        // serialized from a model instance.
+        const readOnlyAttr = model.constructor.getReadOnlyAttributes();
+        const keys = Object.keys(obj);
+        for (let i = 0, l = keys.length; i < l; ++i) {
+            const key = keys[i];
+            const value = obj[key];
+            if ((value !== undefined || isPlainObject(obj)) &&
+                !isInternalProp(key) &&
+                !isFunction(value) &&
+                !readOnlyAttr.includes(key)) {
+                model[key] = value;
+            }
+        }
+    }
+    return model;
+}
+function setRelated(model, relation, models) {
+    relation = ensureRelation(model, relation);
+    if (relation.isOneToOne()) {
+        if (Array.isArray(models)) {
+            if (models.length === 0) {
+                model[relation.name] = null;
+            }
+            else {
+                model[relation.name] = models[0] || null;
+            }
+        }
+        else {
+            model[relation.name] = models || null;
+        }
+    }
+    else {
+        if (!models) {
+            model[relation.name] = [];
+        }
+        else if (Array.isArray(models)) {
+            model[relation.name] = models;
+        }
+        else {
+            model[relation.name] = [models];
+        }
+    }
+    return model;
+}
+function appendRelated(model, relation, models) {
+    relation = ensureRelation(model, relation);
+    if (!model[relation.name] || relation.isOneToOne()) {
+        return model.$setRelated(relation, models);
+    }
+    else {
+        if (Array.isArray(models)) {
+            models.forEach((it) => model[relation.name].push(it));
+        }
+        else if (models) {
+            model[relation.name].push(models);
+        }
+    }
+    return model;
+}
+function ensureRelation(model, relation) {
+    if (isString(relation)) {
+        return model.constructor.getRelation(relation);
+    }
+    else {
+        return relation;
+    }
+}
+module.exports = {
+    setFast,
+    setJson,
+    setDatabaseJson,
+    setRelated,
+    appendRelated,
+};

package/lib/model/modelTableMetadata.js

@@ -0,0 +1,71 @@
+'use strict';
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isPromise } = require('../utils/promiseUtils');
+const TABLE_METADATA = '$$tableMetadata';
+function fetchTableMetadata(modelClass, { parentBuilder = null, knex = null, force = false, table = null } = {}) {
+    // The table isn't necessarily same as `modelClass.getTableName()` for example if
+    // a view is queried instead.
+    if (!table) {
+        if (parentBuilder) {
+            table = parentBuilder.tableNameFor(modelClass);
+        }
+        else {
+            table = modelClass.getTableName();
+        }
+    }
+    // Call tableMetadata first instead of accessing the cache directly beause
+    // tableMetadata may have been overriden.
+    let metadata = modelClass.tableMetadata({ table });
+    if (!force && metadata) {
+        return Promise.resolve(metadata);
+    }
+    // Memoize metadata but only for modelClass. The hasOwnProperty check
+    // will fail for subclasses and the value gets recreated.
+    if (!Object.hasOwn(modelClass, TABLE_METADATA)) {
+        defineNonEnumerableProperty(modelClass, TABLE_METADATA, new Map());
+    }
+    // The cache needs to be checked in addition to calling tableMetadata
+    // because the cache may contain a temporary promise in which case
+    // tableMetadata returns null.
+    metadata = modelClass[TABLE_METADATA].get(table);
+    if (!force && metadata) {
+        return Promise.resolve(metadata);
+    }
+    else {
+        const promise = modelClass
+            .query(knex)
+            .childQueryOf(parentBuilder)
+            .columnInfo({ table })
+            .then((columnInfo) => {
+            const metadata = {
+                columns: Object.keys(columnInfo),
+            };
+            modelClass[TABLE_METADATA].set(table, metadata);
+            return metadata;
+        })
+            .catch((err) => {
+            modelClass[TABLE_METADATA].delete(table);
+            throw err;
+        });
+        modelClass[TABLE_METADATA].set(table, promise);
+        return promise;
+    }
+}
+function tableMetadata(modelClass, { table } = {}) {
+    if (Object.hasOwn(modelClass, TABLE_METADATA)) {
+        const metadata = modelClass[TABLE_METADATA].get(table || modelClass.getTableName());
+        if (isPromise(metadata)) {
+            return null;
+        }
+        else {
+            return metadata;
+        }
+    }
+    else {
+        return null;
+    }
+}
+module.exports = {
+    fetchTableMetadata,
+    tableMetadata,
+};