@e22m4u/js-repository 0.0.41 → 0.1.0

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

@@ -18,6 +18,11 @@ class TestAdapter extends Adapter {
     return Promise.resolve({});
   }
 
+  // eslint-disable-next-line no-unused-vars
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+
   // eslint-disable-next-line no-unused-vars
   patch(modelName, modelData, where = undefined) {
     return Promise.resolve(1);
@@ -54,6 +59,14 @@ describe('DataSanitizingDecorator', function () {
     expect(V.sanitize).to.be.called.with.exactly('model', data);
   });
 
+  it('overrides the "replaceOrCreate" method and sanitizes a given data', async function () {
+    sandbox.on(V, 'sanitize');
+    const data = {};
+    await A.replaceOrCreate('model', data);
+    expect(V.sanitize).to.be.called.once;
+    expect(V.sanitize).to.be.called.with.exactly('model', data);
+  });
+
   it('overrides the "patch" method and sanitizes a given data', async function () {
     sandbox.on(V, 'sanitize');
     const data = {};

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

@@ -32,6 +32,12 @@ export class DataValidationDecorator extends Service {
       return replaceById.call(this, modelName, id, modelData, filter);
     };
 
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = function (modelName, modelData, filter) {
+      this.getService(ModelDataValidator).validate(modelName, modelData);
+      return replaceOrCreate.call(this, modelName, modelData, filter);
+    };
+
     const patch = adapter.patch;
     adapter.patch = function (modelName, modelData, where) {
       this.getService(ModelDataValidator).validate(modelName, modelData, true);

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
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+
   // eslint-disable-next-line no-unused-vars
   patch(modelName, modelData, where = undefined) {
     return Promise.resolve(1);
@@ -54,6 +59,14 @@ describe('DataValidationDecorator', function () {
     expect(V.validate).to.be.called.with.exactly('model', data);
   });
 
+  it('overrides the "replaceOrCreate" method and validates a given data', async function () {
+    sandbox.on(V, 'validate');
+    const data = {};
+    await A.replaceOrCreate('model', data);
+    expect(V.validate).to.be.called.once;
+    expect(V.validate).to.be.called.with.exactly('model', data);
+  });
+
   it('overrides the "patchById" method and validates a given data', async function () {
     sandbox.on(V, 'validate');
     const data = {};

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 replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = function (modelName, modelData, filter) {
+      modelData = setDefaults(modelName, modelData);
+      return replaceOrCreate.call(this, modelName, modelData, filter);
+    };
+
     const patch = adapter.patch;
     adapter.patch = function (modelName, modelData, where) {
       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
+  async replaceOrCreate(modelName, modelData, filter = undefined) {
+    return modelData;
+  }
+
   // eslint-disable-next-line no-unused-vars
   patch(modelName, modelData, where = undefined) {
     return Promise.resolve(modelData);
@@ -81,6 +86,17 @@ describe('DefaultValuesDecorator', function () {
     );
   });
 
+  it('overrides the "replaceOrCreate" method and sets default values to input data', async function () {
+    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+    const retval = await A.replaceOrCreate('model', INPUT_DATA);
+    expect(retval).to.be.eql({prop: 'value'});
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+      'model',
+      INPUT_DATA,
+    );
+  });
+
   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');

package/src/adapter/decorator/fields-filtering-decorator.js

@@ -45,6 +45,19 @@ export class FieldsFilteringDecorator extends Service {
       return result;
     };
 
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      let result = await replaceOrCreate.call(
+        this,
+        modelName,
+        modelData,
+        filter,
+      );
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+
     const patchById = adapter.patchById;
     adapter.patchById = async function (modelName, id, modelData, filter) {
       let result = await patchById.call(this, modelName, id, modelData, filter);

package/src/adapter/decorator/fields-filtering-decorator.spec.js

@@ -32,6 +32,11 @@ class TestAdapter extends Adapter {
     return MODEL_DATA;
   }
 
+  // eslint-disable-next-line no-unused-vars
+  async replaceOrCreate(modelName, modelData, filter = undefined) {
+    return MODEL_DATA;
+  }
+
   // eslint-disable-next-line no-unused-vars
   async patchById(modelName, id, modelData, filter = undefined) {
     return MODEL_DATA;
@@ -81,6 +86,18 @@ describe('FieldsFilteringDecorator', function () {
     );
   });
 
+  it('overrides the "replaceOrCreate" method and filtering output fields', async function () {
+    sandbox.on(T, 'filter');
+    const retval = await A.replaceOrCreate(MODEL_NAME, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.filter).to.be.called.once;
+    expect(T.filter).to.be.called.with.exactly(
+      MODEL_DATA,
+      MODEL_NAME,
+      FILTER.fields,
+    );
+  });
+
   it('overrides the "patchById" method and filtering output fields', async function () {
     sandbox.on(T, 'filter');
     const retval = await A.patchById(MODEL_NAME, 1, {}, FILTER);

package/src/adapter/decorator/inclusion-decorator.js

@@ -45,6 +45,19 @@ export class InclusionDecorator extends Service {
       return retvalData;
     };
 
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      const retvalData = await replaceOrCreate.call(
+        this,
+        modelName,
+        modelData,
+        filter,
+      );
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo([retvalData], modelName, filter.include);
+      return retvalData;
+    };
+
     const patchById = adapter.patchById;
     adapter.patchById = async function (modelName, id, modelData, filter) {
       const retvalData = await patchById.call(

package/src/adapter/decorator/inclusion-decorator.spec.js

@@ -30,6 +30,11 @@ class TestAdapter extends Adapter {
     return Object.assign({}, MODEL_DATA);
   }
 
+  // eslint-disable-next-line no-unused-vars
+  async replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Object.assign({}, MODEL_DATA);
+  }
+
   // eslint-disable-next-line no-unused-vars
   async patchById(modelName, id, modelData, filter = undefined) {
     return Object.assign({}, MODEL_DATA);
@@ -79,6 +84,18 @@ describe('InclusionDecorator', function () {
     expect(T.includeTo).to.be.called.once;
   });
 
+  it('overrides the "replaceOrCreate" method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.replaceOrCreate('model', {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.includeTo).to.be.called.once;
+  });
+
   it('overrides the "patchById" method and applies clause inclusion', async function () {
     sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
       expect(entities).to.be.eql([MODEL_DATA]);

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

@@ -73,7 +73,7 @@ export declare type BelongsToDefinition = {
  *   type: RelationType.BELONGS_TO,
  *   polymorphic: true,
  *   foreignKey: 'referenceId',
- *   discriminator: 'referenceType,
+ *   discriminator: 'referenceType',
  * }
  * ```
  */
@@ -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,23 +127,14 @@ 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,
  *   model: 'model',
  *   polymorphic: true,
  *   foreignKey: 'referenceId',
- *   discriminator: 'referenceType,
+ *   discriminator: 'referenceType',
  * }
  * ```
  */
@@ -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,23 +189,14 @@ 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,
  *   model: 'model',
  *   polymorphic: true,
  *   foreignKey: 'referenceId',
- *   discriminator: 'referenceType,
+ *   discriminator: 'referenceType',
  * }
  * ```
  */
@@ -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.js

@@ -94,8 +94,8 @@ export class RelationsDefinitionValidator extends Service {
    * {
    *   type: RelationType.BELONGS_TO,
    *   polymorphic: true,
-   *   foreignKey: 'referenceId',     // optional
-   *   discriminator: 'referenceType, // optional
+   *   foreignKey: 'referenceId',      // optional
+   *   discriminator: 'referenceType', // optional
    * }
    * ```
    *
@@ -193,7 +193,7 @@ export class RelationsDefinitionValidator extends Service {
    *   model: 'model',
    *   polymorphic: true,
    *   foreignKey: 'referenceId',
-   *   discriminator: 'referenceType,
+   *   discriminator: 'referenceType',
    * }
    * ```
    *
@@ -311,7 +311,7 @@ export class RelationsDefinitionValidator extends Service {
    *   model: 'model',
    *   polymorphic: true,
    *   foreignKey: 'referenceId',
-   *   discriminator: 'referenceType,
+   *   discriminator: 'referenceType',
    * }
    * ```
    *

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/repository/repository.js

@@ -103,12 +103,8 @@ export class Repository extends Service {
    * @returns {Promise<object>}
    */
   async replaceOrCreate(data, filter = undefined) {
-    const pkPropName = this.getService(
-      ModelDefinitionUtils,
-    ).getPrimaryKeyAsPropertyName(this.modelName);
-    const pkValue = data[pkPropName];
-    if (pkValue == null) return this.create(data, filter);
-    return this.replaceById(pkValue, data, filter);
+    const adapter = await this.getAdapter();
+    return adapter.replaceOrCreate(this.modelName, data, filter);
   }
 
   /**

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "entryPoints": ["src/index.d.ts"],
+  "out": "docs"
+}