@e22m4u/js-repository 0.1.8 → 0.1.10

package/src/adapter/decorator/property-uniqueness-decorator.spec.js

@@ -0,0 +1,135 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {PropertyUniquenessValidator} from '../../definition/index.js';
+
+const S = new Schema();
+S.defineModel({name: 'model'});
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  create(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patch(modelName, modelData, where = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patchById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+}
+
+const A = S.getService(TestAdapter);
+const V = S.getService(PropertyUniquenessValidator);
+const sandbox = chai.spy.sandbox();
+
+describe('PropertyUniquenessDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('create');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.create('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "replaceById" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('replaceById');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.eq(1);
+      },
+    );
+    const res = await A.replaceById('model', 1, data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "replaceOrCreate" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('replaceOrCreate');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.replaceOrCreate('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "patch" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('patch');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.patch('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "patchById" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('patchById');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.eq(1);
+      },
+    );
+    const res = await A.patchById('model', 1, data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+});

package/src/definition/definition-registry.spec.js

@@ -8,6 +8,7 @@ const sandbox = chai.spy.sandbox();
 
 describe('DefinitionRegistry', function () {
   let S;
+
   beforeEach(function () {
     S = new DefinitionRegistry();
   });

package/src/definition/model/properties/empty-values-definer.d.ts

@@ -0,0 +1,23 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Empty values definer.
+ */
+export class EmptyValuesDefiner extends Service {
+  /**
+   * Set empty values of.
+   *
+   * @param dataType
+   * @param emptyValues
+   */
+  setEmptyValuesOf(dataType: DataType, emptyValues: unknown[]): this;
+
+  /**
+   * Is empty.
+   *
+   * @param dataType
+   * @param value
+   */
+  isEmpty(dataType: DataType, value: unknown): boolean;
+}

package/src/definition/model/properties/empty-values-definer.js

@@ -0,0 +1,66 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+import {isDeepEqual} from '../../../utils/index.js';
+import {InvalidArgumentError} from '../../../errors/index.js';
+
+/**
+ * Empty values definer.
+ */
+export class EmptyValuesDefiner extends Service {
+  /**
+   * Empty values map.
+   *
+   * @type {Map<string, *[]>}
+   */
+  _emptyValuesMap = new Map([
+    [DataType.ANY, [undefined, null]],
+    [DataType.STRING, [undefined, null, '']],
+    [DataType.NUMBER, [undefined, null, 0]],
+    [DataType.BOOLEAN, [undefined, null]],
+    [DataType.ARRAY, [undefined, null, []]],
+    [DataType.OBJECT, [undefined, null, {}]],
+  ]);
+
+  /**
+   * Set empty values of data type.
+   *
+   * @param {string} dataType
+   * @param {*[]} emptyValues
+   * @returns {EmptyValuesDefiner}
+   */
+  setEmptyValuesOf(dataType, emptyValues) {
+    if (!Object.values(DataType).includes(dataType))
+      throw new InvalidArgumentError(
+        'The argument "dataType" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+          'must be one of data types: %l, but %v given.',
+        Object.values(DataType),
+        dataType,
+      );
+    if (!Array.isArray(emptyValues))
+      throw new InvalidArgumentError(
+        'The argument "emptyValues" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+          'must be an Array, but %v given.',
+        emptyValues,
+      );
+    this._emptyValuesMap.set(dataType, emptyValues);
+    return this;
+  }
+
+  /**
+   * Is empty.
+   *
+   * @param {string} dataType
+   * @param {*} value
+   * @returns {boolean}
+   */
+  isEmpty(dataType, value) {
+    if (!Object.values(DataType).includes(dataType))
+      throw new InvalidArgumentError(
+        'The argument "dataType" of the EmptyValuesDefiner.isEmpty ' +
+          'must be one of data types: %l, but %v given.',
+        Object.values(DataType),
+        dataType,
+      );
+    return this._emptyValuesMap.get(dataType).some(v => isDeepEqual(v, value));
+  }
+}

package/src/definition/model/properties/empty-values-definer.spec.js

@@ -0,0 +1,96 @@
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {Schema} from '../../../schema.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
+
+const getEmptyValues = (definer, dataType) => {
+  return definer['_emptyValuesMap'].get(dataType);
+};
+
+describe('EmptyValuesDefiner', function () {
+  describe('_emptyValuesMap', function () {
+    it('has default values', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(Array.from(S['_emptyValuesMap'])).to.be.eql([
+        [DataType.ANY, [undefined, null]],
+        [DataType.STRING, [undefined, null, '']],
+        [DataType.NUMBER, [undefined, null, 0]],
+        [DataType.BOOLEAN, [undefined, null]],
+        [DataType.ARRAY, [undefined, null, []]],
+        [DataType.OBJECT, [undefined, null, {}]],
+      ]);
+    });
+  });
+
+  describe('setEmptyValuesOf', function () {
+    it('requires the parameter "dataType" to be a DataType enum', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(v, []);
+      const error = v =>
+        format(
+          'The argument "dataType" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be one of data types: %l, but %s given.',
+          Object.values(DataType),
+          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(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(DataType.ANY)();
+    });
+
+    it('requires the parameter "emptyValues" to be an Array', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      const throwable = v => () => S.setEmptyValuesOf(DataType.ANY, v);
+      const error = v =>
+        format(
+          'The argument "emptyValues" of the EmptyValuesDefiner.setEmptyValuesOf ' +
+            'must be an Array, 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(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'));
+      throwable([])();
+      throwable([1, 2, 3])();
+    });
+
+    it('overrides default values of the given data type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      expect(getEmptyValues(S, DataType.ANY)).eql([undefined, null]);
+      S.setEmptyValuesOf(DataType.ANY, [1, 2, 3]);
+      expect(getEmptyValues(S, DataType.ANY)).eql([1, 2, 3]);
+    });
+  });
+
+  describe('isEmpty', function () {
+    it('returns true if the given value exists in the given type', function () {
+      const schema = new Schema();
+      const S = schema.getService(EmptyValuesDefiner);
+      S.setEmptyValuesOf(DataType.ANY, []);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.false;
+      S.setEmptyValuesOf(DataType.ANY, ['bar', 'foo']);
+      expect(S.isEmpty(DataType.ANY, 'foo')).to.be.true;
+    });
+  });
+});

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

