@mgarlik/datastore 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -85,26 +85,32 @@ function systemLog(..._args) {
 }
 
 // src/handleSocketMessage.ts
-var handleSocketMessage = (model, msg, dataProvider) => {
-  const { dispatch, updateDocument } = dataProvider;
+var handleSocketMessage = (msg, dataProvider) => {
+  const { dispatch } = dataProvider;
+  console.log("Mam socket message, data: ", msg);
   const data = JSON.parse(msg);
   switch (data.action) {
     case "create":
       systemLog("sockets", "[create] ", data.model, ", document: ", data.documentId);
+      console.log("[SOCKETS] CREATING model:", data.model, ", document: ", data.documentId, " data:", data.data);
       dispatch?.("createDocument", { model: data.model, documentId: data.documentId, data: data.data });
       break;
     case "update":
+      console.log(`[SOCKETS] UPDATE model: ${data.model}, document: ${data.documentId}, data: `, data.data);
       systemLog("sockets", `[update] ${JSON.stringify(data)}`);
       if (Array.isArray(data.data)) dispatch?.("updateDocuments", { model: data.model, documents: data.data });
-      else updateDocument?.({ model: data.model, documentId: data.documentId, data: data.data });
+      else {
+        dispatch?.("updateDocument", { model: data.model, documentId: data.documentId, data: data.data });
+      }
       break;
     case "delete":
+      console.log(`[SOCKETS] DELETE model: ${data.model}, document: ${data.documentId}`);
       systemLog("sockets", "[delete] model:", data.model, ", document: ", data.documentId);
-      dispatch?.("deleteDocument", { documentId: data.documentId, data: data.data });
+      dispatch?.("deleteDocument", { model: data.model, documentId: data.documentId, data: data.data });
       break;
     case "deleteItem":
-      systemLog("sockets", "DELETE ITEM ", model, ", model: ", data.model, ", data: ", data.data);
-      dispatch?.("removeItem", { model, documentId: data.data.id });
+      systemLog("sockets", "DELETE ITEM ", data.model, ", model: ", data.model, ", data: ", data.data);
+      dispatch?.("removeItem", { model: data.model, documentId: data.data.id });
       break;
     default:
       console.error(`Unknown command ${data.action}`);
@@ -512,12 +518,15 @@ function doesValueMatchFilter(objVal, value, documents = {}) {
   }
 }
 function doesObjectMatchFilter(obj, filter, documents = {}) {
+  console.log("doesObjectMatchFilter", "Obj", JSON.stringify(obj, null, 2), "Filter", JSON.stringify(filter, null, 2));
   if (!filter) return true;
   if (Object.keys(filter)?.includes("$rule")) {
+    console.log("Pravidloo: ", filter.$rule);
     const result2 = doesObjectMatchFilter(obj, filter.$rule, documents);
     if (result2 === true) {
       return result2;
     } else {
+      console.log("Vracim chybovou message ", filter.$message);
       return filter.$message || false;
     }
   }
@@ -666,11 +675,20 @@ var saveData = async ({
   }
   console.timeEnd(`[SQL] saveData ${providerId}`);
 };
+var serializeParams = (params) => {
+  return Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [
+      key,
+      typeof value === "object" ? JSON.stringify(value) : value
+    ])
+  );
+};
 var buildUri = ({
   method,
   dataSource,
   variant
 }) => {
+  console.log("[HANDLE DATA] BUILD URI method ", method, " from", dataSource);
   if (dataSource.crud) {
     if (method === "update" && dataSource.crud.updates) {
       if (variant && dataSource.crud.updates[variant]) return dataSource.crud.updates[variant];
@@ -704,7 +722,7 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime
         console.time("Persisted Data");
         const qDatum = await SQLite.read(`SELECT * FROM documents WHERE model = '${id}' ORDER BY lastUpdate DESC`);
         systemLog("axios", "SQLite.read Posledni datum update: ", qDatum[0]?.lastUpdate);
-        if (qDatum[0]?.lastUpdate) params.changeTime = qDatum[0].lastUpdate;
+        if (qDatum[0]?.lastUpdate) params.changeTimeFrom = qDatum[0].lastUpdate;
         persistedData = qDatum.map((item) => {
           try {
             const parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
@@ -721,8 +739,8 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime
         console.timeEnd("Persisted Data");
       }
       if (dataSource) {
-        systemLog("axios", "Params: ", JSON.stringify(params));
-        const axiosResponse = await import_axios.default.get(buildUri({ dataSource, method: "read" }), { params });
+        console.log("Stahuji data z ", buildUri({ dataSource, method: "read" }), " s parametry ", params);
+        const axiosResponse = await import_axios.default.get(buildUri({ dataSource, method: "read" }), { params: serializeParams(params) });
         if (schema && !dataSource.readAllFields) {
           if (Array.isArray(axiosResponse.data.data)) {
             newData = [];
@@ -1118,9 +1136,12 @@ var DataStoreProvider = (0, import_react.forwardRef)(
     (0, import_react.useEffect)(() => {
       if (isLive) {
         systemLog("dsp", "useEffect[isLive] Sockets: ", JSON.stringify(sockets, null, 2));
-        const ss = Object.keys(sockets);
-        systemLog("dsp", "useEffect[isLive] registruji", ss);
-        if (ss?.length > 0) socket.emit("joinRooms", JSON.stringify(ss));
+        const roomsToJoin = Object.entries(sockets).flatMap(
+          ([roomName, socketItem]) => socketItem.filters.map(({ filter }) => ({ room: roomName, filter }))
+        );
+        console.log("Sokety pro p\u0159ipojen\xED:", roomsToJoin);
+        systemLog("dsp", "useEffect[isLive] registruji", roomsToJoin);
+        if (roomsToJoin.length > 0) socket.emit("joinRooms", roomsToJoin);
         if (!didInitialLiveSyncRef.current) {
           didInitialLiveSyncRef.current = true;
           systemLog("dsp", "useEffect[isLive] Zacinam synchronizovat");
@@ -1134,6 +1155,15 @@ var DataStoreProvider = (0, import_react.forwardRef)(
     (0, import_react.useEffect)(() => {
       socket.on("connect", handleSocketConnect);
       socket.on("disconnect", handleSocketDisconnect);
+      if (socketServer?.params?.socketEvents && socketServer.params.socketEvents.length > 0) {
+        socketServer?.params?.socketEvents?.map(
+          (event) => socket.on(event, (data) => handleSocketMessage(data, socketActionHandlersRef.current))
+        );
+      } else {
+        socket.on("create", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
+        socket.on("update", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
+        socket.on("delete", (data) => handleSocketMessage(data, socketActionHandlersRef.current));
+      }
       return () => {
         socket.off("connect", handleSocketConnect);
         socket.off("disconnect", handleSocketDisconnect);
@@ -1210,6 +1240,7 @@ var DataStoreProvider = (0, import_react.forwardRef)(
               result = await updateDataStore(item.data);
               break;
             case "createDocument":
+              console.log("Dispatcher createDocument", item.data);
               await createDocument(item.data);
               break;
             case "updateDocument":
@@ -1549,14 +1580,27 @@ var DataStoreProvider = (0, import_react.forwardRef)(
     const createDocument = (0, import_react.useCallback)(
       async ({ model, documentId, data }) => {
         const newDocument = data;
-        systemLog("dsp", `Registruji model ${model}, documentId ${documentId}, data: ${JSON.stringify(data)}`);
+        console.log(`Registruji model ${model}, documentId ${documentId}, data: ${JSON.stringify(data)}`);
         var providerListenersCount = 0;
         Object.keys(providers).forEach((key) => {
           const provider = providers[key];
           var socketListeners = provider.dataSource?.socketListeners;
           if ((socketListeners?.includes(model) || key === model) && (!provider.dataSource?.filter || filterDocuments(data, provider.dataSource?.filter))) {
-            systemLog("dsp", "[createDocument] Provider data: ", provider.data.length, " Bytes, documentId: ", documentId);
             if (!provider.data.includes(documentId)) {
+              setCounterDocuments((prev) => {
+                const newC = { ...prev };
+                if (newC[documentId]) {
+                  setDocuments((prev2) => ({
+                    ...prev2,
+                    [documentId]: { ...prev2[documentId], ...newDocument }
+                  }));
+                  newC[documentId] = prev[documentId] + 1;
+                } else {
+                  setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
+                  newC[documentId] = providerListenersCount;
+                }
+                return newC;
+              });
               providerListenersCount++;
               setProviders((prev) => ({
                 ...prev,
@@ -1569,24 +1613,14 @@ var DataStoreProvider = (0, import_react.forwardRef)(
             }
           }
         });
+        console.log("Provider listeners count: ", providerListenersCount);
         if (providerListenersCount > 0) {
           if (providers[model]?.isPersisting && persistenceStorage) {
+            console.log("Persistuji dokument ", documentId, " do modelu ", model);
             await persistDocument({ documentId, model, data: newDocument });
           }
-          setCounterDocuments((prev) => {
-            const newC = { ...prev };
-            if (newC[documentId]) {
-              setDocuments((prev2) => ({
-                ...prev2,
-                [documentId]: { ...prev2[documentId], ...newDocument }
-              }));
-              newC[documentId] = prev[documentId] + providerListenersCount;
-            } else {
-              setDocuments((prev2) => ({ ...prev2, [documentId]: newDocument }));
-              newC[documentId] = providerListenersCount;
-            }
-            return newC;
-          });
+          console.log("Dokument ", documentId, " zaregistrovan do ", providerListenersCount, " provideru");
+          console.log(newDocument);
           return { id: documentId, document: newDocument };
         } else return false;
       },
@@ -1594,6 +1628,7 @@ var DataStoreProvider = (0, import_react.forwardRef)(
     );
     const deleteDocument = (0, import_react.useCallback)(
       async ({ documentId }) => {
+        console.log("Mazani dokumentu ", documentId);
         systemLog("dsp", `[deleteDocument] Mazu document ${documentId}}`);
         await removePersistedDocument(documentId);
         setDocuments((prev) => {
@@ -1660,55 +1695,77 @@ var DataStoreProvider = (0, import_react.forwardRef)(
       [providers]
     );
     const registerProviderSockets = (0, import_react.useCallback)(
-      (sockets2) => {
-        if (sockets2) {
-          systemLog("dsp", "[registerProviderSockets]", sockets2);
-          var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
-          setSockets((prev) => {
-            const newS = { ...prev };
-            d.forEach((item) => {
-              if (newS[item]) {
-                newS[item].listeners = newS[item].listeners + 1;
+      (sockets2, filter) => {
+        if (!sockets2) return;
+        const normalizedFilter = filter ?? {};
+        systemLog("dsp", "[registerProviderSockets]", sockets2, `filter: ${JSON.stringify(normalizedFilter)}`);
+        const d = Array.isArray(sockets2) ? sockets2 : [sockets2];
+        setSockets((prev) => {
+          const newS = { ...prev };
+          d.forEach((item) => {
+            if (newS[item]) {
+              const existingFilter = newS[item].filters.find((f) => (0, import_isEqual.default)(f.filter, normalizedFilter));
+              if (existingFilter) {
+                existingFilter.listeners++;
+                systemLog("dsp", `[registerProviderSockets] Filter uz existuje, navysuji listeners na ${existingFilter.listeners}`);
               } else {
-                const roomHandler = (msg) => {
-                  const { dispatch: currentDispatch, updateDocument: currentUpdateDocument } = socketActionHandlersRef.current;
-                  handleSocketMessage(item, msg, {
-                    dispatch: currentDispatch,
-                    updateDocument: currentUpdateDocument
-                  });
-                };
-                socketRoomHandlersRef.current[item] = roomHandler;
-                newS[item] = { listeners: 1, data: [] };
-                socket.emit("joinRoom", item);
-                socket.on(item, roomHandler);
+                newS[item].filters = [...newS[item].filters, { filter: normalizedFilter, listeners: 1 }];
+                socket.emit("joinRoom", { room: item, filter: normalizedFilter });
+                systemLog(
+                  "dsp",
+                  `[registerProviderSockets] Novy filter, registruji room ${item} s filterem ${JSON.stringify(normalizedFilter)}`
+                );
               }
-            });
-            return newS;
+            } else {
+              newS[item] = {
+                filters: [{ filter: normalizedFilter, listeners: 1 }],
+                data: []
+              };
+              socket.emit("joinRoom", { room: item, filter: normalizedFilter });
+              systemLog("dsp", `[registerProviderSockets] Nova room ${item}, filter: ${JSON.stringify(normalizedFilter)}`);
+            }
           });
-        }
+          return newS;
+        });
       },
       [setSockets, socket]
     );
     const unregisterProviderSockets = (0, import_react.useCallback)(
-      (sockets2) => {
-        systemLog("dsp", "[unregisterProviderSockets] Mazu sockety ", JSON.stringify(sockets2, null, 2));
-        var removeSocketListeners = [];
-        var d = Array.isArray(sockets2) ? sockets2 : [sockets2];
+      (sockets2, filter) => {
+        const normalizedFilter = filter ?? {};
+        systemLog(
+          "dsp",
+          "[unregisterProviderSockets] Mazu sockety",
+          JSON.stringify(sockets2, null, 2),
+          `filter: ${JSON.stringify(normalizedFilter)}`
+        );
+        const d = Array.isArray(sockets2) ? sockets2 : [sockets2];
         setSockets((prev) => {
           const newS = { ...prev };
+          const removeSocketListeners = [];
           d.forEach((item) => {
-            if (newS[item]?.listeners <= 1) {
+            if (!newS[item]) return;
+            const existingFilter = newS[item].filters.find((f) => (0, import_isEqual.default)(f.filter, normalizedFilter));
+            if (!existingFilter) return;
+            if (existingFilter.listeners <= 1) {
+              newS[item].filters = newS[item].filters.filter((f) => !(0, import_isEqual.default)(f.filter, normalizedFilter));
+              socket.emit("leaveRoom", { room: item, filter: normalizedFilter });
+              systemLog(
+                "dsp",
+                `[unregisterProviderSockets] Filter smazan, odhlaseni room ${item} s filterem ${JSON.stringify(normalizedFilter)}`
+              );
+            } else {
+              existingFilter.listeners--;
+              systemLog("dsp", `[unregisterProviderSockets] Filter listeners snizen na ${existingFilter.listeners}`);
+            }
+            if (newS[item].filters.length === 0) {
               removeSocketListeners.push(item);
-              const roomHandler = socketRoomHandlersRef.current[item];
-              if (roomHandler) {
-                socket.off(item, roomHandler);
-                delete socketRoomHandlersRef.current[item];
-              }
               delete newS[item];
-            } else if (newS[item]) newS[item].listeners = newS[item].listeners - 1;
+              systemLog("dsp", `[unregisterProviderSockets] Room ${item} uplne smazana`);
+            }
           });
           if (removeSocketListeners.length > 0) {
-            socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
+            socket.emit("leaveRooms", removeSocketListeners);
           }
           return newS;
         });
@@ -1721,60 +1778,62 @@ var DataStoreProvider = (0, import_react.forwardRef)(
         setCounterProviders((prev) => {
           if (!prev[id]) return prev;
           if (prev[id] + val > 0) {
-            return {
-              ...prev,
-              [id]: prev[id] + val
-            };
-          } else {
-            setProviders((prevP) => {
-              systemLog("dsp", "[DSP] UPDATE PROVIDER - mazu sockets ", id);
-              setSockets((prevS) => {
-                var removeSocketListeners = [];
-                const newS = { ...prevS };
-                const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
-                providerSocketListeners.forEach((socketName) => {
-                  if (!newS[socketName]) return;
-                  if (newS[socketName].listeners + val <= 0) {
-                    const roomHandler = socketRoomHandlersRef.current[socketName];
-                    if (roomHandler) {
-                      socket.off(socketName, roomHandler);
-                      delete socketRoomHandlersRef.current[socketName];
-                    }
-                    delete newS[socketName];
-                    removeSocketListeners.push(socketName);
-                  } else {
-                    newS[socketName].listeners = newS[socketName].listeners + val;
-                  }
-                });
-                if (removeSocketListeners.length > 0) {
-                  socket.emit("leaveRooms", JSON.stringify(removeSocketListeners));
+            return { ...prev, [id]: prev[id] + val };
+          }
+          setProviders((prevP) => {
+            systemLog("dsp", "[DSP] UPDATE PROVIDER - mazu sockets ", id);
+            setSockets((prevS) => {
+              const newS = { ...prevS };
+              const removeSocketListeners = [];
+              const providerSocketListeners = prevP[id].dataSource?.socketListeners || [];
+              const providerFilter = prevP[id].dataSource?.filter;
+              const normalizedFilter = providerFilter ?? {};
+              providerSocketListeners.forEach((socketName) => {
+                if (!newS[socketName]) return;
+                const existingFilter = newS[socketName].filters.find((f) => (0, import_isEqual.default)(f.filter, normalizedFilter));
+                if (!existingFilter) return;
+                if (existingFilter.listeners + val <= 0) {
+                  newS[socketName].filters = newS[socketName].filters.filter((f) => !(0, import_isEqual.default)(f.filter, normalizedFilter));
+                  socket.emit("leaveRoom", { room: socketName, filter: normalizedFilter });
+                  systemLog("dsp", `[updateProviderListeners] Filter smazan pro room ${socketName}`);
+                } else {
+                  existingFilter.listeners = existingFilter.listeners + val;
+                  systemLog("dsp", `[updateProviderListeners] Filter listeners snizen na ${existingFilter.listeners}`);
+                }
+                if (newS[socketName].filters.length === 0) {
+                  removeSocketListeners.push(socketName);
+                  delete newS[socketName];
+                  systemLog("dsp", `[updateProviderListeners] Room ${socketName} uplne smazana`);
                 }
-                return newS;
               });
-              setCounterDocuments((prevC) => {
-                const newC = { ...prevC };
-                prevP[id].data.forEach((document) => {
-                  if (newC[document] + val <= 0) {
-                    setDocuments((prev2) => {
-                      const newD = { ...prev2 };
-                      delete newD[document];
-                      return newD;
-                    });
-                    delete newC[document];
-                  } else {
-                    newC[document] = newC[document] + val;
-                  }
-                });
-                return newC;
+              if (removeSocketListeners.length > 0) {
+                socket.emit("leaveRooms", removeSocketListeners);
+              }
+              return newS;
+            });
+            setCounterDocuments((prevC) => {
+              const newC = { ...prevC };
+              prevP[id].data.forEach((document) => {
+                if (newC[document] + val <= 0) {
+                  setDocuments((prev2) => {
+                    const newD = { ...prev2 };
+                    delete newD[document];
+                    return newD;
+                  });
+                  delete newC[document];
+                } else {
+                  newC[document] = newC[document] + val;
+                }
               });
-              const newP = { ...prevP };
-              delete newP[id];
-              return newP;
+              return newC;
             });
-            const newProvs = { ...prev };
-            delete newProvs[id];
-            return newProvs;
-          }
+            const newP = { ...prevP };
+            delete newP[id];
+            return newP;
+          });
+          const newProvs = { ...prev };
+          delete newProvs[id];
+          return newProvs;
         });
       },
       [setCounterProviders, setProviders, setCounterDocuments, setDocuments, socket]
@@ -1848,7 +1907,7 @@ var DataStoreProvider = (0, import_react.forwardRef)(
               [id]: 1
             }));
             if (provider.dataSource?.socketListeners) {
-              registerProviderSockets(provider.dataSource.socketListeners);
+              registerProviderSockets(provider.dataSource.socketListeners, provider.dataSource.filter);
             }
             console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
           } catch (error) {
@@ -1872,7 +1931,7 @@ var DataStoreProvider = (0, import_react.forwardRef)(
               };
             } else {
               systemLog("dsp", "[unregisterProvider]  mazu ", Object.keys(providers));
-              unregisterProviderSockets(providers[itemId]?.dataSource.socketListeners);
+              unregisterProviderSockets(providers[itemId]?.dataSource.socketListeners, providers[itemId]?.dataSource.filter);
               systemLog("dsp", "[unregisterProvider] Mazu dokumenty providera ", itemId);
               setCounterDocuments((cd) => {
                 const newC = { ...cd };