@e22m4u/js-repository 0.1.2 → 0.1.4

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

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

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

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

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

@@ -2,6 +2,7 @@ import {Service} from '@e22m4u/js-service';
 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 {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
 
 /**
@@ -203,5 +204,51 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
+    if (propDef.validate != null) {
+      const propertyValidatorRegistry = this.getService(
+        PropertyValidatorRegistry,
+      );
+      if (propDef.validate && typeof propDef.validate === 'string') {
+        if (!propertyValidatorRegistry.hasValidator(propDef.validate))
+          throw new InvalidArgumentError(
+            'The property validator %v is not found.',
+            propDef.validate,
+          );
+      } else if (Array.isArray(propDef.validate)) {
+        for (const validatorName of propDef.validate) {
+          if (typeof validatorName !== 'string')
+            throw new InvalidArgumentError(
+              'The provided option "validate" of the property %v in the model %v ' +
+                'has an Array value that should have a non-empty String, ' +
+                'but %v given.',
+              propName,
+              modelName,
+              validatorName,
+            );
+          if (!propertyValidatorRegistry.hasValidator(validatorName))
+            throw new InvalidArgumentError(
+              'The property validator %v is not found.',
+              validatorName,
+            );
+        }
+      } else if (typeof propDef.validate === 'object') {
+        for (const validatorName in propDef.validate) {
+          if (!propertyValidatorRegistry.hasValidator(validatorName))
+            throw new InvalidArgumentError(
+              'The property validator %v is not found.',
+              validatorName,
+            );
+        }
+      } else {
+        throw new InvalidArgumentError(
+          'The provided option "validate" 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.validate,
+        );
+      }
+    }
   }
 }

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

@@ -2,12 +2,15 @@ import chai from 'chai';
 import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
+import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
 import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
 
 const S = new PropertiesDefinitionValidator();
 const sandbox = chai.spy.sandbox();
 
+S.getService(PropertyValidatorRegistry).addValidator('myValidator', () => true);
+
 describe('PropertiesDefinitionValidator', function () {
   afterEach(function () {
     sandbox.restore();
@@ -386,5 +389,52 @@ describe('PropertiesDefinitionValidator', function () {
       expect(V.validate).to.have.been.called.once;
       expect(V.validate).to.have.been.called.with.exactly('model', propDefs);
     });
+
+    it('the option "validate" should have a non-empty String, an Array of String or an Object', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          validate: v,
+        };
+        S.validate('model', {foo});
+      };
+      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(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('myValidator')();
+      validate(['myValidator'])();
+      validate([])();
+      validate({myValidator: true})();
+      validate({})();
+      validate(null)();
+      validate(undefined)();
+    });
+
+    it('the option "validate" requires only existing validator names', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          validate: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = v => format('The property validator %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('myValidator')();
+      validate(['myValidator'])();
+      validate({myValidator: true})();
+    });
   });
 });

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

@@ -1,4 +1,5 @@
 import {DataType} from './data-type.js';
+import {PropertyValidateOptions} from './property-validator/index.js';
 
 /**
  * Full property definition.
@@ -12,6 +13,7 @@ export declare type FullPropertyDefinition = {
   columnType?: string;
   required?: boolean;
   default?: unknown;
+  validate?: PropertyValidateOptions;
 };
 
 /**

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

@@ -0,0 +1,2 @@
+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,2 @@
+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,65 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {maxLengthValidator} from './max-length-validator.js';
+
+describe('maxLengthValidator', function () {
+  it('returns true by the false value in options', function () {
+    const res = maxLengthValidator(undefined, false, {});
+    expect(res).to.be.true;
+  });
+
+  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'));
+  });
+
+  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,65 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {minLengthValidator} from './min-length-validator.js';
+
+describe('minLengthValidator', function () {
+  it('returns true by the false value in options', function () {
+    const res = minLengthValidator(undefined, false, {});
+    expect(res).to.be.true;
+  });
+
+  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'));
+  });
+
+  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/index.d.ts

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

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

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

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

@@ -0,0 +1,29 @@
+import {Service} from '@e22m4u/js-service';
+import {PropertyValidator} from './property-validator.js';
+
+/**
+ * Property validator registry.
+ */
+export declare class PropertyValidatorRegistry extends Service {
+  /**
+   * Add validator.
+   *
+   * @param name
+   * @param validator
+   */
+  addValidator(name: string, validator: PropertyValidator): this;
+
+  /**
+   * Has validator.
+   *
+   * @param name
+   */
+  hasValidator(name: string): boolean;
+
+  /**
+   * Get validator.
+   *
+   * @param name
+   */
+  getValidator(name: string): PropertyValidator;
+}

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

@@ -0,0 +1,74 @@
+import {Service} from '@e22m4u/js-service';
+import {maxLengthValidator} from './builtin/index.js';
+import {minLengthValidator} from './builtin/index.js';
+import {InvalidArgumentError} from '../../../../errors/index.js';
+
+/**
+ * Property validator registry.
+ */
+export class PropertyValidatorRegistry extends Service {
+  /**
+   * Validators.
+   *
+   * @type {object}
+   */
+  _validators = {
+    maxLength: maxLengthValidator,
+    minLength: minLengthValidator,
+  };
+
+  /**
+   * Add validator.
+   *
+   * @param {string} name
+   * @param {Function} validator
+   * @returns {PropertyValidatorRegistry}
+   */
+  addValidator(name, validator) {
+    if (!name || typeof name !== 'string')
+      throw new InvalidArgumentError(
+        'A name of the property validator must ' +
+          'be a non-empty String, but %v given.',
+        name,
+      );
+    if (name in this._validators)
+      throw new InvalidArgumentError(
+        'The property validator %v is already defined.',
+        name,
+      );
+    if (typeof validator !== 'function')
+      throw new InvalidArgumentError(
+        'The property validator %v must be a Function, but %v given.',
+        name,
+        validator,
+      );
+    this._validators[name] = validator;
+    return this;
+  }
+
+  /**
+   * Has validator.
+   *
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasValidator(name) {
+    return Boolean(this._validators[name]);
+  }
+
+  /**
+   * Get validator.
+   *
+   * @param {string} name
+   * @returns {Function}
+   */
+  getValidator(name) {
+    const validator = this._validators[name];
+    if (!validator)
+      throw new InvalidArgumentError(
+        'The property validator %v is not defined.',
+        name,
+      );
+    return validator;
+  }
+}

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

@@ -0,0 +1,120 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {PropertyValidatorRegistry} from './property-validator-registry.js';
+
+describe('PropertyValidatorRegistry', function () {
+  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);
+    });
+
+    it('requires the given name to be a non-empty string', function () {
+      const s = new PropertyValidatorRegistry();
+      const throwable = v => () => s.addValidator(v, () => undefined);
+      const error = v =>
+        format(
+          'A name of the property validator 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 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 error = v =>
+        format(
+          'The property validator "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('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;
+    });
+
+    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;
+    });
+  });
+
+  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);
+    });
+
+    it('throws an error for a not existed name', function () {
+      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('""'));
+      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-validator/property-validator.d.ts

@@ -0,0 +1,30 @@
+import {ServiceContainer} from '@e22m4u/js-service';
+import {FullPropertyDefinition} from '../property-definition.js';
+
+/**
+ * Property validator context.
+ */
+export type PropertyValidatorContext = {
+  validatorName: string,
+  modelName: string,
+  propName: string,
+  propDef: FullPropertyDefinition,
+  container: ServiceContainer,
+}
+
+/**
+ * Property validator.
+ */
+export type PropertyValidator = (
+  value: unknown,
+  options: unknown,
+  context: PropertyValidatorContext,
+) => Promise<boolean> | boolean;
+
+/**
+ * Property validate options.
+ */
+export type PropertyValidateOptions =
+  | string
+  | string[]
+  | {[key: string]: unknown};

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

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

package/src/schema.spec.ts

@@ -5,6 +5,15 @@ import {DefinitionRegistry} from './definition/index.js';
 
 describe('Schema', function () {
   describe('defineDatasource', function () {
+    it('returns this', function () {
+      const schema = new Schema();
+      const res = schema.defineDatasource({
+        name: 'datasource',
+        adapter: 'memory',
+      });
+      expect(res).to.be.eq(schema);
+    });
+
     it('sets the datasource definition', function () {
       const schema = new Schema();
       schema.defineDatasource({name: 'datasource', adapter: 'memory'});
@@ -25,6 +34,12 @@ describe('Schema', function () {
   });
 
   describe('defineModel', function () {
+    it('returns this', function () {
+      const schema = new Schema();
+      const res = schema.defineModel({name: 'model'});
+      expect(res).to.be.eq(schema);
+    });
+
     it('sets the model definition', function () {
       const schema = new Schema();
       schema.defineModel({name: 'model'});