@e22m4u/js-repository 0.1.6 → 0.1.7

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

@@ -3,6 +3,7 @@ import {Schema} from '../../schema.js';
 import {format} from '@e22m4u/js-format';
 import {DataType} from './properties/index.js';
 import {ModelDataValidator} from './model-data-validator.js';
+import {DefinitionRegistry} from '../definition-registry.js';
 import {PropertyValidatorRegistry} from './properties/index.js';
 
 describe('ModelDataValidator', function () {
@@ -1998,7 +1999,7 @@ describe('ModelDataValidator', function () {
 
     describe('validate by property validators', function () {
       describe('the option "validate" with the string value', function () {
-        it('do not validate null and undefined values', function () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2011,20 +2012,41 @@ describe('ModelDataValidator', function () {
                 type: DataType.ANY,
                 validate: 'myValidator',
               },
-              bar: {
-                type: DataType.ANY,
-                validate: 'myValidator',
-              },
-              baz: {
+            },
+          });
+          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".',
+          );
+        });
+
+        it('validates undefined and null values', function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
                 type: DataType.ANY,
                 validate: 'myValidator',
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          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'));
         });
 
         it('throws an error from the validator', function () {
@@ -2211,7 +2233,7 @@ describe('ModelDataValidator', function () {
           });
         });
 
-        it('do not validate null and undefined values', function () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2224,20 +2246,41 @@ describe('ModelDataValidator', function () {
                 type: DataType.ANY,
                 validate: ['myValidator'],
               },
-              bar: {
-                type: DataType.ANY,
-                validate: ['myValidator'],
-              },
-              baz: {
+            },
+          });
+          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".',
+          );
+        });
+
+        it('validates undefined and null values', function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
                 type: DataType.ANY,
                 validate: ['myValidator'],
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          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'));
         });
 
         it('throws an error from the validator', function () {
@@ -2425,7 +2468,7 @@ describe('ModelDataValidator', function () {
           });
         });
 
-        it('do not validate null and undefined values', function () {
+        it('validates a property value even is not provided', function () {
           const S = new Schema();
           S.getService(PropertyValidatorRegistry).addValidator(
             'myValidator',
@@ -2440,13 +2483,26 @@ describe('ModelDataValidator', function () {
                   myValidator: true,
                 },
               },
-              bar: {
-                type: DataType.ANY,
-                validate: {
-                  myValidator: true,
-                },
-              },
-              baz: {
+            },
+          });
+          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".',
+          );
+        });
+
+        it('validates undefined and null values', function () {
+          const S = new Schema();
+          S.getService(PropertyValidatorRegistry).addValidator(
+            'myValidator',
+            () => false,
+          );
+          S.defineModel({
+            name: 'model',
+            properties: {
+              foo: {
                 type: DataType.ANY,
                 validate: {
                   myValidator: true,
@@ -2454,10 +2510,16 @@ describe('ModelDataValidator', function () {
               },
             },
           });
-          S.getService(ModelDataValidator).validate('model', {
-            foo: null,
-            bar: undefined,
-          });
+          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'));
         });
 
         it('throws an error from the validator', function () {
@@ -2676,6 +2738,45 @@ describe('ModelDataValidator', function () {
           expect(validated).to.be.true;
         });
       });
+
+      it('the option "validate" requires a non-empty String, an Array or an Object', function () {
+        const schema = new Schema();
+        schema
+          .getService(PropertyValidatorRegistry)
+          .addValidator('myValidator', () => true);
+        schema.defineModel({
+          name: 'model',
+          properties: {
+            foo: {
+              type: DataType.STRING,
+              validate: undefined,
+            },
+          },
+        });
+        const V = schema.getService(ModelDataValidator);
+        const throwable = v => () => {
+          const models = schema.getService(DefinitionRegistry)['_models'];
+          models.model.properties.foo.validate = v;
+          V.validate('model', {});
+        };
+        const error = v =>
+          format(
+            'The provided option "validate" of the property "foo" in the model "model" ' +
+              'should be a non-empty String, an Array of String or an Object, ' +
+              'but %s given.',
+            v,
+          );
+        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'));
+        throwable('myValidator')();
+        throwable(['myValidator'])();
+        throwable([])();
+        throwable({myValidator: true})();
+        throwable({})();
+      });
     });
   });
 });

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

@@ -1,5 +1,6 @@
 export * from './data-type.js';
 export * from './property-definition.js';
 export * from './property-validator/index.js';
