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

@@ -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: Omit<LayoutMetadata, "id" | "created">, layout: LayoutJSON) => Promise<LayoutMetadata>;
 
   /**
    * Overwrites an existing layout and its corresponding metadata with the provided information

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

@@ -1,31 +1,43 @@
 import { Layout, LayoutMetadata, WithId } from "@finos/vuu-shell";
-import { LayoutJSON, LayoutPersistenceManager } from "@finos/vuu-layout";
 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: Omit<LayoutMetadata, "id" | "created">,
+    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();
+          const newMetadata = {
+            ...metadata,
+            id,
+            created: formatDate(new Date(), "dd.mm.yyyy"),
+          };
           this.appendAndPersist(
             id,
-            metadata,
+            newMetadata,
             layout,
             existingLayouts,
             existingMetadata
           );
-          resolve(id);
-        });
-    })
+          resolve(newMetadata);
+        }
+      );
+    });
   }
 
   updateLayout(
@@ -37,12 +49,14 @@ 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.appendAndPersist(id, newMetadata, newLayout, layouts, metadata);
           resolve();
         })
-        .catch(e => reject(e));
+        .catch((e) => reject(e));
     });
   }
 
@@ -51,24 +65,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,7 +124,7 @@ export class LocalLayoutPersistenceManager implements LayoutPersistenceManager {
   }
 
   private loadLayouts(): Promise<Layout[]> {
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
       const layouts = getLocalEntity<Layout[]>(layoutsSaveLocation);
       resolve(layouts || []);
     });
@@ -132,29 +154,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 +190,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}`));
         }
       });
-    })
+    });
   }
 }

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

@@ -0,0 +1,137 @@
+import { LayoutMetadata } from "@finos/vuu-shell";
+import { LayoutPersistenceManager } from "./LayoutPersistenceManager";
+import { LayoutJSON } from "../layout-reducer";
+import { defaultLayout } from "./data";
+
+const baseURL = "http://127.0.0.1:8081/api";
+const metadataSaveLocation = "layouts/metadata";
+const layoutsSaveLocation = "layouts";
+
+export class RemoteLayoutPersistenceManager
+  implements LayoutPersistenceManager
+{
+  createLayout(
+    metadata: Omit<LayoutMetadata, "id" | "created">,
+    layout: LayoutJSON
+  ): Promise<LayoutMetadata> {
+    return new Promise((resolve, reject) =>
+      fetch(`${baseURL}/${layoutsSaveLocation}`, {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+        body: JSON.stringify({
+          metadata: { ...metadata },
+          definition: JSON.stringify(layout),
+        }),
+      })
+        .then((response) => {
+          if (!response.ok) {
+            reject(new Error(response.statusText));
+          }
+          response.json().then(({ metadata }: { metadata: LayoutMetadata }) => {
+            if (!metadata) {
+              reject(new Error("invalid metadata"));
+            }
+            resolve(metadata);
+          });
+        })
+        .catch((error: Error) => {
+          reject(error);
+        })
+    );
+  }
+
+  updateLayout(
+    id: string,
+    metadata: Omit<LayoutMetadata, "id">,
+    newLayoutJson: LayoutJSON
+  ): Promise<void> {
+    return new Promise((resolve, reject) =>
+      fetch(`${baseURL}/${layoutsSaveLocation}/${id}`, {
+        method: "PUT",
+        body: JSON.stringify({
+          metadata,
+          layout: newLayoutJson,
+        }),
+      })
+        .then((response) => {
+          if (!response.ok) {
+            reject(new Error(response.statusText));
+          }
+          resolve();
+        })
+        .catch((error: Error) => {
+          reject(error);
+        })
+    );
+  }
+
+  deleteLayout(id: string): Promise<void> {
+    return new Promise((resolve, reject) =>
+      fetch(`${baseURL}/${layoutsSaveLocation}/${id}`, {
+        method: "DELETE",
+      })
+        .then((response) => {
+          if (!response.ok) {
+            reject(new Error(response.statusText));
+          }
+          resolve();
+        })
+        .catch((error: Error) => {
+          reject(error);
+        })
+    );
+  }
+
+  loadLayout(id: string): Promise<LayoutJSON> {
+    return new Promise((resolve, reject) => {
+      fetch(`${baseURL}/${layoutsSaveLocation}/${id}`, {})
+        .then((response) => {
+          if (!response.ok) {
+            reject(new Error(response.statusText));
+          }
+          response.json().then((layout) => {
+            if (!layout) {
+              reject(new Error("invalid layout"));
+            }
+            resolve(layout);
+          });
+        })
+        .catch((error: Error) => {
+          reject(error);
+        });
+    });
+  }
+
+  loadMetadata(): Promise<LayoutMetadata[]> {
+    return new Promise((resolve, reject) =>
+      fetch(`${baseURL}/${metadataSaveLocation}`, {})
+        .then(async (response) => {
+          if (!response.ok) {
+            reject(new Error(response.statusText));
+          }
+          response.json().then((metadata: LayoutMetadata[]) => {
+            if (!metadata) {
+              reject(new Error("invalid metadata"));
+            }
+            resolve(metadata);
+          });
+        })
+        .catch((error: Error) => {
+          reject(error);
+        })
+    );
+  }
+
+  saveApplicationLayout(layout: LayoutJSON): Promise<void> {
+    // TODO POST api/layouts/application #71
+    console.log(layout);
+    return new Promise((resolve) => resolve());
+  }
+
+  loadApplicationLayout(): Promise<LayoutJSON> {
+    // TODO GET api/layouts/application #71
+    return new Promise((resolve) => resolve(defaultLayout));
+  }
+}

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

@@ -1,3 +1,4 @@
 export * from './LayoutPersistenceManager';
 export * from './LocalLayoutPersistenceManager';
+export * from './RemoteLayoutPersistenceManager';
 export * from './data';