@@ -1,6 +1,9 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
+export * from './property-uniqueness-validator.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -1,6 +1,9 @@
 export * from './data-type.js';
 export * from './property-definition.js';
+export * from './property-uniqueness.js';
+export * from './empty-values-definer.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
+export * from './property-uniqueness-validator.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -1,6 +1,7 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType as Type} from './data-type.js';
 import {capitalize} from '../../../utils/index.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertyTransformerRegistry} from './property-transformer/index.js';
@@ -297,5 +298,25 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
+    if (
+      propDef.unique &&
+      !Object.values(PropertyUniqueness).includes(propDef.unique)
+    ) {
+      throw new InvalidArgumentError(
+        'The provided option "unique" of the property %v in the model %v ' +
+          'should be one of values: %l, but %v given.',
+        propName,
+        modelName,
+        Object.values(PropertyUniqueness),
+        propDef.unique,
+      );
+    }
+    if (propDef.unique && propDef.primaryKey)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v is a primary key, ' +
+          'so it should not have the option "unique" to be provided.',
+        propName,
+        modelName,
+      );
   }
 }

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

@@ -2,6 +2,7 @@ import chai from 'chai';
 import {expect} from 'chai';
 import {DataType} from './data-type.js';
 import {format} from '@e22m4u/js-format';
+import {PropertyUniqueness} from './property-uniqueness.js';
 import {PropertyValidatorRegistry} from './property-validator/index.js';
 import {PropertyTransformerRegistry} from './property-transformer/index.js';
 import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
@@ -250,6 +251,7 @@ describe('PropertiesDefinitionValidator', function () {
             'should be a Boolean, but %s given.',
           v,
         );
+      expect(validate('str')).to.throw(error('"str"'));
       expect(validate(10)).to.throw(error('10'));
       expect(validate([])).to.throw(error('Array'));
       expect(validate({})).to.throw(error('Object'));
@@ -277,7 +279,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate([])).to.throw(error);
       expect(validate({})).to.throw(error);
       expect(validate(null)).to.throw(error);
