@e22m4u/js-repository 0.1.5 → 0.1.7

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;
+  }
+}

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 () {