VUU-27 remotePersistenceManager implementation

.semgrepignore

@@ -4,6 +4,7 @@ vuu/src/main/resources/www/ws-example.html
 vuu/src/main/scala/org/finos/vuu/provider/simulation/SimulatedBigInstrumentsProvider.scala
 vuu-ui/packages/vuu-data/src/array-data-source/group-utils.ts
 vuu-ui/packages/vuu-datagrid-extras/src/column-expression-input/column-language-parser/walkExpressionTree.ts
+vuu-ui/packages/vuu-layout/src/layout-persistence/RemoteLayoutPersistenceManager.ts
 vuu-ui/packages/vuu-popups/src/menu/useContextMenu.tsx
 vuu-ui/packages/vuu-table-extras/src/cell-edit-validators/PatternValidator.ts
 vuu-ui/packages/vuu-ui-controls/src/list/Highlighter.tsx

layout-server/src/main/java/org/finos/vuu/layoutserver/CorsConfig.java

@@ -0,0 +1,15 @@
+package org.finos.vuu.layoutserver;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CorsConfig implements WebMvcConfigurer {
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOrigins("http://127.0.0.1:5173")
+                .allowedMethods("GET", "POST", "PUT", "DELETE");
+    }
+}

vuu-ui/packages/vuu-layout/src/layout-persistence/LayoutPersistenceManager.ts

@@ -1,5 +1,5 @@
 import { LayoutJSON } from "@finos/vuu-layout";
