@e22m4u/js-repository 0.0.36 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "description": "Абстракция для работы с базами данных для Node.js",
   "type": "module",
   "main": "src/index.js",

package/src/adapter/adapter.js

@@ -39,9 +39,9 @@ export class Adapter extends Service {
     this._settings = settings;
     // decorate only extended classes
     if (this.constructor !== Adapter) {
-      this.getService(DataValidationDecorator).decorate(this);
       this.getService(DataSanitizingDecorator).decorate(this);
       this.getService(DefaultValuesDecorator).decorate(this);
+      this.getService(DataValidationDecorator).decorate(this);
       this.getService(FieldsFilteringDecorator).decorate(this);
       this.getService(InclusionDecorator).decorate(this);
     }

package/src/adapter/adapter.spec.js

@@ -33,9 +33,9 @@ describe('Adapter', function () {
 
     it('decorates only extended adapter', function () {
       const schema = new Schema();
-      const dec1 = schema.getService(DataValidationDecorator);
-      const dec2 = schema.getService(DataSanitizingDecorator);
-      const dec3 = schema.getService(DefaultValuesDecorator);
+      const dec1 = schema.getService(DataSanitizingDecorator);
+      const dec2 = schema.getService(DefaultValuesDecorator);
+      const dec3 = schema.getService(DataValidationDecorator);
       const dec4 = schema.getService(FieldsFilteringDecorator);
       const dec5 = schema.getService(InclusionDecorator);
       const order = [];

package/src/definition/model/model-data-validator.js

@@ -31,7 +31,7 @@ export class ModelDataValidator extends Service {
     propNames.forEach(propName => {
       const propDef = propDefs[propName];
       if (!propDef) return;
-      this.validatePropertyValue(
+      this._validatePropertyValue(
         modelName,
         propName,
         propDef,
@@ -48,7 +48,7 @@ export class ModelDataValidator extends Service {
    * @param {string|object} propDef
    * @param {*} propValue
    */
-  validatePropertyValue(modelName, propName, propDef, propValue) {
+  _validatePropertyValue(modelName, propName, propDef, propValue) {
     // undefined and null
     if (propValue == null) {
       const isRequired =

package/src/definition/model/model-data-validator.spec.js

@@ -1587,6 +1587,61 @@ describe('ModelDataValidator', function () {
               'an Array, but Object given.',
           );
         });
+
+        describe('the "model" option', function () {
+          it('throws an error when the given object element has an invalid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.ARRAY,
+                  itemType: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: [{foo: 10}],
+              });
+            expect(throwable).to.throw(
+              'The property "foo" of the model "modelA" must have ' +
+                'a String, but Number given.',
+            );
+          });
+
+          it('does not throw an error when the given object element has a valid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.ARRAY,
+                  itemType: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('modelB', {
+              bar: [{foo: '10'}],
+            });
+          });
+        });
       });
     });
 
@@ -1883,6 +1938,59 @@ describe('ModelDataValidator', function () {
             foo: {},
           });
         });
+
+        describe('the "model" option', function () {
+          it('throws an error when the given object has an invalid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            const throwable = () =>
+              S.getService(ModelDataValidator).validate('modelB', {
+                bar: {foo: 10},
+              });
+            expect(throwable).to.throw(
+              'The property "foo" of the model "modelA" must have ' +
+                'a String, but Number given.',
+            );
+          });
+
+          it('does not throw an error when the given object has a valid model', function () {
+            const S = new Schema();
+            S.defineModel({
+              name: 'modelA',
+              properties: {
+                foo: DataType.STRING,
+              },
+            });
+            S.defineModel({
+              name: 'modelB',
+              datasource: 'datasource',
+              properties: {
+                bar: {
+                  type: DataType.OBJECT,
+                  model: 'modelA',
+                },
+              },
+            });
+            S.getService(ModelDataValidator).validate('modelB', {
+              bar: {foo: '10'},
+            });
+          });
+        });
       });
     });
   });

package/src/definition/model/properties/index.d.ts

@@ -2,4 +2,3 @@ export * from './data-type.js';
 export * from './property-definition.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';
-export * from './default-values-definition-validator.js';

package/src/definition/model/properties/index.js