+export * from './property-transformer/index.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -1,5 +1,6 @@
 export * from './data-type.js';
 export * from './property-definition.js';
 export * from './property-validator/index.js';
+export * from './property-transformer/index.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -3,6 +3,7 @@ import {DataType as Type} from './data-type.js';
 import {capitalize} from '../../../utils/index.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
+import {PropertyTransformerRegistry} from './property-transformer/index.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
 
 /**
@@ -250,5 +251,51 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
+    if (propDef.transform != null) {
+      const propertyTransformerRegistry = this.getService(
+        PropertyTransformerRegistry,
+      );
+      if (propDef.transform && typeof propDef.transform === 'string') {
+        if (!propertyTransformerRegistry.hasTransformer(propDef.transform))
+          throw new InvalidArgumentError(
+            'The property transformer %v is not found.',
+            propDef.transform,
+          );
+      } else if (Array.isArray(propDef.transform)) {
+        for (const transformerName of propDef.transform) {
+          if (typeof transformerName !== 'string')
+            throw new InvalidArgumentError(
+              'The provided option "transform" of the property %v in the model %v ' +
+                'has an Array value that should have a non-empty String, ' +
+                'but %v given.',
+              propName,
+              modelName,
+              transformerName,
+            );
+          if (!propertyTransformerRegistry.hasTransformer(transformerName))
+            throw new InvalidArgumentError(
+              'The property transformer %v is not found.',
+              transformerName,
+            );
+        }
+      } else if (typeof propDef.transform === 'object') {
+        for (const transformerName in propDef.transform) {
+          if (!propertyTransformerRegistry.hasTransformer(transformerName))
+            throw new InvalidArgumentError(
+              'The property transformer %v is not found.',
+              transformerName,
+            );
+        }
+      } else {
+        throw new InvalidArgumentError(
+          'The provided option "transform" of the property %v in the model %v ' +
+            'should be a non-empty String, an Array of String or an Object, ' +
+            'but %v given.',
+          propName,
+          modelName,
+          propDef.transform,
+        );
+      }
+    }
   }
 }

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

@@ -3,6 +3,7 @@ import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
+import {PropertyTransformerRegistry} from './property-transformer/index.js';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
 
@@ -10,6 +11,10 @@ const S = new PropertiesDefinitionValidator();
 const sandbox = chai.spy.sandbox();
 
 S.getService(PropertyValidatorRegistry).addValidator('myValidator', () => true);
+S.getService(PropertyTransformerRegistry).addTransformer(
+  'myTransformer',
+  () => true,
+);
 
 describe('PropertiesDefinitionValidator', function () {
   afterEach(function () {
@@ -436,5 +441,52 @@ describe('PropertiesDefinitionValidator', function () {
       validate(['myValidator'])();
       validate({myValidator: true})();
     });
+
+    it('the option "transform" should have a non-empty String, an Array of String or an Object', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          transform: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "transform" of the property "foo" in the model "model" ' +
+            'should be a non-empty String, an Array of String or an Object, ' +
+            'but %s given.',
+          v,
+        );
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(0)).to.throw(error('0'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate(() => undefined)).to.throw(error('Function'));
+      validate('myTransformer')();
+      validate(['myTransformer'])();
+      validate([])();
+      validate({myTransformer: true})();
+      validate({})();
+      validate(null)();
+      validate(undefined)();
+    });
+
+    it('the option "transform" requires only existing transformer names', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          transform: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = v => format('The property transformer %s is not found.', v);
+      expect(validate('unknown')).to.throw(error('"unknown"'));
+      expect(validate({unknown: true})).to.throw(error('"unknown"'));
+      expect(validate(['unknown'])).to.throw(error('"unknown"'));
+      validate('myTransformer')();
+      validate(['myTransformer'])();
+      validate({myTransformer: true})();
+    });
   });
 });

package/src/definition/model/properties/property-transformer/builtin/index.d.ts

@@ -0,0 +1 @@
+export * from './trim-transformer.js';

package/src/definition/model/properties/property-transformer/builtin/index.js

@@ -0,0 +1 @@
+export * from './trim-transformer.js';

package/src/definition/model/properties/property-transformer/builtin/trim-transformer.d.ts

@@ -0,0 +1,6 @@
+import {PropertyTransformer} from '../property-transformer.js';
+
+/**
+ * Trim transformer.
+ */
+export declare type trimTransformer = PropertyTransformer;

