fix: replaceOrCreate method should check document existence before create

src/adapter/adapter.d.ts

@@ -52,6 +52,19 @@ export declare class Adapter extends Service {
     filter?: ItemFilterClause,
   ): Promise<ModelData>;
 
+  /**
+   * Replace or create.
+   *
+   * @param modelName
+   * @param modelData
+   * @param filter
+   */
+  replaceOrCreate(
+    modelName: string,
+    modelData: ModelData,
+    filter?: ItemFilterClause,
+  ): Promise<ModelData>;
+
   /**
    * Patch.
    *

src/adapter/adapter.js

@@ -78,6 +78,21 @@ export class Adapter extends Service {
     );
   }
 
+  /**
+   * Replace or create.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.replaceOrCreate is not implemented.',
+      this.constructor.name,
+    );
+  }
+
   /**
    * Patch.
    *

src/adapter/adapter.spec.js

@@ -86,6 +86,14 @@ describe('Adapter', function () {
     });
   });
 
+  describe('replaceOrCreate', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.replaceOrCreate();
+      expect(throwable).to.throw('Adapter.replaceOrCreate is not implemented.');
+    });
+  });
+
   describe('patchById', function () {
     it('throws the "Not implemented"', function () {
       const adapter = new Adapter();

src/adapter/builtin/memory-adapter.d.ts

@@ -52,6 +52,19 @@ export declare class MemoryAdapter extends Adapter {
     filter?: ItemFilterClause,
   ): Promise<ModelData>;
 
+  /**
+   * Replace or create.
+   *
+   * @param modelName
+   * @param modelData
+   * @param filter
+   */
+  replaceOrCreate(
+    modelName: string,
+    modelData: ModelData,
+    filter?: ItemFilterClause,
+  ): Promise<ModelData>;
+
   /**
    * Patch.
    *

src/adapter/builtin/memory-adapter.js

@@ -154,6 +154,36 @@ export class MemoryAdapter extends Adapter {
     ).convertColumnNamesToPropertyNames(modelName, tableData);
   }
 
+  /**
+   * Replace or create.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async replaceOrCreate(modelName, modelData, filter = undefined) {
+    const pkPropName =
+      this.getService(ModelDefinitionUtils).getPrimaryKeyAsPropertyName(
+        modelName,
+      );
+    let idValue = modelData[pkPropName];
+    if (idValue == null) idValue = this._genNextIdValue(modelName, pkPropName);
+
+    const table = this._getTableOrCreate(modelName);
+    modelData = cloneDeep(modelData);
+    modelData[pkPropName] = idValue;
+
+    const tableData = this.getService(
+      ModelDefinitionUtils,
+    ).convertPropertyNamesToColumnNames(modelName, modelData);
+    table.set(idValue, tableData);
+
+    return this.getService(
+      ModelDefinitionUtils,
+    ).convertColumnNamesToPropertyNames(modelName, tableData);
+  }
+
   /**
    * Patch.
    *

src/adapter/builtin/memory-adapter.spec.js

@@ -1133,6 +1133,658 @@ describe('MemoryAdapter', function () {
     });
   });
 
+  describe('replaceOrCreate', function () {
+    it('generates a new identifier when a value of a primary key has not provided', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {foo: 'string', bar: 10};
+      const created = await adapter.replaceOrCreate('model', input);
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
+    it('generates a new identifier when a value of a primary key is undefined', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: undefined,
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.replaceOrCreate('model', input);
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
+    it('generates a new identifier when a value of a primary key is null', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {
+        [DEF_PK]: null,
+        foo: 'string',
+        bar: 10,
+      };
+      const created = await adapter.replaceOrCreate('model', input);
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({...input, [DEF_PK]: idValue});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...input, [DEF_PK]: idValue});
+    });
+
+    it('generates a new identifier for a primary key of a "number" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.NUMBER,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const result1 = await adapter.replaceOrCreate('model', {});
+      const result2 = await adapter.replaceOrCreate('model', {});
+      const result3 = await adapter.replaceOrCreate('model', {});
+      expect(result1).to.be.eql({myId: 1});
+      expect(result2).to.be.eql({myId: 2});
+      expect(result3).to.be.eql({myId: 3});
+    });
+
+    it('generates a new identifier for a primary key of an "any" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.ANY,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const result1 = await adapter.replaceOrCreate('model', {});
+      const result2 = await adapter.replaceOrCreate('model', {});
+      const result3 = await adapter.replaceOrCreate('model', {});
+      expect(result1).to.be.eql({myId: 1});
+      expect(result2).to.be.eql({myId: 2});
+      expect(result3).to.be.eql({myId: 3});
+    });
+
+    it('throws an error when generating a new value for a primary key of a "string" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.STRING,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const promise = adapter.replaceOrCreate('model', {
+        foo: 'string',
+        bar: 10,
+      });
+      await expect(promise).to.be.rejectedWith(
+        'The memory adapter able to generate only Number identifiers, ' +
+          'but the primary key "myId" of the model "model" is defined as String. ' +
+          'Do provide your own value for the "myId" property, or change the type ' +
+          'in the primary key definition to a Number that will be ' +
+          'generated automatically.',
+      );
+    });
+
+    it('throws an error when generating a new value for a primary key of a "boolean" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.BOOLEAN,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const promise = adapter.replaceOrCreate('model', {
+        foo: 'string',
+        bar: 10,
+      });
+      await expect(promise).to.be.rejectedWith(
+        'The memory adapter able to generate only Number identifiers, ' +
+          'but the primary key "myId" of the model "model" is defined as Boolean. ' +
+          'Do provide your own value for the "myId" property, or change the type ' +
+          'in the primary key definition to a Number that will be ' +
+          'generated automatically.',
+      );
+    });
+
+    it('throws an error when generating a new value for a primary key of an "array" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.ARRAY,
+            itemType: DataType.NUMBER,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const promise = adapter.replaceOrCreate('model', {});
+      await expect(promise).to.be.rejectedWith(
+        'The memory adapter able to generate only Number identifiers, ' +
+          'but the primary key "myId" of the model "model" is defined as Array. ' +
+          'Do provide your own value for the "myId" property, or change the type ' +
+          'in the primary key definition to a Number that will be ' +
+          'generated automatically.',
+      );
+    });
+
+    it('throws an error when generating a new value for a primary key of an "object" type', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          myId: {
+            type: DataType.OBJECT,
+            primaryKey: true,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const promise = adapter.replaceOrCreate('model', {});
+      await expect(promise).to.be.rejectedWith(
+        'The memory adapter able to generate only Number identifiers, ' +
+          'but the primary key "myId" of the model "model" is defined as Object. ' +
+          'Do provide your own value for the "myId" property, or change the type ' +
+          'in the primary key definition to a Number that will be ' +
+          'generated automatically.',
+      );
+    });
+
+    it('allows to specify an identifier value for a new item', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const idValue = 5;
+      const input = {foo: 'string', bar: 10};
+      const created = await adapter.replaceOrCreate('model', {
+        [DEF_PK]: idValue,
+        ...input,
+      });
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...input});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...input});
+    });
+
+    it('sets default values if they are not provided for a new item', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 10,
+          },
+          bar: {
+            type: DataType.STRING,
+            default: 'string',
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 10, bar: 'string'};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...defaults});
+    });
+
+    it('sets default values for properties provided with an undefined value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 1,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            default: 2,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {foo: undefined});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 1, bar: 2};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...defaults});
+    });
+
+    it('sets default values for properties provided with a null value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 1,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            default: 2,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {foo: null});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 1, bar: 2};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...defaults});
+    });
+
+    it('uses a specified column name for a primary key', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            primaryKey: true,
+            columnName: 'bar',
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {});
+      expect(created).to.be.eql({foo: created.foo});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(created.foo);
+      expect(tableData).to.be.eql({bar: created.foo});
+    });
+
+    it('uses a specified column name for a regular property', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            columnName: 'bar',
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {foo: 10});
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({[DEF_PK]: idValue, foo: 10});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, bar: 10});
+    });
+
+    it('uses a specified column name for a regular property with a default value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            columnName: 'bar',
+            default: 10,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.replaceOrCreate('model', {});
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({[DEF_PK]: idValue, foo: 10});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, bar: 10});
+    });
+
+    it('uses a short form of a fields clause to filter a return value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {foo: 'string', bar: 10};
+      const filter = {fields: 'foo'};
+      const result = await adapter.replaceOrCreate('model', input, filter);
+      expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], foo: input.foo});
+    });
+
+    it('uses a full form of a fields clause to filter a return value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.STRING,
+          bar: DataType.NUMBER,
+          baz: DataType.BOOLEAN,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {foo: 'string', bar: 10, baz: true};
+      const filter = {fields: ['foo', 'bar']};
+      const result = await adapter.replaceOrCreate('model', input, filter);
+      expect(result).to.be.eql({
+        [DEF_PK]: result[DEF_PK],
+        foo: input.foo,
+        bar: input.bar,
+      });
+    });
+
+    it('a fields clause uses property names instead of column names', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.STRING,
+            columnName: 'fooCol',
+          },
+          bar: {
+            type: DataType.NUMBER,
+            columnName: 'barCol',
+          },
+          baz: {
+            type: DataType.BOOLEAN,
+            columnName: 'bazCol',
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {foo: 'string', bar: 10, baz: true};
+      const filter = {fields: ['foo', 'bar']};
+      const result = await adapter.replaceOrCreate('model', input, filter);
+      expect(result).to.be.eql({
+        [DEF_PK]: result[DEF_PK],
+        foo: input.foo,
+        bar: input.bar,
+      });
+    });
+
+    it('removes properties when replacing an item by a given identifier', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: DataType.NUMBER,
+          bar: DataType.NUMBER,
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const input = {foo: 1, bar: 2};
+      const created = await adapter.create('model', input);
+      const idValue = created[DEF_PK];
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...input});
+      const replacement = {[DEF_PK]: idValue, foo: 2};
+      const replaced = await adapter.replaceOrCreate('model', replacement);
+      expect(replaced).to.be.eql(replacement);
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql(replacement);
+    });
+
+    it('sets a default values for removed properties when replacing an item', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 1,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            default: 2,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.create('model', {});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 1, bar: 2};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const replacement = {[DEF_PK]: idValue, foo: 2};
+      const replaced = await adapter.replaceOrCreate('model', replacement);
+      expect(replaced).to.be.eql({...defaults, ...replacement});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({...defaults, ...replacement});
+    });
+
+    it('sets a default values for replaced properties with an undefined value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 1,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            default: 2,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.create('model', {});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 1, bar: 2};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const replaced = await adapter.replaceOrCreate('model', {
+        [DEF_PK]: idValue,
+        foo: undefined,
+      });
+      expect(replaced).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...defaults});
+    });
+
+    it('sets a default values for replaced properties with a null value', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({
+        name: 'memory',
+        adapter: 'memory',
+      });
+      schema.defineModel({
+        name: 'model',
+        datasource: 'memory',
+        properties: {
+          foo: {
+            type: DataType.NUMBER,
+            default: 1,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            default: 2,
+          },
+        },
+      });
+      const adapter = new MemoryAdapter(schema.container, {});
+      const created = await adapter.create('model', {});
+      const idValue = created[DEF_PK];
+      const defaults = {foo: 1, bar: 2};
+      expect(created).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const replaced = await adapter.replaceOrCreate('model', {
+        [DEF_PK]: idValue,
+        foo: null,
+      });
+      expect(replaced).to.be.eql({[DEF_PK]: idValue, ...defaults});
+      const table = adapter._getTableOrCreate('model');
+      const tableData = table.get(idValue);
+      expect(tableData).to.be.eql({[DEF_PK]: idValue, ...defaults});
+    });
+  });
+
   describe('patch', function () {
     it('updates only provided properties for all items and returns their number', async function () {
       const schema = new Schema();

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

@@ -35,6 +35,12 @@ export class DataSanitizingDecorator extends Service {
       return replaceById.call(this, modelName, id, modelData, filter);
     };
 
+    const replaceOrCreate = adapter.replaceOrCreate;
+    adapter.replaceOrCreate = async function (modelName, modelData, filter) {
+      modelData = sanitize(modelName, modelData);
+      return replaceOrCreate.call(this, modelName, modelData, filter);
+    };
+
     const patch = adapter.patch;
     adapter.patch = async function (modelName, modelData, where) {
       modelData = sanitize(modelName, modelData);

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 = {};

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);

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 = {};

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);

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');

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);

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);

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(

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]);

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);
   }
 
   /**