objection 3.9.1 → 4.0.0-rc.1

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -1,11 +1,8 @@
-'use strict';
+import { DeleteOperation } from './DeleteOperation.js';
+import { InstanceFindOperation } from './InstanceFindOperation.js';
+import { assertHasId } from '../../utils/assert.js';
 
-const { DeleteOperation } = require('./DeleteOperation');
-const { InstanceFindOperation } = require('./InstanceFindOperation');
-const { assertHasId } = require('../../utils/assert');
-const { addWhereGroup } = require('../whereGroups');
-
-class InstanceDeleteOperation extends DeleteOperation {
+export class InstanceDeleteOperation extends DeleteOperation {
   constructor(name, opt) {
     super(name, opt);
     this.instance = opt.instance;
@@ -21,7 +18,7 @@ class InstanceDeleteOperation extends DeleteOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
+    builder.findById(this.instance.$id());
   }
 
   async onAfter2(builder, result) {
@@ -40,7 +37,3 @@ class InstanceDeleteOperation extends DeleteOperation {
     });
   }
 }
-
-module.exports = {
-  InstanceDeleteOperation,
-};

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -1,10 +1,7 @@
-'use strict';
+import { FindOperation } from './FindOperation.js';
+import { assertHasId } from '../../utils/assert.js';
 