@@ -1,4 +1,3 @@
 export * from './data-type.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';
-export * from './default-values-definition-validator.js';

package/src/definition/model/properties/properties-definition-validator.js

@@ -1,8 +1,8 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType as Type} from './data-type.js';
+import {capitalize} from '../../../utils/index.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
 
 /**
  * Properties definition validator.
@@ -38,10 +38,6 @@ export class PropertiesDefinitionValidator extends Service {
       modelName,
       propDefs,
     );
-    this.getService(DefaultValuesDefinitionValidator).validate(
-      modelName,
-      propDefs,
-    );
   }
 
   /**
@@ -182,13 +178,30 @@ export class PropertiesDefinitionValidator extends Service {
         modelName,
         propDef.type,
       );
-    if (propDef.model && propDef.type !== Type.OBJECT)
-      throw new InvalidArgumentError(
-        'The property %v of the model %v has the non-object type, ' +
-          'so it should not have the option "model" to be provided.',
-        propName,
-        modelName,
-        propDef.type,
-      );
+    if (
+      propDef.model &&
+      propDef.type !== Type.OBJECT &&
+      propDef.itemType !== Type.OBJECT
+    ) {
+      if (propDef.type !== Type.ARRAY) {
+        throw new InvalidArgumentError(
+          'The option "model" is not supported for %s property type, ' +
+            'so the property %v of the model %v should not have ' +
+            'the option "model" to be provided.',
+          capitalize(propDef.type),
+          propName,
+          modelName,
+        );
+      } else {
+        throw new InvalidArgumentError(
+          'The option "model" is not supported for Array property type of %s, ' +
+            'so the property %v of the model %v should not have ' +
+            'the option "model" to be provided.',
+          capitalize(propDef.itemType),
+          propName,
+          modelName,
+        );
+      }
+    }
   }
 }

package/src/definition/model/properties/properties-definition-validator.spec.js

@@ -4,7 +4,6 @@ import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
 
 const S = new PropertiesDefinitionValidator();
 const sandbox = chai.spy.sandbox();
@@ -333,7 +332,7 @@ describe('PropertiesDefinitionValidator', function () {
       validate(DataType.ARRAY);
     });
 
-    it('expects a non-object property should not have the option "model" to be provided', function () {
+    it('the option "model" requires the "object" property type', function () {
       const validate = v => () => {
         const foo = {
           type: v,
@@ -341,28 +340,46 @@ describe('PropertiesDefinitionValidator', function () {
         };
         S.validate('model', {foo});
       };
-      const error =
-        'The property "foo" of the model "model" has the non-object type, ' +
-        'so it should not have the option "model" to be provided.';
-      expect(validate(DataType.ANY)).to.throw(error);
-      expect(validate(DataType.STRING)).to.throw(error);
-      expect(validate(DataType.NUMBER)).to.throw(error);
-      expect(validate(DataType.BOOLEAN)).to.throw(error);
-      expect(validate(DataType.ARRAY)).to.throw(error);
-      validate(DataType.OBJECT);
+      const error = v =>
+        format(
+          'The option "model" is not supported for %s property type, ' +
+            'so the property "foo" of the model "model" should not have ' +
+            'the option "model" to be provided.',
+          v,
+        );
+      expect(validate(DataType.ANY)).to.throw(error('Any'));
+      expect(validate(DataType.STRING)).to.throw(error('String'));
+      expect(validate(DataType.NUMBER)).to.throw(error('Number'));
+      expect(validate(DataType.BOOLEAN)).to.throw(error('Boolean'));
+      validate(DataType.OBJECT)();
     });
 
-    it('uses PrimaryKeysDefinitionValidator to validate primary keys', function () {
-      const V = S.getService(PrimaryKeysDefinitionValidator);
-      sandbox.on(V, 'validate');
-      const propDefs = {};
-      S.validate('model', propDefs);
-      expect(V.validate).to.have.been.called.once;
-      expect(V.validate).to.have.been.called.with.exactly('model', propDefs);
+    it('the option "model" requires the "object" item type', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ARRAY,
+          itemType: v,
+          model: 'model',
+        };
+        S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The option "model" is not supported for Array property type of %s, ' +
+            'so the property "foo" of the model "model" should not have ' +
+            'the option "model" to be provided.',
+          v,
+        );
+      expect(validate(DataType.ANY)).to.throw(error('Any'));
+      expect(validate(DataType.STRING)).to.throw(error('String'));
+      expect(validate(DataType.NUMBER)).to.throw(error('Number'));
+      expect(validate(DataType.BOOLEAN)).to.throw(error('Boolean'));
+      expect(validate(DataType.ARRAY)).to.throw(error('Array'));
+      validate(DataType.OBJECT)();
     });
 
-    it('uses DefaultValuesDefinitionValidator to validate default values', function () {
-      const V = S.getService(DefaultValuesDefinitionValidator);
+    it('uses PrimaryKeysDefinitionValidator to validate primary keys', function () {
+      const V = S.getService(PrimaryKeysDefinitionValidator);
       sandbox.on(V, 'validate');
       const propDefs = {};
       S.validate('model', propDefs);

package/src/filter/filter-clause.d.ts

@@ -1,5 +1,3 @@
-import {ModelData} from '../types.js';
-
 /**
  * Filter clause.
  */
