@carbonorm/carbonreact 4.0.13 → 4.0.15

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@carbonorm/carbonreact",
   "license": "MIT",
-  "version": "4.0.13",
+  "version": "4.0.15",
   "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": "^2.0.0",
+    "@carbonorm/carbonnode": "^2.0.8",
     "@fortawesome/fontawesome-svg-core": "^6.4.0",
     "@fortawesome/free-solid-svg-icons": "^6.4.0",
     "@fortawesome/react-fontawesome": "^0.2.0",

package/src/CarbonReact.tsx

@@ -1,4 +1,3 @@
-import { clearCache } from "@carbonorm/carbonnode";
 import changed from "hoc/changed";
 import { GlobalHistory } from "hoc/GlobalHistory";
 import hexToRgb from "hoc/hexToRgb";
@@ -12,10 +11,7 @@ import CarbonWebSocket, { iCarbonWebSocketProps } from "./components/WebSocket/C
 import updateRestfulObjectArrays, { iUpdateRestfulObjectArrays } from "./hoc/updateRestfulObjectArrays";
 import deleteRestfulObjectArrays, { iDeleteRestfulObjectArrays } from "./hoc/deleteRestfulObjectArrays";
 
-
-export type tStatefulApiData<T extends {
-    [key: string]: any
-} = {}> = T[] | undefined | null;
+export type tStatefulApiData<T extends { [key: string]: any } = {}> = T[] | undefined | null;
 
 // our central container, single page application
 export interface iCarbonReactState {
@@ -51,10 +47,11 @@ export function isJsonString(str: string) {
 abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactState> extends Component<{
     children?: ReactNode | ReactNode[],
     instanceId?: string,
+    persistentState?: boolean,
     websocket?: Omit<iCarbonWebSocketProps<P, S>, "instance"> | false
 } & P, S> {
 
-    private static persistentStateMap = new Map<string, { [key: string]: any; }>();
+    private static allInstances = new Map<string, CarbonReact<any, any>>();
     private static activeInstances = new Map<string, CarbonReact<any, any>>();
 
     context: Context<S & iCarbonReactState> = createContext(this.state);
@@ -62,12 +59,28 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
 
     protected static _instance: ThisType<CarbonReact<any, any>>;
 
-    static getInstance<T extends CarbonReact<any, any>>(): T {
+    static getInstance<T extends CarbonReact<any, any>>(instanceId?: string): T {
+
+        const identifier = this.generateIdentifier(instanceId);
+
+        if (undefined !== instanceId) {
+            if (CarbonReact.activeInstances.has(identifier)) {
+                return CarbonReact.activeInstances.get(identifier) as T;
+            }
+            throw new Error(`No instance has been instantiated yet for class (${this.name}) with instanceId (${instanceId})`);
+        }
+
+        if (!this._instance) {
+            throw new Error(`No instance has been instantiated yet for class (${this.name})`);
+        }
+
         return this._instance as T;
     }
+
     static get instance() {
         return this.getInstance();
     }
+
     static set instance(instance: CarbonReact<any, any>) {
         this._instance = instance;
     }
@@ -90,39 +103,50 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
 
     protected constructor(props: {
         children?: ReactNode | ReactNode[];
-        shouldStatePersist?: boolean | undefined;
         websocket?: boolean | iCarbonWebSocketProps<P, S> | undefined;
         instanceId?: string; // Optional instanceId from props
+        persistentState?: boolean; // Optional persistentState from props
     } & P) {
         super(props);
 
-        const target = new.target as typeof CarbonReact;
-        const identifier = props.instanceId || target.name;
+        const identifier = this.generateIdentifier();
 
         if (CarbonReact.activeInstances.has(identifier)) {
-            throw new Error(`Instance with ID ${identifier} already exists! CarbonReact extended classes can only be referenced once in DOM with the same identifier.`);
+            throw new Error(`${identifier} instance already exists in the DOM! Each instance should have a unique instanceId.`);
         }
 
+        // Register the new instance
         CarbonReact.activeInstances.set(identifier, this);
 
-        this.target = target;
+        if (props.persistentState && CarbonReact.allInstances.has(identifier)) {
+            // Reuse the state from the existing instance
+            this.state = CarbonReact.allInstances.get(identifier)!.state as S & iCarbonReactState;
+        } else {
+            this.state = initialCarbonReactState as unknown as S & iCarbonReactState;
+            CarbonReact.allInstances.set(identifier, this);
+        }
+
+        this.target = new.target;
         console.log('CarbonORM TSX CONSTRUCTOR');
 
-        Object.assign(target, {
+        Object.assign(this.target, {
             _instance: this
         });
+    }
 
-        if (CarbonReact.persistentStateMap.has(identifier)) {
-            this.state = CarbonReact.persistentStateMap.get(identifier) as S & iCarbonReactState;
-        } else {
-            clearCache({
-                ignoreWarning: true
-            });
-            this.state = initialCarbonReactState as unknown as S & iCarbonReactState;
-        }
+    private static generateIdentifier(instanceId?: string): string {
+        const className = this.name;
+        return instanceId ? `${className}-${instanceId}` : className;
+    }
+
+    private generateIdentifier(): string {
+        const className = (this.constructor as typeof CarbonReact).name;
+        return this.props.instanceId ? `${className}-${this.props.instanceId}` : className;
+    }
 
-        // Save the initial state to the persistent state map with the identifier
-        CarbonReact.persistentStateMap.set(identifier, this.state);
+    componentWillUnmount() {
+        const identifier = this.generateIdentifier();
+        CarbonReact.activeInstances.delete(identifier);
     }
 
     shouldComponentUpdate(
@@ -130,9 +154,6 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
         nextState: Readonly<S>,
         _nextContext: any): boolean {
 
-        const identifier = this.props.instanceId || (this.constructor as typeof CarbonReact).name;
-        CarbonReact.persistentStateMap.set(identifier, nextState);
-
         changed(this.constructor.name + ' (C6Api)', 'props', this.props, nextProps);
         changed(this.constructor.name + ' (C6Api)', 'state', this.state, nextState);
 
@@ -179,11 +200,6 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
             <ToastContainer />
         </>;
     }
-
-    componentWillUnmount() {
-        const identifier = this.props.instanceId || (this.constructor as typeof CarbonReact).name;
-        CarbonReact.activeInstances.delete(identifier);
-    }
 }
 
 export default CarbonReact;

package/src/components/WebSocket/CarbonWebSocket.tsx

@@ -1,40 +1,44 @@
-import CarbonReact, {iCarbonReactState, isJsonString} from "CarbonReact";
+import CarbonReact, {iCarbonReactState, isJsonString, tStatefulApiData} from "CarbonReact";
 import {addAlert} from "../Alert/Alert";
 import {useEffectOnce} from "../../api/hoc/useEffectOnce";
-import {tC6Tables, tC6RestApi} from "@carbonorm/carbonnode";
+import {iC6Object} from "@carbonorm/carbonnode";
 
 
-export interface iCarbonWebSocketProps<P,S extends iCarbonReactState> {
+export interface iCarbonWebSocketProps<P, S extends iCarbonReactState> {
     url?: string,
     timeoutSeconds?: number,
     heartbeatSeconds?: number,
-    instance: CarbonReact<P,S>,
-    TABLES?: tC6Tables,
-    WsLiveUpdates?: tC6RestApi,
+    instance: CarbonReact<P, S>,
+    C6?: iC6Object,
 }
 
 /**
  * @function connect
  * This function establishes a connection with the websocket and also ensures constant reconnection if connection closes
  **/
-export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonWebSocketProps<P,S>) {
+export function initiateWebsocket<P, S extends iCarbonReactState>(props: iCarbonWebSocketProps<P, S>) {
 
     let {
         instance,
-        TABLES = undefined,
-        WsLiveUpdates = undefined,
         url = 'ws' + (window.location.protocol === 'https:' ? 's' : '') + '://' + window.location.host + '/carbonorm/websocket',
         timeoutSeconds = 250,
-        heartbeatSeconds = 60
+        heartbeatSeconds = 60,
+        C6
     } = props;
 
+    const {
+        TABLES = undefined,
+        IMPORT = undefined,
+    } = C6 ?? {};
+
+
     const {websocket} = instance.state;
 
 
     if (!("WebSocket" in window)) {
 
         // todo - store that this has been shown in the state
-        addAlert<P,S>({
+        addAlert<P, S>({
             title: 'Browser does not support websockets, live updates will fail. You may need to refresh the page to see the newest content.',
             text: 'Please use a modern browser.',
             icon: 'warning',
@@ -105,14 +109,6 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
                 }
 
-                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;
@@ -139,7 +135,7 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
                     const TABLE_NAME_SHORT = TABLE_NAME.substring(TABLE_PREFIX.length);
 
-                    const currentCache: [] = instance.state[TABLE_NAME_SHORT]
+                    const currentCache: tStatefulApiData<{ [key: string]: any }> = 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
@@ -155,7 +151,8 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
                     const primaryKeyKeys = Object.keys(REQUEST_PRIMARY_KEY)
 
-                    const elementsToUpdate = currentCache.filter((row: any) => {
+                    // todo - which direction should we filter
+                    const elementsToUpdate = currentCache?.filter((row: any) => {
 
                         for (const element of primaryKeyKeys) {
 
@@ -174,7 +171,7 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
                         return true
 
-                    })
+                    }) ?? []
 
                     console.log('elementsToUpdate', elementsToUpdate)
 
@@ -192,8 +189,30 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
                     })
 
-                    updatedElements.forEach((row: any) => {
-                        WsLiveUpdates[TABLE_NAME_SHORT][METHOD]({}, row)
+                    updatedElements.forEach(async (row: any) => {
+
+                        const RestRequests = await IMPORT?.(TABLE_NAME_SHORT)
+
+                        const {
+                            postState,
+                            deleteState,
+                            putState,
+                        } = RestRequests;
+
+                        switch (METHOD) {
+                            case 'POST':
+                                postState({}, row)
+                                break;
+                            case 'DELETE':
+                                deleteState({}, row)
+                                break;
+                            case 'PUT':
+                                putState({}, row)
+                                break;
+                            default:
+                                console.error('Method not supported', METHOD)
+                        }
+
                     })
 
                 }
@@ -286,7 +305,7 @@ export function initiateWebsocket<P,S extends iCarbonReactState>(props: iCarbonW
 
 }
 
-export default function <P,S extends iCarbonReactState>(props: iCarbonWebSocketProps<P,S>) {
+export default function <P, S extends iCarbonReactState>(props: iCarbonWebSocketProps<P, S>) {
 
     useEffectOnce(() => {