-const { FindOperation } = require('./FindOperation');
-const { assertHasId } = require('../../utils/assert');
-const { addWhereGroup } = require('../whereGroups');
-
-class InstanceFindOperation extends FindOperation {
+export class InstanceFindOperation extends FindOperation {
   constructor(name, opt) {
     super(name, opt);
     this.instance = opt.instance;
@@ -12,10 +9,6 @@ class InstanceFindOperation extends FindOperation {
 
   onBuild(builder) {
     assertHasId(this.instance);
-    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
+    builder.findById(this.instance.$id());
   }
 }
-
-module.exports = {
-  InstanceFindOperation,
-};

package/lib/queryBuilder/operations/InstanceInsertOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { InsertOperation } from './InsertOperation.js';
 
-const { InsertOperation } = require('./InsertOperation');
-
-class InstanceInsertOperation extends InsertOperation {
+export class InstanceInsertOperation extends InsertOperation {
   constructor(name, opt) {
     super(name, opt);
     this.instance = opt.instance;
@@ -18,7 +16,3 @@ class InstanceInsertOperation extends InsertOperation {
     return super.onAdd(builder, args);
   }
 }
-
-module.exports = {
-  InstanceInsertOperation,
-};

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -1,13 +1,10 @@
-'use strict';
+import { UpdateOperation } from './UpdateOperation.js';
+import { InstanceFindOperation } from './InstanceFindOperation.js';
+import { assertHasId } from '../../utils/assert.js';
+import { isObject } from '../../utils/objectUtils.js';
+import { removeOverriddenQueryProps } from '../../model/modelQueryProps.js';
 
-const { UpdateOperation } = require('./UpdateOperation');
-const { InstanceFindOperation } = require('./InstanceFindOperation');
-const { assertHasId } = require('../../utils/assert');
-const { isObject } = require('../../utils/objectUtils');
-const { addWhereGroup } = require('../whereGroups');
-const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
-
-class InstanceUpdateOperation extends UpdateOperation {
+export class InstanceUpdateOperation extends UpdateOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -30,7 +27,7 @@ class InstanceUpdateOperation extends UpdateOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
+    builder.findById(this.instance.$id());
   }
 
   async onAfter2(builder, result) {
@@ -60,7 +57,3 @@ class InstanceUpdateOperation extends UpdateOperation {
     });
   }
 }
-
-module.exports = {
-  InstanceUpdateOperation,
-};

package/lib/queryBuilder/operations/JoinRelatedOperation.js

@@ -1,11 +1,9 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { RelationExpression } from '../RelationExpression.js';
+import { RelationJoiner } from '../join/RelationJoiner.js';
+import { isString } from '../../utils/objectUtils.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { RelationExpression } = require('../RelationExpression');
-const { RelationJoiner } = require('../join/RelationJoiner');
-const { isString } = require('../../utils/objectUtils');
-
-class JoinRelatedOperation extends QueryBuilderOperation {
+export class JoinRelatedOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.calls = [];
@@ -97,7 +95,3 @@ function renameRelationExpressionNode(expr, oldName, newName) {
   childExpr.$name = newName;
   expr.$childNames = expr.$childNames.map((it) => (it === oldName ? newName : it));
 }
-
-module.exports = {
-  JoinRelatedOperation,
-};

package/lib/queryBuilder/operations/KnexOperation.js

@@ -1,14 +1,8 @@
-'use strict';
-
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+import { ObjectionToKnexConvertingOperation } from './ObjectionToKnexConvertingOperation.js';
 
 // An operation that simply calls the equivalent knex method.
-class KnexOperation extends ObjectionToKnexConvertingOperation {
+export class KnexOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
     return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
   }
 }
-
-module.exports = {
-  KnexOperation,
-};

package/lib/queryBuilder/operations/LimitPerParentOperation.js

@@ -1,18 +1,13 @@
-'use strict';
-
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { RangeOperation } = require('./RangeOperation');
-const { FirstOperation } = require('./FirstOperation');
-const { isString, isNumber } = require('../../utils/objectUtils');
-const { hasWindowFunctions, isKnexRaw } = require('../../utils/knexUtils');
-const { Selection, isSameTable, withoutSchema } = require('./select/Selection');
-
-// Without underscores, so that column name mappers don't change it.
-const rowNumberColumn = 'objectiontmprownum';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { RangeOperation } from './RangeOperation.js';
+import { FirstOperation } from './FirstOperation.js';
+import { isNumber } from '../../utils/objectUtils.js';
+import { withoutSchema } from './select/Selection.js';
+import { getWindowOrder, rowNumberColumn } from './windowOrder.js';
 
 // Applies the `limit()`, `offset()` and `first()` of a relation query that
 // fetches the related models of many parents to each parent separately.
-class LimitPerParentOperation extends QueryBuilderOperation {
+export class LimitPerParentOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.findOperation = opt.findOperation;
@@ -46,10 +41,6 @@ class LimitPerParentOperation extends QueryBuilderOperation {
 
     if (!range) {
       return knexBuilder;
-    } else if (!hasWindowFunctions(knex)) {
-      // `WhereInEagerOperation` fetches the related models of each parent with
-      // a separate query then, so only `first()` still needs to be applied:
-      return range.limit === null ? knexBuilder : knexBuilder.limit(range.limit);
     } else {
       const { limit, offset } = range;
       // Number the rows of each parent one level up, aliased as the related
@@ -97,56 +88,3 @@ class LimitPerParentOperation extends QueryBuilderOperation {
     }
   }
 }
-
-// Convert the `orderBy()` and `orderByRaw()` calls of the query to the order
-// of knex's window functions, which can only refer to the related table by its
-// alias `table`.
-function getWindowOrder(builder, knex, table) {
-  const order = [];
-  const tableRef = builder.tableRef();
-
-  const getAliasedColumn = (column) => {
-    const selection = isString(column) && Selection.create(column);
-    return selection?.table && isSameTable(builder, selection.table, tableRef)
-      ? `${table}.${selection.column}`
-      : column;
-  };
-
-  builder.forEachOperation(builder.constructor.OrderBySelector, (op) => {
-    const args = op.getKnexArgs(builder);
-
-    if (op.name === 'orderByRaw') {
-      const [sql, bindings] = args;
-      order.push({ column: isKnexRaw(sql) ? sql : knex.raw(sql, bindings) });
-    } else {
-      const [column, direction, nulls] = args;
-      const items = Array.isArray(column)
-        ? column.map((item) => (isString(item) ? { column: item } : item))
-        : [{ column, order: direction, nulls }];
-
-      for (const item of items) {
-        const aliasedColumn = getAliasedColumn(item.column);
-
-        if (item.nulls) {
-          // Not all databases support `nulls first` and `nulls last`:
-          order.push({
-            column: knex.raw('(case when ? is null then 0 else 1 end)', [
-              isString(aliasedColumn) ? knex.ref(aliasedColumn) : aliasedColumn,
-            ]),
-            order: item.nulls === 'first' ? 'asc' : 'desc',
-          });
-        }
-
-        // Unlike in `orderBy()`, knex adds the direction to the window as it is:
-        order.push({ column: aliasedColumn, order: /^desc$/i.test(item.order) ? 'desc' : 'asc' });
-      }
-    }
-  });
-
-  // SQL Server requires an order in the window function:
-  return order.length ? order : [{ column: knex.raw('(select null)') }];
-}
-
-module.exports = {
-  LimitPerParentOperation,
-};

package/lib/queryBuilder/operations/MergeOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { isFunction, isEmpty, isObject } from '../../utils/objectUtils.js';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { convertFieldExpressionsToRaw } from './fieldExpressions.js';
 
-const { isFunction, isEmpty, isObject } = require('../../utils/objectUtils');
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { convertFieldExpressionsToRaw } = require('./UpdateOperation');
-
-class MergeOperation extends QueryBuilderOperation {
+export class MergeOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.model = null;
@@ -31,7 +29,7 @@ class MergeOperation extends QueryBuilderOperation {
 
     if (this.model) {
       const json = this.model.$toDatabaseJson(builder);
-      const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+      const convertedJson = convertFieldExpressionsToRaw(builder, json);
 
       return knexBuilder.merge(convertedJson);
     }
@@ -50,7 +48,3 @@ class MergeOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  MergeOperation,
-};

package/lib/queryBuilder/operations/NoneOperation.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
 const AggregateSelector =
   /^(count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct|groupBy\w*)$/;
 
-class NoneOperation extends QueryBuilderOperation {
+export class NoneOperation extends QueryBuilderOperation {
   onBefore1(builder, result) {
     // Resolve the query without executing it, like `cancelQuery()` does.
     if (builder.isFind()) {
@@ -31,7 +29,3 @@ class NoneOperation extends QueryBuilderOperation {
     return knexBuilder.clearWhere().where(false);
   }
 }
-
-module.exports = {
-  NoneOperation,
-};

package/lib/queryBuilder/operations/ObjectionToKnexConvertingOperation.js

@@ -1,15 +1,13 @@
-'use strict';
-
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { isPlainObject, isObject, isFunction, once } = require('../../utils/objectUtils');
-const { isKnexQueryBuilder, isKnexJoinBuilder } = require('../../utils/knexUtils');
-const { transformation } = require('../transformations');
-const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
+import { isPlainObject, isObject, isFunction } from '../../utils/objectUtils.js';
+import { isKnexQueryBuilder, isKnexJoinBuilder } from '../../utils/knexUtils.js';
+import { transformation } from '../transformations/index.js';
+import { getJoinBuilder } from '../getJoinBuilder.js';
 
 // An abstract operation base class that converts all arguments from objection types
 // to knex types. For example objection query builders are converted into knex query
 // builders and objection RawBuilder instances are converted into knex Raw instances.
-class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
+export class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.args = null;
@@ -21,7 +19,8 @@ class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
 
   onAdd(builder, args) {
     this.args = Array.from(args);
-    return shouldBeAdded(this.name, builder, this.args);
+    assertNoUndefinedArgs(this.name, this.args);
+    return true;
   }
 
   clone() {
@@ -31,52 +30,34 @@ class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
   }
 }
 
-function shouldBeAdded(opName, builder, args) {
-  const skipUndefined = builder.internalOptions().skipUndefined;
-
+function assertNoUndefinedArgs(opName, args) {
   for (let i = 0, l = args.length; i < l; ++i) {
-    const arg = args[i];
-
-    if (isUndefined(arg)) {
-      if (skipUndefined) {
-        return false;
-      } else {
-        throw new Error(
-          `undefined passed as argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
-        );
-      }
+    if (args[i] === undefined) {
+      throw new Error(`undefined passed as argument #${i} for '${opName}' operation.`);
     }
   }
-
-  return true;
 }
 
 function convertArgs(opName, builder, args) {
-  const skipUndefined = builder.internalOptions().skipUndefined;
-
   return args.map((arg, i) => {
     if (hasToKnexRawMethod(arg)) {
       return convertToKnexRaw(arg, builder);
     } else if (isObjectionQueryBuilderBase(arg)) {
       return convertQueryBuilderBase(arg, builder);
     } else if (isArray(arg)) {
-      return convertArray(arg, builder, i, opName, skipUndefined);
+      return convertArray(arg, builder, i, opName);
     } else if (isFunction(arg)) {
       return convertFunction(arg, builder);
     } else if (isModel(arg)) {
       return convertModel(arg);
     } else if (isPlainObject(arg)) {
-      return convertPlainObject(arg, builder, i, opName, skipUndefined);
+      return convertPlainObject(arg, builder, i, opName);
     } else {
       return arg;
     }
   });
 }
 
-function isUndefined(item) {
-  return item === undefined;
-}
-
 function hasToKnexRawMethod(item) {
   return isObject(item) && isFunction(item.toKnexRaw);
 }
@@ -98,19 +79,15 @@ function isArray(item) {
   return Array.isArray(item);
 }
 
-function convertArray(arr, builder, i, opName, skipUndefined) {
+function convertArray(arr, builder, i, opName) {
   return arr.map((item) => {
     if (item === undefined) {
-      if (!skipUndefined) {
-        throw new Error(
-          `undefined passed as an item in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
-        );
-      }
+      throw new Error(`undefined passed as an item in argument #${i} for '${opName}' operation.`);
     } else if (opName === 'orderBy' && isObject(item)) {
       // knex's `orderBy()` only reads `{ column, order, nulls }` objects from arrays,
       // so wrap refs, raws and query builders in one and convert its properties.
       const obj = isPlainObject(item) ? item : { column: item };
-      return convertPlainObject(obj, builder, i, opName, skipUndefined);
+      return convertPlainObject(obj, builder, i, opName);
     } else if (hasToKnexRawMethod(item)) {
       return convertToKnexRaw(item, builder);
     } else if (isObjectionQueryBuilderBase(item)) {
@@ -160,16 +137,14 @@ function convertModel(model) {
   return model.$toDatabaseJson();
 }
 
-function convertPlainObject(obj, builder, i, opName, skipUndefined) {
+function convertPlainObject(obj, builder, i, opName) {
   return Object.keys(obj).reduce((out, key) => {
     const item = obj[key];
 
     if (item === undefined) {
-      if (!skipUndefined) {
-        throw new Error(
-          `undefined passed as a property in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
-        );
-      }
+      throw new Error(
+        `undefined passed as a property in argument #${i} for '${opName}' operation.`,
+      );
     } else if (hasToKnexRawMethod(item)) {
       out[key] = convertToKnexRaw(item, builder);
     } else if (isObjectionQueryBuilderBase(item)) {
@@ -181,7 +156,3 @@ function convertPlainObject(obj, builder, i, opName, skipUndefined) {
     return out;
   }, {});
 }
-
-module.exports = {
-  ObjectionToKnexConvertingOperation,
-};

package/lib/queryBuilder/operations/OnBuildKnexOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class OnBuildKnexOperation extends QueryBuilderOperation {
+export class OnBuildKnexOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.func = null;
@@ -23,7 +21,3 @@ class OnBuildKnexOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  OnBuildKnexOperation,
-};

package/lib/queryBuilder/operations/OnBuildOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class OnBuildOperation extends QueryBuilderOperation {
+export class OnBuildOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.func = null;
@@ -23,7 +21,3 @@ class OnBuildOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  OnBuildOperation,
-};

package/lib/queryBuilder/operations/OnErrorOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class OnErrorOperation extends QueryBuilderOperation {
+export class OnErrorOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.func = null;
@@ -23,7 +21,3 @@ class OnErrorOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  OnErrorOperation,
-};

package/lib/queryBuilder/operations/QueryBuilderOperation.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const hookNameToHasMethodName = {
   onAdd: 'hasOnAdd',
   onBefore1: 'hasOnBefore1',
@@ -29,7 +27,7 @@ const hookNameToHasMethodName = {
 // certain hook is called for _all_ operations before the next hook is called. For example if
 // a builder has 5 operations, onBefore1 hook is called for each of them (and their results are awaited)
 // before onBefore2 hook is called for any of the operations.
-class QueryBuilderOperation {
+export class QueryBuilderOperation {
   constructor(name = null, opt = {}) {
     this.name = name;
     this.opt = opt;
@@ -322,7 +320,3 @@ Object.defineProperties(QueryBuilderOperation, {
     value: true,
   },
 });
-
-module.exports = {
-  QueryBuilderOperation,
-};

package/lib/queryBuilder/operations/RangeOperation.js

@@ -1,13 +1,7 @@
-'use strict';
-
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class RangeOperation extends QueryBuilderOperation {
-  constructor(name, opt) {
-    super(name, opt);
-    this.resultSizeBuilder = null;
-  }
+import { RunAfterOperation } from './RunAfterOperation.js';
 
+// Wraps the result in `{ results, total }` as a `runAfter` callback.
+export class RangeOperation extends RunAfterOperation {
   onAdd(builder, args) {
     if (args.length === 2) {
       const start = args[0];
@@ -22,26 +16,17 @@ class RangeOperation extends QueryBuilderOperation {
   }
 
   onBefore1(builder, result) {
-    this.resultSizeBuilder = builder.clone();
-    return super.onBefore1(builder, result);
-  }
+    const resultSizeBuilder = builder.clone();
 
-  async onAfter3(_, results) {
-    const resultSize = await this.resultSizeBuilder.resultSize();
+    this.func = async (results) => {
+      const resultSize = await resultSizeBuilder.resultSize();
 
-    return {
-      results,
-      total: parseInt(resultSize),
+      return {
+        results,
+        total: parseInt(resultSize),
+      };
     };
-  }
 
-  clone() {
-    const clone = super.clone();
-    clone.resultSizeBuilder = this.resultSizeBuilder;
-    return clone;
+    return super.onBefore1(builder, result);
   }
 }
-
-module.exports = {
-  RangeOperation,
-};

package/lib/queryBuilder/operations/RelateOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class RelateOperation extends QueryBuilderOperation {
+export class RelateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -21,7 +19,3 @@ class RelateOperation extends QueryBuilderOperation {
     return clone;
   }
 }
-
-module.exports = {
-  RelateOperation,
-};

package/lib/queryBuilder/operations/ReturningOperation.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const { flatten, isPlainObject } = require('../../utils/objectUtils');
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+import { flatten, isPlainObject } from '../../utils/objectUtils.js';
+import { ObjectionToKnexConvertingOperation } from './ObjectionToKnexConvertingOperation.js';
 
 // This class's purpose is to normalize the arguments into an array and to
 // pass an optional trailing options object (e.g. `includeTriggerModifications`)
@@ -9,7 +7,7 @@ const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvert
 //
 // In knex, if a single column is given to `returning` it returns an array with the that column's value
 // in it. If an array is given with a one item inside, the return value is an object.
-class ReturningOperation extends ObjectionToKnexConvertingOperation {
+export class ReturningOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.options = null;
@@ -49,7 +47,3 @@ class ReturningOperation extends ObjectionToKnexConvertingOperation {
     return clone;
   }
 }
-
-module.exports = {
-  ReturningOperation,
-};

package/lib/queryBuilder/operations/RunAfterOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderOperation } from './QueryBuilderOperation.js';
 
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-
-class RunAfterOperation extends QueryBuilderOperation {
+export class RunAfterOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
     this.func = null;
@@ -13,17 +11,9 @@ class RunAfterOperation extends QueryBuilderOperation {
     return true;
   }
 
-  onAfter3(builder, result) {
-    return this.func.call(builder, result, builder);
-  }
-
   clone() {
     const clone = super.clone();
     clone.func = this.func;
     return clone;
   }
 }
-
-module.exports = {
-  RunAfterOperation,
-};