-import { LayoutMetadata } from "@finos/vuu-shell";
+import { LayoutMetadata, LayoutMetadataDto } from "@finos/vuu-shell";
 
 export interface LayoutPersistenceManager {
   /**
@@ -10,7 +10,7 @@ export interface LayoutPersistenceManager {
    *
    * @returns Unique identifier assigned to the saved layout
    */
-  createLayout: (metadata: Omit<LayoutMetadata, "id">, layout: LayoutJSON) => Promise<string>;
+  createLayout: (metadata: LayoutMetadataDto, layout: LayoutJSON) => Promise<LayoutMetadata>;
 
   /**
    * Overwrites an existing layout and its corresponding metadata with the provided information
@@ -19,7 +19,7 @@ export interface LayoutPersistenceManager {
    * @param metadata - Metadata describing the new layout to overwrite with
    * @param layout   - Full JSON representation of the new layout to overwrite with
    */
-  updateLayout: (id: string, metadata: Omit<LayoutMetadata, "id">, layout: LayoutJSON) => Promise<void>;
+  updateLayout: (id: string, metadata: LayoutMetadataDto, layout: LayoutJSON) => Promise<void>;
 
   /**
    * Deletes an existing layout and its corresponding metadata

vuu-ui/packages/vuu-layout/src/layout-persistence/LocalLayoutPersistenceManager.ts

@@ -1,48 +1,68 @@
-import { Layout, LayoutMetadata, WithId } from "@finos/vuu-shell";
-import { LayoutJSON, LayoutPersistenceManager } from "@finos/vuu-layout";
+import {
+  Layout,
+  LayoutMetadata,
+  LayoutMetadataDto,
+  WithId,
+} from "@finos/vuu-shell";
 import { getLocalEntity, saveLocalEntity } from "@finos/vuu-filters";
-import { getUniqueId } from "@finos/vuu-utils";
+import { formatDate, getUniqueId } from "@finos/vuu-utils";
 
 import { defaultLayout } from "./data";
+import { LayoutPersistenceManager } from "./LayoutPersistenceManager";
+import { LayoutJSON } from "../layout-reducer";
 
 const metadataSaveLocation = "layouts/metadata";
 const layoutsSaveLocation = "layouts/layouts";
 
 export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
-  createLayout(metadata: Omit<LayoutMetadata, "id">, layout: LayoutJSON): Promise<string> {
-    return new Promise(resolve => {
-      console.log(`Saving layout as ${metadata.name} to group ${metadata.group}...`);
+  createLayout(
+    metadata: LayoutMetadataDto,
+    layout: LayoutJSON
+  ): Promise<LayoutMetadata> {
+    return new Promise((resolve) => {
+      console.log(
+        `Saving layout as ${metadata.name} to group ${metadata.group}...`
+      );
 
-      Promise.all([this.loadLayouts(), this.loadMetadata()])
-        .then(([existingLayouts, existingMetadata]) => {
+      Promise.all([this.loadLayouts(), this.loadMetadata()]).then(
+        ([existingLayouts, existingMetadata]) => {
           const id = getUniqueId();
-          this.appendAndPersist(
+          const newMetadata = {
+            ...metadata,
             id,
-            metadata,
-            layout,
-            existingLayouts,
-            existingMetadata
+            created: formatDate(new Date(), "dd.mm.yyyy"),
+          };
+
+          this.saveLayoutsWithMetadata(
+            [...existingLayouts, { id, json: layout }],
+            [...existingMetadata, newMetadata]
           );
-          resolve(id);
-        });
-    })
+          resolve(newMetadata);
+        }
+      );
+    });
   }
 
   updateLayout(
     id: string,
-    newMetadata: Omit<LayoutMetadata, "id">,
+    newMetadata: LayoutMetadataDto,
     newLayout: LayoutJSON
   ): Promise<void> {
     return new Promise((resolve, reject) => {
       this.validateIds(id)
         .then(() => Promise.all([this.loadLayouts(), this.loadMetadata()]))
         .then(([existingLayouts, existingMetadata]) => {
-          const layouts = existingLayouts.filter(layout => layout.id !== id);
-          const metadata = existingMetadata.filter(metadata => metadata.id !== id);
-          this.appendAndPersist(id, newMetadata, newLayout, layouts, metadata);
+          this.saveLayoutsWithMetadata(
+            existingLayouts.map((layout) =>
+              layout.id === id ? { ...layout, json: newLayout } : layout
+            ),
+            existingMetadata.map((metadata) =>
+              metadata.id === id ? { ...metadata, ...newMetadata } : metadata
+            )
+          );
           resolve();
         })
-        .catch(e => reject(e));
+        .catch((e) => reject(e));
     });
   }
 
@@ -51,24 +71,32 @@ export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
       this.validateIds(id)
         .then(() => Promise.all([this.loadLayouts(), this.loadMetadata()]))
         .then(([existingLayouts, existingMetadata]) => {
-          const layouts = existingLayouts.filter(layout => layout.id !== id);
-          const metadata = existingMetadata.filter(metadata => metadata.id !== id);
+          const layouts = existingLayouts.filter((layout) => layout.id !== id);
+          const metadata = existingMetadata.filter(
+            (metadata) => metadata.id !== id
+          );
           this.saveLayoutsWithMetadata(layouts, metadata);
           resolve();
         })
-        .catch(e => reject(e));
+        .catch((e) => reject(e));
     });
   }
 
   loadLayout(id: string): Promise<LayoutJSON> {
     return new Promise((resolve, reject) => {
       this.validateId(id, "layout")
         .then(() => this.loadLayouts())
-        .then(existingLayouts => {
-          const layouts = existingLayouts.find(layout => layout.id === id) as Layout;
-          resolve(layouts.json);
+        .then((existingLayouts) => {
+          const foundLayout = existingLayouts.find(
+            (layout) => layout.id === id
+          );
+          if (foundLayout) {
+            resolve(foundLayout.json);
+          } else {
+            reject(new Error(`no layout found matching id ${id}`));
+          }
         })
-        .catch(e => reject(e));
+        .catch((e) => reject(e));
     });
   }
 
@@ -102,25 +130,12 @@ export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
   }
 
   private loadLayouts(): Promise<Layout[]> {
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
       const layouts = getLocalEntity<Layout[]>(layoutsSaveLocation);
       resolve(layouts || []);
     });
   }
 
-  private appendAndPersist(
-    newId: string,
-    newMetadata: Omit<LayoutMetadata, "id">,
-    newLayout: LayoutJSON,
-    existingLayouts: Layout[],
-    existingMetadata: LayoutMetadata[]
-  ) {
-    existingLayouts.push({ id: newId, json: newLayout });
-    existingMetadata.push({ id: newId, ...newMetadata });
-
-    this.saveLayoutsWithMetadata(existingLayouts, existingMetadata);
-  }
-
   private saveLayoutsWithMetadata(
     layouts: Layout[],
     metadata: LayoutMetadata[]
@@ -132,29 +147,33 @@ export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
   // Ensures that there is exactly one Layout entry and exactly one Metadata
   // entry in local storage corresponding to the provided ID.
   private async validateIds(id: string): Promise<void> {
-    return Promise
-      .all([
-        this.validateId(id, "metadata").catch(error => error.message),
-        this.validateId(id, "layout").catch(error => error.message)
-      ])
-      .then((errorMessages: string[]) => {
-        // filter() is used to remove any blank messages before joining.
-        // Avoids orphaned delimiters in combined messages, e.g. "; " or "; error 2"
-        const combinedMessage = errorMessages.filter(msg => msg !== undefined).join("; ");
-        if (combinedMessage) {
-          throw new Error(combinedMessage);
-        }
-      });
+    return Promise.all([
+      this.validateId(id, "metadata").catch((error) => error.message),
+      this.validateId(id, "layout").catch((error) => error.message),
+    ]).then((errorMessages: string[]) => {
+      // filter() is used to remove any blank messages before joining.
+      // Avoids orphaned delimiters in combined messages, e.g. "; " or "; error 2"
+      const combinedMessage = errorMessages
+        .filter((msg) => msg !== undefined)
+        .join("; ");
+      if (combinedMessage) {
+        throw new Error(combinedMessage);
+      }
+    });
   }
 
   // Ensures that there is exactly one element (Layout or Metadata) in local
   // storage corresponding to the provided ID.
-  private validateId(id: string, dataType: "metadata" | "layout"): Promise<void> {
+  private validateId(
+    id: string,
+    dataType: "metadata" | "layout"
+  ): Promise<void> {
     return new Promise((resolve, reject) => {
-      const loadFunc = dataType === "metadata" ? this.loadMetadata : this.loadLayouts;
+      const loadFunc =
+        dataType === "metadata" ? this.loadMetadata : this.loadLayouts;
 
       loadFunc().then((array: WithId[]) => {
-        const count = array.filter(element => element.id === id).length;
+        const count = array.filter((element) => element.id === id).length;
         switch (count) {
           case 1: {
             resolve();
@@ -164,9 +183,10 @@ export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
             reject(new Error(`No ${dataType} with ID ${id}`));
             break;
           }
-          default: reject(new Error(`Non-unique ${dataType} with ID ${id}`));
+          default:
+            reject(new Error(`Non-unique ${dataType} with ID ${id}`));
         }
       });
-    })
+    });
   }
 }