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

package/lib/queryBuilder/operations/FindOperation.js

@@ -0,0 +1,147 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
+const { isPromise, after, afterReturn } = require('../../utils/promiseUtils');
+const { isObject } = require('../../utils/objectUtils');
+class FindOperation extends QueryBuilderOperation {
+    onBefore2(builder, result) {
+        return afterReturn(callStaticBeforeFind(builder), result);
+    }
+    onAfter3(builder, results) {
+        const opt = builder.findOptions();
+        if (opt.dontCallFindHooks) {
+            return results;
+        }
+        else {
+            return callAfterFind(builder, results);
+        }
+    }
+}
+function callStaticBeforeFind(builder) {
+    if (!hasStaticHook(builder.modelClass(), 'beforeFind')) {
+        return undefined;
+    }
+    const args = StaticHookArguments.create({ builder });
+    return builder.modelClass().beforeFind(args);
+}
+function callAfterFind(builder, result) {
+    const opt = builder.findOptions();
+    const maybePromise = callInstanceAfterFind(builder.context(), result, opt.callAfterFindDeeply);
+    return after(maybePromise, () => callStaticAfterFind(builder, result));
+}
+function callStaticAfterFind(builder, result) {
+    if (!hasStaticHook(builder.modelClass(), 'afterFind')) {
+        return result;
+    }
+    const args = StaticHookArguments.create({ builder, result });
+    const maybePromise = builder.modelClass().afterFind(args);
+    return after(maybePromise, (maybeResult) => {
+        if (maybeResult === undefined) {
+            return result;
+        }
+        else {
+            return maybeResult;
+        }
+    });
+}
+function callInstanceAfterFind(ctx, results, deep) {
+    if (Array.isArray(results)) {
+        if (results.length === 1) {
+            return callAfterFindForOne(ctx, results[0], results, deep);
+        }
+        else {
+            return callAfterFindArray(ctx, results, deep);
+        }
+    }
+    else {
+        return callAfterFindForOne(ctx, results, results, deep);
+    }
+}
+function callAfterFindArray(ctx, results, deep) {
+    if (results.length === 0 || !isObject(results[0])) {
+        return results;
+    }
+    const mapped = new Array(results.length);
+    let containsPromise = false;
+    for (let i = 0, l = results.length; i < l; ++i) {
+        mapped[i] = callAfterFindForOne(ctx, results[i], results[i], deep);
+        if (isPromise(mapped[i])) {
+            containsPromise = true;
+        }
+    }
+    if (containsPromise) {
+        return Promise.all(mapped);
+    }
+    else {
+        return mapped;
+    }
+}
+function callAfterFindForOne(ctx, model, result, deep) {
+    if (!isObject(model) || !model.$isObjectionModel) {
+        return result;
+    }
+    if (deep) {
+        const results = [];
+        const containsPromise = callAfterFindForRelations(ctx, model, results);
+        if (containsPromise) {
+            return Promise.all(results).then(() => {
+                return doCallAfterFind(ctx, model, result);
+            });
+        }
+        else {
+            return doCallAfterFind(ctx, model, result);
+        }
+    }
+    else {
+        return doCallAfterFind(ctx, model, result);
+    }
+}
+function callAfterFindForRelations(ctx, model, results) {
+    const keys = Object.keys(model);
+    let containsPromise = false;
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        const value = model[key];
+        if (isRelation(value)) {
+            const maybePromise = callInstanceAfterFind(ctx, value, true);
+            if (isPromise(maybePromise)) {
+                containsPromise = true;
+            }
+            results.push(maybePromise);
+        }
+    }
+    return containsPromise;
+}
+function isRelation(value) {
+    return ((isObject(value) && value.$isObjectionModel) ||
+        (isNonEmptyObjectArray(value) && value[0].$isObjectionModel));
+}
+function isNonEmptyObjectArray(value) {
+    return Array.isArray(value) && value.length > 0 && isObject(value[0]);
+}
+function doCallAfterFind(ctx, model, result) {
+    const afterFind = getAfterFindHook(model);
+    if (afterFind !== null) {
+        const maybePromise = afterFind.call(model, ctx);
+        if (isPromise(maybePromise)) {
+            return maybePromise.then(() => result);
+        }
+        else {
+            return result;
+        }
+    }
+    else {
+        return result;
+    }
+}
+function getAfterFindHook(model) {
+    if (model.$afterFind !== model.$objectionModelClass.prototype.$afterFind) {
+        return model.$afterFind;
+    }
+    else {
+        return null;
+    }
+}
+module.exports = {
+    FindOperation,
+};

