@e22m4u/js-repository 0.1.1 → 0.1.3

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

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

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,3 +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-definition.js

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

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/definition/model/relations/index.js

@@ -1,2 +1,3 @@
 export * from './relation-type.js';
+export * from './relation-definition.js';
 export * from './relations-definition-validator.js';

package/src/definition/model/relations/relation-definition.js

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

package/src/filter/filter-clause.d.ts

@@ -43,8 +43,8 @@ export declare type ItemFilterClause = Pick<FilterClause, 'fields' | 'include'>;
  * ```
  */
 export declare type WhereClause =
-  & AndClause
-  & OrClause
+  & Partial<AndClause>
+  & Partial<OrClause>
   & PropertiesClause;
 
 /**
@@ -124,7 +124,7 @@ export declare type OperatorClause = {
  * ```
  */
 export interface AndClause {
-  and?: WhereClause[];
+  and: WhereClause[];
 }
 
 /**
@@ -138,7 +138,7 @@ export interface AndClause {
  * ```
  */
 export interface OrClause {
-  or?: WhereClause[];
+  or: WhereClause[];
 }
 
 /**

package/src/index.d.ts

@@ -1,8 +1,8 @@
 export * from './types.js';
 export * from './schema.js';
 export * from './utils/index.js';
-export * from './filter/index.js';
 export * from './errors/index.js';
+export * from './filter/index.js';
 export * from './adapter/index.js';
 export * from './relations/index.js';
 export * from './definition/index.js';

package/src/index.js

@@ -1,3 +1,4 @@
+export * from './types.js';
 export * from './schema.js';
 export * from './utils/index.js';
 export * from './errors/index.js';

package/src/repository/repository.d.ts

@@ -14,11 +14,17 @@ import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME} from '../definition/index.js';
  * Repository.
  */
 export declare class Repository<
-  Data extends ModelData = ModelData,
+  Data extends object = ModelData,
   IdType extends ModelId = ModelId,
   IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
   FlatData extends ModelData = Flatten<Data>,
 > extends Service {
+  // it fixes unused generic bug
+  private _Data?: Data;
+  private _IdType?: IdType;
+  private _IdName?: IdName;
+  private _FlatData?: FlatData;
+
   /**
    * Model name.
    */
@@ -162,7 +168,7 @@ type WithoutId<IdName extends string, Data extends ModelData> = Flatten<
 /**
  * Makes fields as optional and remove id field.
  */
-type PartialWithoutId<IdName extends string, Data extends ModelData> = Flatten<
+type PartialWithoutId<IdName extends string, Data extends object> = Flatten<
   Partial<Omit<Data, IdName>>
 >;
 
@@ -171,5 +177,5 @@ type PartialWithoutId<IdName extends string, Data extends ModelData> = Flatten<
  */
 type OptionalUnlessRequiredId<
   IdName extends string,
-  Data extends ModelData,
+  Data extends object,
 > = Flatten<Data extends {[K in IdName]: any} ? PartialBy<Data, IdName> : Data>;

package/src/repository/repository.js

@@ -3,7 +3,6 @@ import {Adapter} from '../adapter/index.js';
 import {AdapterRegistry} from '../adapter/index.js';
 import {InvalidArgumentError} from '../errors/index.js';
 import {DefinitionRegistry} from '../definition/index.js';
-import {ModelDefinitionUtils} from '../definition/index.js';
 
 /**
  * Repository.

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';
 
@@ -30,8 +31,16 @@ export declare class Schema extends Service {
    * @param modelName
    */
   getRepository<
-    Data extends ModelData = ModelData,
+    Data extends object = ModelData,
     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;
+  }
 }