@e22m4u/js-repository 0.1.8 → 0.1.9

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/index.d.ts

@@ -2,5 +2,6 @@ export * from './data-type.js';
 export * from './property-definition.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

@@ -2,5 +2,6 @@ export * from './data-type.js';
 export * from './property-definition.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

@@ -297,5 +297,20 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
+    if (propDef.unique && typeof propDef.unique !== 'boolean')
+      throw new InvalidArgumentError(
+        'The provided option "unique" of the property %v in the model %v ' +
+          'should be a Boolean, but %v given.',
+        propName,
+        modelName,
+        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

@@ -250,6 +250,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 +278,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 +295,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 +319,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 +338,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 +489,45 @@ describe('PropertiesDefinitionValidator', function () {
       validate(['myTransformer'])();
       validate({myTransformer: true})();
     });
+
+    it('expects provided the option "unique" to be a boolean', 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 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'));
+      validate(true)();
+      validate(false)();
+    });
+
+    it('expects the primary key should not have the option "unique" to be true', 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(true)).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,131 @@
+import {Service} from '@e22m4u/js-service';
+import {isPureObject} from '../../../utils/index.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;
+    for (const propName of propNames) {
+      const propDef = propDefs[propName];
+      if (!propDef || typeof propDef === 'string' || !propDef.unique) continue;
+      const propValue = modelData[propName];
+      // 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,
+        );
+      }
+    }
+  }
+}