@carbonorm/carbonreact 3.4.8 → 3.5.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@carbonorm/carbonreact",
   "license": "MIT",
-  "version": "3.4.8",
+  "version": "3.5.1",
   "browser": "dist/index.umd.js",
   "module": "dist/index.esm.js",
   "main": "dist/index.cjs.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "dependencies": {
-    "@carbonorm/carbonnode": "^1.3.0",
+    "@carbonorm/carbonnode": "^1.4.0",
     "@fortawesome/fontawesome-svg-core": "^6.4.0",
     "@fortawesome/free-solid-svg-icons": "^6.4.0",
     "@fortawesome/react-fontawesome": "^0.2.0",

package/src/components/WebSocket/CarbonWebSocket.tsx

@@ -1,25 +1,28 @@
 import CarbonReact, {isJsonString} from "CarbonReact";
 import {addAlert} from "../Alert/Alert";
 import {useEffectOnce} from "../../api/hoc/useEffectOnce";
-import {tC6Tables} from "@carbonorm/carbonnode";
+import {tC6Tables, tWsLiveUpdate} from "@carbonorm/carbonnode";
 
 
 export interface iCarbonWebSocketProps {
     url?: string,
     timeoutSeconds?: number,
     heartbeatSeconds?: number,
-    TABLES?: tC6Tables
+    TABLES?: tC6Tables,
+    WsLiveUpdates?: tWsLiveUpdate,
 }
 
 /**
  * @function connect
  * This function establishes a connection with the websocket and also ensures constant reconnection if connection closes
  **/
-export function initiateWebsocket({TABLES = undefined,
+export function initiateWebsocket({
+                                      TABLES = undefined,
+                                      WsLiveUpdates = undefined,
                                       url = 'ws://localhost:8080/ws',
                                       timeoutSeconds = 250,
                                       heartbeatSeconds = 60
-}: iCarbonWebSocketProps = {}) {
+                                  }: iCarbonWebSocketProps = {}) {
 
     const {websocket} = CarbonReact.instance.state;
 
@@ -79,19 +82,104 @@ export function initiateWebsocket({TABLES = undefined,
 
             const parsedData = isJsonString(message?.data) ? JSON.parse(message?.data) : message?.data;
 
+            if (message.data === 'pong') {
+                return;
+            }
+
             CarbonReact.instance.setState((prevState: Readonly<any>) => ({
                 websocketEvents: prevState.websocketEvents.concat(message),
                 websocketData: prevState.websocketData.concat(parsedData), // JSON.parse no good - base64?
-            }));
+            }), () => {
+
+                if (undefined === TABLES) {
+
+                    console.log('WebSocket updates without the TABLES property passed will not automatically update the state.')
+
+                    return;
+
+                }
+
+                if (undefined === WsLiveUpdates) {
+
+                    console.log('WebSocket updates without the WsLiveUpdates property passed will not automatically update the state.')
+
+                    return;
+
+                }
+
+                if (parsedData?.REST) {
+
+                    const TABLE_NAME: string = parsedData?.REST?.TABLE_NAME;
+
+                    const TABLE_PREFIX: string = parsedData?.REST?.TABLE_PREFIX;
+
+                    const METHOD: string = parsedData?.REST?.METHOD;
+
+                    const REQUEST: { [key:string]: any } = parsedData?.REST?.REQUEST;
+
+                    const REQUEST_PRIMARY_KEY: {
+                        [key: string]: string
+                    } = parsedData?.REST?.REQUEST_PRIMARY_KEY ?? null;
+
+                    if (null === REQUEST_PRIMARY_KEY) {
+
+                        console.log('WebSocket updates without a primary key are not yet supported.')
+
+                        return;
+
+                    }
+
+                    console.log('todo - going to impl REST', TABLE_NAME, METHOD, REQUEST_PRIMARY_KEY, parsedData?.REST)
+
+                    const TABLE_NAME_SHORT = TABLE_NAME.substring(TABLE_PREFIX.length);
+
+                    const currentCache: [] = CarbonReact.instance.state[TABLE_NAME_SHORT]
+
+                    // just because we have a websocket update, doesn't mean we need the update
+                    // check to see if the primary key is in the current cache
+                    const c6Table = TABLES[TABLE_NAME_SHORT] ?? null;
+
+                    if (null === c6Table) {
+
+                        console.error('WebSocket update could not find (' + TABLE_NAME_SHORT + ') in the TABLES property passed.', TABLES)
+
+                        return;
+
+                    }
+
+                    const primaryKeyKeys = Object.keys(REQUEST_PRIMARY_KEY)
+
+                    const elementsToUpdate = currentCache.filter((row: any) => {
+                        for (const element of primaryKeyKeys) {
+                            console.log('element', element, REQUEST_PRIMARY_KEY[element], row[element])
+                            if (REQUEST_PRIMARY_KEY[element] !== row[element]) {
+                                return false
+                            }
+                        }
+                        return true
+                    })
+
+                    console.log('elementsToUpdate', elementsToUpdate)
+
+                    if (elementsToUpdate.length === 0) {
+                        console.error('Could not find any elements to update in the cache.', elementsToUpdate, primaryKeyKeys, REQUEST_PRIMARY_KEY, currentCache)
+                        return;
+                    }
 
-            console.info('todo - going to impl TABLES', TABLES)
+                    const updatedElements = elementsToUpdate.map((row: any) => {
+                        return {
+                            ...row,
+                            ...REQUEST
+                        }
+                    })
 
-            /*if (undefined !== TABLES) {
+                    console.log('updatedElements', updatedElements)
 
-                TABLES.
+                    WsLiveUpdates[TABLE_NAME_SHORT][METHOD]({}, updatedElements)
 
+                }
 
-            }*/
+            });
 
         };