@@ -45,20 +43,9 @@ export declare type ItemFilterClause = Pick<FilterClause, 'fields' | 'include'>;
  * ```
  */
 export declare type WhereClause =
-  | PredicateClause
-  | PropertiesClause
-  | AndClause
-  | OrClause;
-
-/**
- * Predicate clause.
- *
- * @example
- * ```ts
- * (value) => value.featured === true;
- * ```
- */
-export type PredicateClause = (value: ModelData) => boolean;
+  & PropertiesClause
+  & AndClause
+  & OrClause;
 
 /**
  * Properties clause.

package/src/filter/where-clause-tool.js

@@ -56,7 +56,6 @@ export class WhereClauseTool extends Service {
    * @returns {Function}
    */
   _createFilter(whereClause) {
-    if (typeof whereClause === 'function') return whereClause;
     if (typeof whereClause !== 'object' || Array.isArray(whereClause))
       throw new InvalidArgumentError(
         'The provided option "where" should be an Object, but %v given.',

package/src/filter/where-clause-tool.spec.js

@@ -272,12 +272,6 @@ describe('WhereClauseTool', function () {
       expect(result[0]).to.be.eql(OBJECTS[2]);
       expect(result[1]).to.be.eql(OBJECTS[3]);
     });
-
-    it('uses the given function to filter values', function () {
-      const result = S.filter(OBJECTS, v => v.nickname === 'Flower');
-      expect(result).to.have.length(1);
-      expect(result[0]).to.be.eql(OBJECTS[1]);
-    });
   });
 
   describe('validateWhereClause', function () {

package/src/definition/model/properties/default-values-definition-validator.d.ts

@@ -1,15 +0,0 @@
-import {Service} from '@e22m4u/js-service';
-import {PropertyDefinitionMap} from '../model-definition.js';
-
-/**
- * Default values definition validator.
- */
-export declare class DefaultValuesDefinitionValidator extends Service {
-  /**
-   * Validate.
-   *
-   * @param modelName
-   * @param propDefs
-   */
-  validate(modelName: string, propDefs: PropertyDefinitionMap): void;
-}

package/src/definition/model/properties/default-values-definition-validator.js

@@ -1,53 +0,0 @@
-import {Service} from '@e22m4u/js-service';
-import {ModelDataValidator} from '../model-data-validator.js';
-import {InvalidArgumentError} from '../../../errors/index.js';
-
-/**
- * Default values definition validator.
- */
-export class DefaultValuesDefinitionValidator extends Service {
-  /**
-   * Validate.
-   *
-   * @param {string} modelName
-   * @param {object} propDefs
-   */
-  validate(modelName, propDefs) {
-    if (!modelName || typeof modelName !== 'string')
-      throw new InvalidArgumentError(
-        'The first argument of DefaultValuesDefinitionValidator.validate ' +
-          'should be a non-empty String, but %v given.',
-        modelName,
-      );
-    if (!propDefs || typeof propDefs !== 'object' || Array.isArray(propDefs))
-      throw new InvalidArgumentError(
-        'The provided option "properties" of the model %v ' +
-          'should be an Object, but %v given.',
-        modelName,
-        propDefs,
-      );
-    Object.keys(propDefs).forEach(propName => {
-      const propDef = propDefs[propName];
-      if (typeof propDef === 'string') return;
-      if (!('default' in propDef)) return;
-      const propValue =
-        propDef.default instanceof Function
-          ? propDef.default()
-          : propDef.default;
-      try {
-        this.getService(ModelDataValidator).validatePropertyValue(
-          modelName,
-          propName,
-          propDef,
-          propValue,
-        );
-      } catch (error) {
-        if (error instanceof InvalidArgumentError)
-          throw new InvalidArgumentError(
-            `A default value is invalid. ${error.message}`,
-          );
-        throw error;
-      }
-    });
-  }
-}

package/src/definition/model/properties/default-values-definition-validator.spec.js

@@ -1,136 +0,0 @@
-import {expect} from 'chai';
-import {DataType} from './data-type.js';
-import {format} from '@e22m4u/js-format';
-import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
-
-const S = new DefaultValuesDefinitionValidator();
-
-describe('DefaultValuesDefinitionValidator', function () {
-  describe('validate', function () {
-    it('requires a first argument to be a non-empty string', function () {
-      const validate = v => () => S.validate(v, {});
-      const error = v =>
-        format(
-          'The first argument of DefaultValuesDefinitionValidator.validate ' +
-            'should be a non-empty String, but %s given.',
-          v,
-        );
-      expect(validate('')).to.throw(error('""'));
-      expect(validate(10)).to.throw(error('10'));
-      expect(validate(true)).to.throw(error('true'));
-      expect(validate(false)).to.throw(error('false'));
-      expect(validate([])).to.throw(error('Array'));
-      expect(validate({})).to.throw(error('Object'));
-      expect(validate(undefined)).to.throw(error('undefined'));
-      expect(validate(null)).to.throw(error('null'));
-      validate('model')();
-    });
-
-    it('requires a second argument to be an object', function () {
-      const validate = v => () => S.validate('model', v);
-      const error = v =>
-        format(
-          'The provided option "properties" of the model "model" ' +
-            'should be an Object, but %s given.',
-          v,
-        );
-      expect(validate('str')).to.throw(error('"str"'));
-      expect(validate(10)).to.throw(error('10'));
-      expect(validate(true)).to.throw(error('true'));
-      expect(validate(false)).to.throw(error('false'));
-      expect(validate([])).to.throw(error('Array'));
-      expect(validate(undefined)).to.throw(error('undefined'));
-      expect(validate(null)).to.throw(error('null'));
-      validate({})();
-    });
-
-    it('does not throw an error if no properties defined', function () {
-      S.validate('model', {});
-    });
-
-    it('does not throw an error if no default value specified for a required property', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.STRING,
-          required: true,
-        },
-      });
-    });
-
-    it('does not throw an error if a default value matches a property type', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.BOOLEAN,
-          default: false,
-        },
-      });
-    });
-
-    it('does not throw an error if a default value from a factory function matches a property type', function () {
-      S.validate('model', {
-        foo: {
-          type: DataType.BOOLEAN,
-          default: () => false,
-        },
-      });
-    });
-
-    it('throws an error if a default value does not match a property type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.STRING,
-            default: 10,
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The property "foo" of the model ' +
-          '"model" must have a String, but Number given.',
-      );
-    });
-
-    it('throws an error if a default value from a factory function does not match a property type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.STRING,
-            default: () => 10,
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The property "foo" of the model ' +
-          '"model" must have a String, but Number given.',
-      );
-    });
-
-    it('throws an error if an array element of a default value does not match an item type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.ARRAY,
-            itemType: DataType.STRING,
-            default: [10],
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The array property "foo" of the model "model" ' +
-          'must have a String element, but Number given.',
-      );
-    });
-
-    it('throws an error if an array element from a default value factory does not match an item type', function () {
-      const throwable = () =>
-        S.validate('model', {
-          foo: {
-            type: DataType.ARRAY,
-            itemType: DataType.STRING,
-            default: () => [10],
-          },
-        });
-      expect(throwable).to.throw(
-        'A default value is invalid. The array property "foo" of the model "model" ' +
-          'must have a String element, but Number given.',
-      );
-    });
-  });
-});