package/lib/queryBuilder/operations/FirstOperation.js

@@ -0,0 +1,22 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+class FirstOperation extends QueryBuilderOperation {
+    onBuildKnex(knexBuilder, builder) {
+        const modelClass = builder.modelClass();
+        if (builder.isFind() && modelClass.useLimitInFirst) {
+            knexBuilder = knexBuilder.limit(1);
+        }
+        return knexBuilder;
+    }
+    onAfter3(_, result) {
+        if (Array.isArray(result)) {
+            return result[0];
+        }
+        else {
+            return result;
+        }
+    }
+}
+module.exports = {
+    FirstOperation,
+};

package/lib/queryBuilder/operations/FromOperation.js

@@ -0,0 +1,91 @@
+'use strict';
+const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+const { isPlainObject, isString } = require('../../utils/objectUtils');
+const { isModelClass } = require('../../utils/resolveModel');
+const ALIAS_REGEX = /\s+as\s+/i;
+// FromOperation corresponds to a `.from(args)` call. The call is delegated to
+// knex, but we first try to parse the arguments so that we can determine which
+// tables have been mentioned in a query's from clause. We only parse string
+// references and not `raw` or `ref` etc. references at this point thouhg.
+class FromOperation extends ObjectionToKnexConvertingOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.table = null;
+        this.alias = null;
+    }
+    onAdd(builder, args) {
+        const ret = super.onAdd(builder, args);
+        const parsed = parseTableAndAlias(this.args[0], builder);
+        if (parsed.table) {
+            builder.tableName(parsed.table);
+            this.table = parsed.table;
+        }
+        if (parsed.alias) {
+            builder.aliasFor(builder.modelClass().getTableName(), parsed.alias);
+            this.alias = parsed.alias;
+        }
+        return ret;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        // Simply call knex's from method with the converted arguments.
+        return knexBuilder.from.apply(knexBuilder, this.getKnexArgs(builder));
+    }
+    clone() {
+        const clone = super.clone();
+        clone.table = this.table;
+        clone.alias = this.alias;
+        return clone;
+    }
+}
+function parseTableAndAlias(arg, builder) {
+    if (isModelClass(arg)) {
+        return parseTableAndAliasFromString(arg.getTableName());
+    }
+    else if (isString(arg)) {
+        return parseTableAndAliasFromString(arg);
+    }
+    else if (isPlainObject(arg)) {
+        return parseTableAndAliasFromObject(arg, builder);
+    }
+    else {
+        // Could not parse table and alias from the arguments.
+        return {
+            table: null,
+            alias: null,
+        };
+    }
+}
+function parseTableAndAliasFromString(arg) {
+    if (ALIAS_REGEX.test(arg)) {
+        const parts = arg.split(ALIAS_REGEX);
+        return {
+            table: parts[0].trim(),
+            alias: parts[1].trim(),
+        };
+    }
+    else {
+        return {
+            table: arg.trim(),
+            alias: null,
+        };
+    }
+}
+function parseTableAndAliasFromObject(arg, builder) {
+    for (const alias of Object.keys(arg)) {
+        const value = isModelClass(arg[alias]) ? arg[alias].getTableName() : arg[alias];
+        if (!isString(value)) {
+            continue;
+        }
+        const table = value.trim();
+        if (table === builder.modelClass().getTableName()) {
+            return {
+                alias,
+                table,
+            };
+        }
+    }
+    throw new Error(`one of the tables in ${JSON.stringify(arg)} must be the query's model class's table.`);
+}
+module.exports = {
+    FromOperation,
+};

package/lib/queryBuilder/operations/InsertAndFetchOperation.js

