@e22m4u/js-repository 0.1.9 → 0.1.12

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

@@ -2,6 +2,7 @@ import {expect} from 'chai';
 import {Schema} from '../../schema.js';
 import {format} from '@e22m4u/js-format';
 import {DataType} from './properties/index.js';
+import {EmptyValuesDefiner} from './properties/index.js';
 import {ModelDataValidator} from './model-data-validator.js';
 import {DefinitionRegistry} from '../definition-registry.js';
 import {PropertyValidatorRegistry} from './properties/index.js';
@@ -114,6 +115,28 @@ describe('ModelDataValidator', function () {
       );
     });
 
+    it('throws an error if a required property has an empty value', function () {
+      const schema = new Schema();
+      schema.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            required: true,
+          },
+        },
+      });
+      schema
+        .getService(EmptyValuesDefiner)
+        .setEmptyValuesOf(DataType.STRING, ['empty']);
+      const throwable = () =>
+        schema.getService(ModelDataValidator).validate('model', {foo: 'empty'});
+      expect(throwable).to.throw(
+        'The property "foo" of the model "model" ' +
+          'is required, but "empty" given.',
+      );
+    });
+
     describe('an option "isPartial" is true', function () {
       it('does not throw an error if a given data does not have a required property', function () {
         const schema = new Schema();
@@ -169,9 +192,47 @@ describe('ModelDataValidator', function () {
           'The property "foo" of the model "model" is required, but null given.',
         );
       });
+
+      it('throws an error if a required property has an empty value', function () {
+        const schema = new Schema();
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+        schema
+          .getService(EmptyValuesDefiner)
+          .setEmptyValuesOf(DataType.STRING, [5]);
+        const throwable = () =>
+          schema
+            .getService(ModelDataValidator)
+            .validate('model', {foo: 5}, true);
+        expect(throwable).to.throw(
+          'The property "foo" of the model "model" is required, but 5 given.',
+        );
+      });
     });
 
     describe('validate by property type', function () {
+      it('skips validation for an empty value', function () {
+        const S = new Schema();
+        S.defineModel({
+          name: 'model',
+          datasource: 'datasource',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+            },
+          },
+        });
+        S.getService(EmptyValuesDefiner).setEmptyValuesOf(DataType.STRING, [5]);
+        S.getService(ModelDataValidator).validate('model', {foo: 5});
+      });
+
       describe('DataType.ANY', function () {
         describe('ShortPropertyDefinition', function () {
           it('does not throw an error if an undefined given', function () {
@@ -1998,8 +2059,27 @@ describe('ModelDataValidator', function () {
     });
 
     describe('validate by property validators', function () {
+      it('skips validation for an empty value', function () {
+        const S = new Schema();
+        S.getService(PropertyValidatorRegistry).addValidator(
+          'myValidator',
+          () => false,
+        );
+        S.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              validate: 'myValidator',
+            },
+          },
+        });
+        S.getService(EmptyValuesDefiner).setEmptyValuesOf(DataType.STRING, [5]);
+        S.getService(ModelDataValidator).validate('model', {foo: 5});
+      });
+
       describe('the option "validate" with the string value', function () {
-        it('validates a property value even is not provided', function () {
+        it('does not validate a property value if it is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2015,14 +2095,10 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = () => validator.validate('model', {});
-          expect(throwable).to.throw(
-            'The property "foo" of the model "model" has an invalid value undefined ' +
-              'that caught by the validator "myValidator".',
-          );
+          validator.validate('model', {});
         });
 
-        it('validates undefined and null values', function () {
+        it('does not validate undefined and null values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2038,15 +2114,8 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = v => () => validator.validate('model', {foo: v});
-          const error = v =>
-            format(
-              'The property "foo" of the model "model" has an invalid value %s ' +
-                'that caught by the validator "myValidator".',
-              v,
-            );
-          expect(throwable(undefined)).to.throw(error('undefined'));
-          expect(throwable(null)).to.throw(error('null'));
+          validator.validate('model', {foo: undefined});
+          validator.validate('model', {foo: null});
         });
 
         it('throws an error from the validator', function () {
@@ -2233,7 +2302,7 @@ describe('ModelDataValidator', function () {
           });
         });
 
-        it('validates a property value even is not provided', function () {
+        it('does not validate a property value if it is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2249,14 +2318,10 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = () => validator.validate('model', {});
-          expect(throwable).to.throw(
-            'The property "foo" of the model "model" has an invalid value undefined ' +
-              'that caught by the validator "myValidator".',
-          );
+          validator.validate('model', {});
         });
 
-        it('validates undefined and null values', function () {
+        it('does not validate undefined and null values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2272,15 +2337,8 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = v => () => validator.validate('model', {foo: v});
-          const error = v =>
-            format(
-              'The property "foo" of the model "model" has an invalid value %s ' +
-                'that caught by the validator "myValidator".',
-              v,
-            );
-          expect(throwable(undefined)).to.throw(error('undefined'));
-          expect(throwable(null)).to.throw(error('null'));
+          validator.validate('model', {foo: undefined});
+          validator.validate('model', {foo: null});
         });
 
         it('throws an error from the validator', function () {
@@ -2468,7 +2526,7 @@ describe('ModelDataValidator', function () {
           });
         });
 
-        it('validates a property value even is not provided', function () {
+        it('does not validate a property value if it is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2486,14 +2544,10 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = () => validator.validate('model', {});
-          expect(throwable).to.throw(
-            'The property "foo" of the model "model" has an invalid value undefined ' +
-              'that caught by the validator "myValidator".',
-          );
+          validator.validate('model', {});
         });
 
-        it('validates undefined and null values', function () {
+        it('does not validate undefined and null values', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2511,15 +2565,8 @@ describe('ModelDataValidator', function () {
             },
           });
           const validator = S.getService(ModelDataValidator);
-          const throwable = v => () => validator.validate('model', {foo: v});
-          const error = v =>
-            format(
-              'The property "foo" of the model "model" has an invalid value %s ' +
-                'that caught by the validator "myValidator".',
-              v,
-            );
-          expect(throwable(undefined)).to.throw(error('undefined'));
-          expect(throwable(null)).to.throw(error('null'));
+          validator.validate('model', {foo: undefined});
+          validator.validate('model', {foo: null});
         });
 
         it('throws an error from the validator', function () {
@@ -2748,7 +2795,7 @@ describe('ModelDataValidator', function () {
           name: 'model',
           properties: {
             foo: {
-              type: DataType.STRING,
+              type: DataType.ANY,
               validate: undefined,
             },
           },
@@ -2757,7 +2804,7 @@ describe('ModelDataValidator', function () {
         const throwable = v => () => {
           const models = schema.getService(DefinitionRegistry)['_models'];
           models.model.properties.foo.validate = v;
-          V.validate('model', {});
+          V.validate('model', {foo: 'bar'});
         };
         const error = v =>
           format(

package/src/definition/model/model-definition-utils.d.ts

@@ -2,6 +2,7 @@ import {ModelData} from '../../types.js';
 import {Service} from '@e22m4u/js-service';
 import {DataType} from './properties/index.js';
 import {RelationDefinition} from './relations/index.js';
+import {PropertyDefinition} from './properties/index.js';
 import {PropertyDefinitionMap} from './model-definition.js';
 import {RelationDefinitionMap} from './model-definition.js';
 
@@ -94,6 +95,13 @@ export declare class ModelDefinitionUtils extends Service {
    */
   getDataTypeByPropertyName(modelName: string, propertyName: string): DataType;
 
+  /**
+   * Get data type from property definition.
+   *
+   * @param propDef
+   */
+  getDataTypeFromPropertyDefinition(propDef: PropertyDefinition): DataType;
+
   /**
    * Get own properties definition of primary keys.
    *

package/src/definition/model/model-definition-utils.js

@@ -2,6 +2,7 @@ import {Service} from '@e22m4u/js-service';
 import {DataType} from './properties/index.js';
 import {cloneDeep} from '../../utils/index.js';
 import {excludeObjectKeys} from '../../utils/index.js';
+import {EmptyValuesDefiner} from './properties/index.js';
 import {InvalidArgumentError} from '../../errors/index.js';
 import {DefinitionRegistry} from '../definition-registry.js';
 
@@ -139,10 +140,16 @@ export class ModelDefinitionUtils extends Service {
       ? Object.keys(modelData)
       : Object.keys(propDefs);
     const extendedData = cloneDeep(modelData);
+    const emptyValueDefiner = this.getService(EmptyValuesDefiner);
     propNames.forEach(propName => {
-      const value = extendedData[propName];
-      if (value != null) return;
       const propDef = propDefs[propName];
+      const propValue = extendedData[propName];
+      const propType =
+        propDef != null
+          ? this.getDataTypeFromPropertyDefinition(propDef)
+          : DataType.ANY;
+      const isEmpty = emptyValueDefiner.isEmpty(propType, propValue);
+      if (!isEmpty) return;
       if (
         propDef &&
         typeof propDef === 'object' &&
@@ -226,6 +233,35 @@ export class ModelDefinitionUtils extends Service {
     return propDef.type;
   }
 
+  /**
+   * Get data type from property definition.
+   *
+   * @param {object} propDef
+   * @returns {string}
+   */
+  getDataTypeFromPropertyDefinition(propDef) {
+    if (
+      (!propDef || typeof propDef !== 'object') &&
+      !Object.values(DataType).includes(propDef)
+    ) {
+      throw new InvalidArgumentError(
+        'The argument "propDef" of the ModelDefinitionUtils.getDataTypeFromPropertyDefinition ' +
+          'should be an Object or the DataType enum, but %v given.',
+        propDef,
+      );
+    }
+    if (typeof propDef === 'string') return propDef;
+    const dataType = propDef.type;
+    if (!Object.values(DataType).includes(dataType))
+      throw new InvalidArgumentError(
+        'The given Object to the ModelDefinitionUtils.getDataTypeFromPropertyDefinition ' +
+          'should have the "type" property with one of values: %l, but %v given.',
+        Object.values(DataType),
+        propDef.type,
+      );
+    return dataType;
+  }
+
   /**
    * Get own properties definition of primary keys.
    *

package/src/definition/model/model-definition-utils.spec.js

@@ -4,6 +4,7 @@ import {Schema} from '../../schema.js';
 import {format} from '@e22m4u/js-format';
 import {DataType} from './properties/index.js';
 import {RelationType} from './relations/index.js';
+import {EmptyValuesDefiner} from './properties/index.js';
 import {InvalidArgumentError} from '../../errors/index.js';
 import {ModelDefinitionUtils} from './model-definition-utils.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from './model-definition-utils.js';
@@ -476,6 +477,26 @@ describe('ModelDefinitionUtils', function () {
       expect(result).to.be.eql({foo: 'string'});
     });
 
+    it('sets a default value if a property has an empty value', function () {
+      const schema = new Schema();
+      schema.defineModel({
+        name: 'model',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            default: 'placeholder',
+          },
+        },
+      });
+      schema
+        .getService(EmptyValuesDefiner)
+        .setEmptyValuesOf(DataType.STRING, ['empty']);
+      const result = schema
+        .getService(ModelDefinitionUtils)
+        .setDefaultValuesToEmptyProperties('model', {foo: 'empty'});
+      expect(result).to.be.eql({foo: 'placeholder'});
+    });
+
     it('sets a value from a factory function', function () {
       const schema = new Schema();
       schema.defineModel({
@@ -827,6 +848,67 @@ describe('ModelDefinitionUtils', function () {
     });
   });
 
+  describe('getDataTypeFromPropertyDefinition', function () {
+    it('requires the given argument "propDef" must be an Object or DataType', function () {
+      const schema = new Schema();
+      const S = schema.getService(ModelDefinitionUtils);
+      const throwable = v => () => S.getDataTypeFromPropertyDefinition(v);
+      const error = v =>
+        format(
+          'The argument "propDef" of the ModelDefinitionUtils.getDataTypeFromPropertyDefinition ' +
+            'should be an Object or the DataType enum, but %s given.',
+          v,
+        );
+      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(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable(DataType.ANY)();
+      throwable({type: DataType.ANY})();
+    });
+
+    it('requires the given Object to have the "type" property with the DataType enum', function () {
+      const schema = new Schema();
+      const S = schema.getService(ModelDefinitionUtils);
+      const throwable = v => () =>
+        S.getDataTypeFromPropertyDefinition({type: v});
+      const error = v =>
+        format(
+          'The given Object to the ModelDefinitionUtils.getDataTypeFromPropertyDefinition ' +
+            'should have the "type" property with one of values: %l, but %s given.',
+          Object.values(DataType),
+          v,
+        );
+      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(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      throwable(DataType.ANY)();
+    });
+
+    it('returns the DataType from the given DataType enum', function () {
+      const schema = new Schema();
+      const S = schema.getService(ModelDefinitionUtils);
+      const res = S.getDataTypeFromPropertyDefinition(DataType.STRING);
+      expect(res).to.be.eq(DataType.STRING);
+    });
+
+    it('returns the DataType from the given PropertyDefinition', function () {
+      const schema = new Schema();
+      const S = schema.getService(ModelDefinitionUtils);
+      const res = S.getDataTypeFromPropertyDefinition({type: DataType.STRING});
+      expect(res).to.be.eq(DataType.STRING);
+    });
+  });
+
   describe('getOwnPropertiesDefinitionWithoutPrimaryKeys', function () {
     it('returns an empty object if a model does not have properties', function () {
       const schema = new Schema();

package/src/definition/model/properties/empty-values-definer.d.ts

@@ -0,0 +1,23 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Empty values definer.
+ */
+export class EmptyValuesDefiner extends Service {
+  /**
+   * Set empty values of.
+   *
+   * @param dataType
+   * @param emptyValues
+   */
+  setEmptyValuesOf(dataType: DataType, emptyValues: unknown[]): this;
+
+  /**
+   * Is empty.
+   *
+   * @param dataType
+   * @param value
+   */
+  isEmpty(dataType: DataType, value: unknown): boolean;
+}

package/src/definition/model/properties/empty-values-definer.js

@@ -0,0 +1,66 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+import {isDeepEqual} from '../../../utils/index.js';
+import {InvalidArgumentError} from '../../../errors/index.js';
+
+/**
+ * Empty values definer.
+ */
+export class EmptyValuesDefiner extends Service {
+  /**
+   * Empty values map.
+   *
+   * @type {Map<string, *[]>}
+   */
+  _emptyValuesMap = new Map([
+    [DataType.ANY, [undefined, null]],
+    [DataType.STRING, [undefined, null, '']],
+    [DataType.NUMBER, [undefined, null, 0]],
+    [DataType.BOOLEAN, [undefined, null]],
+    [DataType.ARRAY, [undefined, null, []]],
+    [DataType.OBJECT, [undefined, null, {}]],
+  ]);
+
+  /**
+   * Set empty values of data type.
+   *
+   * @param {string} dataType
+   * @param {*[]} emptyValues
+   * @returns {EmptyValuesDefiner}
+   */
+  setEmptyValuesOf(dataType, emptyValues) {
+    if (!Object.values(DataType).includes(dataType))
+      throw new InvalidArgumentError(
+        'The argument "dataType" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+          'must be one of data types: %l, but %v given.',
+        Object.values(DataType),
+        dataType,
+      );
+    if (!Array.isArray(emptyValues))
+      throw new InvalidArgumentError(
+        'The argument "emptyValues" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+          'must be an Array, but %v given.',
+        emptyValues,
+      );
+    this._emptyValuesMap.set(dataType, emptyValues);
+    return this;
+  }
+
+  /**
+   * Is empty.
+   *
+   * @param {string} dataType
+   * @param {*} value
+   * @returns {boolean}
+   */
+  isEmpty(dataType, value) {
+    if (!Object.values(DataType).includes(dataType))
+      throw new InvalidArgumentError(
+        'The argument "dataType" of the EmptyValuesDefiner.isEmpty ' +
+          'must be one of data types: %l, but %v given.',
+        Object.values(DataType),
+        dataType,
+      );
+    return this._emptyValuesMap.get(dataType).some(v => isDeepEqual(v, value));
+  }
+}

package/src/definition/model/properties/empty-values-definer.spec.js

@@ -0,0 +1,96 @@
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {Schema} from '../../../schema.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
+
+const getEmptyValues = (definer, dataType) => {
+  return definer['_emptyValuesMap'].get(dataType);
+};
+
+describe('EmptyValuesDefiner', function () {
+  describe('_emptyValuesMap', function () {
+    it('has default values', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(Array.from(S['_emptyValuesMap'])).to.be.eql([
+        [DataType.ANY, [undefined, null]],
+        [DataType.STRING, [undefined, null, '']],
+        [DataType.NUMBER, [undefined, null, 0]],
+        [DataType.BOOLEAN, [undefined, null]],
+        [DataType.ARRAY, [undefined, null, []]],
+        [DataType.OBJECT, [undefined, null, {}]],
+      ]);
+    });
+  });
+
+  describe('setEmptyValuesOf', function () {
+    it('requires the parameter "dataType" to be a DataType enum', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(v, []);
+      const error = v =>
+        format(
+          'The argument "dataType" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be one of data types: %l, but %s given.',
+          Object.values(DataType),
+          v,
+        );
+      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(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([])).to.throw(error('Array'));
+      throwable(DataType.ANY)();
+    });
+
+    it('requires the parameter "emptyValues" to be an Array', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(DataType.ANY, v);
+      const error = v =>
+        format(
+          'The argument "emptyValues" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be an Array, but %s given.',
+          v,
+        );
+      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(undefined)).to.throw(error('undefined'));
+      expect(throwable(null)).to.throw(error('null'));
+      expect(throwable({})).to.throw(error('Object'));
+      throwable([])();
+      throwable([1, 2, 3])();
+    });
+
+    it('overrides default values of the given data type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(getEmptyValues(S, DataType.ANY)).eql([undefined, null]);
+      S.setEmptyValuesOf(DataType.ANY, [1, 2, 3]);
+      expect(getEmptyValues(S, DataType.ANY)).eql([1, 2, 3]);
+    });
+  });
+
+  describe('isEmpty', function () {
+    it('returns true if the given value exists in the given type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      S.setEmptyValuesOf(DataType.ANY, []);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar', 'foo']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.true;
+    });
+  });
+});

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

@@ -1,5 +1,7 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
 export * from './property-uniqueness-validator.js';

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

@@ -1,5 +1,7 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
 export * from './property-uniqueness-validator.js';

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

@@ -1,6 +1,7 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType as Type} from './data-type.js';
 import {capitalize} from '../../../utils/index.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertyTransformerRegistry} from './property-transformer/index.js';
@@ -297,14 +298,19 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
-    if (propDef.unique && typeof propDef.unique !== 'boolean')
+    if (
+      propDef.unique &&
+      !Object.values(PropertyUniqueness).includes(propDef.unique)
+    ) {
       throw new InvalidArgumentError(
         'The provided option "unique" of the property %v in the model %v ' +
-          'should be a Boolean, but %v given.',
+          'should be one of values: %l, but %v given.',
         propName,
         modelName,
+        Object.values(PropertyUniqueness),
         propDef.unique,
       );
+    }
     if (propDef.unique && propDef.primaryKey)
       throw new InvalidArgumentError(
         'The property %v of the model %v is a primary key, ' +