@e22m4u/js-repository 0.8.2 → 0.8.4

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

@@ -0,0 +1,95 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+import {BlankValuesService} from '@e22m4u/js-empty-values';
+import {InvalidArgumentError} from '../../../errors/index.js';
+import {ModelDefinitionUtils} from '../model-definition-utils.js';
+
+/**
+ * Required property validator.
+ */
+export class RequiredPropertyValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {boolean} [isPartial]
+   */
+  validate(modelName, modelData, isPartial = false) {
+    if (!modelName || typeof modelName !== 'string') {
+      throw new InvalidArgumentError(
+        'Parameter "modelName" must be a non-empty String, but %v was given.',
+        modelName,
+      );
+    }
+    if (
+      !modelData ||
+      typeof modelData !== 'object' ||
+      Array.isArray(modelData)
+    ) {
+      throw new InvalidArgumentError(
+        'Data of the model %v should be an Object, but %v was given.',
+        modelName,
+        modelData,
+      );
+    }
+    if (typeof isPartial !== 'boolean') {
+      throw new InvalidArgumentError(
+        'Parameter "isPartial" must be a Boolean, but %v was given.',
+        isPartial,
+      );
+    }
+    const propDefs =
+      this.getService(
+        ModelDefinitionUtils,
+      ).getPropertiesDefinitionInBaseModelHierarchy(modelName);
+    const propNames = Object.keys(isPartial ? modelData : propDefs);
+    const blankValuesService = this.getService(BlankValuesService);
+    for (const propName of propNames) {
+      const propDef = propDefs[propName];
+      if (!propDef || typeof propDef !== 'object') {
+        continue;
+      }
+      // проверка основного значения
+      const propValue = modelData[propName];
+      if (propDef.required) {
+        const propType = propDef.type || DataType.ANY;
+        if (blankValuesService.isBlankOf(propType, propValue)) {
+          throw new InvalidArgumentError(
+            'Property %v of the model %v is required, but %v was given.',
+            propName,
+            modelName,
+            propValue,
+          );
+        }
+      }
+      // проверка вложенного объекта
+      if (
+        propDef.type === DataType.OBJECT &&
+        propDef.model &&
+        propValue !== null &&
+        typeof propValue === 'object' &&
+        !Array.isArray(propValue)
+      ) {
+        this.validate(propDef.model, propValue);
+      }
+      // проверка массива объектов
+      else if (
+        propDef.type === DataType.ARRAY &&
+        propDef.itemType === DataType.OBJECT &&
+        propDef.itemModel &&
+        Array.isArray(propValue)
+      ) {
+        propValue.forEach(itemData => {
+          if (
+            itemData !== null &&
+            typeof itemData === 'object' &&
+            !Array.isArray(itemData)
+          ) {
+            this.validate(propDef.itemModel, itemData);
+          }
+        });
+      }
+    }
+  }
+}

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