package/src/definition/model/properties/property-transformer/builtin/trim-transformer.js

@@ -0,0 +1,19 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * Trim transformer.
+ *
+ * @param {*} value
+ * @param {undefined} options
+ * @param {object} context
+ * @returns {string|undefined|null}
+ */
+export function trimTransformer(value, options, context) {
+  if (value == null) return value;
+  if (typeof value === 'string') return value.trim();
+  throw new InvalidArgumentError(
+    'The property transformer %v requires a String value, but %v given.',
+    context.transformerName,
+    value,
+  );
+}

package/src/definition/model/properties/property-transformer/builtin/trim-transformer.spec.js

@@ -0,0 +1,39 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {trimTransformer} from './trim-transformer.js';
+
+describe('trimTransformer', function () {
+  it('returns undefined and null values as is', function () {
+    const res1 = trimTransformer(undefined, undefined, {});
+    const res2 = trimTransformer(null, undefined, {});
+    expect(res1).to.be.undefined;
+    expect(res2).to.be.null;
+  });
+
+  it('trims the given string', function () {
+    const res = trimTransformer(' test ', undefined, {});
+    expect(res).to.be.eq('test');
+  });
+
+  it('throws an error if the given value is not a string', function () {
+    const throwable = v => () =>
+      trimTransformer(v, undefined, {
+        transformerName: 'trim',
+      });
+    const error = v =>
+      format(
+        'The property transformer "trim" requires a String value, but %s given.',
+        v,
+      );
+    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('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable('str')();
+    throwable('')();
+    throwable(undefined)();
+    throwable(null)();
+  });
+});

package/src/definition/model/properties/property-transformer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './property-transformer.js';
+export * from './property-transformer-registry.js';

package/src/definition/model/properties/property-transformer/index.js

@@ -0,0 +1,2 @@
+export * from './property-transformer.js';
+export * from './property-transformer-registry.js';

package/src/definition/model/properties/property-transformer/property-transformer-registry.d.ts

@@ -0,0 +1,29 @@
+import {Service} from '@e22m4u/js-service';
+import {PropertyTransformer} from './property-transformer.js';
+
+/**
+ * Property transformer registry.
+ */
+export declare class PropertyTransformerRegistry extends Service {
+  /**
+   * Add transformer.
+   *
+   * @param name
+   * @param transformer
+   */
+  addTransformer(name: string, transformer: PropertyTransformer): this;
+
+  /**
+   * Has transformer.
+   *
+   * @param name
+   */
+  hasTransformer(name: string): boolean;
+
+  /**
+   * Get transformer.
+   *
+   * @param name
+   */
+  getTransformer(name: string): PropertyTransformer;
+}

package/src/definition/model/properties/property-transformer/property-transformer-registry.js

@@ -0,0 +1,72 @@
+import {Service} from '@e22m4u/js-service';
+import {trimTransformer} from './builtin/index.js';
+import {InvalidArgumentError} from '../../../../errors/index.js';
+
+/**
+ * Property transformer registry.
+ */
+export class PropertyTransformerRegistry extends Service {
+  /**
+   * Transformers.
+   *
+   * @type {object}
+   */
+  _transformers = {
+    trim: trimTransformer,
+  };
+
+  /**
+   * Add transformer.
+   *
+   * @param {string} name
+   * @param {Function} transformer
+   * @returns {PropertyTransformerRegistry}
+   */
+  addTransformer(name, transformer) {
+    if (!name || typeof name !== 'string')
+      throw new InvalidArgumentError(
+        'A name of the property transformer must ' +
+          'be a non-empty String, but %v given.',
+        name,
+      );
+    if (name in this._transformers)
+      throw new InvalidArgumentError(
+        'The property transformer %v is already defined.',
+        name,
+      );
+    if (typeof transformer !== 'function')
+      throw new InvalidArgumentError(
+        'The property transformer %v must be a Function, but %v given.',
+        name,
+        transformer,
+      );
+    this._transformers[name] = transformer;
+    return this;
+  }
+
+  /**
+   * Has transformer.
+   *
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasTransformer(name) {
+    return Boolean(this._transformers[name]);
+  }
+
+  /**
+   * Get transformer.
+   *
+   * @param {string} name
+   * @returns {Function}
+   */
+  getTransformer(name) {
+    const transformer = this._transformers[name];
+    if (!transformer)
+      throw new InvalidArgumentError(
+        'The property transformer %v is not defined.',
+        name,
+      );
+    return transformer;
+  }
+}