@e22m4u/js-repository 0.1.3 → 0.1.5

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

@@ -0,0 +1,3 @@
+export * from './regexp-validator.js';
+export * from './max-length-validator.js';
+export * from './min-length-validator.js';

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

@@ -0,0 +1,3 @@
+export * from './regexp-validator.js';
+export * from './max-length-validator.js';
+export * from './min-length-validator.js';

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

@@ -0,0 +1,6 @@
+import {PropertyValidator} from '../property-validator.js';
+
+/**
+ * Max length validator.
+ */
+export declare type maxLengthValidator = PropertyValidator;

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

@@ -0,0 +1,28 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * Max length validator.
+ *
+ * @param {*} value
+ * @param {number|boolean} options
+ * @param {object} context
+ * @returns {boolean}
+ */
+export function maxLengthValidator(value, options, context) {
+  if (options === false) return true;
+  if (typeof options !== 'number')
+    throw new InvalidArgumentError(
+      'The validator %v requires the "options" argument ' +
+        'as a Number, but %v given.',
+      context.validatorName,
+      options,
+    );
+  if (typeof value === 'string' || Array.isArray(value))
+    return value.length <= options;
+  throw new InvalidArgumentError(
+    'The property validator %v requires a String ' +
+      'or an Array value, but %v given.',
+    context.validatorName,
+    value,
+  );
+}

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

@@ -0,0 +1,93 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+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, {});
+    expect(res).to.be.true;
+  });
+
+  it('requires the "value" argument as a String or an Array', function () {
+    const throwable = v => () =>
+      maxLengthValidator(v, 10, {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The property validator "myValidator" requires a String ' +
+          'or an Array 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(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([])();
+  });
+
+  it('requires the "options" argument to be a number', function () {
+    const throwable = v => () =>
+      maxLengthValidator('test', v, {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The validator "myValidator" requires the "options" argument ' +
+          'as a Number, but %s given.',
+        v,
+      );
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(true)).to.throw(error('true'));
+    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(10)();
+    throwable(0)();
+    throwable(false)();
+  });
+
+  describe('a string value', function () {
+    it('returns false if the value length is greater than the max length option', function () {
+      const res = maxLengthValidator('1234', 3, {});
+      expect(res).to.be.false;
+    });
+
+    it('returns true if the value length is equal to the max length option', function () {
+      const res = maxLengthValidator('123', 3, {});
+      expect(res).to.be.true;
+    });
+
+    it('returns true if the value length is lower than the max length option', function () {
+      const res = maxLengthValidator('12', 3, {});
+      expect(res).to.be.true;
+    });
+  });
+
+  describe('an array value', function () {
+    it('returns false if the value length is greater than the max length option', function () {
+      const res = maxLengthValidator([1, 2, 3, 4], 3, {});
+      expect(res).to.be.false;
+    });
+
+    it('returns true if the value length is equal to the max length option', function () {
+      const res = maxLengthValidator([1, 2, 3], 3, {});
+      expect(res).to.be.true;
+    });
+
+    it('returns true if the value length is lower than the max length option', function () {
+      const res = maxLengthValidator([1, 2], 3, {});
+      expect(res).to.be.true;
+    });
+  });
+});

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

@@ -0,0 +1,6 @@
+import {PropertyValidator} from '../property-validator.js';
+
+/**
+ * Min length validator.
+ */
+export declare type minLengthValidator = PropertyValidator;

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

@@ -0,0 +1,28 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * Min length validator.
+ *
+ * @param {*} value
+ * @param {number|boolean} options
+ * @param {object} context
+ * @returns {boolean}
+ */
+export function minLengthValidator(value, options, context) {
+  if (options === false) return true;
+  if (typeof options !== 'number')
+    throw new InvalidArgumentError(
+      'The validator %v requires the "options" argument ' +
+        'as a Number, but %v given.',
+      context.validatorName,
+      options,
+    );
+  if (typeof value === 'string' || Array.isArray(value))
+    return value.length >= options;
+  throw new InvalidArgumentError(
+    'The property validator %v requires a String ' +
+      'or an Array value, but %v given.',
+    context.validatorName,
+    value,
+  );
+}

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

