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

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -0,0 +1,27 @@
+'use strict';
+const { withWhereScope } = require('../../../queryBuilder/whereScopes');
+const { UnrelateOperation } = require('../../../queryBuilder/operations/UnrelateOperation');
+class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+    queryExecutor(builder) {
+        const unrelateQuery = this.relation
+            .getJoinModelClass(builder.knex())
+            .query()
+            .childQueryOf(builder)
+            .delete();
+        withWhereScope(unrelateQuery, () => {
+            this.applyModifyFilterForJoinTable(unrelateQuery);
+        });
+        return unrelateQuery.modify(this.relation.joinTableModify);
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForRelatedTable(builder) {
+        throw new Error('not implemented');
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForJoinTable(builder) {
+        throw new Error('not implemented');
+    }
+}
+module.exports = {
+    ManyToManyUnrelateOperationBase,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateSqliteOperation.js

@@ -0,0 +1,11 @@
+'use strict';
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
+class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(ManyToManyUnrelateOperationBase) {
+    get modifyMainQuery() {
+        return false;
+    }
+}
+module.exports = {
+    ManyToManyUnrelateSqliteOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateOperation.js

@@ -0,0 +1,8 @@
+'use strict';
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
+class ManyToManyUpdateOperation extends ManyToManyModifyMixin(ManyToManyUpdateOperationBase) {
+}
+module.exports = {
+    ManyToManyUpdateOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -0,0 +1,65 @@
+'use strict';
+const { withWhereScope } = require('../../../queryBuilder/whereScopes');
+const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
+class ManyToManyUpdateOperationBase extends UpdateOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+        this.hasExtraProps = false;
+        this.joinTablePatch = {};
+        this.joinTablePatchFilterQuery = null;
+    }
+    onAdd(builder, args) {
+        const obj = args[0];
+        // Copy all extra properties to the `joinTablePatch` object.
+        for (const extra of this.relation.joinTableExtras) {
+            if (extra.aliasProp in obj) {
+                this.hasExtraProps = true;
+                this.joinTablePatch[extra.joinTableProp] = obj[extra.aliasProp];
+            }
+        }
+        const res = super.onAdd(builder, args);
+        if (this.hasExtraProps) {
+            // Make sure we don't try to insert the extra properties
+            // to the target table.
+            this.relation.omitExtraProps([this.model]);
+        }
+        return res;
+    }
+    async onAfter1(builder, result) {
+        if (this.hasExtraProps) {
+            const joinTableUpdateQuery = this.relation
+                .getJoinModelClass(builder.knex())
+                .query()
+                .childQueryOf(builder)
+                .patch(this.joinTablePatch);
+            withWhereScope(joinTableUpdateQuery, () => {
+                this.applyModifyFilterForJoinTable(joinTableUpdateQuery);
+            });
+            await joinTableUpdateQuery.modify(this.relation.joinTableModify);
+            return result;
+        }
+        else {
+            return result;
+        }
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForRelatedTable(builder) {
+        throw new Error('not implemented');
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForJoinTable(builder) {
+        throw new Error('not implemented');
+    }
+    clone() {
+        const clone = super.clone();
+        clone.hasExtraProps = this.hasExtraProps;
+        clone.joinTablePatch = this.joinTablePatch;
+        clone.joinTablePatchFilterQuery = this.joinTablePatchFilterQuery;
+        return clone;
+    }
+}
+module.exports = {
+    ManyToManyUpdateOperationBase,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateSqliteOperation.js

@@ -0,0 +1,8 @@
+'use strict';
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
+class ManyToManyUpdateSqliteOperation extends ManyToManySqliteModifyMixin(ManyToManyUpdateOperationBase) {
+}
+module.exports = {
+    ManyToManyUpdateSqliteOperation,
+};

package/lib/transaction.js

@@ -0,0 +1,66 @@
+'use strict';
+const promiseUtils = require('./utils/promiseUtils');
+const { isFunction } = require('./utils/objectUtils');
+function transaction() {
+    // There must be at least one model class and the callback.
+    if (arguments.length < 2) {
+        return Promise.reject(new Error('objection.transaction: provide at least one Model class to bind to the transaction or a knex instance'));
+    }
+    let args = Array.from(arguments);
+    if (!isModelClass(args[0]) && isFunction(args[0].transaction)) {
+        const knex = args[0];
+        args = args.slice(1);
+        return knex.transaction.apply(knex, args);
+    }
+    else {
+        // The last argument should be the callback and all other Model subclasses.
+        const callback = args[args.length - 1];
+        const modelClasses = args.slice(0, args.length - 1);
+        let i;
+        for (i = 0; i < modelClasses.length; ++i) {
+            if (!isModelClass(modelClasses[i])) {
+                return Promise.reject(new Error('objection.transaction: all but the last argument should be Model subclasses'));
+            }
+        }
+        const knex = modelClasses[0].knex();
+        for (i = 0; i < modelClasses.length; ++i) {
+            if (modelClasses[i].knex() !== knex) {
+                return Promise.reject(new Error('objection.transaction: all Model subclasses must be bound to the same database'));
+            }
+        }
+        return knex.transaction((trx) => {
+            const args = new Array(modelClasses.length + 1);
+            for (let i = 0; i < modelClasses.length; ++i) {
+                args[i] = modelClasses[i].bindTransaction(trx);
+            }
+            args[args.length - 1] = trx;
+            return promiseUtils.try(() => {
+                return callback.apply(trx, args);
+            });
+        });
+    }
+}
+transaction.start = function (modelClassOrKnex) {
+    let knex = modelClassOrKnex;
+    if (isModelClass(modelClassOrKnex)) {
+        knex = modelClassOrKnex.knex();
+    }
+    if (!knex || !isFunction(knex.transaction)) {
+        return Promise.reject(new Error('objection.transaction.start: first argument must be a model class or a knex instance'));
+    }
+    return new Promise((resolve, reject) => {
+        knex
+            .transaction((trx) => {
+            resolve(trx);
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    });
+};
+function isModelClass(maybeModel) {
+    return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
+}
+module.exports = {
+    transaction,
+};

package/lib/utils/assert.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHasId = assertHasId;
+exports.assertIdNotUndefined = assertIdNotUndefined;
+function assertHasId(model) {
+    if (!model.$hasId()) {
+        const modelClass = model.constructor;
+        const ids = modelClass.getIdColumnArray().join(', ');
+        throw new Error(`one of the identifier columns [${ids}] is null or undefined. Have you specified the correct identifier column for the model '${modelClass.name}' using the 'idColumn' property?`);
+    }
+}
+function assertIdNotUndefined(id, message) {
+    if (Array.isArray(id)) {
+        id.forEach((id) => assertIdNotUndefined(id, message));
+    }
+    else if (id === undefined) {
+        throw Error(message);
+    }
+}

package/lib/utils/buildUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildArg = buildArg;
+const objectUtils_1 = require("./objectUtils");
+function buildArg(arg, builder) {
+    if (!(0, objectUtils_1.isObject)(arg)) {
+        return arg;
+    }
+    const buildable = arg;
+    if ((0, objectUtils_1.isFunction)(buildable.toKnexRaw)) {
+        return buildable.toKnexRaw(builder);
+    }
+    else if (buildable.isObjectionQueryBuilderBase === true) {
+        return buildable.subqueryOf(builder).toKnexQuery();
+    }
+    else {
+        return arg;
+    }
+}

package/lib/utils/classUtils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inherit = inherit;
+function inherit(Constructor, BaseConstructor) {
+    Constructor.prototype = Object.create(BaseConstructor.prototype);
+    Constructor.prototype.constructor = BaseConstructor;
+    Object.setPrototypeOf(Constructor, BaseConstructor);
+    return Constructor;
+}

package/lib/utils/cloneDeep.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeep = cloneDeep;
+const node_util_1 = require("node:util");
+const { isTypedArray, isMap, isSet, isProxy } = node_util_1.types;
+const toString = Object.prototype.toString;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+const getPrototypeOf = Object.getPrototypeOf;
+const getOwnPropertySymbols = Object.getOwnPropertySymbols;
+const objectKeys = Object.keys;
+const objectProto = Object.prototype;
+const symToStringTag = Symbol.toStringTag;
+const symbolValueOf = Symbol.prototype.valueOf;
+const ARGS_TAG = '[object Arguments]';
+const ARRAY_BUFFER_TAG = '[object ArrayBuffer]';
+const BOOL_TAG = '[object Boolean]';
+const DATA_VIEW_TAG = '[object DataView]';
+const DATE_TAG = '[object Date]';
+const FUNC_TAG = '[object Function]';
+const GEN_TAG = '[object GeneratorFunction]';
+const MAP_TAG = '[object Map]';
+const NUMBER_TAG = '[object Number]';
+const OBJECT_TAG = '[object Object]';
+const REGEXP_TAG = '[object RegExp]';
+const SET_TAG = '[object Set]';
+const STRING_TAG = '[object String]';
+const SYMBOL_TAG = '[object Symbol]';
+const TYPED_ARRAY_TAGS = [
+    '[object Float32Array]',
+    '[object Float64Array]',
+    '[object Int8Array]',
+    '[object Int16Array]',
+    '[object Int32Array]',
+    '[object Uint8Array]',
+    '[object Uint8ClampedArray]',
+    '[object Uint16Array]',
+    '[object Uint32Array]',
+];
+// The tags lodash clones by type. Values with other tags (Error, WeakMap,
+// Promise, a custom `Symbol.toStringTag` and so on) aren't cloned.
+const CLONEABLE_TAGS = new Set([
+    ARGS_TAG,
+    '[object Array]',
+    ARRAY_BUFFER_TAG,
+    DATA_VIEW_TAG,
+    BOOL_TAG,
+    DATE_TAG,
+    MAP_TAG,
+    NUMBER_TAG,
+    OBJECT_TAG,
+    REGEXP_TAG,
+    SET_TAG,
+    STRING_TAG,
+    SYMBOL_TAG,
+    ...TYPED_ARRAY_TAGS,
+]);
+const RE_FLAGS = /\w*$/;
+const RE_IS_UINT = /^(?:0|[1-9]\d*)$/;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+function cloneDeep(value) {
+    if (!isObject(value)) {
+        return value;
+    }
+    return baseClone(value, false, new Map());
+}
+// `isNested` is true when the value is inside another value.
+function baseClone(value, isNested, seen) {
+    if (!isObject(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return cloneArray(value, seen);
+    }
+    if (Buffer.isBuffer(value)) {
+        // Buffers are cloned before the lookup of values already seen, so a
+        // buffer found twice gives two copies, as in lodash.
+        const result = Buffer.allocUnsafe(value.length);
+        value.copy(result);
+        return result;
+    }
+    if (getPrototypeOf(value) === objectProto && !hasOwnProperty.call(value, symToStringTag)) {
+        return clonePlainObject(value, seen);
+    }
+    return cloneOther(value, isNested, seen);
+}
+function cloneArray(array, seen) {
+    const length = array.length;
+    const Ctor = array.constructor;
+    const result = new Ctor(length);
+    // The properties `RegExp#exec` adds to its result.
+    if (length && typeof array[0] === 'string' && hasOwnProperty.call(array, 'index')) {
+        result.index = array.index;
+        result.input = array.input;
+    }
+    const cloned = seen.get(array);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    seen.set(array, result);
+    if (Ctor === Array) {
+        // A new Array has no elements yet, so every assignment happens.
+        for (let i = 0; i < length; ++i) {
+            result[i] = baseClone(array[i], true, seen);
+        }
+    }
+    else {
+        for (let i = 0; i < length; ++i) {
+            assignValue(result, i, baseClone(array[i], true, seen));
+        }
+    }
+    return result;
+}
+// An object whose prototype is Object.prototype. This is the same as the
+// general path for such objects, without the checks that can't apply.
+function clonePlainObject(obj, seen) {
+    const cloned = seen.get(obj);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    const result = {};
+    seen.set(obj, result);
+    const keys = objectKeys(obj);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        // lodash skips the `constructor` key of prototype objects.
+        if (key === 'constructor' && !isArrayLike(obj) && isPrototype(obj)) {
+            continue;
+        }
+        const value = baseClone(obj[key], true, seen);
+        if (key === '__proto__') {
+            defineOwn(result, key, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    copySymbols(obj, result, seen);
+    return result;
+}
+function cloneOther(value, isNested, seen) {
+    const tag = getTag(value);
+    const isFunc = tag === FUNC_TAG || tag === GEN_TAG;
+    let result;
+    if (tag === OBJECT_TAG || tag === ARGS_TAG || (isFunc && !isNested)) {
+        result = isFunc ? {} : initCloneObject(value);
+    }
+    else if (!CLONEABLE_TAGS.has(tag)) {
+        return isNested ? value : {};
+    }
+    else {
+        result = initCloneByTag(value, tag);
+    }
+    const cloned = seen.get(value);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    seen.set(value, result);
+    if (isSet(value)) {
+        value.forEach((item) => {
+            result.add(baseClone(item, true, seen));
+        });
+        return result;
+    }
+    if (isMap(value)) {
+        value.forEach((item, key) => {
+            result.set(key, baseClone(item, true, seen));
+        });
+        return result;
+    }
+    const keys = getKeys(value);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        assignValue(result, key, baseClone(value[key], true, seen));
+    }
+    copySymbols(value, result, seen);
+    return result;
+}
+function copySymbols(source, result, seen) {
+    const symbols = getOwnPropertySymbols(source);
+    for (let i = 0, l = symbols.length; i < l; ++i) {
+        const symbol = symbols[i];
+        if (propertyIsEnumerable.call(source, symbol)) {
+            assignValue(result, symbol, baseClone(source[symbol], true, seen));
+        }
+    }
+}
+function initCloneObject(value) {
+    if (typeof value.constructor === 'function' && !isPrototype(value)) {
+        const proto = getPrototypeOf(value);
+        return isObject(proto) ? Object.create(proto) : {};
+    }
+    return {};
+}
+// `value` is an object with one of the tags in CLONEABLE_TAGS, other than
+// the object, arguments and array tags.
+function initCloneByTag(value, tag) {
+    const Ctor = value.constructor;
+    switch (tag) {
+        case ARRAY_BUFFER_TAG:
+            return cloneArrayBuffer(value);
+        case BOOL_TAG:
+        case DATE_TAG:
+            return new Ctor(+value);
+        case DATA_VIEW_TAG: {
+            const dataView = value;
+            return new Ctor(cloneArrayBuffer(dataView.buffer), dataView.byteOffset, dataView.byteLength);
+        }
+        case MAP_TAG:
+        case SET_TAG:
+            return new Ctor();
+        case NUMBER_TAG:
+        case STRING_TAG:
+            return new Ctor(value);
+        case REGEXP_TAG: {
+            const regExp = value;
+            const result = new Ctor(regExp.source, RE_FLAGS.exec(regExp));
+            result.lastIndex = regExp.lastIndex;
+            return result;
+        }
+        case SYMBOL_TAG:
+            return Object(symbolValueOf.call(value));
+        default: {
+            // A typed array.
+            const typedArray = value;
+            return new Ctor(cloneArrayBuffer(typedArray.buffer), typedArray.byteOffset, typedArray.length);
+        }
+    }
+}
+function cloneArrayBuffer(arrayBuffer) {
+    const result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+    return result;
+}
+// lodash's `keys`: the own enumerable string keys, except the indexes and
+// `length` of arguments objects and typed arrays (which are listed by index
+// instead) and the `constructor` key of prototype objects.
+function getKeys(value) {
+    if (isArrayLike(value)) {
+        return arrayLikeKeys(value);
+    }
+    const keys = objectKeys(value);
+    return isPrototype(value) ? keys.filter((key) => key !== 'constructor') : keys;
+}
+function arrayLikeKeys(value) {
+    const isArgs = getTag(value) === ARGS_TAG;
+    const isTyped = !isArgs && isTypedArray(value);
+    const skipIndexes = isArgs || isTyped;
+    const length = skipIndexes ? value.length : 0;
+    const result = [];
+    for (let i = 0; i < length; ++i) {
+        result.push(String(i));
+    }
+    for (const key in value) {
+        if (hasOwnProperty.call(value, key) &&
+            !(skipIndexes &&
+                (key === 'length' ||
+                    (isTyped && (key === 'buffer' || key === 'byteLength' || key === 'byteOffset')) ||
+                    isIndex(key, length)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+// lodash's `getTag`, which reads the built-in tag of an object whose
+// `Symbol.toStringTag` property can be written over, the way lodash does it:
+// lodash writes `undefined` over the tag, reads the tag and puts it back.
+// Writing over a read-only tag, like the ones of Map, Set and the typed
+// arrays, throws. That is checked first, because a throw is slow.
+function getTag(value) {
+    if (!(symToStringTag in value)) {
+        return toString.call(value);
+    }
+    if (isProxy(value)) {
+        return getTagByWriting(value);
+    }
+    return canWriteTag(value) ? getTagByWriting(value) : toString.call(value);
+}
+// Whether `value[Symbol.toStringTag] = undefined` would succeed: the first
+// object up the prototype chain that has the property decides, as in the
+// [[Set]] of ordinary objects.
+function canWriteTag(value) {
+    let obj = value;
+    while (obj !== null) {
+        if (isProxy(obj)) {
+            // A proxy decides for itself. Try it, as lodash does.
+            return true;
+        }
+        const desc = Object.getOwnPropertyDescriptor(obj, symToStringTag);
+        if (desc !== undefined) {
+            if ('value' in desc) {
+                return desc.writable && (obj === value || Object.isExtensible(value));
+            }
+            return desc.set !== undefined;
+        }
+        obj = getPrototypeOf(obj);
+    }
+    return true;
+}
+function getTagByWriting(value) {
+    const obj = value;
+    const isOwn = hasOwnProperty.call(obj, symToStringTag);
+    const tag = obj[symToStringTag];
+    let unmasked = false;
+    try {
+        obj[symToStringTag] = undefined;
+        unmasked = true;
+    }
+    catch (err) {
+        // The tag can't be written over, so it's used as is.
+    }
+    const result = toString.call(obj);
+    if (unmasked) {
+        if (isOwn) {
+            obj[symToStringTag] = tag;
+        }
+        else {
+            delete obj[symToStringTag];
+        }
+    }
+    return result;
+}
+// Assigns unless the property already has the same value, as lodash does.
+function assignValue(object, key, value) {
+    const objValue = object[key];
+    if (!(hasOwnProperty.call(object, key) && sameValueZero(objValue, value)) ||
+        (value === undefined && !(key in object))) {
+        if (key === '__proto__') {
+            defineOwn(object, key, value);
+        }
+        else {
+            object[key] = value;
+        }
+    }
+}
+function defineOwn(object, key, value) {
+    Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+function isObject(value) {
+    const type = typeof value;
+    return value !== null && (type === 'object' || type === 'function');
+}
+function isPrototype(value) {
+    const Ctor = value.constructor;
+    const proto = (typeof Ctor === 'function' && Ctor.prototype) || objectProto;
+    return value === proto;
+}
+function isArrayLike(value) {
+    return typeof value !== 'function' && isLength(value.length);
+}
+function isLength(value) {
+    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
+}
+function isIndex(key, length) {
+    // `key < length` compares the key as a number.
+    return length > 0 && RE_IS_UINT.test(key) && key < length;
+}
+function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
+}

package/lib/utils/createModifier.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModifier = createModifier;
+const objectUtils_1 = require("./objectUtils");
+function createModifier({ modelClass, modifier, modifiers, }) {
+    const modelModifiers = modelClass ? modelClass.getModifiers() : {};
+    const modifierFunctions = (0, objectUtils_1.asArray)(modifier).map((modifier) => {
+        let modify = null;
+        if ((0, objectUtils_1.isString)(modifier)) {
+            modify = (modifiers && modifiers[modifier]) || modelModifiers[modifier];
+            // Modifiers can be pointers to other modifiers. Call this function recursively.
+            if (modify && !(0, objectUtils_1.isFunction)(modify)) {
+                return createModifier({ modelClass, modifier: modify, modifiers });
+            }
+        }
+        else if ((0, objectUtils_1.isFunction)(modifier)) {
+            modify = modifier;
+        }
+        else if ((0, objectUtils_1.isPlainObject)(modifier)) {
+            modify = (builder) => builder.where(modifier);
+        }
+        else if (Array.isArray(modifier)) {
+            return createModifier({ modelClass, modifier, modifiers });
+        }
+        if (!modify) {
+            // Without a model class this throws when the modifier is called, as it did
+            // in the JavaScript code.
+            modify = (builder) => modelClass.modifierNotFound(builder, modifier);
+        }
+        return modify;
+    });
+    return (builder, ...args) => {
+        for (const modifier of modifierFunctions) {
+            modifier.call(builder, builder, ...args);
+        }
+    };
+}

package/lib/utils/deprecate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecate = deprecate;
+const LOGGED_DEPRECATIONS = new Set();
+function deprecate(message) {
+    // Only log deprecation messages once.
+    if (!LOGGED_DEPRECATIONS.has(message)) {
+        LOGGED_DEPRECATIONS.add(message);
+        console.warn(message);
+    }
+}