@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.0

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -1,108 +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');
+    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;
     }
-
-    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;
+    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;
     }
-  }
-
-  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,
+    InsertGraphOperation,
 };

package/lib/queryBuilder/operations/InsertOperation.js

@@ -1,206 +1,173 @@
 'use strict';
-
 /* global BigInt */
-
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments } = require('../StaticHookArguments');
+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);
+    constructor(name, opt) {
+        super(name, opt);
+        this.models = null;
+        this.isArray = false;
+        this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+        this.autoIncrementIncrement = null;
     }
-
-    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;
+    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;
     }
-
-    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;
+    async onBefore2(builder, result) {
+        await callBeforeInsert(builder, this.models);
+        if (this.models.length > 1 && isMySql(builder.knex())) {
+            await this.prepareMySqlBatchInsert(builder);
+        }
+        return result;
     }
-
-    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);
+    // 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;
     }
-
-    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());
+    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)));
     }
-
-    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;
+    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;
     }
-
-    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]);
+    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));
         }
-      }
     }
-
-    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;
+    onAfter2(builder, models) {
+        const result = this.isArray ? models : models[0] || null;
+        return callAfterInsert(builder, this.models, result);
+    }
+    toFindOperation() {
+        return null;
     }
-
-    for (let i = 0, l = this.models.length; i < l; ++i) {
-      this.models[i].$id(addToId(firstId, i * increment));
+    clone() {
+        const clone = super.clone();
+        clone.models = this.models;
+        clone.isArray = this.isArray;
+        clone.autoIncrementIncrement = this.autoIncrementIncrement;
+        return clone;
     }
-  }
-
-  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));
-  }
+    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));
+    const maybePromise = callInstanceBeforeInsert(builder, models);
+    return after(maybePromise, () => callStaticBeforeInsert(builder));
 }
-
 function callInstanceBeforeInsert(builder, models) {
-  return mapAfterAllReturn(models, (model) => model.$beforeInsert(builder.context()), models);
+    return mapAfterAllReturn(models, (model) => model.$beforeInsert(builder.context()), models);
 }
-
 function callStaticBeforeInsert(builder) {
-  const args = StaticHookArguments.create({ builder });
-  return builder.modelClass().beforeInsert(args);
+    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));
+    const maybePromise = callInstanceAfterInsert(builder, models);
+    return after(maybePromise, () => callStaticAfterInsert(builder, result));
 }
-
 function callInstanceAfterInsert(builder, models) {
-  return mapAfterAllReturn(models, (model) => model.$afterInsert(builder.context()), models);
+    return mapAfterAllReturn(models, (model) => model.$afterInsert(builder.context()), models);
 }
-
 function callStaticAfterInsert(builder, 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;
+    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,
+    InsertOperation,
 };

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -1,46 +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];
+    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,
+        });
     }
-
-    await this.instance.$afterDelete(builder.context());
-    return super.onAfter2(builder, result);
-  }
-
-  toFindOperation() {
-    return new InstanceFindOperation('find', {
-      instance: this.instance,
-    });
-  }
 }
-
 module.exports = {
-  InstanceDeleteOperation,
+    InstanceDeleteOperation,
 };

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -1,21 +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()));
-  }
+    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,
+    InstanceFindOperation,
 };

package/lib/queryBuilder/operations/InstanceInsertOperation.js

@@ -1,24 +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;
+    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);
     }
-
-    return super.onAdd(builder, args);
-  }
 }
-
 module.exports = {
-  InstanceInsertOperation,
+    InstanceInsertOperation,
 };