@e22m4u/js-repository 0.0.40 → 0.0.42

package/src/adapter/decorator/data-validation-decorator.spec.js

@@ -18,6 +18,11 @@ class TestAdapter extends Adapter {
     return Promise.resolve({});
   }
 
+  // eslint-disable-next-line no-unused-vars
+  patch(modelName, modelData, where = undefined) {
+    return Promise.resolve(1);
+  }
+
   // eslint-disable-next-line no-unused-vars
   patchById(modelName, id, modelData, filter = undefined) {
     return Promise.resolve({});

package/src/adapter/decorator/default-values-decorator.js

@@ -36,6 +36,12 @@ export class DefaultValuesDecorator extends Service {
       return replaceById.call(this, modelName, id, modelData, filter);
     };
 
+    const patch = adapter.patch;
+    adapter.patch = function (modelName, modelData, where) {
+      modelData = setDefaults(modelName, modelData, true);
+      return patch.call(this, modelName, modelData, where);
+    };
+
     const patchById = adapter.patchById;
     adapter.patchById = function (modelName, id, modelData, filter) {
       modelData = setDefaults(modelName, modelData, true);

package/src/adapter/decorator/default-values-decorator.spec.js

@@ -29,6 +29,11 @@ class TestAdapter extends Adapter {
     return modelData;
   }
 
+  // eslint-disable-next-line no-unused-vars
+  patch(modelName, modelData, where = undefined) {
+    return Promise.resolve(modelData);
+  }
+
   // eslint-disable-next-line no-unused-vars
   async patchById(modelName, id, modelData, filter = undefined) {
     return modelData;
@@ -76,6 +81,47 @@ describe('DefaultValuesDecorator', function () {
     );
   });
 
+  describe('overrides the "patch" method and sets default values to input data', function () {
+    it('does not set default values to not existing properties of input data', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {};
+      const retval = await A.patch('model', data);
+      expect(retval).to.be.eql({});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+
+    it('does set default values to input properties of null', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {prop: null};
+      const retval = await A.patch('model', data);
+      expect(retval).to.be.eql({prop: 'value'});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+
+    it('does set default values to input properties of undefined', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {prop: undefined};
+      const retval = await A.patch('model', data);
+      expect(retval).to.be.eql({prop: 'value'});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+  });
+
   describe('overrides the "patchById" method and sets default values to input data', function () {
     it('does not set default values to not existing properties of input data', async function () {
       sandbox.on(U, 'setDefaultValuesToEmptyProperties');

package/src/definition/model/relations/relation-definition.d.ts

@@ -99,8 +99,8 @@ export declare type PolyBelongsToDefinition = {
 export declare type HasOneDefinition = {
   type: RelationType.HAS_ONE;
   model: string;
+  foreignKey: string;
   polymorphic?: false;
-  foreignKey?: string;
   discriminator?: undefined;
 };
 
@@ -127,16 +127,7 @@ export declare type PolyHasOneDefinitionWithTargetRelationName = {
 /**
  * The polymorphic "hasOne" relation with target relation keys.
  *
- * @example Required options only.
- * ```
- * {
- *   type: RelationType.HAS_ONE,
- *   model: 'model',
- *   polymorphic: true,
- * }
- * ```
- *
- * @example Verbose definition.
+ * @example
  * ```
  * {
  *   type: RelationType.HAS_ONE,
@@ -151,8 +142,8 @@ export declare type PolyHasOneDefinitionWithTargetKeys = {
   type: RelationType.HAS_ONE;
   model: string;
   polymorphic: true;
-  foreignKey?: string;
-  discriminator?: string;
+  foreignKey: string;
+  discriminator: string;
 };
 
 /**
@@ -170,8 +161,8 @@ export declare type PolyHasOneDefinitionWithTargetKeys = {
 export declare type HasManyDefinition = {
   type: RelationType.HAS_MANY;
   model: string;
+  foreignKey: string;
   polymorphic?: false;
-  foreignKey?: string;
   discriminator?: undefined;
 };
 
@@ -198,16 +189,7 @@ export declare type PolyHasManyDefinitionWithTargetRelationName = {
 /**
  * The polymorphic "hasMany" relation with target relation keys.
  *
- * @example Required options only.
- * ```
- * {
- *   type: RelationType.HAS_MANY,
- *   model: 'model',
- *   polymorphic: true,
- * }
- * ```
- *
- * @example Verbose definition.
+ * @example
  * ```
  * {
  *   type: RelationType.HAS_MANY,
@@ -222,8 +204,8 @@ export declare type PolyHasManyDefinitionWithTargetKeys = {
   type: RelationType.HAS_MANY;
   model: string;
   polymorphic: true;
-  foreignKey?: string;
-  discriminator?: string;
+  foreignKey: string;
+  discriminator: string;
 };
 
 /**

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

@@ -253,15 +253,15 @@ describe('RelationsDefinitionValidator', function () {
           const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
-              model: 'model',
-              foreignKey: v,
+              model: v,
+              foreignKey: 'modelId',
             };
             return () => S.validate('model', {foo});
           };
           const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
-                'so it requires the option "foreignKey" to be a non-empty String, ' +
+                'so it requires the option "model" to be a non-empty String, ' +
                 'but %s given.',
               v,
             );
@@ -273,22 +273,22 @@ describe('RelationsDefinitionValidator', function () {
           expect(validate([])).to.throw(error('Array'));
           expect(validate(undefined)).to.throw(error('undefined'));
           expect(validate(null)).to.throw(error('null'));
-          validate('modelId')();
+          validate('model')();
         });
 
-        it('requires the option "foreignKey" to be a string', function () {
+        it('requires the option "foreignKey" to be a non-empty string', function () {
           const validate = v => {
             const foo = {
               type: RelationType.HAS_ONE,
-              model: v,
-              foreignKey: 'modelId',
+              model: 'model',
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
           const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasOne", ' +
-                'so it requires the option "model" to be a non-empty String, ' +
+                'so it requires the option "foreignKey" to be a non-empty String, ' +
                 'but %s given.',
               v,
             );
@@ -300,7 +300,7 @@ describe('RelationsDefinitionValidator', function () {
           expect(validate([])).to.throw(error('Array'));
           expect(validate(undefined)).to.throw(error('undefined'));
           expect(validate(null)).to.throw(error('null'));
-          validate('model')();
+          validate('modelId')();
         });
 
         it('throws an error if the option "discriminator" is provided', function () {
@@ -479,15 +479,15 @@ describe('RelationsDefinitionValidator', function () {
           const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
-              model: 'model',
-              foreignKey: v,
+              model: v,
+              foreignKey: 'modelId',
             };
             return () => S.validate('model', {foo});
           };
           const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
-                'so it requires the option "foreignKey" to be a non-empty String, ' +
+                'so it requires the option "model" to be a non-empty String, ' +
                 'but %s given.',
               v,
             );
@@ -499,22 +499,22 @@ describe('RelationsDefinitionValidator', function () {
           expect(validate([])).to.throw(error('Array'));
           expect(validate(undefined)).to.throw(error('undefined'));
           expect(validate(null)).to.throw(error('null'));
-          validate('modelId')();
+          validate('model')();
         });
 
-        it('requires the option "foreignKey" to be a string', function () {
+        it('requires the option "foreignKey" to be a non-empty string', function () {
           const validate = v => {
             const foo = {
               type: RelationType.HAS_MANY,
-              model: v,
-              foreignKey: 'modelId',
+              model: 'model',
+              foreignKey: v,
             };
             return () => S.validate('model', {foo});
           };
           const error = v =>
             format(
               'The relation "foo" of the model "model" has the type "hasMany", ' +
-                'so it requires the option "model" to be a non-empty String, ' +
+                'so it requires the option "foreignKey" to be a non-empty String, ' +
                 'but %s given.',
               v,
             );
@@ -526,7 +526,7 @@ describe('RelationsDefinitionValidator', function () {
           expect(validate([])).to.throw(error('Array'));
           expect(validate(undefined)).to.throw(error('undefined'));
           expect(validate(null)).to.throw(error('null'));
-          validate('model')();
+          validate('modelId')();
         });
 
         it('throws an error if the option "discriminator" is provided', function () {

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

@@ -43,9 +43,9 @@ export declare type ItemFilterClause = Pick<FilterClause, 'fields' | 'include'>;
  * ```
  */
 export declare type WhereClause =
-  | AndClause
-  | OrClause
-  | PropertiesClause;
+  & AndClause
+  & OrClause
+  & PropertiesClause;
 
 /**
  * Properties clause.
@@ -67,7 +67,8 @@ export type PropertiesClause = {
     | boolean
     | RegExp
     | null
-    | undefined;
+    | undefined
+    | object;
 };
 
 /**

package/src/filter/where-clause-tool.js

@@ -127,8 +127,12 @@ export class WhereClauseTool extends Service {
    */
   _test(example, value) {
     // Test null.
-    if (example == null) {
-      return value == null;
+    if (example === null) {
+      return value === null;
+    }
+    // Test undefined.
+    if (example === undefined) {
+      return value === undefined;
     }
     // Test RegExp.
     // noinspection ALL

package/src/filter/where-clause-tool.spec.js

@@ -266,11 +266,16 @@ describe('WhereClauseTool', function () {
       expect(result[0]).to.be.eql(OBJECTS[2]);
     });
 
-    it('uses null to match an undefined and null value', function () {
+    it('does not use null to match an undefined value', function () {
       const result = S.filter(OBJECTS, {nickname: null});
-      expect(result).to.have.length(2);
+      expect(result).to.have.length(1);
       expect(result[0]).to.be.eql(OBJECTS[2]);
-      expect(result[1]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('does not use undefined to match a null value', function () {
+      const result = S.filter(OBJECTS, {nickname: undefined});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[3]);
     });
   });
 

package/src/repository/repository.d.ts

@@ -77,6 +77,17 @@ export declare class Repository<
     filter?: ItemFilterClause,
   ): Promise<FlatData>;
 
+  /**
+   * Patch.
+   *
+   * @param data
+   * @param where
+   */
+  patch(
+    data: PartialWithoutId<IdName, Data>,
+    where?: WhereClause,
+  ): Promise<number>;
+
   /**
    * Patch by id.
    *

package/src/repository/repository.js

@@ -111,6 +111,18 @@ export class Repository extends Service {
     return this.replaceById(pkValue, data, filter);
   }
 
+  /**
+   * Patch.
+   *
+   * @param {object} data
+   * @param {object|undefined} where
+   * @returns {Promise<number>}
+   */
+  async patch(data, where = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.patch(this.modelName, data, where);
+  }
+
   /**
    * Patch by id.
    *

package/src/repository/repository.spec.js

@@ -50,6 +50,32 @@ describe('Repository', function () {
     });
   });
 
+  describe('patch', function () {
+    it('patches all items', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'a1', bar: 'b1'});
+      await rep.create({foo: 'a2', bar: 'b2'});
+      await rep.create({foo: 'a3', bar: 'b3'});
+      const result = await rep.patch({foo: 'test'});
+      expect(result).to.be.eq(3);
+    });
+
+    it('patches found items by the "where" clause', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'a', bar: '1'});
+      await rep.create({foo: 'b', bar: '2'});
+      await rep.create({foo: 'c', bar: '2'});
+      const result = await rep.patch({foo: 'test'}, {bar: '2'});
+      expect(result).to.be.eq(2);
+    });
+  });
+
   describe('patchById', function () {
     it('patches an item by the given id', async function () {
       const schema = new Schema();