-      validate(undefined);
+      validate(undefined)();
     });
 
     it('expects the primary key should not have the option "required" to be true', function () {
@@ -294,8 +296,8 @@ describe('PropertiesDefinitionValidator', function () {
           'so it should not have the option "required" to be provided.',
       );
       expect(validate(true)).to.throw(error);
-      validate(false);
-      validate(undefined);
+      validate(false)();
+      validate(undefined)();
     });
 
     it('expects the primary key should not have the option "default" to be provided', function () {
@@ -318,7 +320,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate([])).to.throw(error);
       expect(validate({})).to.throw(error);
       expect(validate(null)).to.throw(error);
-      validate(undefined);
+      validate(undefined)();
     });
 
     it('expects a non-array property should not have the option "itemType" to be provided', function () {
@@ -337,7 +339,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate(DataType.NUMBER)).to.throw(error);
       expect(validate(DataType.BOOLEAN)).to.throw(error);
       expect(validate(DataType.OBJECT)).to.throw(error);
-      validate(DataType.ARRAY);
+      validate(DataType.ARRAY)();
     });
 
     it('the option "model" requires the "object" property type', function () {
@@ -488,5 +490,48 @@ describe('PropertiesDefinitionValidator', function () {
       validate(['myTransformer'])();
       validate({myTransformer: true})();
     });
+
+    it('expects provided the option "unique" to be the PropertyUniqueness', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          unique: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "unique" of the property "foo" in the model "model" ' +
+            'should be one of values: %l, but %s given.',
+          Object.values(PropertyUniqueness),
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate(PropertyUniqueness.UNIQUE)();
+      validate(PropertyUniqueness.SPARSE)();
+      validate(PropertyUniqueness.NON_UNIQUE)();
+    });
+
+    it('expects the primary key should not have the option "unique"', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          primaryKey: true,
+          unique: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = format(
+        'The property "foo" of the model "model" is a primary key, ' +
+          'so it should not have the option "unique" to be provided.',
+      );
+      expect(validate(PropertyUniqueness.UNIQUE)).to.throw(error);
+      expect(validate(PropertyUniqueness.SPARSE)).to.throw(error);
+      validate(false)();
+      validate(undefined)();
+    });
   });
 });

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

@@ -1,5 +1,6 @@
 import {DataType} from './data-type.js';
 import {PropertyValidateOptions} from './property-validator/index.js';
+import {PropertyTransformOptions} from './property-transformer/index.js';
 
 /**
  * Full property definition.
@@ -14,6 +15,8 @@ export declare type FullPropertyDefinition = {
   required?: boolean;
   default?: unknown;
   validate?: PropertyValidateOptions;
+  transform?: PropertyTransformOptions;
+  unique?: boolean;
 };
 
 /**

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

@@ -0,0 +1,31 @@
+import {ModelId} from '../../../types.js';
+import {Service} from '@e22m4u/js-service';
+import {ModelData} from '../../../types.js';
+import {WhereClause} from '../../../filter/index.js';
+
+/**
+ * Count method.
+ */
+type CountMethod = (where: WhereClause) => Promise<number>;
+
+/**
+ * Property uniqueness validator.
+ */
+export declare class PropertyUniquenessValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param countMethod
+   * @param methodName
+   * @param modelName
+   * @param modelData
+   * @param modelId
+   */
+  validate(
+    countMethod: CountMethod,
+    methodName: string,
+    modelName: string,
+    modelData: ModelData,
+    modelId?: ModelId,
+  ): Promise<void>;
+}

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

