tinybase 5.0.0-beta.1 → 5.0.0-beta.11

package/lib/debug/persisters/persister-expo-sqlite-next.js

@@ -43,8 +43,6 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
-const objIds = object.keys;
-const objFreeze = object.freeze;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -55,15 +53,16 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
+const objIds = object.keys;
+const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
 const objMerge = (...objs) => object.assign({}, ...objs);
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
   delete obj[id];
   return obj;
 };
-const objMap = (obj, cb) =>
+const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
 const objValues = (obj) => object.values(obj);
 const objSize = (obj) => size(objIds(obj));
@@ -78,14 +77,16 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
 const mapMatch = (map, obj, set, del = mapSet) => {
-  objMap(obj, (value, id) => set(map, id, value));
+  objToArray(obj, (value, id) => set(map, id, value));
   mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
   return map;
 };
@@ -98,10 +99,18 @@ const setNew = (entryOrEntries) =>
   );
 const setAdd = (set, value) => set?.add(value);
 
+const TABLE = 'TABLE';
+const ALTER_TABLE = 'ALTER ' + TABLE;
+const DELETE_FROM = 'DELETE FROM';
 const SELECT_STAR_FROM = SELECT + '*FROM';
 const FROM_PRAGMA_TABLE = 'FROM pragma_table_';
 const WHERE = 'WHERE';