@@ -0,0 +1,93 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+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, {});
+    expect(res).to.be.true;
+  });
+
+  it('requires the "value" argument as a String or an Array', function () {
+    const throwable = v => () =>
+      minLengthValidator(v, 0, {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The property validator "myValidator" requires a String ' +
+          'or an Array 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(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([])();
+  });
+
+  it('requires the "options" argument to be a number', function () {
+    const throwable = v => () =>
+      minLengthValidator('test', v, {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The validator "myValidator" requires the "options" argument ' +
+          'as a Number, but %s given.',
+        v,
+      );
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(true)).to.throw(error('true'));
+    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(10)();
+    throwable(0)();
+    throwable(false)();
+  });
+
+  describe('a string value', function () {
+    it('returns false if the value length is lower than the min length option', function () {
+      const res = minLengthValidator('12', 3, {});
+      expect(res).to.be.false;
+    });
+
+    it('returns true if the value length is equal to the min length option', function () {
+      const res = minLengthValidator('123', 3, {});
+      expect(res).to.be.true;
+    });
+
+    it('returns true if the value length is greater than the min length option', function () {
+      const res = minLengthValidator('1234', 3, {});
+      expect(res).to.be.true;
+    });
+  });
+
+  describe('an array value', function () {
+    it('returns false if the value length is lower than the min length option', function () {
+      const res = minLengthValidator([1, 2], 3, {});
+      expect(res).to.be.false;
+    });
+
+    it('returns true if the value length is equal to the min length option', function () {
+      const res = minLengthValidator([1, 2, 3], 3, {});
+      expect(res).to.be.true;
+    });
+
+    it('returns true if the value length is greater than the min length option', function () {
+      const res = minLengthValidator([1, 2, 3, 4], 3, {});
+      expect(res).to.be.true;
+    });
+  });
+});

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

@@ -0,0 +1,6 @@
+import {PropertyValidator} from '../property-validator.js';
+
+/**
+ * Regexp validator.
+ */
+export declare type regexpValidator = PropertyValidator;

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

@@ -0,0 +1,30 @@
+import {stringToRegexp} from '../../../../../utils/index.js';
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * Regexp validator.
+ *
+ * @param {*} value
+ * @param {string|RegExp|boolean} options
+ * @param {object} context
+ * @returns {boolean}
+ */
+export function regexpValidator(value, options, context) {
+  if (options === false) return true;
+  if (typeof options !== 'string' && !(options instanceof RegExp))
+    throw new InvalidArgumentError(
+      'The validator %v requires the "options" argument ' +
+        'as a String or RegExp, but %v given.',
+      context.validatorName,
+      options,
+    );
+  if (typeof value === 'string') {
+    const regexp = stringToRegexp(options);
+    return regexp.test(value);
+  }
+  throw new InvalidArgumentError(
+    'The property validator %v requires ' + 'a String value, but %v given.',
+    context.validatorName,
+    value,
+  );
+}

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