@@ -0,0 +1,38 @@
+'use strict';
+const { InsertOperation } = require('./InsertOperation');
+const { DelegateOperation } = require('./DelegateOperation');
+const { keyByProps } = require('../../model/modelUtils');
+const { asArray } = require('../../utils/objectUtils');
+class InsertAndFetchOperation extends DelegateOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(InsertOperation)) {
+            throw new Error('Invalid delegate');
+        }
+    }
+    get models() {
+        return this.delegate.models;
+    }
+    async onAfter2(builder, inserted) {
+        const modelClass = builder.modelClass();
+        const insertedModels = await super.onAfter2(builder, inserted);
+        const insertedModelArray = asArray(insertedModels);
+        const idProps = modelClass.getIdPropertyArray();
+        const ids = insertedModelArray.map((model) => model.$id());
+        const fetchedModels = await modelClass
+            .query()
+            .childQueryOf(builder)
+            .findByIds(ids)
+            .castTo(builder.resultModelClass());
+        const modelsById = keyByProps(fetchedModels, idProps);
+        // Instead of returning the freshly fetched models, update the input
+        // models with the fresh values.
+        insertedModelArray.forEach((insertedModel) => {
+            insertedModel.$set(modelsById.get(insertedModel.$propKey(idProps)));
+        });
+        return insertedModels;
+    }
+}
+module.exports = {
+    InsertAndFetchOperation,
+};

package/lib/queryBuilder/operations/InsertGraphAndFetchOperation.js

@@ -0,0 +1,35 @@
+'use strict';
+const { DelegateOperation } = require('./DelegateOperation');
+const { InsertGraphOperation } = require('./InsertGraphOperation');
+const { RelationExpression } = require('../RelationExpression');
+class InsertGraphAndFetchOperation extends DelegateOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        if (!this.delegate.is(InsertGraphOperation)) {
+            throw new Error('Invalid delegate');
+        }
+    }
+    get models() {
+        return this.delegate.models;
+    }
+    get isArray() {
+        return this.delegate.isArray;
+    }
+    async onAfter2(builder) {
+        if (this.models.length === 0) {
+            return this.isArray ? [] : null;
+        }
+        const eager = RelationExpression.fromModelGraph(this.models);
+        const modelClass = this.models[0].constructor;
+        const ids = this.models.map((model) => model.$id());
+        const models = await modelClass
+            .query()
+            .childQueryOf(builder)
+            .findByIds(ids)
+            .withGraphFetched(eager);
+        return this.isArray ? models : models[0] || null;
+    }
+}
+module.exports = {
+    InsertGraphAndFetchOperation,
+};

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -0,0 +1,87 @@
+'use strict';
+const { DelegateOperation } = require('./DelegateOperation');
+const { InsertOperation } = require('./InsertOperation');
+const { GraphUpsert } = require('../graph/GraphUpsert');
+class InsertGraphOperation extends DelegateOperation {
+    constructor(name, opt = null) {
+        super(name, opt);
+        if (!this.delegate.is(InsertOperation)) {
+            throw new Error('Invalid delegate');
+        }
+        Object.assign(this.delegate.modelOptions, GraphUpsert.modelOptions);
+        this.upsertOptions = opt.opt || {};
+        this.upsert = null;
+    }
+    get models() {
+        return this.delegate.models;
+    }
+    get isArray() {
+        return this.delegate.isArray;
+    }
+    get relation() {
+        return this.delegate.relation;
+    }
+    onAdd(builder, args) {
+        const retVal = super.onAdd(builder, args);
+        this.upsert = new GraphUpsert({
+            objects: this.models,
+            rootModelClass: builder.modelClass(),
+            upsertOptions: Object.assign({}, this.upsertOptions, {
+                noUpdate: true,
+                noDelete: true,
+                noUnrelate: true,
+                insertMissing: true,
+            }),
+        });
+        // We resolve this query here and will not execute it. This is because the root
+        // value may depend on other models in the graph and cannot be inserted first.
+        builder.resolve([]);
+        return retVal;
+    }
+    onBefore1(_, result) {
+        // Do nothing.
+        return result;
+    }
+    onBefore2(builder, result) {
+        // We override this with empty implementation so that the $beforeInsert()
+        // hooks are not called twice for the root models.
+        if (this.relation) {
+            // We still need to call the relation before insert hook if the the
+            // delegate operation is a RelationInsertOperation.
+            return this.relation.executeBeforeInsert(this.models, builder.context(), result);
+        }
+        else {
+            return result;
+        }
+    }
+    onBefore3(_, result) {
+        // Do nothing.
+        return result;
+    }
+    onBuild() {
+        // Do nothing.
+    }
+    onBuildKnex(knexBuilder) {
+        // Do nothing.
+        return knexBuilder;
+    }
+    // We overrode all other hooks but this one and do all the work in here.
+    // This is a bit hacky.
+    async onAfter1(builder, ...restArgs) {
+        await this.upsert.run(builder);
+        return await super.onAfter1(builder, ...restArgs);
+    }
+    onAfter2() {
+        // We override this with empty implementation so that the $afterInsert() hooks
+        // are not called twice for the root models.
+        return this.isArray ? this.models : this.models[0] || null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.upsert = this.upsert;
+        return clone;
+    }
+}
+module.exports = {
+    InsertGraphOperation,
+};

