159: API V2: Properly define and support multi-resources patches/operations (#107)

159: API V2: Properly define and support multi-resources patches/operations

- Add the possibility to specify Json Patches via a list of "Model
Patch" objects, referencing a modelUri and a Patch. This allows edition
of multi-resource models, with one Json Patch per resource.
- Update parameter name for consistency with modified type

Additional minor fixes:

- Fix a minor warning in the integration tests
- Support the optional "format" attribute in the client V2
implementation

Contributed on behalf of STMicroelectronics.

refs eclipse-emfcloud/emfcloud-modelserver#159

Signed-off-by: Camille Letavernier <cletavernier@eclipsesource.com>

Author: CamilleLetavernier

packages/modelserver-client/src/model-server-client-api-v2.ts

@@ -53,6 +53,16 @@ export interface SubscriptionOptionsV2 extends SubscriptionOptions {
     paths?: string;
 }
 
+/**
+ * A union type that represents all Patches or Commands supported by the model server:
+ * - Operation
+ * - Operation[] (Json Patch)
+ * - ModelPatch
+ * - ModelPatch[]
+ * - ModelServerCommand
+ */
+export type PatchOrCommand = Operation | Operation[] | ModelPatch | ModelPatch[] | ModelServerCommand;
+
 /**
  * Basic client API to interact with a model server that conforms to the Modelserver API Version 2.
  */
@@ -113,8 +123,7 @@ export interface ModelServerClientApiV2 {
 
     ping(): Promise<boolean>;
 
-    edit(modeluri: string, patch: Operation | Operation[], format?: Format): Promise<ModelUpdateResult>;
-    edit(modeluri: string, command: ModelServerCommand, format?: Format): Promise<ModelUpdateResult>;
+    edit(modeluri: string, patchOrCommand: PatchOrCommand, format?: Format): Promise<ModelUpdateResult>;
 
     undo(modeluri: string): Promise<ModelUpdateResult>;
 

packages/modelserver-client/src/model-server-client-v2-integration.spec.ts

@@ -32,7 +32,7 @@ describe('Integration tests for ModelServerClientV2', () => {
     let client: ModelServerClientV2;
     const baseUrl = `http://localhost:8081${ModelServerClientApiV2.API_ENDPOINT}`;
 
-    const testUndoRedo: (modeluri: string, originalModel: any, patchedModel: any) => void = async (
+    const testUndoRedo: (modeluri: string, originalModel: any, patchedModel: any) => Promise<void> = async (
         modeluri,
         originalModel,
         patchedModel
@@ -387,5 +387,41 @@ describe('Integration tests for ModelServerClientV2', () => {
 
             await testUndoRedo(modeluri, machine, updatedMachineFirstPatch);
         });
+
+        it('test model patches', async () => {
+            const modeluri = 'SuperBrewer3000.coffee';
+            const newName = 'Super Brewer 6000';
+            const machine = await client.get(modeluri, ModelServerObjectV2.is);
+
+            const patchedMachine = deepClone(machine);
+
+            // Directly change the model
+            patchedMachine.name = newName;
+            patchedMachine.children[1].processor.clockSpeed = 6;
+
+            // Generate patch by diffing the original model and the patched one
+            const patch = jsonpatch.compare(machine, patchedMachine);
+            const modelPatch = {
+                modelUri: modeluri,
+                patch
+            };
+
+            const result = await client.edit(modeluri, modelPatch);
+            expect(result.success).to.be.true;
+
+            expect(result.patch).to.not.be.undefined;
+            expect(result.allPatches).to.not.be.undefined;
+            expect(result.allPatches).to.be.an('array').of.length(1);
+
+            // Patch the main resource
+            const updatedMachineMainPatch = result.patchModel!(machine, true);
+            expect(patchedMachine).to.deep.equal(updatedMachineMainPatch);
+
+            // Patch the first resource
+            const updatedMachineFirstPatch = result.patchModel!(machine, true, result.allPatches![0].modelUri);
+            expect(patchedMachine).to.deep.equal(updatedMachineFirstPatch);
+
+            await testUndoRedo(modeluri, machine, updatedMachineFirstPatch);
+        });
     });
 });

packages/modelserver-client/src/model-server-client-v2.ts

@@ -9,13 +9,13 @@
  * SPDX-License-Identifier: EPL-2.0 OR MIT
  *******************************************************************************/
 import axios, { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { deepClone, Operation } from 'fast-json-patch';
+import { deepClone } from 'fast-json-patch';
 import WebSocket from 'isomorphic-ws';
 
 import { ModelServerCommand } from './model/command-model';
 import { Diagnostic } from './model/diagnostic';
 import { ModelServerError, ServerConfiguration, SubscriptionOptions } from './model-server-client-api-v1';
-import { Format, FORMAT_JSON_V2, ModelServerClientApiV2, ModelUpdateResult } from './model-server-client-api-v2';
+import { Format, FORMAT_JSON_V2, ModelServerClientApiV2, ModelUpdateResult, PatchOrCommand } from './model-server-client-api-v2';
 import { MessageDataMapper, Model, ModelServerMessage } from './model-server-message';
 import { ModelServerPaths } from './model-server-paths';
 import { SubscriptionListener } from './subscription-listener';
@@ -212,17 +212,15 @@ export class ModelServerClientV2 implements ModelServerClientApiV2 {
         return this.process(this.restClient.get(ModelServerPaths.SERVER_PING), MessageDataMapper.isSuccess);
     }
 
-    edit(modeluri: string, patch: Operation): Promise<ModelUpdateResult>;
-    edit(modeluri: string, patch: Operation[]): Promise<ModelUpdateResult>;
-    edit(modeluri: string, command: ModelServerCommand): Promise<ModelUpdateResult>;
-    edit(modeluri: string, patchOrCommand: Operation | Operation[] | ModelServerCommand): Promise<ModelUpdateResult> {
+    edit(modeluri: string, patchOrCommand: PatchOrCommand, format = this.defaultFormat): Promise<ModelUpdateResult> {
         let patchMessage: any;
         if (patchOrCommand instanceof ModelServerCommand) {
             patchMessage = {
                 type: 'modelserver.emfcommand',
                 data: patchOrCommand
             };
         } else {
+            // Operation[] and ModelPatch[] are treated in the same way; we don't need to distinguish both cases
             const fullPatch = Array.isArray(patchOrCommand) ? patchOrCommand : [patchOrCommand];
             patchMessage = {
                 type: 'modelserver.patch',
@@ -238,8 +236,8 @@ export class ModelServerClientV2 implements ModelServerClientApiV2 {
             }
         }
         return this.process(
-            this.restClient.patch(ModelServerPaths.MODEL_CRUD, encodeRequestBody(this.defaultFormat)(patchMessage), {
-                params: { modeluri, format: this.defaultFormat }
+            this.restClient.patch(ModelServerPaths.MODEL_CRUD, encodeRequestBody(format)(patchMessage), {
+                params: { modeluri, format: format }
             }),
             MessageDataMapper.patchModel
         );

packages/modelserver-theia/src/node/theia-model-server-client-v2.ts

@@ -11,17 +11,17 @@
 import {
     AddCommand,
     CompoundCommand,
+    Format,
     ModelServerClientV2,
     ModelServerCommand,
     ModelUpdateResult,
-    Operations,
+    PatchOrCommand,
     RemoveCommand,
     SetCommand,
     SubscriptionListener,
     SubscriptionOptionsV2
 } from '@eclipse-emfcloud/modelserver-client';
 import { decorate, inject, injectable, optional } from '@theia/core/shared/inversify';
-import { Operation } from 'fast-json-patch';
 import { CancellationToken } from 'vscode-jsonrpc';
 
 import { ModelServerFrontendClient, TheiaModelServerClientV2 } from '../common';
@@ -88,14 +88,11 @@ export class TheiaBackendModelServerClientV2 extends ModelServerClientV2 impleme
         this.subscribe(modeluri, undefined, options);
     }
 
-    edit(modeluri: string, patchOrCommand: Operation | Operation[] | ModelServerCommand): Promise<ModelUpdateResult> {
+    edit(modeluri: string, patchOrCommand: PatchOrCommand, format?: Format): Promise<ModelUpdateResult> {
         if (ModelServerCommand.is(patchOrCommand)) {
             return super.edit(modeluri, ensureCommandPrototype(patchOrCommand));
         }
-        if (Operations.isOperation(patchOrCommand)) {
-            return super.edit(modeluri, patchOrCommand);
-        }
-        return super.edit(modeluri, patchOrCommand);
+        return super.edit(modeluri, patchOrCommand, format);
     }
 }