-const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
+const getCommandFunctions = (
+  cmd,
+  managedTableNames,
+  onIgnoredError,
+  useOnConflict,
+) => {
   const schemaMap = mapNew();
   const canSelect = (tableName, rowIdColumnName) =>
     !isUndefined(mapGet(mapGet(schemaMap, tableName), rowIdColumnName));
@@ -114,7 +123,7 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
             await cmd(
               'SELECT name ' +
                 FROM_PRAGMA_TABLE +
-                `list WHERE schema='main'AND type='table'AND name IN(` +
+                `list WHERE schema='main'AND(type='table'OR type='view')AND name IN(` +
                 getPlaceholders(managedTableNames) +
                 `)ORDER BY name`,
               managedTableNames,
@@ -169,31 +178,38 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
   const saveTable = async (
     tableName,
     rowIdColumnName,
-    table,
+    content,
     deleteEmptyColumns,
     deleteEmptyTable,
     partial = false,
   ) => {
-    const tableCellIds = setNew();
-    objMap(table ?? {}, (row) =>
-      arrayMap(objIds(row ?? {}), (cellId) => setAdd(tableCellIds, cellId)),
+    const tableCellOrValueIds = setNew();
+    objToArray(content ?? {}, (contentRow) =>
+      arrayMap(objIds(contentRow ?? {}), (cellOrValueId) =>
+        setAdd(tableCellOrValueIds, cellOrValueId),
+      ),
     );
-    const tableColumnNames = collValues(tableCellIds);
+    const tableColumnNames = collValues(tableCellOrValueIds);
     if (
       !partial &&
       deleteEmptyTable &&
       arrayIsEmpty(tableColumnNames) &&
       collHas(schemaMap, tableName)
     ) {
-      await cmd('DROP TABLE' + escapeId(tableName));
+      await cmd('DROP ' + TABLE + escapeId(tableName));
       mapSet(schemaMap, tableName);
       return;
     }
     if (!arrayIsEmpty(tableColumnNames) && !collHas(schemaMap, tableName)) {
       await cmd(
-        `CREATE TABLE${escapeId(tableName)}(${escapeId(rowIdColumnName)} PRIMARY KEY ON CONFLICT REPLACE${arrayJoin(
-          arrayMap(tableColumnNames, (cellId) => COMMA + escapeId(cellId)),
-        )});`,
+        `CREATE ` +
+          TABLE +
+          escapeId(tableName) +
+          '(' +
+          escapeId(rowIdColumnName) +
+          ` PRIMARY KEY ON CONFLICT REPLACE${arrayJoin(
+            arrayMap(tableColumnNames, (cellId) => COMMA + escapeId(cellId)),
+          )});`,
       );
       mapSet(
         schemaMap,
@@ -213,7 +229,7 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
         ...arrayMap(tableColumnNames, async (columnName) => {
           if (!collDel(columnNamesAccountedFor, columnName)) {
             await cmd(
-              `ALTER TABLE${escapeId(tableName)}ADD${escapeId(columnName)}`,
+              ALTER_TABLE + escapeId(tableName) + 'ADD' + escapeId(columnName),
             );
             mapSet(tableSchemaMap, columnName, EMPTY_STRING);
           }
@@ -224,9 +240,10 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
               async (columnName) => {
                 if (columnName != rowIdColumnName) {
                   await cmd(
-                    `ALTER TABLE${escapeId(tableName)}DROP${escapeId(
-                      columnName,
-                    )}`,
+                    ALTER_TABLE +
+                      escapeId(tableName) +
+                      'DROP' +
+                      escapeId(columnName),
                   );
                   mapSet(tableSchemaMap, columnName);
                 }
@@ -236,14 +253,14 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
       ]);
     }
     if (partial) {
-      if (isUndefined(table)) {
-        await cmd('DELETE FROM' + escapeId(tableName) + 'WHERE 1');
+      if (isUndefined(content)) {
+        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' 1');
       } else {
         await promiseAll(
-          objMap(table, async (row, rowId) => {
+          objToArray(content, async (row, rowId) => {
             if (isUndefined(row)) {
               await cmd(
-                'DELETE FROM' +
+                DELETE_FROM +
                   escapeId(tableName) +
                   WHERE +
                   escapeId(rowIdColumnName) +
@@ -251,10 +268,14 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
                 [rowId],
               );
             } else if (!arrayIsEmpty(tableColumnNames)) {
-              await upsert(cmd, tableName, rowIdColumnName, objIds(row), [
-                rowId,
-                ...objValues(row),
-              ]);
+              await upsert(
+                cmd,
+                tableName,
+                rowIdColumnName,
+                objIds(row),
+                [rowId, ...objValues(row)],
+                useOnConflict,
+              );
             }
           }),
         );
@@ -267,7 +288,7 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
         );
         const args = [];
         const deleteRowIds = [];
-        objMap(table ?? {}, (row, rowId) => {
+        objToArray(content ?? {}, (row, rowId) => {
           arrayPush(
             args,
             rowId,
@@ -281,9 +302,10 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
           rowIdColumnName,
           changingColumnNames,
           args,
+          useOnConflict,
         );
         await cmd(
-          'DELETE FROM' +
+          DELETE_FROM +
             escapeId(tableName) +
             WHERE +
             escapeId(rowIdColumnName) +
@@ -293,7 +315,7 @@ const getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
           deleteRowIds,
         );
       } else if (collHas(schemaMap, tableName)) {
-        await cmd('DELETE FROM' + escapeId(tableName) + 'WHERE 1');
+        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' 1');
       }
     }
   };
@@ -316,9 +338,12 @@ const upsert = async (
   rowIdColumnName,
   changingColumnNames,
   args,
+  useOnConflict = true,
 ) =>
   await cmd(
-    'INSERT INTO' +
+    'INSERT ' +
+      (useOnConflict ? EMPTY_STRING : 'OR REPLACE ') +
+      'INTO' +
       escapeId(tableName) +
       '(' +
       escapeId(rowIdColumnName) +
@@ -336,18 +361,20 @@ const upsert = async (
         ),
         1,
       ) +
-      'ON CONFLICT(' +
-      escapeId(rowIdColumnName) +
-      ')DO UPDATE SET' +
-      arrayJoin(
-        arrayMap(
-          changingColumnNames,
-          (columnName) =>
-            escapeId(columnName) + '=excluded.' + escapeId(columnName),
-        ),
-        COMMA,
-      ),
-    args,
+      (useOnConflict
+        ? 'ON CONFLICT(' +
+          escapeId(rowIdColumnName) +
+          ')DO UPDATE SET' +
+          arrayJoin(
+            arrayMap(
+              changingColumnNames,
+              (columnName) =>
+                escapeId(columnName) + '=excluded.' + escapeId(columnName),
+            ),
+            COMMA,
+          )
+        : EMPTY_STRING),
+    arrayMap(args, (arg) => arg ?? null),
   );
 const getPlaceholders = (array) =>
   arrayJoin(
@@ -355,7 +382,7 @@ const getPlaceholders = (array) =>
     COMMA,
   );
 
-const jsonString = (obj) =>
+const jsonStringWithMap = (obj) =>
   JSON.stringify(obj, (_key, value) =>
     isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
   );
@@ -363,6 +390,27 @@ const jsonParse = JSON.parse;
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
+const getStoreFunctions = (supportedStoreType = 1, store) =>
+  supportedStoreType > 1 && 'getMergeableContent' in store
+    ? [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : supportedStoreType != 2
+      ? [
+          0,
+          store.getContent,
+          store.getTransactionChanges,
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : /* istanbul ignore next */
+        0;
 const createCustomPersister = (
   store,
   getPersisted,
@@ -370,18 +418,25 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  [getThing, thing] = [],
+  supportedStoreType,
+  extra = {},
   scheduleId = [],
 ) => {
-  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = 0;
   let action;
-  let listeningHandle;
+  let autoLoadHandle;
+  let autoSaveListenerId;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(supportedStoreType, store);
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -399,109 +454,121 @@ const createCustomPersister = (
       mapSet(scheduleRunning, scheduleId, 0);
     }
   };
-  const loadLock = async (actions) => {
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = async (initialContent) => {
     /* istanbul ignore else */
     if (loadSave != 2) {
       loadSave = 1;
       {
         loads++;
       }
-      await persister.schedule(async () => {
-        await actions();
+      await schedule(async () => {
+        try {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
+          if (initialContent) {
+            setDefaultContent(initialContent);
+          }
+        }
         loadSave = 0;
       });
     }
     return persister;
   };
-  const persister = {
-    load: async (initialTables, initialValues) =>
-      await loadLock(async () => {
-        try {
-          store.setContent(await getPersisted());
-        } catch {
-          store.setContent([initialTables, initialValues]);
-        }
-      }),
-    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
-      persister.stopAutoLoad();
-      await persister.load(initialTables, initialValues);
-      listening = 1;
-      listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
-            await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
-            );
-          } else {
-            await loadLock(async () => {
-              try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
-              } catch (error) {
-                onIgnoredError?.(error);
-              }
-            });
+  const startAutoLoad = async (initialContent) => {
+    await stopAutoLoad().load(initialContent);
+    autoLoadHandle = addPersisterListener(async (content, changes) => {
+      if (changes || content) {
+        /* istanbul ignore else */
+        if (loadSave != 2) {
+          loadSave = 1;
+          {
+            loads++;
           }
-        },
-      );
-      return persister;
-    },
-    stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
+          setContentOrChanges(changes ?? content);
+          loadSave = 0;
+        }
+      } else {
+        await load();
       }
-      return persister;
-    },
-    save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
+    });
+    return persister;
+  };
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (loadSave != 1) {
+      loadSave = 2;
+      {
+        saves++;
+      }
+      await schedule(async () => {
+        try {
+          await setPersisted(getContent, changes);
+        } catch (error) {
+          /* istanbul ignore next */
+          onIgnoredError?.(error);
         }
-        await persister.schedule(async () => {
-          try {
-            await setPersisted(store.getContent, getTransactionChanges);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          loadSave = 0;
-        });
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    await stopAutoSave().save();
+    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+      const changes = getChanges();
+      if (hasChanges(changes)) {
+        save(changes);
       }
-      return persister;
-    },
-    startAutoSave: async () => {
-      await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) => {
-          const [tableChanges, valueChanges] = getTransactionChanges();
-          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-            persister.save(() => [tableChanges, valueChanges]);
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoSave: () => {
-      ifNotUndefined(listenerId, store.delListener);
-      listenerId = void 0;
-      return persister;
-    },
-    schedule: async (...actions) => {
-      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-      await run();
-      return persister;
-    },
-    getStore: () => store,
-    destroy: () => persister.stopAutoLoad().stopAutoSave(),
-    getStats: () => ({loads, saves}),
+    });
+    return persister;
+  };
+  const stopAutoSave = () => {
+    ifNotUndefined(autoSaveListenerId, store.delListener);
+    autoSaveListenerId = void 0;
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const schedule = async (...actions) => {
+    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+    await run();
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = () => stopAutoLoad().stopAutoSave();
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    schedule,
+    getStore,
+    destroy,
+    getStats,
+    ...extra,
   };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
   return objFreeze(persister);
 };
 
@@ -516,9 +583,10 @@ const createJsonSqlitePersister = (
   managedTableNames,
   db,
   getThing,
+  useOnConflict,
 ) => {
   const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError);
+    getCommandFunctions(cmd, managedTableNames, onIgnoredError, useOnConflict);
   const getPersisted = async () =>
     await transaction(async () => {
       await refreshSchema();
@@ -535,7 +603,9 @@ const createJsonSqlitePersister = (
         storeTableName,
         DEFAULT_ROW_ID_COLUMN_NAME,
         {
-          [SINGLE_ROW_ID]: {[STORE_COLUMN]: jsonString(getContent() ?? null)},
+          [SINGLE_ROW_ID]: {
+            [STORE_COLUMN]: jsonStringWithMap(getContent() ?? null),
+          },
         },
         true,
         true,
@@ -548,7 +618,8 @@ const createJsonSqlitePersister = (
     addPersisterListener,
     delPersisterListener,
     onIgnoredError,
-    [getThing, db],
+    1,
+    {[getThing]: () => db},
     db,
   );
   return persister;
@@ -568,9 +639,10 @@ const createTabularSqlitePersister = (
   managedTableNames,
   db,
   getThing,
+  useOnConflict,
 ) => {
   const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError);
+    getCommandFunctions(cmd, managedTableNames, onIgnoredError, useOnConflict);
   const saveTables = async (tables, partial) =>
     await promiseAll(
       mapMap(
@@ -579,12 +651,11 @@ const createTabularSqlitePersister = (
           [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
           tableId,
         ) => {
-          const table = tables[tableId];
-          if (!partial || table !== void 0) {
+          if (!partial || objHas(tables, tableId)) {
             await saveTable(
               tableName,
               rowIdColumnName,
-              table,
+              tables[tableId],
               deleteEmptyColumns,
               deleteEmptyTable,
               partial,
@@ -634,13 +705,12 @@ const createTabularSqlitePersister = (
         ? [tables, values]
         : void 0;
     });
-  const setPersisted = async (getContent, getTransactionChanges) =>
+  const setPersisted = async (getContent, changes) =>
     await transaction(async () => {
       await refreshSchema();
-      if (!isUndefined(getTransactionChanges)) {
-        const [tableChanges, valueChanges] = getTransactionChanges();
-        await saveTables(tableChanges, true);
-        await saveValues(valueChanges, true);
+      if (!isUndefined(changes)) {
+        await saveTables(changes[0], true);
+        await saveValues(changes[1], true);
       } else {
         const [tables, values] = getContent();
         await saveTables(tables);
@@ -654,7 +724,8 @@ const createTabularSqlitePersister = (
     addPersisterListener,
     delPersisterListener,
     onIgnoredError,
-    [getThing, db],
+    1,
+    {[getThing]: () => db},
     db,
   );
   return persister;
@@ -691,7 +762,7 @@ const getDefaultedTabularConfigMap = (
   filter,
 ) => {
   const configMap = mapNew();
-  objMap(configsObj, (configObj, id) => {
+  objToArray(configsObj, (configObj, id) => {
     const defaultedConfig = slice(
       objValues(
         objMerge(
@@ -766,6 +837,7 @@ const createSqlitePersister = (
   onIgnoredError,
   db,
   getThing = 'getDb',
+  useOnConflict,
 ) => {
   let dataVersion;
   let schemaVersion;
@@ -828,6 +900,7 @@ const createSqlitePersister = (
     collValues(managedTableNamesSet),
     db,
     getThing,
+    useOnConflict,
   );
 };