package/lib/queryBuilder/operations/InsertOperation.js

@@ -0,0 +1,173 @@
+'use strict';
+/* global BigInt */
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
+const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
+const { isSqlite, isMySql } = require('../../utils/knexUtils');
+const { isObject } = require('../../utils/objectUtils');
+// `@@auto_increment_increment` for each MySQL knex instance, keyed by the knex config,
+// which transactions share with the knex they were started from.
+const autoIncrementIncrements = new WeakMap();
+// Base class for all insert operations.
+class InsertOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.models = null;
+        this.isArray = false;
+        this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+        this.autoIncrementIncrement = null;
+    }
+    onAdd(builder, args) {
+        const json = args[0];
+        const modelClass = builder.modelClass();
+        this.isArray = Array.isArray(json);
+        this.models = modelClass.ensureModelArray(json, this.modelOptions);
+        return true;
+    }
+    async onBefore2(builder, result) {
+        await callBeforeInsert(builder, this.models);
+        if (this.models.length > 1 && isMySql(builder.knex())) {
+            await this.prepareMySqlBatchInsert(builder);
+        }
+        return result;
+    }
+    // MySQL only returns the id of the first row of a multi-row insert. InnoDB
+    // gives the rows of one multi-row VALUES insert consecutive ids (in every
+    // `innodb_autoinc_lock_mode`), so the other ids can be computed from it and
+    // `@@auto_increment_increment`.
+    async prepareMySqlBatchInsert(builder) {
+        const withId = this.models.filter((model) => model.$hasId()).length;
+        if (withId === this.models.length) {
+            return;
+        }
+        if (withId > 0) {
+            throw new Error(`batch insert on MySQL can't return ids when only some rows have an id. Set the id on all rows or none.`);
+        }
+        if (Array.isArray(builder.modelClass().getIdColumn())) {
+            return;
+        }
+        const knex = builder.knex();
+        let increment = autoIncrementIncrements.get(knex.client.config);
+        if (increment === undefined) {
+            const [rows] = await knex.raw('select @@auto_increment_increment as increment');
+            increment = Number(rows[0].increment);
+            autoIncrementIncrements.set(knex.client.config, increment);
+        }
+        this.autoIncrementIncrement = increment;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        const knex = builder.knex();
+        const returnsIds = !isMySql(knex) && (!isSqlite(knex) || this.models.length > 1);
+        if (returnsIds && !builder.has(/returning/)) {
+            // If the user hasn't specified a `returning` clause, we make sure
+            // that at least the identifier is returned. SQLite only returns the
+            // id of the last row without one.
+            knexBuilder = knexBuilder.returning(builder.modelClass().getIdColumn());
+        }
+        return knexBuilder.insert(this.models.map((model) => model.$toDatabaseJson(builder)));
+    }
+    onAfter1(builder, ret) {
+        if (!Array.isArray(ret) || !ret.length || ret === this.models) {
+            // Early exit if there is nothing to do.
+            return this.models;
+        }
+        if (ret.length === 1 && this.models.length > 1) {
+            this.setMySqlBatchInsertIds(builder, ret[0]);
+        }
+        else if (isObject(ret[0])) {
+            // If the user specified a `returning` clause the result may be an array of objects.
+            // Merge all values of the objects to our models.
+            for (let i = 0, l = this.models.length; i < l; ++i) {
+                this.models[i].$setDatabaseJson(ret[i]);
+            }
+        }
+        else {
+            // If the return value is not an array of objects, we assume it is an array of identifiers.
+            for (let i = 0, l = this.models.length; i < l; ++i) {
+                const model = this.models[i];
+                // Don't set the id if the model already has one. MySQL and Sqlite don't return the correct
+                // primary key value if the id is not generated in db, but given explicitly.
+                if (!model.$id()) {
+                    model.$id(ret[i]);
+                }
+            }
+        }
+        return this.models;
+    }
+    setMySqlBatchInsertIds(builder, firstId) {
+        const increment = this.autoIncrementIncrement;
+        // `onConflict()` may skip or update rows, which breaks the id sequence.
+        if (increment === null || builder.has(/onConflict/) || !firstId) {
+            return;
+        }
+        for (let i = 0, l = this.models.length; i < l; ++i) {
+            this.models[i].$id(addToId(firstId, i * increment));
+        }
+    }
+    onAfter2(builder, models) {
+        const result = this.isArray ? models : models[0] || null;
+        return callAfterInsert(builder, this.models, result);
+    }
+    toFindOperation() {
+        return null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.models = this.models;
+        clone.isArray = this.isArray;
+        clone.autoIncrementIncrement = this.autoIncrementIncrement;
+        return clone;
+    }
+}
+// The id can be a string or a BigInt when the driver is configured to
+// return big numbers that way.
+function addToId(id, amount) {
+    if (typeof id === 'number') {
+        return id + amount;
+    }
+    else if (typeof id === 'bigint') {
+        return id + BigInt(amount);
+    }
+    else {
+        return String(BigInt(id) + BigInt(amount));
+    }
+}
+function callBeforeInsert(builder, models) {
+    const maybePromise = callInstanceBeforeInsert(builder, models);
+    return after(maybePromise, () => callStaticBeforeInsert(builder));
+}
+function callInstanceBeforeInsert(builder, models) {
+    return mapAfterAllReturn(models, (model) => model.$beforeInsert(builder.context()), models);
+}
+function callStaticBeforeInsert(builder) {
+    if (!hasStaticHook(builder.modelClass(), 'beforeInsert')) {
+        return undefined;
+    }
+    const args = StaticHookArguments.create({ builder });
+    return builder.modelClass().beforeInsert(args);
+}
+function callAfterInsert(builder, models, result) {
+    const maybePromise = callInstanceAfterInsert(builder, models);
+    return after(maybePromise, () => callStaticAfterInsert(builder, result));
+}
+function callInstanceAfterInsert(builder, models) {
+    return mapAfterAllReturn(models, (model) => model.$afterInsert(builder.context()), models);
+}
+function callStaticAfterInsert(builder, result) {
+    if (!hasStaticHook(builder.modelClass(), 'afterInsert')) {
+        return result;
+    }
+    const args = StaticHookArguments.create({ builder, result });
+    const maybePromise = builder.modelClass().afterInsert(args);
+    return after(maybePromise, (maybeResult) => {
+        if (maybeResult === undefined) {
+            return result;
+        }
+        else {
+            return maybeResult;
+        }
+    });
+}
+module.exports = {
+    InsertOperation,
+};

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -0,0 +1,37 @@
+'use strict';
+const { withWhereScope } = require('../whereScopes');
+const { DeleteOperation } = require('./DeleteOperation');
+const { InstanceFindOperation } = require('./InstanceFindOperation');
+const { assertHasId } = require('../../utils/assert');
+class InstanceDeleteOperation extends DeleteOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.instance = opt.instance;
+    }
+    async onBefore2(builder, result) {
+        await this.instance.$beforeDelete(builder.context());
+        await super.onBefore2(builder, result);
+        return result;
+    }
+    onBuild(builder) {
+        super.onBuild(builder);
+        assertHasId(this.instance);
+        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+    }
+    async onAfter2(builder, result) {
+        // The result may be an object if `returning` was used.
+        if (Array.isArray(result)) {
+            result = result[0];
+        }
+        await this.instance.$afterDelete(builder.context());
+        return super.onAfter2(builder, result);
+    }
+    toFindOperation() {
+        return new InstanceFindOperation('find', {
+            instance: this.instance,
+        });
+    }
+}
+module.exports = {
+    InstanceDeleteOperation,
+};

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -0,0 +1,17 @@
+'use strict';
+const { withWhereScope } = require('../whereScopes');
+const { FindOperation } = require('./FindOperation');
+const { assertHasId } = require('../../utils/assert');
+class InstanceFindOperation extends FindOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.instance = opt.instance;
+    }
+    onBuild(builder) {
+        assertHasId(this.instance);
+        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+    }
+}
+module.exports = {
+    InstanceFindOperation,
+};

package/lib/queryBuilder/operations/InstanceInsertOperation.js

@@ -0,0 +1,20 @@
+'use strict';
+const { InsertOperation } = require('./InsertOperation');
+class InstanceInsertOperation extends InsertOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.instance = opt.instance;
+    }
+    onAdd(builder, args) {
+        if (!args || args.length === 0) {
+            args = [this.instance];
+        }
+        else {
+            args[0] = this.instance;
+        }
+        return super.onAdd(builder, args);
+    }
+}
+module.exports = {
+    InstanceInsertOperation,
+};