objection 3.9.0 → 4.0.0-rc.1

package/lib/model/AjvValidator.js

@@ -1,20 +1,18 @@
-'use strict';
-
-const Ajv = require('ajv');
-const addFormats = require('ajv-formats');
-const { Validator } = require('./Validator');
-const { ValidationErrorType } = require('../model/ValidationError');
-const {
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { Validator } from './Validator.js';
+import { ValidationErrorType } from '../model/ValidationError.js';
+import {
   isObject,
   hasOwn,
   once,
-  cloneDeep: lodashCloneDeep,
+  cloneDeep as lodashCloneDeep,
   omit,
-} = require('../utils/objectUtils');
-const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
-const { getQueryPropKeys } = require('./modelQueryProps');
+} from '../utils/objectUtils.js';
+import { parseFieldExpression, isFieldExpressionKey } from '../utils/parseFieldExpression.js';
+import { getQueryPropKeys } from './modelQueryProps.js';
 
-class AjvValidator extends Validator {
+export class AjvValidator extends Validator {
   static init(self, conf) {
     super.init(self, conf);
 
@@ -85,60 +83,27 @@ class AjvValidator extends Validator {
       return json;
     }
 
+    const modelClass = model.constructor;
+    const validator = this.getValidator(
+      modelClass,
+      ctx.jsonSchema,
+      !!options.patch,
+      options.patch ? null : getMissingQueryPropKeys(model, json, ctx.jsonSchema),
+    );
+
     // We need to clone the input json if we are about to set default values.
     if (!options.mutable && !options.patch && setsDefaultValues(ctx.jsonSchema)) {
       json = cloneDeep(json);
     }
 
-    // Patch and update objects can contain field expression keys like `'meta:b'`
-    // that update a single property inside a json column. Validate them against
-    // the nested schema by converting them into nested objects like
-    // `{ meta: { b: value } }`.
-    const queryPropKeys = getQueryPropKeys(model);
-    const fieldExpressions = nestFieldExpressions(json, queryPropKeys, ctx.jsonSchema);
-    let validationJson = fieldExpressions ? fieldExpressions.json : json;
+    // Patch objects can contain field expression keys like `'meta:b'` that update
+    // a single property inside a json column. Validate them against the nested
+    // schema by converting them into nested objects like `{ meta: { b: value } }`.
+    const fieldExpressions = options.patch ? nestFieldExpressions(json, ctx.jsonSchema) : null;
+    const validationJson = fieldExpressions ? fieldExpressions.json : json;
 
-    const modelClass = model.constructor;
-    const validate = (json, isPatchObject, givenKeys = []) => {
-      const validator = this.getValidator(
-        modelClass,
-        ctx.jsonSchema,
-        isPatchObject,
-        isPatchObject ? null : getRequiredKeysGivenOutside(json, ctx.jsonSchema, givenKeys),
-      );
-      validator.call(model, json);
-      return validator.errors || [];
-    };
-
-    let errors;
-
-    if (options.patch) {
-      errors = validate(validationJson, true);
-    } else if (fieldExpressions && fieldExpressions.columns.length > 0) {
-      // Field expressions only write parts of their json columns. Validate these
-      // parts like patches, and the rest normally, with the columns counted as
-      // present like the query properties.
-      const { columns } = fieldExpressions;
-      const columnsJson = Object.fromEntries(
-        columns
-          .filter((column) => hasOwn(validationJson, column))
-          .map((column) => [column, validationJson[column]]),
-      );
-      const restJson = omit(validationJson, columns);
-
-      errors = [
-        ...validate(columnsJson, true),
-        ...validate(restJson, false, [...queryPropKeys, ...columns]),
-      ];
-
-      // Combine the parts again, without the defaults that Ajv set for the
-      // columns in `restJson`.
-      validationJson = Object.assign(restJson, columnsJson);
-    } else {
-      errors = validate(validationJson, false, queryPropKeys);
-    }
-
-    const error = parseValidationError(errors, modelClass, options, this.ajvOptions);
+    validator.call(model, validationJson);
+    const error = parseValidationError(validator.errors, modelClass, options, this.ajvOptions);
 
     if (error) {
       throw error;
@@ -146,7 +111,7 @@ class AjvValidator extends Validator {
 
     if (fieldExpressions) {
       // Copy back the changes made by Ajv options like `coerceTypes` and `removeAdditional`.
-      unnestFieldExpressions(json, validationJson, fieldExpressions);
+      unnestFieldExpressions(json, fieldExpressions);
     }
 
     return json;
@@ -187,8 +152,7 @@ class AjvValidator extends Validator {
         normalValidator: null,
 
         // Validators created for the schema object without the `required`
-        // properties that are given outside the json, as query properties or
-        // json columns written by field expressions, keyed by their names.
+        // properties that are given as query properties, keyed by their names.
         queryPropValidators: null,
       };
 
@@ -318,7 +282,7 @@ function parseValidationError(errors, modelClass, options, ajvOptions) {
       }
     }
 
-    const key = `${options.dataPath || ''}${path}`.substring(1);
+    const key = `${options.dataPath || ''}${path}`.replace(/^\./, '');
 
     // More than one error can occur for the same key in Ajv, merge them in the array:
     const array = errorHash[key] || (errorHash[key] = []);
@@ -352,11 +316,11 @@ function parseValidationError(errors, modelClass, options, ajvOptions) {
   });
 }
 
-function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
+function nestFieldExpressions(json, jsonSchema) {
   const isFieldExpression = (key) => isFieldExpressionKey(key, jsonSchema.properties);
   const keys = Object.keys(json);
 
-  if (!keys.some(isFieldExpression) && !queryPropKeys.some(isFieldExpression)) {
+  if (!keys.some(isFieldExpression)) {
     return null;
   }
 
@@ -365,15 +329,6 @@ function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
   // The objects created here for the nested paths. Other objects are values
   // of the input json and must not be modified.
   const createdObjects = new Set();
-  // The json columns that are only written partially, by field expressions in
-  // the json or the query properties.
-  const columns = new Set();
-
-  const addColumn = (expression) => {
-    if (expression && !hasOwn(json, expression.column)) {
-      columns.add(expression.column);
-    }
-  };
 
   for (const key of keys) {
     if (!isFieldExpression(key)) {
@@ -384,10 +339,7 @@ function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
 
   for (const key of keys) {
     if (isFieldExpression(key)) {
-      const expression = parseFieldExpressionKey(key);
-      // Not a valid field expression, validate it as a top-level property:
-      const path = expression ? expression.path : [key];
-      addColumn(expression);
+      const path = fieldExpressionPath(key);
 
       // Field expressions with array access, and those that conflict with other
       // keys of the patch, can't be validated without the current value of the
@@ -398,16 +350,10 @@ function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
     }
   }
 
-  for (const key of queryPropKeys) {
-    if (isFieldExpression(key)) {
-      addColumn(parseFieldExpressionKey(key));
-    }
-  }
-
-  return { json: nested, paths, columns: [...columns] };
+  return { json: nested, paths };
 }
 
-function unnestFieldExpressions(json, nested, { paths, columns }) {
+function unnestFieldExpressions(json, { json: nested, paths }) {
   for (const [key, path] of paths) {
     let value = nested;
     let found = true;
@@ -429,35 +375,25 @@ function unnestFieldExpressions(json, nested, { paths, columns }) {
       json[key] = value;
     }
   }
-
-  // Copy over the default values that Ajv set for missing properties, but not
-  // the json columns written by the field expressions.
-  for (const key of Object.keys(nested)) {
-    if (!paths.has(key) && !columns.includes(key)) {
-      json[key] = nested[key];
-    }
-  }
 }
 
-// Parse a field expression key into its json column and nested path, with the
-// path set to `null` if the key accesses array elements.
-function parseFieldExpressionKey(key) {
+function fieldExpressionPath(key) {
   let parsed;
 
   try {
     parsed = parseFieldExpression(key);
   } catch (err) {
-    return null;
+    // Not a valid field expression, validate it as a top-level property.
+    return [key];
   }
 
-  const { column, access } = parsed;
   // Numeric keys like the `0` in `tags:0` also access array elements when the
   // json value is an array, so treat them like `[0]`.
-  const isArrayAccess = access.some(({ type, ref }) => type !== 'object' || /^-?\d+$/.test(ref));
-  return {
-    column,
-    path: isArrayAccess ? null : [column, ...access.map(({ ref }) => String(ref))],
-  };
+  if (parsed.access.some((access) => access.type !== 'object' || /^-?\d+$/.test(access.ref))) {
+    return null;
+  }
+
+  return [parsed.column, ...parsed.access.map((access) => String(access.ref))];
 }
 
 function setPath(obj, path, value, createdObjects) {
@@ -537,20 +473,22 @@ function objectHasDefaults(obj) {
   return false;
 }
 
-// Returns the `keys` that are required by the schema but given outside of
-// `json`, sorted, or `null` if there are none. Query properties (`raw()`,
-// `val()`, `ref()`, subqueries...) are split from the json before validation,
-// but they do provide a value for the property, and so do field expressions
-// for their json columns.
-function getRequiredKeysGivenOutside(json, jsonSchema, keys) {
+// Returns the keys of the query properties of `model` (`raw()`, `val()`,
+// `ref()`, subqueries...) that are required by the schema but missing from
+// `json`, sorted, or `null` if there are none. Query properties are split from
+// the json before validation, but they do provide a value for the property.
+function getMissingQueryPropKeys(model, json, jsonSchema) {
   const required = jsonSchema.required;
 
   if (!Array.isArray(required) || required.length === 0) {
     return null;
   }
 
-  const givenKeys = required.filter((key) => keys.includes(key) && !hasOwn(json, key));
-  return givenKeys.length > 0 ? givenKeys.sort() : null;
+  const keys = getQueryPropKeys(model).filter(
+    (key) => required.includes(key) && !hasOwn(json, key),
+  );
+
+  return keys.length > 0 ? keys.sort() : null;
 }
 
 function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {
@@ -647,7 +585,3 @@ function subSchemaWithoutRequired(jsonSchema, prop) {
 function matchesAnything(schema) {
   return schema === true || (isObject(schema) && Object.keys(schema).length === 0);
 }
-
-module.exports = {
-  AjvValidator,
-};

package/lib/model/Model.js

@@ -1,51 +1,54 @@
-'use strict';
-
-const { clone } = require('./modelClone');
-const { bindKnex } = require('./modelBindKnex');
-const { validate } = require('./modelValidate');
-const { isMsSql } = require('../utils/knexUtils');
-const { visitModels } = require('./modelVisitor');
-const { hasId, getSetId } = require('./modelId');
-const { map: promiseMap } = require('../utils/promiseUtils');
-const { toJson, toDatabaseJson } = require('./modelToJson');
-const { values, propKey, hasProps } = require('./modelValues');
-const { defineNonEnumerableProperty } = require('./modelUtils');
-const { parseRelationsIntoModelInstances } = require('./modelParseRelations');
-const { removeOverriddenQueryProps } = require('./modelQueryProps');
-const { fetchTableMetadata, tableMetadata } = require('./modelTableMetadata');
-const { asArray, isFunction, isString, asSingle } = require('../utils/objectUtils');
-const { setJson, setFast, setRelated, appendRelated, setDatabaseJson } = require('./modelSet');
-const {
+import { clone } from './modelClone.js';
+import { bindKnex } from './modelBindKnex.js';
+import { validate } from './modelValidate.js';
+import { isMsSql } from '../utils/knexUtils.js';
+import { visitModels } from './modelVisitor.js';
+import { hasId, getSetId } from './modelId.js';
+import { map as promiseMap } from '../utils/promiseUtils/index.js';
+import { toJson, toDatabaseJson } from './modelToJson.js';
+import { values, propKey, hasProps } from './modelValues.js';
+import { defineNonEnumerableProperty } from './modelUtils.js';
+import { parseRelationsIntoModelInstances } from './modelParseRelations.js';
+import { removeOverriddenQueryProps } from './modelQueryProps.js';
+import { isFieldExpressionKey } from '../utils/parseFieldExpression.js';
+import { fetchTableMetadata, tableMetadata } from './modelTableMetadata.js';
+import { asArray, isFunction, isString, asSingle } from '../utils/objectUtils.js';
+import { setJson, setFast, setRelated, appendRelated, setDatabaseJson } from './modelSet.js';
+import {
   getJsonAttributes,
   parseJsonAttributes,
   formatJsonAttributes,
-} = require('./modelJsonAttributes');
-const { columnNameToPropertyName, propertyNameToColumnName } = require('./modelColPropMap');
-
-const { raw } = require('../queryBuilder/RawBuilder');
-const { ref } = require('../queryBuilder/ReferenceBuilder');
-const { fn } = require('../queryBuilder/FunctionBuilder');
-
-const { AjvValidator } = require('./AjvValidator');
-const { QueryBuilder } = require('../queryBuilder/QueryBuilder');
-const { NotFoundError } = require('./NotFoundError');
-const { ValidationError } = require('./ValidationError');
-const { ModifierNotFoundError } = require('./ModifierNotFoundError');
-const { RelationProperty } = require('../relations/RelationProperty');
-const { RelationOwner } = require('../relations/RelationOwner');
-
-const { HasOneRelation } = require('../relations/hasOne/HasOneRelation');
-const { HasManyRelation } = require('../relations/hasMany/HasManyRelation');
-const { ManyToManyRelation } = require('../relations/manyToMany/ManyToManyRelation');
-const { BelongsToOneRelation } = require('../relations/belongsToOne/BelongsToOneRelation');
-const { HasOneThroughRelation } = require('../relations/hasOneThrough/HasOneThroughRelation');
-
-const { InstanceFindOperation } = require('../queryBuilder/operations/InstanceFindOperation');
-const { InstanceInsertOperation } = require('../queryBuilder/operations/InstanceInsertOperation');
-const { InstanceUpdateOperation } = require('../queryBuilder/operations/InstanceUpdateOperation');
-const { InstanceDeleteOperation } = require('../queryBuilder/operations/InstanceDeleteOperation');
-
-class Model {
+} from './modelJsonAttributes.js';
+import { columnNameToPropertyName, propertyNameToColumnName } from './modelColPropMap.js';
+
+import { raw } from '../queryBuilder/RawBuilder.js';
+import { ref } from '../queryBuilder/ReferenceBuilder.js';
+import { fn } from '../queryBuilder/FunctionBuilder.js';
+
+import { AjvValidator } from './AjvValidator.js';
+import { QueryBuilder } from '../queryBuilder/QueryBuilder.js';
+import { NotFoundError } from './NotFoundError.js';
+import { ValidationError } from './ValidationError.js';
+import { ModifierNotFoundError } from './ModifierNotFoundError.js';
+import { RelationProperty } from '../relations/RelationProperty.js';
+import { RelationOwner } from '../relations/RelationOwner.js';
+import { RelationWriteResultOperation } from '../relations/RelationWriteResultOperation.js';
+
+import { HasOneRelation } from '../relations/hasOne/HasOneRelation.js';
+import { HasManyRelation } from '../relations/hasMany/HasManyRelation.js';
+import { ManyToManyRelation } from '../relations/manyToMany/ManyToManyRelation.js';
+import { BelongsToOneRelation } from '../relations/belongsToOne/BelongsToOneRelation.js';
+import { HasOneThroughRelation } from '../relations/hasOneThrough/HasOneThroughRelation.js';
+import { BelongsToManyRelation } from '../relations/belongsToMany/BelongsToManyRelation.js';
+
+import { InstanceFindOperation } from '../queryBuilder/operations/InstanceFindOperation.js';
+import { InstanceInsertOperation } from '../queryBuilder/operations/InstanceInsertOperation.js';
+import { InstanceUpdateOperation } from '../queryBuilder/operations/InstanceUpdateOperation.js';
+import { InstanceDeleteOperation } from '../queryBuilder/operations/InstanceDeleteOperation.js';
+import { transaction } from '../transaction.js';
+import { setModel } from './getModel.js';
+
+export class Model {
   get $modelClass() {
     return this.constructor;
   }
@@ -95,23 +98,27 @@ class Model {
     // Do nothing by default.
   }
 
-  $parseDatabaseJson(json) {
+  // Queries pass their `knex` in `options`, to parse JSON attributes depending on
+  // the driver. Without it, the source of `json` is unknown.
+  $parseDatabaseJson(json, options) {
     const columnNameMappers = this.constructor.getColumnNameMappers();
 
     if (columnNameMappers) {
       json = columnNameMappers.parse(json);
     }
 
-    return parseJsonAttributes(json, this.constructor);
+    return parseJsonAttributes(json, this.constructor, options?.knex);
   }
 
   $formatDatabaseJson(json) {
-    const columnNameMappers = this.constructor.getColumnNameMappers();
+    const modelClass = this.constructor;
+    const columnNameMappers = modelClass.getColumnNameMappers();
 
-    json = formatJsonAttributes(json, this.constructor);
+    json = formatJsonAttributes(json, modelClass);
 
     if (columnNameMappers) {
-      json = columnNameMappers.format(json);
+      const properties = modelClass.getJsonSchema()?.properties;
+      json = columnNameMappers.format(json, (key) => isFieldExpressionKey(key, properties));
     }
 
     return json;
@@ -129,8 +136,8 @@ class Model {
     return setJson(this, json, options);
   }
 
-  $setDatabaseJson(json) {
-    return setDatabaseJson(this, json);
+  $setDatabaseJson(json, options) {
+    return setDatabaseJson(this, json, options);
   }
 
   $set(obj) {
@@ -266,9 +273,12 @@ class Model {
     return model;
   }
 
-  static fromDatabaseJson(json) {
+  static fromDatabaseJson(json, options) {
     const model = new this();
-    model.$setDatabaseJson(json || {});
+    model.$setDatabaseJson(json || {}, options);
+    // Mark models loaded from the database, as their missing properties weren't
+    // selected, e.g. the join properties of relations (#1832).
+    defineNonEnumerableProperty(model, '$$isFromDatabase', true);
     return model;
   }
 
@@ -531,7 +541,6 @@ class Model {
   }
 
   static startTransaction(knexOrTrx) {
-    const { transaction } = require('../transaction');
     return transaction.start(knexOrTrx || this.knex());
   }
 
@@ -702,11 +711,14 @@ Object.defineProperties(Model.prototype, {
 
 Model.QueryBuilder = QueryBuilder;
 
+setModel(Model);
+
 Model.HasOneRelation = HasOneRelation;
 Model.HasManyRelation = HasManyRelation;
 Model.ManyToManyRelation = ManyToManyRelation;
 Model.BelongsToOneRelation = BelongsToOneRelation;
 Model.HasOneThroughRelation = HasOneThroughRelation;
+Model.BelongsToManyRelation = BelongsToManyRelation;
 
 Model.JoinEagerAlgorithm = 'JoinEagerAlgorithm';
 Model.NaiveEagerAlgorithm = 'NaiveEagerAlgorithm';
@@ -735,6 +747,7 @@ Model.defaultGraphOptions = null;
 Model.defaultFindOptions = Object.freeze({});
 Model.modifiers = null;
 Model.useLimitInFirst = false;
+Model.jsonColumnFormat = 'auto';
 Model.columnNameMappers = null;
 Model.relatedFindQueryMutates = false;
 Model.relatedInsertQueryMutates = false;
@@ -774,6 +787,13 @@ function instanceQuery({ instance, transaction }) {
 function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray } = {}) {
   const relation = modelClass.getRelation(relationName);
   const relatedModelClass = relation.relatedModelClass;
+  // Writes to a to-one relation of one owner resolve to one model with
+  // `returning()`, like its finds:
+  const addWriteResult = (builder) => {
+    if (!alwaysReturnArray && relation.isOneToOne()) {
+      builder.addOperation(new RelationWriteResultOperation('relationWriteResult'), []);
+    }
+  };
 
   return relatedModelClass
     .query(transaction)
@@ -789,6 +809,12 @@ function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray
       operation.alwaysReturnArray = alwaysReturnArray;
       operation.alias = isSubQuery ? relation.name : null;
 
+      if (operation.assignResultToOwner) {
+        // Assign what the query returns last, after all other `runAfter()`
+        // callbacks of the query.
+        builder.runAfter((result, builder) => operation.assignResult(builder, result));
+      }
+
       return operation;
     })
     .insertOperationFactory((builder) => {
@@ -800,14 +826,17 @@ function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray
     })
     .updateOperationFactory((builder) => {
       const owner = RelationOwner.create(builder.for());
+      addWriteResult(builder);
       return relation.update(builder, owner);
     })
     .patchOperationFactory((builder) => {
       const owner = RelationOwner.create(builder.for());
+      addWriteResult(builder);
       return relation.patch(builder, owner);
     })
     .deleteOperationFactory((builder) => {
       const owner = RelationOwner.create(builder.for());
+      addWriteResult(builder);
       return relation.delete(builder, owner);
     })
     .relateOperationFactory((builder) => {
@@ -923,7 +952,3 @@ function asPropsArray(props) {
   }
   return props;
 }
-
-module.exports = {
-  Model,
-};

package/lib/model/ModifierNotFoundError.js

@@ -1,12 +1,6 @@
-'use strict';
-
-class ModifierNotFoundError extends Error {
+export class ModifierNotFoundError extends Error {
   constructor(modifierName) {
     super(`Unable to determine modify function from provided value: "${modifierName}".`);
     this.modifierName = modifierName;
   }
 }
-
-module.exports = {
-  ModifierNotFoundError,
-};

package/lib/model/NotFoundError.js

@@ -1,6 +1,4 @@
-'use strict';
-
-class NotFoundError extends Error {
+export class NotFoundError extends Error {
   constructor({ modelClass, data = {}, statusCode = 404, ...rest } = {}) {
     super(rest.message || 'NotFoundError');
 
@@ -17,7 +15,3 @@ class NotFoundError extends Error {
     });
   }
 }
-
-module.exports = {
-  NotFoundError,
-};

package/lib/model/RelationDoesNotExistError.js

@@ -1,6 +1,4 @@
-'use strict';
-
-class RelationDoesNotExistError extends Error {
+export class RelationDoesNotExistError extends Error {
   constructor(relationName) {
     super(`unknown relation "${relationName}" in a relation expression`);
 
@@ -8,7 +6,3 @@ class RelationDoesNotExistError extends Error {
     this.relationName = relationName;
   }
 }
-
-module.exports = {
-  RelationDoesNotExistError,
-};

package/lib/model/ValidationError.js

@@ -1,15 +1,13 @@
-'use strict';
+import { asArray, isString } from '../utils/objectUtils.js';
 
-const { asArray, isString } = require('../utils/objectUtils');
-
-const ValidationErrorType = {
+export const ValidationErrorType = {
   ModelValidation: 'ModelValidation',
   RelationExpression: 'RelationExpression',
   UnallowedRelation: 'UnallowedRelation',
   InvalidGraph: 'InvalidGraph',
 };
 
-class ValidationError extends Error {
+export class ValidationError extends Error {
   static get Type() {
     return ValidationErrorType;
   }
@@ -47,8 +45,3 @@ function message(it) {
     return it.message;
   }
 }
-
-module.exports = {
-  ValidationError,
-  ValidationErrorType,
-};

package/lib/model/Validator.js

@@ -1,6 +1,4 @@
-'use strict';
-
-class Validator {
+export class Validator {
   constructor(...args) {
     this.constructor.init(this, ...args);
   }
@@ -20,7 +18,3 @@ class Validator {
     model.$afterValidate(json, options);
   }
 }
-
-module.exports = {
-  Validator,
-};

package/lib/model/getModel.js

@@ -1,9 +1,10 @@
-'use strict';
-
-// A small helper method for cached lazy-importing of the Model class.
+// A small helper for lazy access to the Model class, for modules that the Model
+// module imports itself. Importing Model.js there would create a circular import,
+// so Model.js registers itself here instead.
 let Model;
-const getModel = () => Model || (Model = require('./Model').Model);
 
-module.exports = {
-  getModel,
+export const getModel = () => Model;
+
+export const setModel = (model) => {
+  Model = model;
 };

package/lib/model/inheritModel.js

@@ -1,8 +1,6 @@
-'use strict';
-
 const cache = new Map();
 
-function inheritModel(modelClass) {
+export function inheritModel(modelClass) {
   let inherit = cache.get(modelClass.name);
 
   if (!inherit) {
@@ -22,7 +20,3 @@ function createClassInheritor(className) {
   `,
   );
 }
-
-module.exports = {
-  inheritModel,
-};