@e22m4u/js-repository 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Реализация репозитория для работы с базами данных",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",
@@ -39,13 +39,12 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@e22m4u/js-empty-values": "~0.3.2",
     "@e22m4u/js-format": "~0.3.2",
     "@e22m4u/js-service": "~0.5.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "~20.2.0",
-    "@commitlint/config-conventional": "~20.2.0",
+    "@commitlint/cli": "~20.3.0",
+    "@commitlint/config-conventional": "~20.3.0",
     "@e22m4u/js-spy": "~0.3.5",
     "@types/chai": "~5.2.3",
     "@types/chai-as-promised": "~8.0.2",

package/src/adapter/adapter.js

@@ -8,6 +8,7 @@ import {
   DefaultValuesDecorator,
   DataSanitizingDecorator,
   FieldsFilteringDecorator,
+  RequiredPropertyDecorator,
   PropertyUniquenessDecorator,
 } from './decorator/index.js';
 
@@ -58,6 +59,7 @@ export class Adapter extends Service {
     if (this.constructor !== Adapter) {
       this.getService(DataSanitizingDecorator).decorate(this);
       this.getService(DefaultValuesDecorator).decorate(this);
+      this.getService(RequiredPropertyDecorator).decorate(this);
       this.getService(PropertyUniquenessDecorator).decorate(this);
       this.getService(FieldsFilteringDecorator).decorate(this);
       this.getService(InclusionDecorator).decorate(this);

package/src/adapter/adapter.spec.js

@@ -9,13 +9,14 @@ import {
   DefaultValuesDecorator,
   DataSanitizingDecorator,
   FieldsFilteringDecorator,
+  RequiredPropertyDecorator,
   PropertyUniquenessDecorator,
 } from './decorator/index.js';
 
 const sandbox = createSandbox();
 
 describe('Adapter', function () {
-  it('exposes static property "kinds"', function () {
+  it('should expose the static property "kinds"', function () {
     const kinds = [...Service.kinds, ADAPTER_CLASS_NAME];
     expect(Adapter.kinds).to.be.eql(kinds);
     const MyAdapter = class extends Adapter {};
@@ -27,12 +28,12 @@ describe('Adapter', function () {
       sandbox.restore();
     });
 
-    it('inherits from the Service class', function () {
+    it('should extend the Service class', function () {
       const adapter = new Adapter();
       expect(adapter).to.be.instanceof(Service);
     });
 
-    it('sets given service container and settings', function () {
+    it('should set given service container and settings', function () {
       const container = new ServiceContainer();
       const settings = {};
       const adapter = new Adapter(container, settings);
@@ -40,47 +41,36 @@ describe('Adapter', function () {
       expect(adapter._settings).to.be.eq(settings);
     });
 
-    it('decorates only extended adapter', function () {
+    it('should decorate only when the instance inherits the Adapter class', function () {
+      const decCtors = [
+        DataSanitizingDecorator,
+        DefaultValuesDecorator,
+        RequiredPropertyDecorator,
+        PropertyUniquenessDecorator,
+        FieldsFilteringDecorator,
+        InclusionDecorator,
+      ];
       const dbs = new DatabaseSchema();
-      const dec1 = dbs.getService(DataSanitizingDecorator);
-      const dec2 = dbs.getService(DefaultValuesDecorator);
-      const dec3 = dbs.getService(PropertyUniquenessDecorator);
-      const dec4 = dbs.getService(FieldsFilteringDecorator);
-      const dec5 = dbs.getService(InclusionDecorator);
+      const decs = decCtors.map(ctor => dbs.getService(ctor));
       const order = [];
-      const decorate = function (ctx) {
-        expect(ctx).to.be.instanceof(Adapter);
+      const decorate = function (...args) {
+        expect(args[0]).to.be.instanceof(Adapter);
+        expect(args).to.have.length(1);
         order.push(this);
       };
-      sandbox.on(dec1, 'decorate', decorate);
-      sandbox.on(dec2, 'decorate', decorate);
-      sandbox.on(dec3, 'decorate', decorate);
-      sandbox.on(dec4, 'decorate', decorate);
-      sandbox.on(dec5, 'decorate', decorate);
+      decs.forEach(dec => sandbox.on(dec, 'decorate', decorate));
       new Adapter(dbs.container);
       expect(order).to.be.empty;
-      expect(dec1.decorate).to.be.not.called;
-      expect(dec2.decorate).to.be.not.called;
-      expect(dec3.decorate).to.be.not.called;
-      expect(dec4.decorate).to.be.not.called;
-      expect(dec5.decorate).to.be.not.called;
+      decs.forEach(dec => expect(dec.decorate).to.be.not.called);
       class ExtendedAdapter extends Adapter {}
       new ExtendedAdapter(dbs.container);
-      expect(order[0]).to.be.eql(dec1);
-      expect(order[1]).to.be.eql(dec2);
-      expect(order[2]).to.be.eql(dec3);
-      expect(order[3]).to.be.eql(dec4);
-      expect(order[4]).to.be.eql(dec5);
-      expect(dec1.decorate).to.be.called.once;
-      expect(dec2.decorate).to.be.called.once;
-      expect(dec3.decorate).to.be.called.once;
-      expect(dec4.decorate).to.be.called.once;
-      expect(dec5.decorate).to.be.called.once;
+      decs.forEach((dec, index) => expect(order[index]).to.be.eq(dec));
+      decs.forEach(dec => expect(dec.decorate).to.be.called.once);
     });
   });
 
   describe('create', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.create();
       expect(throwable).to.throw('Adapter.create is not implemented.');
@@ -88,7 +78,7 @@ describe('Adapter', function () {
   });
 
   describe('replaceById', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.replaceById();
       expect(throwable).to.throw('Adapter.replaceById is not implemented.');
@@ -96,15 +86,23 @@ describe('Adapter', function () {
   });
 
   describe('replaceOrCreate', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.replaceOrCreate();
       expect(throwable).to.throw('Adapter.replaceOrCreate is not implemented.');
     });
   });
 
+  describe('patch', function () {
+    it('should throw the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.patch();
+      expect(throwable).to.throw('Adapter.patch is not implemented.');
+    });
+  });
+
   describe('patchById', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.patchById();
       expect(throwable).to.throw('Adapter.patchById is not implemented.');
@@ -112,7 +110,7 @@ describe('Adapter', function () {
   });
 
   describe('find', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.find();
       expect(throwable).to.throw('Adapter.find is not implemented.');
@@ -120,7 +118,7 @@ describe('Adapter', function () {
   });
 
   describe('findById', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.findById();
       expect(throwable).to.throw('Adapter.findById is not implemented.');
@@ -128,7 +126,7 @@ describe('Adapter', function () {
   });
 
   describe('delete', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.delete();
       expect(throwable).to.throw('Adapter.delete is not implemented.');
@@ -136,7 +134,7 @@ describe('Adapter', function () {
   });
 
   describe('deleteById', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.deleteById();
       expect(throwable).to.throw('Adapter.deleteById is not implemented.');
@@ -144,7 +142,7 @@ describe('Adapter', function () {
   });
 
   describe('exists', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.exists();
       expect(throwable).to.throw('Adapter.exists is not implemented.');
@@ -152,7 +150,7 @@ describe('Adapter', function () {
   });
 
   describe('count', function () {
-    it('throws the "Not implemented"', function () {
+    it('should throw the "Not implemented"', function () {
       const adapter = new Adapter();
       const throwable = () => adapter.count();
       expect(throwable).to.throw('Adapter.count is not implemented.');

package/src/adapter/decorator/index.d.ts

@@ -2,4 +2,5 @@ export * from './inclusion-decorator.js';
 export * from './default-values-decorator.js';
 export * from './data-sanitizing-decorator.js';
 export * from './fields-filtering-decorator.js';
+export * from './required-property-decorator.js';
 export * from './property-uniqueness-decorator.js';

package/src/adapter/decorator/index.js

@@ -2,4 +2,5 @@ export * from './inclusion-decorator.js';
 export * from './default-values-decorator.js';
 export * from './data-sanitizing-decorator.js';
 export * from './fields-filtering-decorator.js';
+export * from './required-property-decorator.js';
 export * from './property-uniqueness-decorator.js';

package/src/adapter/decorator/required-property-decorator.d.ts

@@ -0,0 +1,14 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Required property decorator.
+ */
+export declare class RequiredPropertyDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter: Adapter): void;
+}

package/src/adapter/decorator/required-property-decorator.js

@@ -0,0 +1,54 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {RequiredPropertyValidator} from '../../definition/index.js';
+
+/**
+ * Required property decorator.
+ */
+export class RequiredPropertyDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'The first argument of RequiredPropertyDecorator.decorate should be ' +
+          'an Adapter instance, but %v was given.',
+        adapter,
+      );
+    const validator = this.getService(RequiredPropertyValidator);
+
+    const create = adapter.create;
+    adapter.create = async function (modelName, modelData, filter) {
+      validator.validate(modelName, modelData);
+      return create.call(this, modelName, modelData, filter);
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      validator.validate(modelName, modelData);
+      return replaceById.call(this, modelName, id, modelData, filter);
+    };
+
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      validator.validate(modelName, modelData);
+      return replaceOrCreate.call(this, modelName, modelData, filter);
+    };
+
+    const patch = adapter.patch;
+    adapter.patch = async function (modelName, modelData, where) {
+      validator.validate(modelName, modelData, true);
+      return patch.call(this, modelName, modelData, where);
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      validator.validate(modelName, modelData, true);
+      return patchById.call(this, modelName, id, modelData, filter);
+    };
+  }
+}

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

@@ -0,0 +1,105 @@
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {createSandbox} from '@e22m4u/js-spy';
+import {DatabaseSchema} from '../../database-schema.js';
+import {RequiredPropertyValidator} from '../../definition/index.js';
+
+const dbs = new DatabaseSchema();
+dbs.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 = dbs.getService(TestAdapter);
+const V = dbs.getService(RequiredPropertyValidator);
+const sandbox = createSandbox();
+
+describe('RequiredPropertyDecorator', 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', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    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', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    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', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.false;
+    });
+    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', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.true;
+    });
+    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', (modelName, modelData, isPartial = false) => {
+      expect(modelName).to.be.eq('model');
+      expect(modelData).to.be.eql(data);
+      expect(isPartial).to.be.true;
+    });
+    const res = await A.patchById('model', 1, data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+});

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

@@ -1,6 +1,5 @@
 import {Service} from '@e22m4u/js-service';
 import {DataType} from './properties/index.js';
-import {EmptyValuesService} from '@e22m4u/js-empty-values';
 import {InvalidArgumentError} from '../../errors/index.js';
 import {DefinitionRegistry} from '../definition-registry.js';
 import {cloneDeep, excludeObjectKeys} from '../../utils/index.js';
@@ -121,7 +120,7 @@ export class ModelDefinitionUtils extends Service {
   }
 
   /**
-   * Set default values for empty properties.
+   * Set default values to empty properties.
    *
    * @param {string} modelName
    * @param {object} modelData
@@ -139,16 +138,14 @@ export class ModelDefinitionUtils extends Service {
       ? Object.keys(modelData)
       : Object.keys(propDefs);
     const extendedData = cloneDeep(modelData);
-    const emptyValuesService = this.getService(EmptyValuesService);
     propNames.forEach(propName => {
       const propDef = propDefs[propName];
       const propValue = extendedData[propName];
-      const propType =
-        propDef != null
-          ? this.getDataTypeFromPropertyDefinition(propDef)
-          : DataType.ANY;
-      const isEmpty = emptyValuesService.isEmptyOf(propType, propValue);
-      if (!isEmpty) return;
+      // если значение свойства не является undefined и null,
+      // то свойство пропускается (остается исходное значение)
+      if (propValue != null) {
+        return;
+      }
       if (
         propDef &&
         typeof propDef === 'object' &&

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

@@ -4,7 +4,6 @@ import {createSandbox} from '@e22m4u/js-spy';
 import {DataType} from './properties/index.js';
 import {RelationType} from './relations/index.js';
 import {DatabaseSchema} from '../../database-schema.js';
-import {EmptyValuesService} from '@e22m4u/js-empty-values';
 import {InvalidArgumentError} from '../../errors/index.js';
 
 import {
@@ -480,7 +479,7 @@ describe('ModelDefinitionUtils', function () {
       expect(result).to.be.eql({foo: 'string'});
     });
 
-    it('sets a default value if a property has an empty value', function () {
+    it('sets a default value if a property value is undefined', function () {
       const dbs = new DatabaseSchema();
       dbs.defineModel({
         name: 'model',
@@ -491,12 +490,9 @@ describe('ModelDefinitionUtils', function () {
           },
         },
       });
-      dbs
-        .getService(EmptyValuesService)
-        .setEmptyValuesOf(DataType.STRING, ['empty']);
       const result = dbs
         .getService(ModelDefinitionUtils)
-        .setDefaultValuesToEmptyProperties('model', {foo: 'empty'});
+        .setDefaultValuesToEmptyProperties('model', {foo: undefined});
       expect(result).to.be.eql({foo: 'placeholder'});
     });
 

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

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

@@ -1,7 +1,5 @@
-import {DataType} from './data-type.js';
 import {Service} from '@e22m4u/js-service';
 import {isPlainObject} from '../../../utils/index.js';
-import {EmptyValuesService} from '@e22m4u/js-empty-values';
 import {PropertyUniqueness} from './property-uniqueness.js';
 import {InvalidArgumentError} from '../../../errors/index.js';
 import {ModelDefinitionUtils} from '../model-definition-utils.js';
@@ -70,7 +68,6 @@ export class PropertyUniquenessValidator extends Service {
         propValue,
       );
     let willBeReplaced = undefined;
-    const emptyValuesService = this.getService(EmptyValuesService);
     for (const propName of propNames) {
       const propDef = propDefs[propName];
       if (
@@ -81,12 +78,11 @@ export class PropertyUniquenessValidator extends Service {
       ) {
         continue;
       }
-      // sparse
+      // в режиме "sparse" проверка на уникальность
+      // должна игнорировать ложные значения
       const propValue = modelData[propName];
-      if (propDef.unique === PropertyUniqueness.SPARSE) {
-        const propType = propDef.type || DataType.ANY;
-        const isEmpty = emptyValuesService.isEmptyOf(propType, propValue);
-        if (isEmpty) continue;
+      if (propDef.unique === PropertyUniqueness.SPARSE && !propValue) {
+        continue;
       }
       // create
       if (methodName === 'create') {