@e22m4u/js-repository 0.1.2 → 0.1.3

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/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,69 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../../../errors/index.js';
+
+/**
+ * Property validator registry.
+ */
+export class PropertyValidatorRegistry extends Service {
+  /**
+   * Validators.
+   *
+   * @type {object}
+   */
+  _validators = {};
+
+  /**
+   * 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']).to.be.eql({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.d.ts

@@ -3,6 +3,7 @@ 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';
 
@@ -34,4 +35,12 @@ 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,6 +2,7 @@ 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.
@@ -38,4 +39,16 @@ 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,9 +2,19 @@ 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 () {
+    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 +35,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'});
@@ -68,4 +84,32 @@ 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.',
+      );
+    });
+  });
 });