@mgarlik/datastore 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,15 +1,10 @@
+import {
+  systemLog
+} from "./chunk-7XDRKNJQ.js";
+
 // src/DataStoreProvider.tsx
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 
-// src/log.ts
-function systemLog(..._args) {
-}
-function systemLogError(...args) {
-  if (typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(...args);
-  }
-}
-
 // src/handleSocketMessage.ts
 var handleSocketMessage = (model, msg, dataProvider) => {
   const { dispatch, updateDocument } = dataProvider;
@@ -40,9 +35,6 @@ var handleSocketMessage = (model, msg, dataProvider) => {
 // src/handleData.ts
 import axios from "axios";
 
-// src/utils.ts
-import * as Crypto from "expo-crypto";
-
 // src/dotPath.ts
 function propToArray(prop) {
   return prop.split(".").reduce((ret, el, index, list) => {
@@ -87,6 +79,13 @@ function getValueByDotPath(obj, prop, value) {
 
 // src/utils.ts
 import dayjs from "dayjs";
+function randomUuidSegment(template) {
+  return template.replace(/[xy]/g, (char) => {
+    const random = Math.floor(Math.random() * 16);
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -549,7 +548,13 @@ var dataStoreFilterObject = (obj, filter) => {
   return result;
 };
 function uuid() {
-  return Crypto.randomUUID();
+  return [
+    randomUuidSegment("xxxxxxxx"),
+    randomUuidSegment("xxxx"),
+    "4" + randomUuidSegment("xxx"),
+    randomUuidSegment("yxxx"),
+    randomUuidSegment("xxxxxxxxxxxx")
+  ].join("-");
 }
 function isUuid(val) {
   if (typeof val !== "string") return false;
@@ -562,7 +567,7 @@ var saveData = async ({
   providerId,
   newData,
   dateUpdate,
-  SQLite: SQLite3
+  SQLite
 }) => {
   console.time(`[SQL] saveData ${providerId}`);
   const batchSize = 8e3;
@@ -577,8 +582,7 @@ var saveData = async ({
       }
     }
     const placeholdersArray = Array.from({ length: Math.ceil(values.length / 4) }, () => placeholders).join(",");
-    if (placeholdersArray.length < 10) console.log("DATA TO UPDATE", JSON.stringify(values, null, 2));
-    const row = await SQLite3.query(`INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES ${placeholdersArray}`, values);
+    const row = await SQLite.query(`INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES ${placeholdersArray}`, values);
     systemLog("axios", "saveData result: ", JSON.stringify(row));
   }
   console.timeEnd(`[SQL] saveData ${providerId}`);
@@ -600,7 +604,7 @@ var buildUri = ({
   }
   return dataSource.uri || `${dataSource.model || ""}/`;
 };
-var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, changeTime }) => {
+var getData = async ({ id, dataSource, isPersisting, schema, SQLite, changeTime }) => {
   if (dataSource) systemLog("axios", "GET Data Source: ", buildUri({ dataSource, method: "read" }));
   else systemLog("axios", "No DataSource for ", id);
   let persistedData = [];
@@ -617,12 +621,24 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, ch
     } else {
       if (changeTime) {
         params.changeTime = changeTime;
-      } else if (isPersisting && SQLite3) {
+      } else if (isPersisting && SQLite) {
         console.time("Persisted Data");
-        const qDatum = await SQLite3.read(`SELECT * FROM documents WHERE model = '${id}' ORDER BY lastUpdate DESC`);
+        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;
-        persistedData = qDatum.map((item) => ({ id: item.id, ...JSON.parse(item.data) }));
+        persistedData = qDatum.map((item) => {
+          try {
+            const parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
+            if (!parsedData || typeof parsedData !== "object" || Array.isArray(parsedData)) {
+              systemLog("axios", "SQLite.read Preskakuji neplatny dokument:", item.id);
+              return null;
+            }
+            return { id: item.id, ...parsedData };
+          } catch (error) {
+            console.error("[datastore] Nepodarilo se zpracovat SQL data pro dokument", item.id, error);
+            return null;
+          }
+        }).filter((item) => item !== null);
         console.timeEnd("Persisted Data");
       }
       if (dataSource) {
@@ -670,8 +686,8 @@ var getData = async ({ id, dataSource, isPersisting, schema, SQLite: SQLite3, ch
           JSON.stringify(newData).length,
           "Bytes"
         );
-        if (isPersisting && SQLite3) {
-          await saveData({ providerId: id, newData, SQLite: SQLite3, dateUpdate: axiosResponse.data.queryAt || (/* @__PURE__ */ new Date()).toISOString() });
+        if (isPersisting && SQLite) {
+          await saveData({ providerId: id, newData, SQLite, dateUpdate: axiosResponse.data.queryAt || (/* @__PURE__ */ new Date()).toISOString() });
         }
       }
     }
@@ -736,7 +752,6 @@ var deleteData = async ({ dataSource, data }) => {
 // src/DataStoreProvider.tsx
 import { io as ioSockets } from "socket.io-client";
 import axios2 from "axios";
-import { getLocales } from "expo-localization";
 
 // src/templates.ts
 var _renderMyTemplate = (templateString, data) => {
@@ -767,162 +782,7 @@ function renderJSONTemplate(val, data) {
 
 // src/DataStoreProvider.tsx
 import isEqual from "lodash/isEqual.js";
-
-// src/database.ts
-import * as SQL from "expo-sqlite";
-var SQLite = class {
-  constructor(name) {
-    this.db = null;
-    this.dbName = name || "modelaz.db";
-    this.initDB();
-  }
-  async initDB() {
-    if (!this.db) {
-      try {
-        systemLog("sql", "[initDB]");
-        this.db = await SQL.openDatabaseAsync(this.dbName);
-        await this.createTables({
-          documents: "id TEXT PRIMARY KEY, data TEXT, model TEXT, lastUpdate TEXT"
-          // logs: "time TEXT PRIMARY KEY, module TEXT, message TEXT",
-        });
-      } catch (e) {
-        console.log("INITDB ERROR", e);
-        throw e;
-      }
-    }
-  }
-  async getDb() {
-    if (!this.db) {
-      await this.initDB();
-    }
-    if (!this.db) {
-      throw new Error("Database is not initialized");
-    }
-    return this.db;
-  }
-  async createTable(table, tableSchema) {
-    try {
-      systemLog("sql", "[createTable]", table);
-      const db = await this.getDb();
-      const result = await db.runAsync(`CREATE TABLE IF NOT EXISTS '${table}' (${tableSchema})`);
-      systemLog("sql", "[createTable] result: ", JSON.stringify(result));
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[createTable]", e);
-      throw e;
-    }
-  }
-  async createTables(tables) {
-    try {
-      systemLog("sql", "[createTables]", tables);
-      const query = Object.entries(tables).reduce((acc, [table, schema]) => {
-        return acc + `CREATE TABLE IF NOT EXISTS '${table}' (${schema});`;
-      }, "");
-      const db = await this.getDb();
-      const result = await db.runAsync(query);
-      systemLog("sql", "[createTables] result: ", JSON.stringify(result));
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[createTable]", e);
-      throw e;
-    }
-  }
-  /**
-   * Smazani starych logu
-   */
-  async deleteLogs() {
-    systemLog("sql", "[query] delete old Logs", this.db);
-    try {
-      const db = await this.getDb();
-      await db.runAsync(`DELETE FROM logs WHERE strftime('%s', 'now') - strftime('%s', time) > 3600`);
-    } catch (error) {
-      throw error;
-    }
-  }
-  async read(query, args) {
-    try {
-      systemLog("sql", "[read]", query);
-      const db = await this.getDb();
-      const result = args === void 0 ? await db.getAllAsync(query) : await db.getAllAsync(query, args);
-      systemLog("sql", "[read] result ", result.length);
-      return result;
-    } catch (e) {
-      systemLogError("sql", "[read]", e);
-      throw e;
-    }
-  }
-  async query(query, args) {
-    try {
-      systemLog("sql", "[query]->", query);
-      const db = await this.getDb();
-      const result = args === void 0 ? await db.getAllAsync(query) : await db.getAllAsync(query, args);
-      systemLog("sql", result);
-      return result;
-    } catch (error) {
-      console.error("INSERT ERROR", error);
-      systemLogError("sql", error);
-      throw error;
-    }
-  }
-  async dropTable(table) {
-    try {
-      systemLog("sql", "dropTable", table);
-      console.time("[SQL] dropTable");
-      const db = await this.getDb();
-      const result = await db.runAsync(`DROP TABLE ${table}`);
-      console.timeEnd("[SQL] dropTable");
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async emptyTable(table) {
-    try {
-      systemLog("sql", `[emptyTable]`, table);
-      const db = await this.getDb();
-      const result = await db.runAsync(`DELETE FROM '${table}'`);
-      systemLog("sql", "[emptyTable] result", result);
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getTables() {
-    systemLog("sql", "Jdu zkusit nacist tabulky z ", JSON.stringify(this.dbName));
-    try {
-      const db = await this.getDb();
-      const result = await db.getAllAsync('SELECT name FROM sqlite_master WHERE type="table"');
-      systemLog("sql", "DB Result:", result);
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-  async resetDatabase() {
-    try {
-      systemLog("sql", "Reset database", this.dbName);
-      console.time("DELETING");
-      systemLog("sql", "Closing");
-      const db = await this.getDb();
-      await db.closeAsync();
-      systemLog("sql", "Deleting");
-      await SQL.deleteDatabaseAsync(this.dbName);
-      console.timeEnd("DELETING");
-      console.time("INIT");
-      this.db = null;
-      systemLog("sql", "Zacinam inicializovat databazi databaze");
-      await this.initDB();
-      systemLog("sql", "Inicializovana databaze");
-      console.timeEnd("INIT");
-    } catch (e) {
-      systemLogError("sql", "[resetDatabase]", e);
-    }
-  }
-};
-
-// src/DataStoreProvider.tsx
 import { jsx } from "react/jsx-runtime";
-var SQLite2 = new SQLite("modelaz.db");
 var DataStoreContext = createContext({});
 var DataStoreDocumentsContext = createContext({});
 var DataStoreProvidersContext = createContext({});
@@ -1002,7 +862,23 @@ var buildDocumentTemplateParams = (model, documentId) => {
     [templateIdKey]: documentId
   };
 };
-var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true, ...props }) => {
+var resolveLocale = () => {
+  if (typeof Intl !== "undefined" && typeof Intl.DateTimeFormat === "function") {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (locale) return locale;
+  }
+  if (typeof navigator !== "undefined") {
+    if (typeof navigator.language === "string" && navigator.language.length > 0) {
+      return navigator.language;
+    }
+    if (Array.isArray(navigator.languages) && navigator.languages.length > 0) {
+      const firstLocale = navigator.languages.find((value) => typeof value === "string" && value.length > 0);
+      if (firstLocale) return firstLocale;
+    }
+  }
+  return void 0;
+};
+var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true, locale, storage = null, ...props }) => {
   const [isLive, setIsLive] = useState(false);
   const [isSynchronizing, setIsSynchronizing] = useState(true);
   const [sockets, setSockets] = useState({});
@@ -1016,11 +892,17 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
   const [counterProviders, setCounterProviders] = useState({});
   const [counterDocuments, setCounterDocuments] = useState({});
   const didInitialLiveSyncRef = useRef(false);
+  const persistenceStorage = useMemo(
+    () => usePersistentStorage ? storage : null,
+    [storage, usePersistentStorage]
+  );
   useEffect(() => {
     if (!restServer) return;
-    const localization = getLocales();
+    const resolvedLocale = locale || resolveLocale();
     axios2.defaults.baseURL = restServer;
-    axios2.defaults.headers.common["Accept-Language"] = localization[0]?.languageCode;
+    if (resolvedLocale) {
+      axios2.defaults.headers.common["Accept-Language"] = resolvedLocale;
+    }
     systemLog("dsp", "[INIT] Axios baseURL:", restServer);
     async function checkServer() {
       try {
@@ -1040,7 +922,12 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
       }
     }
     checkServer();
-  }, [restServer]);
+  }, [locale, restServer]);
+  useEffect(() => {
+    if (usePersistentStorage && !storage) {
+      systemLog("dsp", "[INIT] Persistence is enabled but no storage adapter was provided.");
+    }
+  }, [persistenceStorage, storage, usePersistentStorage]);
   const socketRoomHandlersRef = useRef({});
   const socketActionHandlersRef = useRef({});
   systemLog("dsp", "START");
@@ -1099,22 +986,22 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
       data,
       lastUpdate = (/* @__PURE__ */ new Date()).toISOString()
     }) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
+      if (!persistenceStorage) return;
+      await persistenceStorage.query("INSERT OR REPLACE INTO documents (id, data, model, lastUpdate) VALUES (?, ?, ?, ?)", [
         documentId,
         JSON.stringify(data),
         model,
         lastUpdate
       ]);
     },
-    [usePersistentStorage]
+    [persistenceStorage]
   );
   const removePersistedDocument = useCallback(
     async (documentId) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query("DELETE FROM documents WHERE id = ?", [documentId]);
+      if (!persistenceStorage) return;
+      await persistenceStorage.query("DELETE FROM documents WHERE id = ?", [documentId]);
     },
-    [usePersistentStorage]
+    [persistenceStorage]
   );
   const synchronizeDataStore = useCallback(async () => {
     setIsSynchronizing(true);
@@ -1187,8 +1074,8 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
   }, [socket]);
   const resetDataStore = useCallback(async () => {
     console.time("[DSP] resetDataStore");
-    if (usePersistentStorage) {
-      await SQLite2.emptyTable("documents");
+    if (persistenceStorage?.emptyTable) {
+      await persistenceStorage.emptyTable("documents");
     }
     setSockets({});
     setProviders({});
@@ -1196,13 +1083,13 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
     setCounterProviders({});
     setCounterDocuments({});
     console.timeEnd("[DSP] resetDataStore");
-  }, [usePersistentStorage]);
+  }, [persistenceStorage]);
   const resetProvider = useCallback(
     async (provider) => {
-      if (!usePersistentStorage) return;
-      await SQLite2.query(`DELETE FROM documents WHERE model='${provider}'`);
+      if (!persistenceStorage) return;
+      await persistenceStorage.query(`DELETE FROM documents WHERE model='${provider}'`);
     },
-    [usePersistentStorage]
+    [persistenceStorage]
   );
   const initProvider = useCallback(
     async (id, data) => {
@@ -1214,7 +1101,7 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
       }
       return false;
     },
-    [presetProviders]
+    [persistenceStorage, presetProviders, usePersistentStorage]
   );
   const dispatch = useCallback((action, data, callback) => {
     systemLog("dsp", "[DSP] DISPATCH Ukladam akci", action, ",", data);
@@ -1380,12 +1267,12 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         };
         return newP;
       });
-      if (modelProvider?.isPersisting && usePersistentStorage) {
+      if (modelProvider?.isPersisting && persistenceStorage) {
         await Promise.all(documentsToPersist.map((item) => persistDocument({ documentId: item.id, model, data: item.data })));
         await Promise.all(documentIdsToDelete.map((documentId) => removePersistedDocument(documentId)));
       }
     },
-    [providers, setDocuments, setProviders, persistDocument, removePersistedDocument]
+    [providers, setDocuments, setProviders, persistDocument, removePersistedDocument, persistenceStorage]
   );
   const updateDocument = useCallback(
     async ({ documentId, model, fields, data: pData }) => {
@@ -1402,9 +1289,9 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
           const dataFromSource = await getData({
             id: dP.id,
             dataSource: { ...dP.dataSource, params: { select: fields.join(" ") } },
-            isPersisting: !!dP.isPersisting && usePersistentStorage,
+            isPersisting: !!dP.isPersisting && !!persistenceStorage,
             schema: dP.schema,
-            SQLite: SQLite2
+            SQLite: persistenceStorage || void 0
           });
           systemLog("dsp", "[updateDocument] DATA: ", dataFromSource);
           data = dataFromSource;
@@ -1516,7 +1403,7 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         } else {
           systemLog("dsp", "updateDocument - nemenim counterDocuments. Dokument zustava v", listeningProviders, "Providers");
         }
-        if (providers[model]?.isPersisting && usePersistentStorage) {
+        if (providers[model]?.isPersisting && persistenceStorage) {
           if (listeningProviders > 0) {
             await persistDocument({
               documentId,
@@ -1529,7 +1416,7 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         }
       }
     },
-    [documents, providers, setDocuments, setProviders, setCounterDocuments, persistDocument, removePersistedDocument]
+    [documents, providers, setDocuments, setProviders, setCounterDocuments, persistDocument, removePersistedDocument, persistenceStorage]
   );
   const updateDataStore = useCallback(
     async ({
@@ -1603,7 +1490,7 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         }
       });
       if (providerListenersCount > 0) {
-        if (providers[model]?.isPersisting && usePersistentStorage) {
+        if (providers[model]?.isPersisting && persistenceStorage) {
           await persistDocument({ documentId, model, data: newDocument });
         }
         setCounterDocuments((prev) => {
@@ -1623,7 +1510,7 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         return { id: documentId, document: newDocument };
       } else return false;
     },
-    [providers, setProviders, setCounterDocuments, setDocuments, persistDocument]
+    [providers, setProviders, setCounterDocuments, setDocuments, persistDocument, persistenceStorage]
   );
   const deleteDocument = useCallback(
     async ({ documentId }) => {
@@ -1827,66 +1714,71 @@ var DataStoreProvider = ({ socketServer, restServer, usePersistentStorage = true
         });
         result = providers[id];
       } else {
-        const dataFromSource = await getData({
-          schema: newItem.schema,
-          dataSource: newItem.dataSource || {},
-          id: newItem.id,
-          isPersisting: !!newItem.isPersisting && usePersistentStorage,
-          SQLite: SQLite2
-        });
-        console.time(`[DSP] VYTVARENI PROVIDERA ${id}`);
-        var dataList = [];
-        var items = {};
-        const dataS = Array.isArray(dataFromSource) ? dataFromSource : [dataFromSource];
-        dataS.forEach((item) => {
-          if (!item) return;
-          const { id: itId, ...data } = item;
-          const id2 = itId || uuid();
-          dataList.push(id2);
-          if (documents[id2]) {
-            items[id2] = {
-              ...documents[id2],
-              ...data
-            };
-          } else {
-            items[id2] = data;
-          }
-        });
-        setCounterDocuments((prev) => {
-          {
+        try {
+          const dataFromSource = await getData({
+            schema: newItem.schema,
+            dataSource: newItem.dataSource || {},
+            id: newItem.id,
+            isPersisting: !!newItem.isPersisting && !!persistenceStorage,
+            SQLite: persistenceStorage || void 0
+          });
+          console.time(`[DSP] VYTVARENI PROVIDERA ${id}`);
+          var dataList = [];
+          var items = {};
+          const dataS = Array.isArray(dataFromSource) ? dataFromSource : [dataFromSource];
+          dataS.forEach((item) => {
+            if (!item) return;
+            const { id: itId, ...data } = item;
+            const normalizedId = itId || uuid();
+            dataList.push(normalizedId);
+            if (documents[normalizedId]) {
+              items[normalizedId] = {
+                ...documents[normalizedId],
+                ...data
+              };
+            } else {
+              items[normalizedId] = data;
+            }
+          });
+          setCounterDocuments((prev) => {
             const newC = { ...prev };
-            dataList.forEach((i) => {
-              if (newC[i]) {
-                newC[i] = newC[i] + 1;
+            dataList.forEach((itemId) => {
+              if (newC[itemId]) {
+                newC[itemId] = newC[itemId] + 1;
               } else {
-                newC[i] = 1;
+                newC[itemId] = 1;
               }
             });
             return newC;
+          });
+          if (Object.keys(items).length > 0) {
+            setDocuments((prev) => ({ ...prev, ...items }));
           }
-        });
-        if (Object.keys(items).length > 0)
-          setDocuments((prev) => ({ ...prev, ...items }));
-        result = {
-          ...provider,
-          data: dataList,
-          lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
-        };
-        setProviders((prev) => ({
-          ...prev,
-          [id]: result
-        }));
-        setCounterProviders((prev) => ({
-          ...prev,
-          [id]: 1
-        }));
-        dataList;
-        if (provider.dataSource?.socketListeners) registerProviderSockets(provider.dataSource.socketListeners);
-        console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
+          result = {
+            ...provider,
+            data: dataList,
+            lastUpdate: { id: uuid(), time: /* @__PURE__ */ new Date() }
+          };
+          setProviders((prev) => ({
+            ...prev,
+            [id]: result
+          }));
+          setCounterProviders((prev) => ({
+            ...prev,
+            [id]: 1
+          }));
+          if (provider.dataSource?.socketListeners) {
+            registerProviderSockets(provider.dataSource.socketListeners);
+          }
+          console.timeEnd(`[DSP] VYTVARENI PROVIDERA ${id}`);
+        } catch (error) {
+          console.error("[DataStoreProvider] registerProvider:error", { id: newItem.id, error });
+          throw error;
+        }
       }
       return result;
     },
-    [providers, SQLite2, documents, setDocuments, setProviders, setCounterProviders, registerProviderSockets]
+    [providers, documents, setDocuments, setProviders, setCounterProviders, registerProviderSockets, persistenceStorage]
   );
   const unregisterProvider = useCallback(
     async (itemId) => {
@@ -2266,7 +2158,6 @@ export {
   DataStoreProvider_default as DataStoreProvider,
   DataStoreProvidersContext,
   DataStoreStableContext,
-  SQLite2 as SQLite,
   dataStoreFilterObject,
   doesObjectMatchFilter,
   doesValueMatchFilter,