@@ -0,0 +1,95 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {regexpValidator} from './regexp-validator.js';
+
+describe('regexpValidator', function () {
+  it('returns true if the "options" argument is false', function () {
+    const res = regexpValidator(undefined, false, {});
+    expect(res).to.be.true;
+  });
+
+  it('requires the "value" argument to be a string', function () {
+    const throwable = v => () =>
+      regexpValidator(v, '.*', {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The property validator "myValidator" requires ' +
+          'a String value, but %s given.',
+        v,
+      );
+    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('')();
+  });
+
+  it('requires the "options" argument to be a string or RegExp', function () {
+    const throwable = v => () =>
+      regexpValidator('test', v, {
+        validatorName: 'myValidator',
+      });
+    const error = v =>
+      format(
+        'The validator "myValidator" requires the "options" argument ' +
+          'as a String or RegExp, but %s given.',
+        v,
+      );
+    expect(throwable(true)).to.throw(error('true'));
+    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(false)();
+    throwable(new RegExp(''))();
+  });
+
+  describe('the given regexp as a String', function () {
+    it('returns false if the given regexp is not matched', function () {
+      const res1 = regexpValidator('foo', 'bar', {});
+      const res2 = regexpValidator('foo', '^\\d+', {});
+      const res3 = regexpValidator('foo', '^baz$', {});
+      expect(res1).to.be.false;
+      expect(res2).to.be.false;
+      expect(res3).to.be.false;
+    });
+
+    it('returns true if the given regexp is matched', function () {
+      const res1 = regexpValidator('foo', '^fo', {});
+      const res2 = regexpValidator('foo', '^foo$', {});
+      const res3 = regexpValidator('foo', '^\\w+$', {});
+      expect(res1).to.be.true;
+      expect(res2).to.be.true;
+      expect(res3).to.be.true;
+    });
+  });
+
+  describe('the given regexp as an instance of RegExp', function () {
+    it('returns false if the given regexp is not matched', function () {
+      const res1 = regexpValidator('foo', /bar/, {});
+      const res2 = regexpValidator('foo', /^\d+/, {});
+      const res3 = regexpValidator('foo', /^bar$/, {});
+      expect(res1).to.be.false;
+      expect(res2).to.be.false;
+      expect(res3).to.be.false;
+    });
+
+    it('returns true if the given regexp is matched', function () {
+      const res1 = regexpValidator('foo', /^fo/, {});
+      const res2 = regexpValidator('foo', /^foo$/, {});
+      const res3 = regexpValidator('foo', /^\w+$/, {});
+      expect(res1).to.be.true;
+      expect(res2).to.be.true;
+      expect(res3).to.be.true;
+    });
+  });
+});

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

@@ -1,4 +1,7 @@
 import {Service} from '@e22m4u/js-service';
+import {regexpValidator} from './builtin/index.js';
+import {maxLengthValidator} from './builtin/index.js';
+import {minLengthValidator} from './builtin/index.js';
 import {InvalidArgumentError} from '../../../../errors/index.js';
 
 /**
@@ -10,7 +13,11 @@ export class PropertyValidatorRegistry extends Service {
    *
    * @type {object}
    */
-  _validators = {};
+  _validators = {
+    maxLength: maxLengthValidator,
+    minLength: minLengthValidator,
+    regexp: regexpValidator,
+  };
 
   /**
    * Add validator.

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

@@ -9,7 +9,7 @@ describe('PropertyValidatorRegistry', function () {
       const myValidator = () => {};
       const res = s.addValidator('myValidator', myValidator);
       expect(res).to.be.eq(s);
-      expect(s['_validators']).to.be.eql({myValidator});
+      expect(s['_validators']['myValidator']).to.be.eq(myValidator);
     });
 
     it('requires the given name to be a non-empty string', function () {

package/src/schema.d.ts

@@ -3,7 +3,6 @@ import {ModelData} from './types.js';
 import {Service} from '@e22m4u/js-service';
 import {Repository} from './repository/index.js';
 import {ModelDefinition} from './definition/index.js';
-import {PropertyValidator} from './definition/index.js';
 import {DatasourceDefinition} from './definition/index.js';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME} from './definition/index.js';
 
@@ -35,12 +34,4 @@ export declare class Schema extends Service {
     IdType extends ModelId = ModelId,
     IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
   >(modelName: string): Repository<Data, IdType, IdName>;
-
-  /**
-   * Add property validator.
-   *
-   * @param name
-   * @param validator
-   */
-  addPropertyValidator(name: string, validator: PropertyValidator): this;
 }

package/src/schema.js

@@ -2,7 +2,6 @@ import {Service} from '@e22m4u/js-service';
 import {Repository} from './repository/index.js';
 import {DefinitionRegistry} from './definition/index.js';
 import {RepositoryRegistry} from './repository/index.js';
-import {PropertyValidatorRegistry} from './definition/index.js';
 
 /**
  * Schema.
@@ -39,16 +38,4 @@ export class Schema extends Service {
   getRepository(modelName) {
     return this.getService(RepositoryRegistry).getRepository(modelName);
   }
-
-  /**
-   * Add property validator.
-   *
-   * @param {string} name
-   * @param {Function} validator
-   * @returns {this}
-   */
-  addPropertyValidator(name, validator) {
-    this.getService(PropertyValidatorRegistry).addValidator(name, validator);
-    return this;
-  }
 }

package/src/schema.spec.ts

@@ -2,7 +2,6 @@ import {expect} from 'chai';
 import {Schema} from './schema.js';
 import {Repository} from './repository/index.js';
 import {DefinitionRegistry} from './definition/index.js';
-import {PropertyValidatorRegistry} from './definition/index.js';
 
 describe('Schema', function () {
   describe('defineDatasource', function () {
@@ -84,32 +83,4 @@ describe('Schema', function () {
       expect(res1).to.be.eq(res2);
     });
   });
-
-  describe('addPropertyValidator', function () {
-    it('returns this', function () {
-      const schema = new Schema();
-      const res = schema.addPropertyValidator('validator', () => true);
-      expect(res).to.be.eq(schema);
-    });
-
-    it('adds a new property validator', function () {
-      const schema = new Schema();
-      const validator = () => true;
-      schema.addPropertyValidator('validator', validator);
-      const res = schema.getService(PropertyValidatorRegistry)
-        .getValidator('validator');
-      expect(res).to.be.eq(validator);
-    });
-
-    it('throws an error for already existing validator name', function () {
-      const schema = new Schema();
-      const validator = () => true;
-      schema.addPropertyValidator('validator', validator);
-      const throwable =
-        () => schema.addPropertyValidator('validator', validator);
-      expect(throwable).to.throw(
-        'The property validator "validator" is already defined.',
-      );
-    });
-  });
 });