@@ -0,0 +1,583 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {DatabaseSchema} from '../../../database-schema.js';
+import {RequiredPropertyValidator} from './required-property-validator.js';
+import {DataType} from './data-type.js';
+import {BlankValuesService} from '@e22m4u/js-empty-values';
+
+describe('RequiredPropertyValidator', function () {
+  describe('validate', function () {
+    it('should require the parameter "modelName" to be a non-empty String', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      dbs.defineModel({name: 'model'});
+      const throwable = v => () => S.validate(v, {});
+      const error = s =>
+        format(
+          'Parameter "modelName" must be a non-empty String, but %s was given.',
+          s,
+        );
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable('model')();
+    });
+
+    it('should require the parameter "modelData" to be an Object', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      dbs.defineModel({name: 'model'});
+      const throwable = v => () => S.validate('model', v);
+      const error = s =>
+        format(
+          'Data of the model "model" should be an Object, but %s was given.',
+          s,
+        );
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable(true)).to.throw(error('true'));
+      expect(throwable(false)).to.throw(error('false'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable({})();
+    });
+
+    it('should require the parameter "isPartial" to be an Object', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      dbs.defineModel({name: 'model'});
+      const throwable = v => () => S.validate('model', {}, v);
+      const error = s =>
+        format('Parameter "isPartial" must be a Boolean, but %s was given.', s);
+      expect(throwable('str')).to.throw(error('"str"'));
+      expect(throwable('')).to.throw(error('""'));
+      expect(throwable(10)).to.throw(error('10'));
+      expect(throwable(0)).to.throw(error('0'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable(true)();
+      throwable(false)();
+      throwable(undefined)();
+    });
+
+    it('should not throw an error if no properties in the model definition', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      dbs.defineModel({name: 'model'});
+      S.validate('model', {foo: 'bar', baz: undefined});
+    });
+
+    it('should not throw an error if the property definition in short form', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      dbs.defineModel({name: 'model', properties: {foo: DataType.STRING}});
+      S.validate('model', {foo: 'bar'});
+    });
+
+    it('should not throw an error if a required property is not blank', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      const blankValues = S.getService(BlankValuesService);
+      blankValues.setBlankValues([undefined]);
+      dbs.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            required: true,
+          },
+        },
+      });
+      S.validate('model', {foo: 'bar'});
+    });
+
+    it('should throw an error if a required property is blank', function () {
+      const dbs = new DatabaseSchema();
+      const S = dbs.getService(RequiredPropertyValidator);
+      const blankValues = S.getService(BlankValuesService);
+      blankValues.setBlankValues([undefined]);
+      dbs.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            required: true,
+          },
+        },
+      });
+      const throwable = () => S.validate('model', {foo: undefined});
+      expect(throwable).to.throw(
+        'Property "foo" of the model "model" is required, ' +
+          'but undefined was given.',
+      );
+    });
+
+    describe('embedded model', function () {
+      it('should not throw an error if no data is provided for an embedded model', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {embedded: undefined});
+      });
+
+      it('should throw an error if an embedded model is required but not provided', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+              required: true,
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        const throwable = () => S.validate('modelA', {embedded: undefined});
+        expect(throwable).to.throw(
+          'Property "embedded" of the model "modelA" is required, ' +
+            'but undefined was given.',
+        );
+      });
+
+      it('should allow a model data to have properties without a specified schema', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {embedded: {bar: 'baz', qux: undefined}});
+      });
+
+      it('should allow omit a model data when its model has a required property', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        S.validate('modelA', {embedded: undefined});
+      });
+
+      it('should allow omit an optional property for an embedded model', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {embedded: {}});
+      });
+
+      it('should throw an error if a required property is not provided', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        const throwable = () => S.validate('modelA', {embedded: {}});
+        expect(throwable).to.throw(
+          'Property "foo" of the model "modelB" is required, ' +
+            'but undefined was given.',
+        );
+      });
+    });
+
+    describe('object array', function () {
+      it('should allow omit an optional array', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {});
+      });
+
+      it('should allow a required array to be empty', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+              required: true,
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {array: []});
+      });
+
+      it('should allow omit an optional array even if the item model has a required property', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        S.validate('modelA', {});
+      });
+
+      it('should allow an empty array even if the item model has a required property', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        S.validate('modelA', {});
+      });
+
+      it('should throw an error when a required array is not provided', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+              required: true,
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        const throwable = () => S.validate('modelA', {});
+        expect(throwable).to.throw(
+          'Property "array" of the model "modelA" is required, ' +
+            'but undefined was given.',
+        );
+      });
+
+      it('should allow omit an optional property of the item model', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+              required: true,
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {array: [{}]});
+      });
+
+      it('should allow an item date to have properties without a specified schema', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+              required: true,
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.validate('modelA', {array: [{bar: 'baz', qux: undefined}]});
+      });
+    });
+
+    describe('isPartial', function () {
+      it('should throw an error if a required property is blank', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        const throwable = () => S.validate('model', {foo: undefined}, true);
+        expect(throwable).to.throw(
+          'Property "foo" of the model "model" is required, ' +
+            'but undefined was given.',
+        );
+      });
+
+      it('should not validate a required but not provided properties', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        S.validate('model', {}, true);
+      });
+
+      it('should validate not provided properties of an embedded model', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            embedded: {
+              type: DataType.OBJECT,
+              model: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        const throwable = () => S.validate('modelA', {embedded: {}}, true);
+        expect(throwable).to.throw(
+          'Property "foo" of the model "modelB" is required, ' +
+            'but undefined was given.',
+        );
+      });
+
+      it('should validate not provided properties of an item model', function () {
+        const dbs = new DatabaseSchema();
+        const S = dbs.getService(RequiredPropertyValidator);
+        const blankValues = S.getService(BlankValuesService);
+        blankValues.setBlankValues([undefined]);
+        dbs.defineModel({
+          name: 'modelA',
+          properties: {
+            array: {
+              type: DataType.ARRAY,
+              itemType: DataType.OBJECT,
+              itemModel: 'modelB',
+            },
+          },
+        });
+        dbs.defineModel({
+          name: 'modelB',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        const throwable = () => S.validate('modelA', {array: [{}]}, true);
+        expect(throwable).to.throw(
+          'Property "foo" of the model "modelB" is required, ' +
+            'but undefined was given.',
+        );
+      });
+    });
+  });
+});