tinybase 4.0.1 → 4.0.2

package/lib/debug/persisters/persister-cr-sqlite-wasm.js

@@ -68,10 +68,6 @@ const mapMatch = (map, obj, set, del = mapSet) => {
   return map;
 };
 
-const SINGLE_ROW_ID = '_';
-const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
-const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
-
 const setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -80,6 +76,10 @@ const setNew = (entryOrEntries) =>
   );
 const setAdd = (set, value) => set?.add(value);
 
+const SINGLE_ROW_ID = '_';
+const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
+const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
+
 const SELECT_STAR_FROM = 'SELECT*FROM';
 const FROM_PRAGMA_TABLE = 'FROM pragma_table_';
 const WHERE = 'WHERE';
@@ -133,21 +133,6 @@ const getCommandFunctions = (cmd, managedTableNames) => {
         ),
       (_, name) => mapSet(schemaMap, name),
     );
-  const loadSingleRow = async (tableName, rowIdColumnName) => {
-    const rows = canSelect(tableName, rowIdColumnName)
-      ? await cmd(
-          SELECT_STAR_FROM +
-            escapeId(tableName) +
-            WHERE +
-            escapeId(rowIdColumnName) +
-            '=?',
-          [SINGLE_ROW_ID],
-        )
-      : [];
-    return arrayIsEmpty(rows) ? null : objDel(rows[0], rowIdColumnName);
-  };
-  const saveSingleRow = async (tableName, rowIdColumnName, rowId, row) =>
-    await saveTable(tableName, rowIdColumnName, true, true, {[rowId]: row});
   const loadTable = async (tableName, rowIdColumnName) =>
     canSelect(tableName, rowIdColumnName)
       ? objNew(
@@ -166,30 +151,32 @@ const getCommandFunctions = (cmd, managedTableNames) => {
   const saveTable = async (
     tableName,
     rowIdColumnName,
+    table,
     deleteEmptyColumns,
     deleteEmptyTable,
-    table,
+    partial = false,
   ) => {
-    const cellIds = setNew();
+    const tableCellIds = setNew();
     objMap(table ?? {}, (row) =>
-      arrayMap(objIds(row), (cellId) => setAdd(cellIds, cellId)),
+      arrayMap(objIds(row ?? {}), (cellId) => setAdd(tableCellIds, cellId)),
     );
-    const columnNames = collValues(cellIds);
+    const tableColumnNames = collValues(tableCellIds);
     if (
-      arrayIsEmpty(columnNames) &&
-      collHas(schemaMap, tableName) &&
-      deleteEmptyTable
+      !partial &&
+      deleteEmptyTable &&
+      arrayIsEmpty(tableColumnNames) &&
+      collHas(schemaMap, tableName)
     ) {
       await cmd('DROP TABLE' + escapeId(tableName));
       mapSet(schemaMap, tableName);
       return;
     }
-    if (!arrayIsEmpty(columnNames) && !collHas(schemaMap, tableName)) {
+    if (!arrayIsEmpty(tableColumnNames) && !collHas(schemaMap, tableName)) {
       await cmd(
         `CREATE TABLE${escapeId(tableName)}(${escapeId(
           rowIdColumnName,
         )} PRIMARY KEY ON CONFLICT REPLACE${arrayJoin(
-          arrayMap(columnNames, (cellId) => COMMA + escapeId(cellId)),
+          arrayMap(tableColumnNames, (cellId) => COMMA + escapeId(cellId)),
         )});`,
       );
       mapSet(
@@ -197,14 +184,17 @@ const getCommandFunctions = (cmd, managedTableNames) => {
         tableName,
         mapNew([
           [rowIdColumnName, EMPTY_STRING],
-          ...arrayMap(columnNames, (columnName) => [columnName, EMPTY_STRING]),
+          ...arrayMap(tableColumnNames, (columnName) => [
+            columnName,
+            EMPTY_STRING,
+          ]),
         ]),
       );
     } else {
       const tableSchemaMap = mapGet(schemaMap, tableName);
       const columnNamesAccountedFor = setNew(mapKeys(tableSchemaMap));
       await promiseAll([
-        ...arrayMap(columnNames, async (columnName) => {
+        ...arrayMap(tableColumnNames, async (columnName) => {
           if (!collDel(columnNamesAccountedFor, columnName)) {
             await cmd(
               `ALTER TABLE${escapeId(tableName)}ADD${escapeId(columnName)}`,
@@ -212,7 +202,7 @@ const getCommandFunctions = (cmd, managedTableNames) => {
             mapSet(tableSchemaMap, columnName, EMPTY_STRING);
           }
         }),
-        ...(deleteEmptyColumns
+        ...(!partial && deleteEmptyColumns
           ? arrayMap(
               collValues(columnNamesAccountedFor),
               async (columnName) => {
@@ -229,68 +219,106 @@ const getCommandFunctions = (cmd, managedTableNames) => {
           : []),
       ]);
     }
-    if (!arrayIsEmpty(columnNames)) {
-      const insertSlots = [];
-      const insertBinds = [];
-      const deleteRowIds = [];
-      const allColumnNames = arrayFilter(
-        mapKeys(mapGet(schemaMap, tableName)),
-        (columnName) => columnName != rowIdColumnName,
-      );
-      objMap(table, (row, rowId) => {
-        arrayPush(
-          insertSlots,
-          `(?${strRepeat(',?', arrayLength(allColumnNames))})`,
+    if (partial) {
+      if (isUndefined(table)) {
+        await cmd('DELETE FROM' + escapeId(tableName) + 'WHERE 1');
+      } else {
+        await promiseAll(
+          objMap(table, async (row, rowId) => {
+            if (isUndefined(row)) {
+              await cmd(
+                'DELETE FROM' +
+                  escapeId(tableName) +
+                  WHERE +
+                  escapeId(rowIdColumnName) +
+                  '=?',
+                [rowId],
+              );
+            } else if (!arrayIsEmpty(tableColumnNames)) {
+              await upsert(cmd, tableName, rowIdColumnName, objIds(row), [
+                rowId,
+                ...objValues(row),
+              ]);
+            }
+          }),
         );
-        arrayPush(
-          insertBinds,
-          rowId,
-          ...arrayMap(allColumnNames, (cellId) => row[cellId]),
+      }
+    } else {
+      if (!arrayIsEmpty(tableColumnNames)) {
+        const changingColumnNames = arrayFilter(
+          mapKeys(mapGet(schemaMap, tableName)),
+          (columnName) => columnName != rowIdColumnName,
         );
-        arrayPush(deleteRowIds, rowId);
-      });
-      await cmd(
-        'INSERT INTO' +
-          escapeId(tableName) +
-          '(' +
-          escapeId(rowIdColumnName) +
-          arrayJoin(
-            arrayMap(
-              allColumnNames,
-              (columnName) => COMMA + escapeId(columnName),
-            ),
-          ) +
-          ')VALUES' +
-          arrayJoin(insertSlots, COMMA) +
-          'ON CONFLICT(' +
-          escapeId(rowIdColumnName) +
-          ')DO UPDATE SET' +
-          arrayJoin(
-            arrayMap(
-              allColumnNames,
-              (columnName) =>
-                escapeId(columnName) + '=excluded.' + escapeId(columnName),
-            ),
-            COMMA,
-          ),
-        insertBinds,
-      );
-      await cmd(
-        'DELETE FROM' +
-          escapeId(tableName) +
-          WHERE +
-          escapeId(rowIdColumnName) +
-          'NOT IN(' +
-          getPlaceholders(deleteRowIds) +
-          ')',
-        deleteRowIds,
-      );
-    } else if (collHas(schemaMap, tableName)) {
-      await cmd('DELETE FROM' + escapeId(tableName));
+        const args = [];
+        const deleteRowIds = [];
+        objMap(table ?? {}, (row, rowId) => {
+          arrayPush(
+            args,
+            rowId,
+            ...arrayMap(changingColumnNames, (cellId) => row?.[cellId]),
+          );
+          arrayPush(deleteRowIds, rowId);
+        });
+        await upsert(
+          cmd,
+          tableName,
+          rowIdColumnName,
+          changingColumnNames,
+          args,
+        );
+        await cmd(
+          'DELETE FROM' +
+            escapeId(tableName) +
+            WHERE +
+            escapeId(rowIdColumnName) +
+            'NOT IN(' +
+            getPlaceholders(deleteRowIds) +
+            ')',
+          deleteRowIds,
+        );
+      } else if (collHas(schemaMap, tableName)) {
+        await cmd('DELETE FROM' + escapeId(tableName) + 'WHERE 1');
+      }
     }
   };
-  return [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable];
+  return [refreshSchema, loadTable, saveTable];
 };
+const upsert = async (
+  cmd,
+  tableName,
+  rowIdColumnName,
+  changingColumnNames,
+  args,
+) =>
+  await cmd(
+    'INSERT INTO' +
+      escapeId(tableName) +
+      '(' +
+      escapeId(rowIdColumnName) +
+      arrayJoin(
+        arrayMap(
+          changingColumnNames,
+          (columnName) => COMMA + escapeId(columnName),
+        ),
+      ) +
+      ')VALUES' +
+      strRepeat(
+        `,(?${strRepeat(',?', arrayLength(changingColumnNames))})`,
+        arrayLength(args) / (arrayLength(changingColumnNames) + 1),
+      ).substring(1) +
+      'ON CONFLICT(' +
+      escapeId(rowIdColumnName) +
+      ')DO UPDATE SET' +
+      arrayJoin(
+        arrayMap(
+          changingColumnNames,
+          (columnName) =>
+            escapeId(columnName) + '=excluded.' + escapeId(columnName),
+        ),
+        COMMA,
+      ),
+    args,
+  );
 const getPlaceholders = (array) =>
   arrayJoin(
     arrayMap(array, () => '?'),
@@ -433,25 +461,28 @@ const createJsonSqlitePersister = (
   [storeTableName],
   managedTableNames,
 ) => {
-  const [refreshSchema, loadSingleRow, saveSingleRow] = getCommandFunctions(
+  const [refreshSchema, loadTable, saveTable] = getCommandFunctions(
     cmd,
     managedTableNames,
   );
   const getPersisted = async () => {
     await refreshSchema();
     return jsonParse(
-      ((await loadSingleRow(storeTableName, DEFAULT_ROW_ID_COLUMN_NAME)) ?? {})[
-        STORE_COLUMN
-      ],
+      (await loadTable(storeTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
+        SINGLE_ROW_ID
+      ]?.[STORE_COLUMN],
     );
   };
   const setPersisted = async (getContent) =>
     persister.schedule(refreshSchema, async () => {
-      await saveSingleRow(
+      await saveTable(
         storeTableName,
         DEFAULT_ROW_ID_COLUMN_NAME,
-        SINGLE_ROW_ID,
-        {[STORE_COLUMN]: jsonString(getContent())},
+        {
+          [SINGLE_ROW_ID]: {[STORE_COLUMN]: jsonString(getContent())},
+        },
+        true,
+        true,
       );
     });
   const persister = createCustomPersister(
@@ -476,32 +507,41 @@ const createTabularSqlitePersister = (
   ],
   managedTableNames,
 ) => {
-  const [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable] =
-    getCommandFunctions(cmd, managedTableNames);
-  const saveTables = async (tables) =>
+  const [refreshSchema, loadTable, saveTable] = getCommandFunctions(
+    cmd,
+    managedTableNames,
+  );
+  const saveTables = async (tables, partial) =>
     await promiseAll(
       mapMap(
         tablesSaveConfig,
         async (
           [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
           tableId,
-        ) =>
-          await saveTable(
-            tableName,
-            rowIdColumnName,
-            deleteEmptyColumns,
-            deleteEmptyTable,
-            tables[tableId],
-          ),
+        ) => {
+          const table = tables[tableId];
+          if (!partial || table !== void 0) {
+            await saveTable(
+              tableName,
+              rowIdColumnName,
+              table,
+              deleteEmptyColumns,
+              deleteEmptyTable,
+              partial,
+            );
+          }
+        },
       ),
     );
-  const saveValues = async (values) =>
+  const saveValues = async (values, partial) =>
     valuesSave
-      ? await saveSingleRow(
+      ? await saveTable(
           valuesTableName,
           DEFAULT_ROW_ID_COLUMN_NAME,
-          SINGLE_ROW_ID,
-          values,
+          {[SINGLE_ROW_ID]: values},
+          true,
+          true,
+          partial,
         )
       : null;
   const loadTables = async () =>
@@ -521,7 +561,9 @@ const createTabularSqlitePersister = (
     );
   const loadValues = async () =>
     valuesLoad
-      ? await loadSingleRow(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME)
+      ? (await loadTable(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
+          SINGLE_ROW_ID
+        ]
       : {};
   const getPersisted = async () => {
     await refreshSchema();
@@ -531,11 +573,17 @@ const createTabularSqlitePersister = (
       ? [tables, values]
       : void 0;
   };
-  const setPersisted = async (getContent) => {
-    const [tables, values] = getContent();
+  const setPersisted = async (getContent, getTransactionChanges) => {
     await refreshSchema();
-    await saveTables(tables);
-    await saveValues(values);
+    if (!isUndefined(getTransactionChanges)) {
+      const [tableChanges, valueChanges] = getTransactionChanges();
+      await saveTables(tableChanges, true);
+      await saveValues(valueChanges, true);
+    } else {
+      const [tables, values] = getContent();
+      await saveTables(tables);
+      await saveValues(values);
+    }
   };
   const persister = createCustomPersister(
     store,
@@ -649,6 +697,7 @@ const createSqlitePersister = (
   cmd,
   addUpdateListener,
   delUpdateListener,
+  logSql,
 ) => {
   let dataVersion;
   let schemaVersion;
@@ -688,7 +737,12 @@ const createSqlitePersister = (
   };
   return (isJson ? createJsonSqlitePersister : createTabularSqlitePersister)(
     store,
-    cmd,
+    logSql
+      ? async (sql, args) => {
+          logSql(sql, args);
+          return await cmd(sql, args);
+        }
+      : cmd,
     addPersisterListener,
     delPersisterListener,
     defaultedConfig,
@@ -696,13 +750,19 @@ const createSqlitePersister = (
   );
 };
 
-const createCrSqliteWasmPersister = (store, db, configOrStoreTableName) =>
+const createCrSqliteWasmPersister = (
+  store,
+  db,
+  configOrStoreTableName,
+  logSql,
+) =>
   createSqlitePersister(
     store,
     configOrStoreTableName,
     async (sql, args = []) => await db.execO(sql, args),
     (listener) => db.onUpdate((_, _2, tableName) => listener(tableName)),
     (removeListener) => removeListener(),
+    logSql,
   );
 
 export {createCrSqliteWasmPersister};