@e22m4u/js-repository 0.1.6 → 0.1.7

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

@@ -0,0 +1,129 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {trimTransformer} from './builtin/index.js';
+import {PropertyTransformerRegistry} from './property-transformer-registry.js';
+
+describe('PropertyTransformerRegistry', function () {
+  describe('addTransformer', function () {
+    it('has builtin transformers', function () {
+      const S = new PropertyTransformerRegistry();
+      expect(S['_transformers']).to.be.eql({
+        trim: trimTransformer,
+      });
+    });
+
+    it('adds a given transformer with the name', function () {
+      const S = new PropertyTransformerRegistry();
+      const myTransformer = () => undefined;
+      const res = S.addTransformer('myTransformer', myTransformer);
+      expect(res).to.be.eq(S);
+      expect(S['_transformers']['myTransformer']).to.be.eq(myTransformer);
+    });
+
+    it('requires the given name to be a non-empty string', function () {
+      const S = new PropertyTransformerRegistry();
+      const throwable = v => () => S.addTransformer(v, () => undefined);
+      const error = v =>
+        format(
+          'A name of the property transformer must ' +
+            'be a non-empty String, 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(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'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+      throwable('str')();
+    });
+
+    it('throws an error if the given name already exists', function () {
+      const S = new PropertyTransformerRegistry();
+      S.addTransformer('test', () => undefined);
+      const throwable = () => S.addTransformer('test', () => undefined);
+      expect(throwable).to.throw(
+        'The property transformer "test" is already defined.',
+      );
+    });
+
+    it('requires the given transformer to be a function', function () {
+      const S = new PropertyTransformerRegistry();
+      const throwable = v => () => S.addTransformer('test', v);
+      const error = v =>
+        format(
+          'The property transformer "test" must be a Function, 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(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(() => undefined)();
+    });
+  });
+
+  describe('hasTransformer', function () {
+    it('returns false for a not existing name', function () {
+      const S = new PropertyTransformerRegistry();
+      expect(S.hasTransformer('str')).to.be.false;
+      expect(S.hasTransformer('')).to.be.false;
+      expect(S.hasTransformer(10)).to.be.false;
+      expect(S.hasTransformer(0)).to.be.false;
+      expect(S.hasTransformer(true)).to.be.false;
+      expect(S.hasTransformer(false)).to.be.false;
+      expect(S.hasTransformer(null)).to.be.false;
+      expect(S.hasTransformer(undefined)).to.be.false;
+      expect(S.hasTransformer({})).to.be.false;
+      expect(S.hasTransformer([])).to.be.false;
+      expect(S.hasTransformer(() => undefined)).to.be.false;
+    });
+
+    it('returns true for an existing name', function () {
+      const S = new PropertyTransformerRegistry();
+      expect(S.hasTransformer('test')).to.be.false;
+      S.addTransformer('test', () => undefined);
+      expect(S.hasTransformer('test')).to.be.true;
+    });
+  });
+
+  describe('getTransformer', function () {
+    it('returns transformer by its name', function () {
+      const S = new PropertyTransformerRegistry();
+      const myTransformer1 = () => undefined;
+      const myTransformer2 = () => undefined;
+      S.addTransformer('foo', myTransformer1);
+      S.addTransformer('bar', myTransformer2);
+      const res1 = S.getTransformer('foo');
+      const res2 = S.getTransformer('bar');
+      expect(res1).to.be.eq(myTransformer1);
+      expect(res2).to.be.eq(myTransformer2);
+    });
+
+    it('throws an error for a not existed name', function () {
+      const S = new PropertyTransformerRegistry();
+      const throwable = v => () => S.getTransformer(v);
+      const error = v =>
+        format('The property transformer %s is not defined.', 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(null)).to.throw(error('null'));
+      expect(throwable(undefined)).to.throw(error('undefined'));
+      expect(throwable({})).to.throw(error('Object'));
+      expect(throwable([])).to.throw(error('Array'));
+      expect(throwable(() => undefined)).to.throw(error('Function'));
+    });
+  });
+});

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

@@ -0,0 +1,25 @@
+/**
+ * Property transformer context.
+ */
+export declare type PropertyTransformerContext = {
+  transformerName: string,
+  modelName: string,
+  propName: string,
+}
+
+/**
+ * Property transformer.
+ */
+export declare type PropertyTransformer = (
+  value: unknown,
+  options: unknown,
+  context: PropertyTransformerContext,
+) => boolean;
+
+/**
+ * Property transform options.
+ */
+export type PropertyTransformOptions =
+  | string
+  | string[]
+  | {[key: string]: unknown};

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

@@ -0,0 +1 @@
+export {};

package/src/definition/model/properties/property-validator/builtin/max-length-validator.js

@@ -9,7 +9,7 @@ import {InvalidArgumentError} from '../../../../../errors/index.js';
  * @returns {boolean}
  */
 export function maxLengthValidator(value, options, context) {
-  if (options === false) return true;
+  if (value == null || options === false) return true;
   if (typeof options !== 'number')
     throw new InvalidArgumentError(
       'The validator %v requires the "options" argument ' +

package/src/definition/model/properties/property-validator/builtin/max-length-validator.spec.js

@@ -4,10 +4,17 @@ import {maxLengthValidator} from './max-length-validator.js';
 
 describe('maxLengthValidator', function () {
   it('returns true if the "options" argument is false', function () {
-    const res = maxLengthValidator(undefined, false, {});
+    const res = maxLengthValidator('test', false, {});
     expect(res).to.be.true;
   });
 
+  it('returns true for undefined and null values', function () {
+    const res1 = maxLengthValidator(undefined, 10, {});
+    const res2 = maxLengthValidator(null, 10, {});
+    expect(res1).to.be.true;
+    expect(res2).to.be.true;
+  });
+
   it('requires the "value" argument as a String or an Array', function () {
     const throwable = v => () =>
       maxLengthValidator(v, 10, {
@@ -23,14 +30,14 @@ describe('maxLengthValidator', function () {
     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(() => undefined)).to.throw(error('Function'));
     throwable('str')();
     throwable('')();
     throwable([1, 2, 3])();
     throwable([])();
+    throwable(undefined)();
+    throwable(null)();
   });
 
   it('requires the "options" argument to be a number', function () {

package/src/definition/model/properties/property-validator/builtin/min-length-validator.js

@@ -9,7 +9,7 @@ import {InvalidArgumentError} from '../../../../../errors/index.js';
  * @returns {boolean}
  */
 export function minLengthValidator(value, options, context) {
-  if (options === false) return true;
+  if (value == null || options === false) return true;
   if (typeof options !== 'number')
     throw new InvalidArgumentError(
       'The validator %v requires the "options" argument ' +

package/src/definition/model/properties/property-validator/builtin/min-length-validator.spec.js

@@ -4,10 +4,17 @@ import {minLengthValidator} from './min-length-validator.js';
 
 describe('minLengthValidator', function () {
   it('returns true if the "options" argument is false', function () {
-    const res = minLengthValidator(undefined, false, {});
+    const res = minLengthValidator('test', false, {});
     expect(res).to.be.true;
   });
 
+  it('returns true for undefined and null values', function () {
+    const res1 = minLengthValidator(undefined, 10, {});
+    const res2 = minLengthValidator(null, 10, {});
+    expect(res1).to.be.true;
+    expect(res2).to.be.true;
+  });
+
   it('requires the "value" argument as a String or an Array', function () {
     const throwable = v => () =>
       minLengthValidator(v, 0, {
@@ -23,14 +30,14 @@ describe('minLengthValidator', function () {
     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(() => undefined)).to.throw(error('Function'));
     throwable('str')();
     throwable('')();
     throwable([1, 2, 3])();
     throwable([])();
+    throwable(undefined)();
+    throwable(null)();
   });
 
   it('requires the "options" argument to be a number', function () {

package/src/definition/model/properties/property-validator/builtin/regexp-validator.js

@@ -10,7 +10,7 @@ import {InvalidArgumentError} from '../../../../../errors/index.js';
  * @returns {boolean}
  */
 export function regexpValidator(value, options, context) {
-  if (options === false) return true;
+  if (value == null || options === false) return true;
   if (typeof options !== 'string' && !(options instanceof RegExp))
     throw new InvalidArgumentError(
       'The validator %v requires the "options" argument ' +

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

@@ -4,10 +4,17 @@ import {regexpValidator} from './regexp-validator.js';
 
 describe('regexpValidator', function () {
   it('returns true if the "options" argument is false', function () {
-    const res = regexpValidator(undefined, false, {});
+    const res = regexpValidator('test', false, {});
     expect(res).to.be.true;
   });
 
+  it('returns true for undefined and null values', function () {
+    const res1 = regexpValidator(undefined, '.*', {});
+    const res2 = regexpValidator(null, '.*', {});
+    expect(res1).to.be.true;
+    expect(res2).to.be.true;
+  });
+
   it('requires the "value" argument to be a string', function () {
     const throwable = v => () =>
       regexpValidator(v, '.*', {
@@ -21,13 +28,13 @@ describe('regexpValidator', function () {
       );
     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'));
     expect(throwable(() => undefined)).to.throw(error('Function'));
     throwable('str')();
     throwable('')();
+    throwable(undefined)();
+    throwable(null)();
   });
 
   it('requires the "options" argument to be a string or RegExp', function () {

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

@@ -1,20 +1,32 @@
 import {expect} from 'chai';
 import {format} from '@e22m4u/js-format';
+import {regexpValidator} from './builtin/index.js';
+import {maxLengthValidator} from './builtin/index.js';
+import {minLengthValidator} from './builtin/index.js';
 import {PropertyValidatorRegistry} from './property-validator-registry.js';
 
 describe('PropertyValidatorRegistry', function () {
+  it('has builtin validators', function () {
+    const S = new PropertyValidatorRegistry();
+    expect(S['_validators']).to.be.eql({
+      maxLength: maxLengthValidator,
+      minLength: minLengthValidator,
+      regexp: regexpValidator,
+    });
+  });
+
   describe('addValidator', function () {
     it('adds a given validator with the name', function () {
-      const s = new PropertyValidatorRegistry();
-      const myValidator = () => {};
-      const res = s.addValidator('myValidator', myValidator);
-      expect(res).to.be.eq(s);
-      expect(s['_validators']['myValidator']).to.be.eq(myValidator);
+      const S = new PropertyValidatorRegistry();
+      const myValidator = () => undefined;
+      const res = S.addValidator('myValidator', myValidator);
+      expect(res).to.be.eq(S);
+      expect(S['_validators']['myValidator']).to.be.eq(myValidator);
     });
 
     it('requires the given name to be a non-empty string', function () {
-      const s = new PropertyValidatorRegistry();
-      const throwable = v => () => s.addValidator(v, () => undefined);
+      const S = new PropertyValidatorRegistry();
+      const throwable = v => () => S.addValidator(v, () => undefined);
       const error = v =>
         format(
           'A name of the property validator must ' +
@@ -34,17 +46,17 @@ describe('PropertyValidatorRegistry', function () {
     });
 
     it('throws an error if the given name already exists', function () {
-      const s = new PropertyValidatorRegistry();
-      s.addValidator('test', () => undefined);
-      const throwable = () => s.addValidator('test', () => undefined);
+      const S = new PropertyValidatorRegistry();
+      S.addValidator('test', () => undefined);
+      const throwable = () => S.addValidator('test', () => undefined);
       expect(throwable).to.throw(
         'The property validator "test" is already defined.',
       );
     });
 
     it('requires the given validator to be a function', function () {
-      const s = new PropertyValidatorRegistry();
-      const throwable = v => () => s.addValidator('test', v);
+      const S = new PropertyValidatorRegistry();
+      const throwable = v => () => S.addValidator('test', v);
       const error = v =>
         format(
           'The property validator "test" must be a Function, but %s given.',
@@ -65,44 +77,44 @@ describe('PropertyValidatorRegistry', function () {
 
   describe('hasValidator', function () {
     it('returns false for a not existing name', function () {
-      const s = new PropertyValidatorRegistry();
-      expect(s.hasValidator('str')).to.be.false;
-      expect(s.hasValidator('')).to.be.false;
-      expect(s.hasValidator(10)).to.be.false;
-      expect(s.hasValidator(0)).to.be.false;
-      expect(s.hasValidator(true)).to.be.false;
-      expect(s.hasValidator(false)).to.be.false;
-      expect(s.hasValidator(null)).to.be.false;
-      expect(s.hasValidator(undefined)).to.be.false;
-      expect(s.hasValidator({})).to.be.false;
-      expect(s.hasValidator([])).to.be.false;
-      expect(s.hasValidator(() => undefined)).to.be.false;
+      const S = new PropertyValidatorRegistry();
+      expect(S.hasValidator('str')).to.be.false;
+      expect(S.hasValidator('')).to.be.false;
+      expect(S.hasValidator(10)).to.be.false;
+      expect(S.hasValidator(0)).to.be.false;
+      expect(S.hasValidator(true)).to.be.false;
+      expect(S.hasValidator(false)).to.be.false;
+      expect(S.hasValidator(null)).to.be.false;
+      expect(S.hasValidator(undefined)).to.be.false;
+      expect(S.hasValidator({})).to.be.false;
+      expect(S.hasValidator([])).to.be.false;
+      expect(S.hasValidator(() => undefined)).to.be.false;
     });
 
     it('returns true for an existing name', function () {
-      const s = new PropertyValidatorRegistry();
-      expect(s.hasValidator('test')).to.be.false;
-      s.addValidator('test', () => undefined);
-      expect(s.hasValidator('test')).to.be.true;
+      const S = new PropertyValidatorRegistry();
+      expect(S.hasValidator('test')).to.be.false;
+      S.addValidator('test', () => undefined);
+      expect(S.hasValidator('test')).to.be.true;
     });
   });
 
   describe('getValidator', function () {
     it('returns validator by its name', function () {
-      const s = new PropertyValidatorRegistry();
-      const validator1 = () => undefined;
-      const validator2 = () => undefined;
-      s.addValidator('foo', validator1);
-      s.addValidator('bar', validator2);
-      const res1 = s.getValidator('foo');
-      const res2 = s.getValidator('bar');
-      expect(res1).to.be.eq(validator1);
-      expect(res2).to.be.eq(validator2);
+      const S = new PropertyValidatorRegistry();
+      const myValidator1 = () => undefined;
+      const myValidator2 = () => undefined;
+      S.addValidator('foo', myValidator1);
+      S.addValidator('bar', myValidator2);
+      const res1 = S.getValidator('foo');
+      const res2 = S.getValidator('bar');
+      expect(res1).to.be.eq(myValidator1);
+      expect(res2).to.be.eq(myValidator2);
     });
 
     it('throws an error for a not existed name', function () {
-      const s = new PropertyValidatorRegistry();
-      const throwable = v => () => s.getValidator(v);
+      const S = new PropertyValidatorRegistry();
+      const throwable = v => () => S.getValidator(v);
       const error = v => format('The property validator %s is not defined.', v);
       expect(throwable('str')).to.throw(error('"str"'));
       expect(throwable('')).to.throw(error('""'));