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

package/lib/model/Model.js

@@ -1,53 +1,55 @@
-'use strict';
-const { clone } = require('./modelClone');
-const { bindKnex } = require('./modelBindKnex');
-const { validate } = require('./modelValidate');
-const { isMsSql, isMySql } = 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 { fetchTableMetadata, tableMetadata } = require('./modelTableMetadata');
-const { asArray, isFunction, isString, asSingle } = require('../utils/objectUtils');
-const { setJson, setFast, setRelated, appendRelated, setDatabaseJson } = require('./modelSet');
-const { 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 { markDefaultStaticHook } = require('../queryBuilder/StaticHookArguments');
-const { setDefaultGetConcurrency } = require('./modelConcurrency');
-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');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const modelClone_1 = require("./modelClone");
+const modelBindKnex_1 = require("./modelBindKnex");
+const modelValidate_1 = require("./modelValidate");
+const knexUtils_1 = require("../utils/knexUtils");
+const modelVisitor_1 = require("./modelVisitor");
+const modelId_1 = require("./modelId");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const modelToJson_1 = require("./modelToJson");
+const modelValues_1 = require("./modelValues");
+const modelUtils_1 = require("./modelUtils");
+const modelParseRelations_1 = require("./modelParseRelations");
+const modelTableMetadata_1 = require("./modelTableMetadata");
+const objectUtils_1 = require("../utils/objectUtils");
+const modelSet_1 = require("./modelSet");
+const modelJsonAttributes_1 = require("./modelJsonAttributes");
+const modelColPropMap_1 = require("./modelColPropMap");
+const RawBuilder_1 = require("../queryBuilder/RawBuilder");
+const ReferenceBuilder_1 = require("../queryBuilder/ReferenceBuilder");
+const FunctionBuilder_1 = require("../queryBuilder/FunctionBuilder");
+const AjvValidator_1 = require("./AjvValidator");
+const QueryBuilder_1 = require("../queryBuilder/QueryBuilder");
+const StaticHookArguments_1 = require("../queryBuilder/StaticHookArguments");
+const modelConcurrency_1 = require("./modelConcurrency");
+const NotFoundError_1 = require("./NotFoundError");
+const ValidationError_1 = require("./ValidationError");
+const ModifierNotFoundError_1 = require("./ModifierNotFoundError");
+const RelationProperty_1 = require("../relations/RelationProperty");
+const RelationOwner_1 = require("../relations/RelationOwner");
+const HasOneRelation_1 = require("../relations/hasOne/HasOneRelation");
+const HasManyRelation_1 = require("../relations/hasMany/HasManyRelation");
+const ManyToManyRelation_1 = require("../relations/manyToMany/ManyToManyRelation");
+const BelongsToOneRelation_1 = require("../relations/belongsToOne/BelongsToOneRelation");
+const HasOneThroughRelation_1 = require("../relations/hasOneThrough/HasOneThroughRelation");
+const InstanceFindOperation_1 = require("../queryBuilder/operations/InstanceFindOperation");
+const InstanceInsertOperation_1 = require("../queryBuilder/operations/InstanceInsertOperation");
+const InstanceUpdateOperation_1 = require("../queryBuilder/operations/InstanceUpdateOperation");
+const InstanceDeleteOperation_1 = require("../queryBuilder/operations/InstanceDeleteOperation");
 class Model {
     get $modelClass() {
         return this.constructor;
     }
     $id(maybeId) {
-        return getSetId(this, maybeId);
+        return (0, modelId_1.getSetId)(this, maybeId);
     }
     $hasId() {
-        return hasId(this);
+        return (0, modelId_1.hasId)(this);
     }
     $hasProps(props) {
-        return hasProps(this, props);
+        return (0, modelValues_1.hasProps)(this, props);
     }
     $query(trx) {
         return instanceQuery({
@@ -71,7 +73,7 @@ class Model {
         return jsonSchema;
     }
     $validate(json, options) {
-        return validate(this, json, options);
+        return (0, modelValidate_1.validate)(this, json, options);
     }
     $afterValidate(json, options) {
         // Do nothing by default.
@@ -81,11 +83,11 @@ class Model {
         if (columnNameMappers) {
             json = columnNameMappers.parse(json);
         }
-        return parseJsonAttributes(json, this.constructor);
+        return (0, modelJsonAttributes_1.parseJsonAttributes)(json, this.constructor);
     }
     $formatDatabaseJson(json) {
         const columnNameMappers = this.constructor.getColumnNameMappers();
-        json = formatJsonAttributes(json, this.constructor);
+        json = (0, modelJsonAttributes_1.formatJsonAttributes)(json, this.constructor);
         if (columnNameMappers) {
             json = columnNameMappers.format(json);
         }
@@ -98,28 +100,28 @@ class Model {
         return json;
     }
     $setJson(json, options) {
-        return setJson(this, json, options);
+        return (0, modelSet_1.setJson)(this, json, options);
     }
     $setDatabaseJson(json) {
-        return setDatabaseJson(this, json);
+        return (0, modelSet_1.setDatabaseJson)(this, json);
     }
     $set(obj) {
-        return setFast(this, obj);
+        return (0, modelSet_1.setFast)(this, obj);
     }
     $setRelated(relation, models) {
-        return setRelated(this, relation, models);
+        return (0, modelSet_1.setRelated)(this, relation, models);
     }
     $appendRelated(relation, models) {
-        return appendRelated(this, relation, models);
+        return (0, modelSet_1.appendRelated)(this, relation, models);
     }
     $toJson(opt) {
-        return toJson(this, opt);
+        return (0, modelToJson_1.toJson)(this, opt);
     }
     toJSON(opt) {
         return this.$toJson(opt);
     }
     $toDatabaseJson(builder) {
-        return toDatabaseJson(this, builder);
+        return (0, modelToJson_1.toDatabaseJson)(this, builder);
     }
     $beforeInsert(queryContext) {
         // Do nothing by default.
@@ -143,16 +145,16 @@ class Model {
         // Do nothing by default.
     }
     $values(props) {
-        return values(this, props);
+        return (0, modelValues_1.values)(this, props);
     }
     $propKey(props) {
-        return propKey(this, props);
+        return (0, modelValues_1.propKey)(this, props);
     }
     $idKey() {
         return this.$propKey(this.constructor.getIdPropertyArray());
     }
     $clone(opt) {
-        return clone(this, !!(opt && opt.shallow), false);
+        return (0, modelClone_1.clone)(this, !!(opt && opt.shallow), false);
     }
     $traverse(filterConstructor, callback) {
         if (callback === undefined) {
@@ -170,24 +172,24 @@ class Model {
         return this.constructor.traverseAsync(filterConstructor, this, callback);
     }
     $omitFromJson(...props) {
-        if (arguments.length === 0) {
+        if (props.length === 0) {
             return this.$$omitFromJson;
         }
         else {
             if (!Object.hasOwn(this, '$$omitFromJson')) {
-                defineNonEnumerableProperty(this, '$$omitFromJson', []);
+                (0, modelUtils_1.defineNonEnumerableProperty)(this, '$$omitFromJson', []);
             }
             this.$$omitFromJson = this.$$omitFromJson.concat(asPropsArray(props));
             return this;
         }
     }
     $omitFromDatabaseJson(...props) {
-        if (arguments.length === 0) {
+        if (props.length === 0) {
             return this.$$omitFromDatabaseJson;
         }
         else {
             if (!Object.hasOwn(this, '$$omitFromDatabaseJson')) {
-                defineNonEnumerableProperty(this, '$$omitFromDatabaseJson', []);
+                (0, modelUtils_1.defineNonEnumerableProperty)(this, '$$omitFromDatabaseJson', []);
             }
             this.$$omitFromDatabaseJson = this.$$omitFromDatabaseJson.concat(asPropsArray(props));
             return this;
@@ -249,7 +251,7 @@ class Model {
         return `${relationPath}_join`;
     }
     static createValidator() {
-        return new AjvValidator({
+        return new AjvValidator_1.AjvValidator({
             options: {
                 allErrors: true,
                 validateSchema: false,
@@ -269,17 +271,17 @@ class Model {
     }
     static getTableName() {
         let tableName = this.tableName;
-        if (isFunction(tableName)) {
+        if ((0, objectUtils_1.isFunction)(tableName)) {
             tableName = this.tableName();
         }
-        if (!isString(tableName)) {
+        if (!(0, objectUtils_1.isString)(tableName)) {
             throw new Error(`Model ${this.name} must have a static property tableName`);
         }
         return tableName;
     }
     static getIdColumn() {
         let idColumn = this.idColumn;
-        if (isFunction(idColumn)) {
+        if ((0, objectUtils_1.isFunction)(idColumn)) {
             idColumn = this.idColumn();
         }
         return idColumn;
@@ -291,7 +293,7 @@ class Model {
         return cachedGet(this, '$$jsonSchema', getJsonSchema);
     }
     static getJsonAttributes() {
-        return cachedGet(this, '$$jsonAttributes', getJsonAttributes);
+        return cachedGet(this, '$$jsonAttributes', modelJsonAttributes_1.getJsonAttributes);
     }
     static getColumnNameMappers() {
         return cachedGet(this, '$$columnNameMappers', getColumnNameMappers);
@@ -306,7 +308,7 @@ class Model {
             // On MySQL, concurrent graph updates and deletes deadlock: MySQL needs
             // them wrapped in a subquery, which locks the rows of the join tables
             // it reads.
-            if (isMsSql(knex) || isMySql(knex)) {
+            if ((0, knexUtils_1.isMsSql)(knex) || (0, knexUtils_1.isMySql)(knex)) {
                 return 1;
             }
             else {
@@ -314,7 +316,7 @@ class Model {
             }
         }
         else {
-            if (isFunction(this.concurrency)) {
+            if ((0, objectUtils_1.isFunction)(this.concurrency)) {
                 return this.concurrency();
             }
             else {
@@ -329,7 +331,7 @@ class Model {
         const colToProp = cachedGet(this, '$$colToProp', () => new Map());
         let propertyName = colToProp.get(columnName);
         if (!propertyName) {
-            propertyName = columnNameToPropertyName(this, columnName);
+            propertyName = (0, modelColPropMap_1.columnNameToPropertyName)(this, columnName);
             colToProp.set(columnName, propertyName);
         }
         return propertyName;
@@ -338,7 +340,7 @@ class Model {
         const propToCol = cachedGet(this, '$$propToCol', () => new Map());
         let columnName = propToCol.get(propertyName);
         if (!columnName) {
-            columnName = propertyNameToColumnName(this, propertyName);
+            columnName = (0, modelColPropMap_1.propertyNameToColumnName)(this, propertyName);
             propToCol.set(propertyName, columnName);
         }
         return columnName;
@@ -403,14 +405,14 @@ class Model {
         });
     }
     static fetchTableMetadata(opt) {
-        return fetchTableMetadata(this, opt);
+        return (0, modelTableMetadata_1.fetchTableMetadata)(this, opt);
     }
     static tableMetadata(opt) {
-        return tableMetadata(this, opt);
+        return (0, modelTableMetadata_1.tableMetadata)(this, opt);
     }
     static knex(...args) {
         if (args.length) {
-            defineNonEnumerableProperty(this, '$$knex', args[0]);
+            (0, modelUtils_1.defineNonEnumerableProperty)(this, '$$knex', args[0]);
         }
         else {
             return this.$$knex;
@@ -428,15 +430,15 @@ class Model {
         return transaction.start(knexOrTrx || this.knex());
     }
     static get raw() {
-        return raw;
+        return RawBuilder_1.raw;
     }
     static get ref() {
         return (...args) => {
-            return ref(...args).model(this);
+            return (0, ReferenceBuilder_1.ref)(...args).model(this);
         };
     }
     static get fn() {
-        return fn;
+        return FunctionBuilder_1.fn;
     }
     static knexQuery() {
         return this.knex().table(this.getTableName());
@@ -450,10 +452,10 @@ class Model {
         }
     }
     static bindKnex(knex) {
-        return bindKnex(this, knex);
+        return (0, modelBindKnex_1.bindKnex)(this, knex);
     }
     static bindTransaction(trx) {
-        return bindKnex(this, trx);
+        return (0, modelBindKnex_1.bindKnex)(this, trx);
     }
     static ensureModel(model, options) {
         const modelClass = this;
@@ -461,7 +463,7 @@ class Model {
             return null;
         }
         if (model instanceof modelClass) {
-            return parseRelationsIntoModelInstances(model, model, options);
+            return (0, modelParseRelations_1.parseRelationsIntoModelInstances)(model, model, options);
         }
         else {
             return modelClass.fromJson(model, options);
@@ -488,7 +490,7 @@ class Model {
             return null;
         }
         if (!Object.hasOwn(this, '$$relations')) {
-            defineNonEnumerableProperty(this, '$$relations', Object.create(null));
+            (0, modelUtils_1.defineNonEnumerableProperty)(this, '$$relations', Object.create(null));
         }
         if (!this.$$relations[name]) {
             this.$$relations[name] = new mapping.relation(name, this);
@@ -512,11 +514,11 @@ class Model {
     }
     static traverse(...args) {
         const { traverser, models, filterConstructor } = getTraverseArgs(...args);
-        if (!asSingle(models)) {
+        if (!(0, objectUtils_1.asSingle)(models)) {
             return;
         }
-        const modelClass = asSingle(models).constructor;
-        visitModels(models, modelClass, (model, _, parent, relation) => {
+        const modelClass = (0, objectUtils_1.asSingle)(models).constructor;
+        (0, modelVisitor_1.visitModels)(models, modelClass, (model, _, parent, relation) => {
             if (!filterConstructor || model instanceof filterConstructor) {
                 traverser(model, parent, relation && relation.name);
             }
@@ -525,20 +527,23 @@ class Model {
     }
     static traverseAsync(...args) {
         const { traverser, models, filterConstructor } = getTraverseArgs(...args);
-        if (!asSingle(models)) {
+        if (!(0, objectUtils_1.asSingle)(models)) {
             return Promise.resolve();
         }
-        const modelClass = asSingle(models).constructor;
+        const modelClass = (0, objectUtils_1.asSingle)(models).constructor;
         const promises = [];
-        visitModels(models, modelClass, (model, _, parent, relation) => {
+        (0, modelVisitor_1.visitModels)(models, modelClass, (model, _, parent, relation) => {
             if (!filterConstructor || model instanceof filterConstructor) {
                 const maybePromise = traverser(model, parent, relation && relation.name);
                 promises.push(maybePromise);
             }
         });
-        return promiseMap(promises, (it) => it, { concurrency: this.getConcurrency(this.knex()) });
+        return (0, promiseUtils_1.map)(promises, (it) => it, {
+            concurrency: this.getConcurrency(this.knex()),
+        });
     }
 }
+exports.Model = Model;
 Object.defineProperties(Model, {
     isObjectionModelClass: {
         enumerable: false,
@@ -568,21 +573,21 @@ for (const hookName of [
     'beforeDelete',
     'afterDelete',
 ]) {
-    markDefaultStaticHook(Model[hookName]);
+    (0, StaticHookArguments_1.markDefaultStaticHook)(Model[hookName]);
 }
-setDefaultGetConcurrency(Model.getConcurrency);
-Model.QueryBuilder = QueryBuilder;
-Model.HasOneRelation = HasOneRelation;
-Model.HasManyRelation = HasManyRelation;
-Model.ManyToManyRelation = ManyToManyRelation;
-Model.BelongsToOneRelation = BelongsToOneRelation;
-Model.HasOneThroughRelation = HasOneThroughRelation;
+(0, modelConcurrency_1.setDefaultGetConcurrency)(Model.getConcurrency);
+Model.QueryBuilder = QueryBuilder_1.QueryBuilder;
+Model.HasOneRelation = HasOneRelation_1.HasOneRelation;
+Model.HasManyRelation = HasManyRelation_1.HasManyRelation;
+Model.ManyToManyRelation = ManyToManyRelation_1.ManyToManyRelation;
+Model.BelongsToOneRelation = BelongsToOneRelation_1.BelongsToOneRelation;
+Model.HasOneThroughRelation = HasOneThroughRelation_1.HasOneThroughRelation;
 Model.JoinEagerAlgorithm = 'JoinEagerAlgorithm';
 Model.NaiveEagerAlgorithm = 'NaiveEagerAlgorithm';
 Model.WhereInEagerAlgorithm = 'WhereInEagerAlgorithm';
-Model.ValidationError = ValidationError;
-Model.NotFoundError = NotFoundError;
-Model.ModifierNotFoundError = ModifierNotFoundError;
+Model.ValidationError = ValidationError_1.ValidationError;
+Model.NotFoundError = NotFoundError_1.NotFoundError;
+Model.ModifierNotFoundError = ModifierNotFoundError_1.ModifierNotFoundError;
 Model.tableName = null;
 Model.jsonSchema = null;
 Model.idColumn = 'id';
@@ -604,27 +609,27 @@ Model.columnNameMappers = null;
 Model.relatedFindQueryMutates = false;
 Model.relatedInsertQueryMutates = false;
 Model.concurrency = null;
-function instanceQuery({ instance, transaction }) {
+function instanceQuery({ instance, transaction, }) {
     const modelClass = instance.constructor;
     return modelClass
         .query(transaction)
         .findOperationFactory(() => {
-        return new InstanceFindOperation('find', { instance });
+        return new InstanceFindOperation_1.InstanceFindOperation('find', { instance });
     })
         .insertOperationFactory(() => {
-        return new InstanceInsertOperation('insert', { instance });
+        return new InstanceInsertOperation_1.InstanceInsertOperation('insert', { instance });
     })
         .updateOperationFactory(() => {
-        return new InstanceUpdateOperation('update', { instance });
+        return new InstanceUpdateOperation_1.InstanceUpdateOperation('update', { instance });
     })
         .patchOperationFactory(() => {
-        return new InstanceUpdateOperation('patch', {
+        return new InstanceUpdateOperation_1.InstanceUpdateOperation('patch', {
             instance,
             modelOptions: { patch: true },
         });
     })
         .deleteOperationFactory(() => {
-        return new InstanceDeleteOperation('delete', { instance });
+        return new InstanceDeleteOperation_1.InstanceDeleteOperation('delete', { instance });
     })
         .relateOperationFactory(() => {
         throw new Error('`relate` makes no sense in this context');
@@ -633,7 +638,7 @@ function instanceQuery({ instance, transaction }) {
         throw new Error('`unrelate` makes no sense in this context');
     });
 }
-function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray } = {}) {
+function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray, } = {}) {
     const relation = modelClass.getRelation(relationName);
     const relatedModelClass = relation.relatedModelClass;
     const query = relatedModelClass
@@ -641,8 +646,8 @@ function relatedQuery({ modelClass, relationName, transaction, alwaysReturnArray
         .findOperationFactory((builder) => {
         const isSubQuery = !builder.for();
         const owner = isSubQuery
-            ? RelationOwner.createParentReference(builder, relation)
-            : RelationOwner.create(builder.for());
+            ? RelationOwner_1.RelationOwner.createParentReference(builder, relation)
+            : RelationOwner_1.RelationOwner.create(builder.for());
         const operation = relation.find(builder, owner);
         operation.assignResultToOwner = modelClass.getRelatedFindQueryMutates();
         operation.alwaysReturnArray = alwaysReturnArray;
@@ -686,11 +691,11 @@ function writeOperationOwner(builder, method) {
         // when the query is built or executed.
         builder._forError = new Error(`relatedQuery(): for() must be called before ${method}()`);
     }
-    return RelationOwner.create(owner);
+    return RelationOwner_1.RelationOwner.create(owner);
 }
 function cachedGet(target, hiddenPropertyName, creator) {
     if (!Object.hasOwn(target, hiddenPropertyName)) {
-        defineNonEnumerableProperty(target, hiddenPropertyName, creator(target));
+        (0, modelUtils_1.defineNonEnumerableProperty)(target, hiddenPropertyName, creator(target));
     }
     return target[hiddenPropertyName];
 }
@@ -704,8 +709,8 @@ function getColumnNameMappers(modelClass) {
     return modelClass.columnNameMappers;
 }
 function getIdRelationProperty(modelClass) {
-    const idColumn = asArray(modelClass.getIdColumn());
-    return new RelationProperty(idColumn.map((idCol) => `${modelClass.getTableName()}.${idCol}`), () => modelClass);
+    const idColumn = (0, objectUtils_1.asArray)(modelClass.getIdColumn());
+    return new RelationProperty_1.RelationProperty(idColumn.map((idCol) => `${modelClass.getTableName()}.${idCol}`), () => modelClass);
 }
 function getReadOnlyAttributes(modelClass) {
     return [...new Set(getReadOnlyAttributesRecursively(modelClass))];
@@ -720,13 +725,13 @@ function getReadOnlyAttributesRecursively(modelClass) {
         ...getReadOnlyAttributes(Object.getPrototypeOf(modelClass)),
         ...propertyNames.filter((propName) => {
             const desc = Object.getOwnPropertyDescriptor(modelClass.prototype, propName);
-            return (desc.get && !desc.set) || desc.writable === false || isFunction(desc.value);
+            return (desc.get && !desc.set) || desc.writable === false || (0, objectUtils_1.isFunction)(desc.value);
         }),
     ];
 }
 function getRelationMappings(modelClass) {
     let relationMappings = modelClass.relationMappings;
-    if (isFunction(relationMappings)) {
+    if ((0, objectUtils_1.isFunction)(relationMappings)) {
         relationMappings = relationMappings.call(modelClass);
     }
     return relationMappings || {};
@@ -744,7 +749,7 @@ function getTraverseArgs(filterConstructor, models, traverser) {
         models = filterConstructor;
         filterConstructor = null;
     }
-    if (!isFunction(traverser)) {
+    if (!(0, objectUtils_1.isFunction)(traverser)) {
         throw new Error('traverser must be a function');
     }
     return {
@@ -767,6 +772,3 @@ function asPropsArray(props) {
     }
     return props;
 }
-module.exports = {
-    Model,
-};

package/lib/model/ModifierNotFoundError.js

@@ -1,10 +1,10 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifierNotFoundError = void 0;
 class ModifierNotFoundError extends Error {
     constructor(modifierName) {
         super(`Unable to determine modify function from provided value: "${modifierName}".`);
         this.modifierName = modifierName;
     }
 }
-module.exports = {
-    ModifierNotFoundError,
-};
+exports.ModifierNotFoundError = ModifierNotFoundError;

package/lib/model/NotFoundError.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
 class NotFoundError extends Error {
     constructor({ modelClass, data = {}, statusCode = 404, ...rest } = {}) {
         super(rest.message || 'NotFoundError');
@@ -14,6 +16,4 @@ class NotFoundError extends Error {
         });
     }
 }
-module.exports = {
-    NotFoundError,
-};
+exports.NotFoundError = NotFoundError;

package/lib/model/RelationDoesNotExistError.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationDoesNotExistError = void 0;
 class RelationDoesNotExistError extends Error {
     constructor(relationName) {
         super(`unknown relation "${relationName}" in a relation expression`);
@@ -6,6 +8,4 @@ class RelationDoesNotExistError extends Error {
         this.relationName = relationName;
     }
 }
-module.exports = {
-    RelationDoesNotExistError,
-};
+exports.RelationDoesNotExistError = RelationDoesNotExistError;

package/lib/model/ValidationError.js

@@ -1,11 +1,14 @@
-'use strict';
-const { asArray, isString } = require('../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationErrorType = exports.ValidationError = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
 const ValidationErrorType = {
     ModelValidation: 'ModelValidation',
     RelationExpression: 'RelationExpression',
     UnallowedRelation: 'UnallowedRelation',
     InvalidGraph: 'InvalidGraph',
 };
+exports.ValidationErrorType = ValidationErrorType;
 class ValidationError extends Error {
     static get Type() {
         return ValidationErrorType;
@@ -24,23 +27,20 @@ class ValidationError extends Error {
         });
     }
 }
+exports.ValidationError = ValidationError;
 function errorsToMessage(data) {
     return Object.keys(data)
         .reduce((messages, key) => {
-        messages.push(`${key}: ${asArray(data[key]).map(message).join(', ')}`);
+        messages.push(`${key}: ${(0, objectUtils_1.asArray)(data[key]).map(message).join(', ')}`);
         return messages;
     }, [])
         .join(', ');
 }
 function message(it) {
-    if (isString(it)) {
+    if ((0, objectUtils_1.isString)(it)) {
         return it;
     }
     else {
         return it.message;
     }
 }
-module.exports = {
-    ValidationError,
-    ValidationErrorType,
-};

package/lib/model/Validator.js

@@ -1,13 +1,16 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
 class Validator {
     constructor(...args) {
         this.constructor.init(this, ...args);
     }
-    static init() { }
+    static init(..._args) { }
     beforeValidate({ model, json, options }) {
         model.$beforeValidate(null, json, options);
     }
-    validate() {
+    // A rest parameter keeps `validate.length` 0, as it was in JavaScript.
+    validate(..._args) {
         /* istanbul ignore next */
         throw new Error('not implemented');
     }
@@ -15,6 +18,4 @@ class Validator {
         model.$afterValidate(json, options);
     }
 }
-module.exports = {
-    Validator,
-};
+exports.Validator = Validator;

package/lib/model/getModel.js

@@ -1,7 +1,7 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = void 0;
 // A small helper method for cached lazy-importing of the Model class.
 let Model;
 const getModel = () => Model || (Model = require('./Model').Model);
-module.exports = {
-    getModel,
-};
+exports.getModel = getModel;