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

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

@@ -1,34 +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');
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUnrelateOperationBase = void 0;
+const whereScopes_1 = require("../../../queryBuilder/whereScopes");
+const UnrelateOperation_1 = require("../../../queryBuilder/operations/UnrelateOperation");
+class ManyToManyUnrelateOperationBase extends UnrelateOperation_1.UnrelateOperation {
+    queryExecutor(builder) {
+        const unrelateQuery = this.relation
+            .getJoinModelClass(builder.knex())
+            .query()
+            .childQueryOf(builder)
+            .delete();
+        (0, whereScopes_1.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,
-};
+exports.ManyToManyUnrelateOperationBase = ManyToManyUnrelateOperationBase;

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

@@ -1,16 +1,11 @@
-'use strict';
-
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
-
-class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
-  ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUnrelateSqliteOperation = void 0;
+const ManyToManyUnrelateOperationBase_1 = require("./ManyToManyUnrelateOperationBase");
+const ManyToManySqliteModifyMixin_1 = require("../ManyToManySqliteModifyMixin");
+class ManyToManyUnrelateSqliteOperation extends (0, ManyToManySqliteModifyMixin_1.ManyToManySqliteModifyMixin)(ManyToManyUnrelateOperationBase_1.ManyToManyUnrelateOperationBase) {
+    get modifyMainQuery() {
+        return false;
+    }
 }
-
-module.exports = {
-  ManyToManyUnrelateSqliteOperation,
-};
+exports.ManyToManyUnrelateSqliteOperation = ManyToManyUnrelateSqliteOperation;

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

@@ -1,10 +1,8 @@
-'use strict';
-
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
-
-class ManyToManyUpdateOperation extends ManyToManyModifyMixin(ManyToManyUpdateOperationBase) {}
-
-module.exports = {
-  ManyToManyUpdateOperation,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUpdateOperation = void 0;
+const ManyToManyUpdateOperationBase_1 = require("./ManyToManyUpdateOperationBase");
+const ManyToManyModifyMixin_1 = require("../ManyToManyModifyMixin");
+class ManyToManyUpdateOperation extends (0, ManyToManyModifyMixin_1.ManyToManyModifyMixin)(ManyToManyUpdateOperationBase_1.ManyToManyUpdateOperationBase) {
+}
+exports.ManyToManyUpdateOperation = ManyToManyUpdateOperation;

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

@@ -1,82 +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];
-      }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUpdateOperationBase = void 0;
+const whereScopes_1 = require("../../../queryBuilder/whereScopes");
+const UpdateOperation_1 = require("../../../queryBuilder/operations/UpdateOperation");
+class ManyToManyUpdateOperationBase extends UpdateOperation_1.UpdateOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+        this.hasExtraProps = false;
+        this.joinTablePatch = {};
+        this.joinTablePatchFilterQuery = null;
     }
-
-    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]);
+    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;
     }
-
-    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;
+    async onAfter1(builder, result) {
+        if (this.hasExtraProps) {
+            const joinTableUpdateQuery = this.relation
+                .getJoinModelClass(builder.knex())
+                .query()
+                .childQueryOf(builder)
+                .patch(this.joinTablePatch);
+            (0, whereScopes_1.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;
     }
-  }
-
-  /* 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,
-};
+exports.ManyToManyUpdateOperationBase = ManyToManyUpdateOperationBase;

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

@@ -1,12 +1,8 @@
-'use strict';
-
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
-
-class ManyToManyUpdateSqliteOperation extends ManyToManySqliteModifyMixin(
-  ManyToManyUpdateOperationBase,
-) {}
-
-module.exports = {
-  ManyToManyUpdateSqliteOperation,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyUpdateSqliteOperation = void 0;
+const ManyToManyUpdateOperationBase_1 = require("./ManyToManyUpdateOperationBase");
+const ManyToManySqliteModifyMixin_1 = require("../ManyToManySqliteModifyMixin");
+class ManyToManyUpdateSqliteOperation extends (0, ManyToManySqliteModifyMixin_1.ManyToManySqliteModifyMixin)(ManyToManyUpdateOperationBase_1.ManyToManyUpdateOperationBase) {
+}
+exports.ManyToManyUpdateSqliteOperation = ManyToManyUpdateSqliteOperation;

package/lib/transaction.js

@@ -1,96 +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)) {
-    let 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.
-    let callback = args[args.length - 1];
-    let 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'),
-        );
-      }
+    // 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 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',
-          ),
-        );
-      }
+    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);
+            });
+        });
     }
-
-    return knex.transaction((trx) => {
-      let 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);
-      });
-  });
+    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;
+    return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
 }
-
 module.exports = {
-  transaction,
+    transaction,
 };

package/lib/utils/assert.js

@@ -1,25 +1,19 @@
-'use strict';
-
+"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?`,
-    );
-  }
+    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);
-  }
+    if (Array.isArray(id)) {
+        id.forEach((id) => assertIdNotUndefined(id, message));
+    }
+    else if (id === undefined) {
+        throw Error(message);
+    }
 }
-
-module.exports = {
-  assertHasId,
-  assertIdNotUndefined,
-};

package/lib/utils/buildUtils.js

@@ -1,21 +1,19 @@
-'use strict';
-
-const { isObject, isFunction } = require('./objectUtils');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildArg = buildArg;
+const objectUtils_1 = require("./objectUtils");
 function buildArg(arg, builder) {
-  if (!isObject(arg)) {
-    return arg;
-  }
-
-  if (isFunction(arg.toKnexRaw)) {
-    return arg.toKnexRaw(builder);
-  } else if (arg.isObjectionQueryBuilderBase === true) {
-    return arg.subqueryOf(builder).toKnexQuery();
-  } else {
-    return arg;
-  }
+    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;
+    }
 }
-
-module.exports = {
-  buildArg,
-};

package/lib/utils/classUtils.js

@@ -1,13 +1,9 @@
-'use strict';
-
+"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;
+    Constructor.prototype = Object.create(BaseConstructor.prototype);
+    Constructor.prototype.constructor = BaseConstructor;
+    Object.setPrototypeOf(Constructor, BaseConstructor);
+    return Constructor;
 }
-
-module.exports = {
-  inherit,
-};