@@ -0,0 +1,141 @@
+import {DataType} from './data-type.js';
+import {Service} from '@e22m4u/js-service';
+import {isPureObject} from '../../../utils/index.js';
+import {PropertyUniqueness} from './property-uniqueness.js';
+import {EmptyValuesDefiner} from './empty-values-definer.js';
+import {InvalidArgumentError} from '../../../errors/index.js';
+import {ModelDefinitionUtils} from '../model-definition-utils.js';
+
+/**
+ * Property uniqueness validator.
+ */
+export class PropertyUniquenessValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {Function} countMethod
+   * @param {string} methodName
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {*} modelId
+   * @returns {Promise<undefined>}
+   */
+  async validate(
+    countMethod,
+    methodName,
+    modelName,
+    modelData,
+    modelId = undefined,
+  ) {
+    if (typeof countMethod !== 'function')
+      throw new InvalidArgumentError(
+        'The parameter "countMethod" of the PropertyUniquenessValidator ' +
+          'must be a Function, but %v given.',
+        countMethod,
+      );
+    if (!methodName || typeof methodName !== 'string')
+      throw new InvalidArgumentError(
+        'The parameter "methodName" of the PropertyUniquenessValidator ' +
+          'must be a non-empty String, but %v given.',
+        methodName,
+      );
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'The parameter "modelName" of the PropertyUniquenessValidator ' +
+          'must be a non-empty String, but %v given.',
+        modelName,
+      );
+    if (!isPureObject(modelData))
+      throw new InvalidArgumentError(
+        'The data of the model %v should be an Object, but %v given.',
+        modelName,
+        modelData,
+      );
+    const propDefs =
+      this.getService(
+        ModelDefinitionUtils,
+      ).getPropertiesDefinitionInBaseModelHierarchy(modelName);
+    const isPartial = methodName === 'patch' || methodName === 'patchById';
+    const propNames = Object.keys(isPartial ? modelData : propDefs);
+    const idProp =
+      this.getService(ModelDefinitionUtils).getPrimaryKeyAsPropertyName(
+        modelName,
+      );
+    const createError = (propName, propValue) =>
+      new InvalidArgumentError(
+        'An existing document of the model %v already has ' +
+          'the property %v with the value %v and should be unique.',
+        modelName,
+        propName,
+        propValue,
+      );
+    let willBeReplaced = undefined;
+    const emptyValuesDefiner = this.getService(EmptyValuesDefiner);
+    for (const propName of propNames) {
+      const propDef = propDefs[propName];
+      if (!propDef || typeof propDef === 'string' || !propDef.unique) continue;
+      // sparse
+      const propValue = modelData[propName];
+      if (propDef.unique === PropertyUniqueness.SPARSE) {
+        const propType = propDef.type || DataType.ANY;
+        const isEmpty = emptyValuesDefiner.isEmpty(propType, propValue);
+        if (isEmpty) continue;
+      }
+      // create
+      if (methodName === 'create') {
+        const count = await countMethod({[propName]: propValue});
+        if (count > 0) throw createError(propName, propValue);
+      }
+      // replaceById
+      else if (methodName === 'replaceById') {
+        const count = await countMethod({
+          [idProp]: {neq: modelId},
+          [propName]: propValue,
+        });
+        if (count > 0) throw createError(propName, propValue);
+      }
+      // replaceOrCreate
+      else if (methodName === 'replaceOrCreate') {
+        const idFromData = modelData[idProp];
+        if (willBeReplaced == null && idFromData != null) {
+          const count = await countMethod({[idProp]: idFromData});
+          willBeReplaced = count > 0;
+        }
+        // replaceById by replaceOrCreate
+        if (willBeReplaced) {
+          const count = await countMethod({
+            [idProp]: {neq: idFromData},
+            [propName]: propValue,
+          });
+          if (count > 0) throw createError(propName, propValue);
+        }
+        // create by replaceOrCreate
+        else {
+          const count = await countMethod({[propName]: propValue});
+          if (count > 0) throw createError(propName, propValue);
+        }
+      }
+      // patch
+      else if (methodName === 'patch') {
+        const count = await countMethod({[propName]: propValue});
+        if (count > 0) throw createError(propName, propValue);
+      }
+      // patchById
+      else if (methodName === 'patchById') {
+        const count = await countMethod({
+          [idProp]: {neq: modelId},
+          [propName]: propValue,
+        });
+        if (count > 0) throw createError(propName, propValue);
+      }
+      // unsupported method
+      else {
+        throw new InvalidArgumentError(
+          'The PropertyUniquenessValidator does not ' +
+            'support the adapter method %v.',
+          methodName,
+        );
+      }
+    }
+  }
+}