Fixed upsert method and added tests

lib/modules/asset/AssetService.ts

@@ -135,60 +135,36 @@ export class AssetService extends BaseService {
     });
   }
 
-  /**
-   * Update or Create an asset metadata
-   */
   /**
    * Update or Create an asset metadata
    */
   public async upsert(
     engineId: string,
     assetId: string,
+    model: string,
+    reference: string,
     metadata: Metadata,
     request: KuzzleRequest
   ): Promise<KDocument<AssetContent>> {
     return lock(`asset:${engineId}:${assetId}`, async () => {
-      let asset = null;
-      try {
-        asset = await this.get(engineId, assetId, request);
-      } catch (error) {
-        this.app.log.error(`Asset ${assetId} not found`);
-        asset = {
-          _id: assetId,
-          _source: {
-            groups: [],
-            lastMeasuredAt: 0,
-            linkedDevices: [],
-            measures: undefined,
-            metadata: {},
-            model: "",
-            reference: "",
-          },
-        };
+      const asset = await this.get(engineId, assetId, request).catch(
+        () => null
+      );
+
+      if (!asset) {
+        return this.create(engineId, model, reference, metadata, request);
       }
 
-      const upsertedPayload = await this.app.trigger<EventAssetUpdateBefore>(
+      const updatedPayload = await this.app.trigger<EventAssetUpdateBefore>(
         "device-manager:asset:update:before",
         { asset, metadata }
       );
 
-      const _source = asset
-        ? { ...asset._source, metadata: upsertedPayload.metadata }
-        : {
-            groups: [],
-            lastMeasuredAt: 0,
-            linkedDevices: [],
-            measures: undefined,
-            metadata: upsertedPayload.metadata,
-            model: "",
-            reference: "",
-          };
-
-      const upsertedAsset = await this.upsertDocument<AssetContent>(
+      const updatedAsset = await this.updateDocument<AssetContent>(
         request,
         {
           _id: assetId,
-          _source,
+          _source: { metadata: updatedPayload.metadata },
         },
         {
           collection: InternalCollection.ASSETS,
@@ -199,27 +175,27 @@ export class AssetService extends BaseService {
 
       await this.assetHistoryService.add<AssetHistoryEventMetadata>(engineId, [
         {
-          asset: upsertedAsset._source,
+          asset: updatedAsset._source,
           event: {
             metadata: {
-              names: Object.keys(flattenObject(upsertedPayload.metadata)),
+              names: Object.keys(flattenObject(updatedPayload.metadata)),
             },
             name: "metadata",
           },
-          id: upsertedAsset._id,
+          id: updatedAsset._id,
           timestamp: Date.now(),
         },
       ]);
 
       await this.app.trigger<EventAssetUpdateAfter>(
         "device-manager:asset:update:after",
         {
-          asset: upsertedAsset,
-          metadata: upsertedPayload.metadata,
+          asset: updatedAsset,
+          metadata: updatedPayload.metadata,
         }
       );
 
-      return upsertedAsset;
+      return updatedAsset;
     });
   }
 

lib/modules/asset/AssetsController.ts

@@ -139,11 +139,15 @@ export class AssetsController {
   async upsert(request: KuzzleRequest): Promise<ApiAssetUpsertResult> {
     const engineId = request.getString("engineId");
     const assetId = request.getId();
+    const model = request.getBodyString("model");
+    const reference = request.getBodyString("reference");
     const metadata = request.getBodyObject("metadata");
 
     const upsertAsset = await this.assetService.upsert(
       engineId,
       assetId,
+      model,
+      reference,
       metadata,
       request
     );

lib/modules/shared/services/BaseService.ts

@@ -155,50 +155,6 @@ export abstract class BaseService {
     return endDocument;
   }
 
-  /**
-   * Wrapper to SDK upsert method with trigger generic:document events
-   *
-   * @param {KuzzleRequest} request
-   * @param {KDocument} document
-   * @param {PayloadRequest} payload
-   * @param {ArgsDocumentControllerUpdate} [options]
-   * @returns {Promise<KDocument>}
-   */
-  protected async upsertDocument<T extends KDocumentContent = KDocumentContent>(
-    request: KuzzleRequest,
-    document: KDocument<T>,
-    { collection, engineId }: PayloadRequest,
-    options: ArgsDocumentControllerUpsert<T> = {}
-  ): Promise<KDocument<T>> {
-    const kuzzleRequest = this.normalizeKuzzleRequest(request, {
-      collection,
-      engineId,
-    });
-    const user = kuzzleRequest.getUser();
-    const refresh = kuzzleRequest.getRefresh();
-    const retryOnConflict = options.retryOnConflict || false;
-
-    const [modifiedDocument] = await this.app.trigger<
-      EventGenericDocumentBeforeWrite<T>
-    >("generic:document:beforeWrite", [document], kuzzleRequest);
-
-    const upsertedDocument = await this.impersonatedSdk(
-      user
-    ).document.upsert<T>(
-      engineId,
-      collection,
-      modifiedDocument._id,
-      modifiedDocument._source,
-      { refresh, retryOnConflict, ...options }
-    );
-
-    const [endDocument] = await this.app.trigger<
-      EventGenericDocumentAfterWrite<T>
-    >("generic:document:afterWrite", [upsertedDocument], kuzzleRequest);
-
-    return endDocument;
-  }
-
   /**
    * Wrapper to SDK update method with trigger generic:document events
    *

tests/scenario/migrated/asset-controller.test.ts

@@ -172,4 +172,68 @@ describe("features/Asset/Controller", () => {
       sdk.document.exists("engine-kuzzle", "devices", "DummyTemp-foobar")
     ).resolves.toBe(true);
   });
+
+  it("Upsert asset", async () => {
+    const response = await sdk.query({
+      controller: "device-manager/assets",
+      action: "upsert",
+      engineId: "engine-kuzzle",
+      _id: "Container-linked2",
+      body: {
+        model: "Container",
+        reference: "linked2",
+        metadata: { height: 21, weight: 42 },
+      },
+    });
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    expect(response.result._id).toEqual("Container-linked2");
+    expect(response.result._source.model).toEqual("Container");
+    expect(response.result._source.reference).toEqual("linked2");
+    expect(response.result._source.metadata).toEqual({
+      height: 21,
+      trailer: null,
+      weight: 42,
+    });
+  });
+
+  it("Upsert asset - update existing asset", async () => {
+    // create asset
+    await sdk.query({
+      controller: "device-manager/assets",
+      action: "upsert",
+      engineId: "engine-kuzzle",
+      _id: "Container-linked2",
+      body: {
+        model: "Container",
+        reference: "linked2",
+        metadata: { height: 21, trailer: null, weight: 42 },
+      },
+    });
+
+    // update asset
+    const response = await sdk.query({
+      controller: "device-manager/assets",
+      action: "upsert",
+      engineId: "engine-kuzzle",
+      _id: "Container-linked2",
+      body: {
+        model: "Container",
+        reference: "linked2",
+        metadata: { height: 22, trailer: null, weight: 43 },
+      },
+    });
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    expect(response.result._id).toEqual("Container-linked2");
+    expect(response.result._source.model).toEqual("Container");
+    expect(response.result._source.reference).toEqual("linked2");
+    expect(response.result._source.metadata).toEqual({
+      height: 22,
+      trailer: null,
+      weight: 43,
+    });
+  });
 });