tinybase 4.0.0 → 4.0.2

package/lib/debug/persisters/persister-sqlite3.js

@@ -9,27 +9,12 @@ const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
 const arrayMap = (array, cb) => array.map(cb);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
-const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayFilter = (array, cb) => array.filter(cb);
 const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
 
 const promise = Promise;
-const jsonString = (obj) =>
-  JSON.stringify(obj, (_key, value) =>
-    isInstanceOf(value, Map)
-      ? arrayReduce(
-          [...value],
-          (obj2, [key, value2]) => {
-            obj2[key] = value2;
-            return obj2;
-          },
-          {},
-        )
-      : value,
-  );
-const jsonParse = JSON.parse;
 const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
@@ -84,10 +69,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)
@@ -96,6 +77,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';
@@ -149,21 +134,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(
@@ -182,30 +152,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(
@@ -213,14 +185,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)}`,
@@ -228,7 +203,7 @@ const getCommandFunctions = (cmd, managedTableNames) => {
             mapSet(tableSchemaMap, columnName, EMPTY_STRING);
           }
         }),
-        ...(deleteEmptyColumns
+        ...(!partial && deleteEmptyColumns
           ? arrayMap(
               collValues(columnNamesAccountedFor),
               async (columnName) => {
@@ -245,74 +220,118 @@ 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, () => '?'),
     COMMA,
   );
 
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
+  );
+const jsonParse = JSON.parse;
+
 const createCustomPersister = (
   store,
   getPersisted,
@@ -443,25 +462,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(
@@ -486,32 +508,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 () =>
@@ -531,7 +562,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();
@@ -541,11 +574,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,
@@ -659,6 +698,7 @@ const createSqlitePersister = (
   cmd,
   addUpdateListener,
   delUpdateListener,
+  logSql,
 ) => {
   let dataVersion;
   let schemaVersion;
@@ -698,7 +738,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,
@@ -707,7 +752,7 @@ const createSqlitePersister = (
 };
 
 const CHANGE = 'change';
-const createSqlite3Persister = (store, db, configOrStoreTableName) =>
+const createSqlite3Persister = (store, db, configOrStoreTableName, logSql) =>
   createSqlitePersister(
     store,
     configOrStoreTableName,
@@ -723,6 +768,7 @@ const createSqlite3Persister = (store, db, configOrStoreTableName) =>
       return observer;
     },
     (observer) => db.off(CHANGE, observer),
+    logSql,
   );
 
 export {createSqlite3Persister};

package/lib/debug/persisters.js

@@ -1,12 +1,12 @@
-const arrayLength = (array) => array.length;
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayShift = (array) => array.shift();
-
 const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
 
+const arrayLength = (array) => array.length;
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
 const object = Object;
 const objIds = object.keys;
 const objFreeze = object.freeze;

package/lib/debug/relationships.js

@@ -2,6 +2,13 @@ const getTypeOf = (thing) => typeof thing;
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
 
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+const test = (regex, subject) => regex.test(subject);
+
 const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
   arrayLength(array1) === arrayLength(array2) &&
@@ -13,13 +20,6 @@ const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
 
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-const isArray = (thing) => Array.isArray(thing);
-const test = (regex, subject) => regex.test(subject);
-
 const object = Object;
 const objFreeze = object.freeze;
 

package/lib/debug/store.js

@@ -21,6 +21,16 @@ const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
 const id = (key) => EMPTY_STRING + key;
 
+const isFiniteNumber = isFinite;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+const isArray = (thing) => Array.isArray(thing);
+const test = (regex, subject) => regex.test(subject);
+
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
@@ -35,30 +45,6 @@ const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
 
-const jsonString = (obj) =>
-  JSON.stringify(obj, (_key, value) =>
-    isInstanceOf(value, Map)
-      ? arrayReduce(
-          [...value],
-          (obj2, [key, value2]) => {
-            obj2[key] = value2;
-            return obj2;
-          },
-          {},
-        )
-      : value,
-  );
-const jsonParse = JSON.parse;
-const isFiniteNumber = isFinite;
-const isInstanceOf = (thing, cls) => thing instanceof cls;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
-const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
-const isArray = (thing) => Array.isArray(thing);
-const test = (regex, subject) => regex.test(subject);
-
 const object = Object;
 const objIds = object.keys;
 const objFrozen = object.isFrozen;
@@ -269,6 +255,12 @@ const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
 const setOrDelValue = (store, valueId, value) =>
   isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);
 
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
+  );
+const jsonParse = JSON.parse;
+
 const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
 const validate = (obj, validateChild, onInvalidObj) => {

package/lib/debug/tinybase.js

@@ -28,6 +28,20 @@ const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
 const id = (key) => EMPTY_STRING + key;
 
+const mathMax = Math.max;
+const mathMin = Math.min;
+const isFiniteNumber = isFinite;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+const isArray = (thing) => Array.isArray(thing);
+const test = (regex, subject) => regex.test(subject);
+const getUndefined = () => void 0;
+
 const arrayHas = (array, value) => array.includes(value);
 const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
@@ -52,34 +66,6 @@ const arrayPop = (array) => array.pop();
 const arrayUnshift = (array, ...values) => array.unshift(...values);
 const arrayShift = (array) => array.shift();
 
-const jsonString = (obj) =>
-  JSON.stringify(obj, (_key, value) =>
-    isInstanceOf(value, Map)
-      ? arrayReduce(
-          [...value],
-          (obj2, [key, value2]) => {
-            obj2[key] = value2;
-            return obj2;
-          },
-          {},
-        )
-      : value,
-  );
-const jsonParse = JSON.parse;
-const mathMax = Math.max;
-const mathMin = Math.min;
-const isFiniteNumber = isFinite;
-const isInstanceOf = (thing, cls) => thing instanceof cls;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
-const isString = (thing) => getTypeOf(thing) == STRING;
-const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
-const isArray = (thing) => Array.isArray(thing);
-const test = (regex, subject) => regex.test(subject);
-const getUndefined = () => void 0;
-
 const object = Object;
 const objIds = object.keys;
 const objFrozen = object.isFrozen;
@@ -1780,6 +1766,12 @@ const pairNewMap = () => [mapNew(), mapNew()];
 const pairClone = (array) => [...array];
 const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
+  );
+const jsonParse = JSON.parse;
+
 const validate = (obj, validateChild, onInvalidObj) => {
   if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
     onInvalidObj?.();