tinybase 4.0.0-beta.5.2 → 4.0.0

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

@@ -1,3 +1,4 @@
+const arrayLength = (array) => array.length;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayPush = (array, ...values) => array.push(...values);
 const arrayShift = (array) => array.shift();
@@ -22,7 +23,12 @@ const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
 
 const object = Object;
+const objIds = object.keys;
 const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objSize = (obj) => arrayLength(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 const createCustomPersister = (
   store,
@@ -59,27 +65,28 @@ const createCustomPersister = (
       {
         loads++;
       }
-      await actions();
-      loadSave = 0;
+      await persister.schedule(async () => {
+        await actions();
+        loadSave = 0;
+      });
     }
+    return persister;
   };
   const persister = {
-    load: async (initialTables, initialValues) => {
+    load: async (initialTables, initialValues) =>
       await loadLock(async () => {
         try {
           store.setContent(await getPersisted());
         } catch {
           store.setContent([initialTables, initialValues]);
         }
-      });
-      return persister;
-    },
+      }),
     startAutoLoad: async (initialTables = {}, initialValues = {}) => {
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
       listening = 1;
       listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
+        async (getContent, getTransactionChanges) =>
           await loadLock(async () => {
             if (getTransactionChanges) {
               store.setTransactionChanges(getTransactionChanges());
@@ -88,8 +95,7 @@ const createCustomPersister = (
                 store.setContent(getContent?.() ?? (await getPersisted()));
               } catch {}
             }
-          });
-        },
+          }),
       );
       return persister;
     },
@@ -102,27 +108,29 @@ const createCustomPersister = (
       return persister;
     },
     save: async (getTransactionChanges) => {
-      await persister.schedule(async () => {
-        /* istanbul ignore else */
-        if (loadSave != 1) {
-          loadSave = 2;
-          {
-            saves++;
-          }
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await persister.schedule(async () => {
           try {
             await setPersisted(store.getContent, getTransactionChanges);
           } catch {}
           loadSave = 0;
-        }
-      });
+        });
+      }
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
       listenerId = store.addDidFinishTransactionListener(
         (_store, getTransactionChanges) => {
-          const transactionChanges = getTransactionChanges();
-          persister.save(() => transactionChanges);
+          const [tableChanges, valueChanges] = getTransactionChanges();
+          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
+            persister.save(() => [tableChanges, valueChanges]);
+          }
         },
       );
       return persister;

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

@@ -38,6 +38,11 @@ const isString = (thing) => getTypeOf(thing) == STRING;
 const isArray = (thing) => Array.isArray(thing);
 const promiseAll = async (promises) => promise.all(promises);
 
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
 const object = Object;
 const objIds = object.keys;
 const objFreeze = object.freeze;
@@ -57,11 +62,6 @@ const objValues = (obj) => object.values(obj);
 const objSize = (obj) => arrayLength(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
-const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-const collValues = (coll) => [...(coll?.values() ?? [])];
-const collForEach = (coll, cb) => coll?.forEach(cb);
-const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
-
 const mapNew = (entries) => new Map(entries);
 const mapKeys = (map) => [...(map?.keys() ?? [])];
 const mapGet = (map, key) => map?.get(key);
@@ -98,9 +98,7 @@ const setAdd = (set, value) => set?.add(value);
 const SELECT_STAR_FROM = 'SELECT*FROM';
 const FROM_PRAGMA_TABLE = 'FROM pragma_table_';
 const WHERE = 'WHERE';
-const WHERE_MAIN_TABLE =
-  WHERE + ` schema='main'AND type='table'AND name!='sqlite_schema'`;
-const getCommandFunctions = (cmd) => {
+const getCommandFunctions = (cmd, managedTableNames) => {
   const schemaMap = mapNew();
   const canSelect = (tableName, rowIdColumnName) =>
     !isUndefined(mapGet(mapGet(schemaMap, tableName), rowIdColumnName));
@@ -111,7 +109,12 @@ const getCommandFunctions = (cmd) => {
         await promiseAll(
           arrayMap(
             await cmd(
-              'SELECT name ' + FROM_PRAGMA_TABLE + 'list ' + WHERE_MAIN_TABLE,
+              'SELECT name ' +
+                FROM_PRAGMA_TABLE +
+                `list WHERE schema='main'AND type='table'AND name IN(` +
+                getPlaceholders(managedTableNames) +
+                `)`,
+              managedTableNames,
             ),
             async ({name: tableName}) => [
               tableName,
@@ -245,15 +248,19 @@ const getCommandFunctions = (cmd) => {
       const insertSlots = [];
       const insertBinds = [];
       const deleteRowIds = [];
+      const allColumnNames = arrayFilter(
+        mapKeys(mapGet(schemaMap, tableName)),
+        (columnName) => columnName != rowIdColumnName,
+      );
       objMap(table, (row, rowId) => {
         arrayPush(
           insertSlots,
-          `(?${strRepeat(',?', arrayLength(columnNames))})`,
+          `(?${strRepeat(',?', arrayLength(allColumnNames))})`,
         );
         arrayPush(
           insertBinds,
           rowId,
-          ...arrayMap(columnNames, (cellId) => row[cellId]),
+          ...arrayMap(allColumnNames, (cellId) => row[cellId]),
         );
         arrayPush(deleteRowIds, rowId);
       });
@@ -263,10 +270,24 @@ const getCommandFunctions = (cmd) => {
           '(' +
           escapeId(rowIdColumnName) +
           arrayJoin(
-            arrayMap(columnNames, (columnName) => COMMA + escapeId(columnName)),
+            arrayMap(
+              allColumnNames,
+              (columnName) => COMMA + escapeId(columnName),
+            ),
           ) +
           ')VALUES' +
-          arrayJoin(insertSlots, COMMA),
+          arrayJoin(insertSlots, COMMA) +
+          'ON CONFLICT(' +
+          escapeId(rowIdColumnName) +
+          ')DO UPDATE SET' +
+          arrayJoin(
+            arrayMap(
+              allColumnNames,
+              (columnName) =>
+                escapeId(columnName) + '=excluded.' + escapeId(columnName),
+            ),
+            COMMA,
+          ),
         insertBinds,
       );
       await cmd(
@@ -275,19 +296,21 @@ const getCommandFunctions = (cmd) => {
           WHERE +
           escapeId(rowIdColumnName) +
           'NOT IN(' +
-          arrayJoin(
-            arrayMap(deleteRowIds, () => '?'),
-            COMMA,
-          ) +
+          getPlaceholders(deleteRowIds) +
           ')',
         deleteRowIds,
       );
-    } else {
+    } else if (collHas(schemaMap, tableName)) {
       await cmd('DELETE FROM' + escapeId(tableName));
     }
   };
   return [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable];
 };
+const getPlaceholders = (array) =>
+  arrayJoin(
+    arrayMap(array, () => '?'),
+    COMMA,
+  );
 
 const createCustomPersister = (
   store,
@@ -324,27 +347,28 @@ const createCustomPersister = (
       {
         loads++;
       }
-      await actions();
-      loadSave = 0;
+      await persister.schedule(async () => {
+        await actions();
+        loadSave = 0;
+      });
     }
+    return persister;
   };
   const persister = {
-    load: async (initialTables, initialValues) => {
+    load: async (initialTables, initialValues) =>
       await loadLock(async () => {
         try {
           store.setContent(await getPersisted());
         } catch {
           store.setContent([initialTables, initialValues]);
         }
-      });
-      return persister;
-    },
+      }),
     startAutoLoad: async (initialTables = {}, initialValues = {}) => {
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
       listening = 1;
       listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
+        async (getContent, getTransactionChanges) =>
           await loadLock(async () => {
             if (getTransactionChanges) {
               store.setTransactionChanges(getTransactionChanges());
@@ -353,8 +377,7 @@ const createCustomPersister = (
                 store.setContent(getContent?.() ?? (await getPersisted()));
               } catch {}
             }
-          });
-        },
+          }),
       );
       return persister;
     },
@@ -367,27 +390,29 @@ const createCustomPersister = (
       return persister;
     },
     save: async (getTransactionChanges) => {
-      await persister.schedule(async () => {
-        /* istanbul ignore else */
-        if (loadSave != 1) {
-          loadSave = 2;
-          {
-            saves++;
-          }
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await persister.schedule(async () => {
           try {
             await setPersisted(store.getContent, getTransactionChanges);
           } catch {}
           loadSave = 0;
-        }
-      });
+        });
+      }
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
       listenerId = store.addDidFinishTransactionListener(
         (_store, getTransactionChanges) => {
-          const transactionChanges = getTransactionChanges();
-          persister.save(() => transactionChanges);
+          const [tableChanges, valueChanges] = getTransactionChanges();
+          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
+            persister.save(() => [tableChanges, valueChanges]);
+          }
         },
       );
       return persister;
@@ -414,10 +439,13 @@ const createJsonSqlitePersister = (
   cmd,
   addPersisterListener,
   delPersisterListener,
-  {storeTableName = TINYBASE},
+  [storeTableName],
+  managedTableNames,
 ) => {
-  const [refreshSchema, loadSingleRow, saveSingleRow] =
-    getCommandFunctions(cmd);
+  const [refreshSchema, loadSingleRow, saveSingleRow] = getCommandFunctions(
+    cmd,
+    managedTableNames,
+  );
   const getPersisted = async () => {
     await refreshSchema();
     return jsonParse(
@@ -445,97 +473,28 @@ const createJsonSqlitePersister = (
   return persister;
 };
 
-const ROW_ID_COLUMN_NAME = 'rowIdColumnName';
-const TABLE_ID = 'tableId';
-const TABLE_NAME = 'tableName';
-const DELETE_EMPTY_COLUMNS = 'deleteEmptyColumns';
-const DELETE_EMPTY_TABLE = 'deleteEmptyTable';
-const DEFAULTED_VALUES_CONFIG = {
-  load: 0,
-  save: 0,
-  [TABLE_NAME]: TINYBASE + '_values',
-};
-const getDefaultedTableConfigMap = (
-  configsObj,
-  defaultObj,
-  tableField,
-  filter,
-) => {
-  const configMap = mapNew();
-  objMap(configsObj, (configObj, id) => {
-    const defaultedConfig = arraySlice(
-      objValues(
-        objMerge(
-          defaultObj,
-          isString(configObj) ? {[tableField]: configObj} : configObj,
-        ),
-      ),
-      0,
-      objSize(defaultObj),
-    );
-    if (!isUndefined(defaultedConfig[0]) && !filter(id, defaultedConfig[0])) {
-      mapSet(configMap, id, defaultedConfig);
-    }
-  });
-  return configMap;
-};
-const getDefaultedConfig = ({
-  tables: {load = {}, save = {}} = {},
-  values = {},
-}) => {
-  const valuesConfig = arraySlice(
-    objValues(objMerge(DEFAULTED_VALUES_CONFIG, values)),
-    0,
-    objSize(DEFAULTED_VALUES_CONFIG),
-  );
-  const valuesTable = valuesConfig[2];
-  return [
-    getDefaultedTableConfigMap(
-      load,
-      {
-        [TABLE_ID]: null,
-        [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
-      },
-      TABLE_ID,
-      (tableName) => tableName == valuesTable,
-    ),
-    getDefaultedTableConfigMap(
-      save,
-      {
-        [TABLE_NAME]: null,
-        [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
-        [DELETE_EMPTY_COLUMNS]: 0,
-        [DELETE_EMPTY_TABLE]: 0,
-      },
-      TABLE_NAME,
-      (_, tableName) => tableName == valuesTable,
-    ),
-    valuesConfig,
-  ];
-};
-
 const createTabularSqlitePersister = (
   store,
   cmd,
   addPersisterListener,
   delPersisterListener,
-  config,
-) => {
-  const [
+  [
     tablesLoadConfig,
     tablesSaveConfig,
     [valuesLoad, valuesSave, valuesTableName],
-  ] = getDefaultedConfig(config);
+  ],
+  managedTableNames,
+) => {
   const [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable] =
-    getCommandFunctions(cmd);
-  const getSaveTablesActions = (tables) =>
-    mapMap(
-      tablesSaveConfig,
-      (
+    getCommandFunctions(cmd, managedTableNames);
+  const saveTables = async (tables) =>
+    await promiseAll(
+      mapMap(
+        tablesSaveConfig,
+        async (
           [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
           tableId,
         ) =>
-        async () =>
           await saveTable(
             tableName,
             rowIdColumnName,
@@ -543,16 +502,16 @@ const createTabularSqlitePersister = (
             deleteEmptyTable,
             tables[tableId],
           ),
+      ),
     );
-  const getSaveValuesAction = (values) =>
+  const saveValues = async (values) =>
     valuesSave
-      ? async () =>
-          await saveSingleRow(
-            valuesTableName,
-            DEFAULT_ROW_ID_COLUMN_NAME,
-            SINGLE_ROW_ID,
-            values,
-          )
+      ? await saveSingleRow(
+          valuesTableName,
+          DEFAULT_ROW_ID_COLUMN_NAME,
+          SINGLE_ROW_ID,
+          values,
+        )
       : null;
   const loadTables = async () =>
     objNew(
@@ -583,11 +542,9 @@ const createTabularSqlitePersister = (
   };
   const setPersisted = async (getContent) => {
     const [tables, values] = getContent();
-    persister.schedule(
-      refreshSchema,
-      ...getSaveTablesActions(tables),
-      getSaveValuesAction(values),
-    );
+    await refreshSchema();
+    await saveTables(tables);
+    await saveValues(values);
   };
   const persister = createCustomPersister(
     store,
@@ -601,10 +558,97 @@ const createTabularSqlitePersister = (
 
 const JSON$1 = 'json';
 const AUTO_LOAD_INTERVAL_SECONDS = 'autoLoadIntervalSeconds';
+const STORE_TABLE_NAME = 'storeTableName';
+const ROW_ID_COLUMN_NAME = 'rowIdColumnName';
+const TABLE_ID = 'tableId';
+const TABLE_NAME = 'tableName';
+const DELETE_EMPTY_COLUMNS = 'deleteEmptyColumns';
+const DELETE_EMPTY_TABLE = 'deleteEmptyTable';
 const DEFAULT_CONFIG = {
   mode: JSON$1,
   [AUTO_LOAD_INTERVAL_SECONDS]: 1,
 };
+const DEFAULT_TABULAR_VALUES_CONFIG = {
+  load: 0,
+  save: 0,
+  [TABLE_NAME]: TINYBASE + '_values',
+};
+const getDefaultedConfig = (configOrStoreTableName) =>
+  objMerge(
+    DEFAULT_CONFIG,
+    isString(configOrStoreTableName)
+      ? {[STORE_TABLE_NAME]: configOrStoreTableName}
+      : configOrStoreTableName ?? {},
+  );
+const getDefaultedTabularConfigMap = (
+  configsObj,
+  defaultObj,
+  tableField,
+  filter,
+) => {
+  const configMap = mapNew();
+  objMap(configsObj, (configObj, id) => {
+    const defaultedConfig = arraySlice(
+      objValues(
+        objMerge(
+          defaultObj,
+          isString(configObj) ? {[tableField]: configObj} : configObj,
+        ),
+      ),
+      0,
+      objSize(defaultObj),
+    );
+    if (!isUndefined(defaultedConfig[0]) && !filter(id, defaultedConfig[0])) {
+      mapSet(configMap, id, defaultedConfig);
+    }
+  });
+  return configMap;
+};
+const getConfigStructures = (configOrStoreTableName) => {
+  const config = getDefaultedConfig(configOrStoreTableName);
+  const autoLoadIntervalSeconds = config[AUTO_LOAD_INTERVAL_SECONDS];
+  if (config.mode == JSON$1) {
+    const {storeTableName = TINYBASE} = config;
+    return [
+      1,
+      autoLoadIntervalSeconds,
+      [storeTableName],
+      setNew(storeTableName),
+    ];
+  }
+  const {tables: {load = {}, save = {}} = {}, values = {}} = config;
+  const valuesConfig = arraySlice(
+    objValues(objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values)),
+    0,
+    objSize(DEFAULT_TABULAR_VALUES_CONFIG),
+  );
+  const valuesTable = valuesConfig[2];
+  const managedTableNames = setNew(valuesTable);
+  const tabularConfig = [
+    getDefaultedTabularConfigMap(
+      load,
+      {[TABLE_ID]: null, [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME},
+      TABLE_ID,
+      (tableName) =>
+        setAdd(managedTableNames, tableName) && tableName == valuesTable,
+    ),
+    getDefaultedTabularConfigMap(
+      save,
+      {
+        [TABLE_NAME]: null,
+        [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
+        [DELETE_EMPTY_COLUMNS]: 0,
+        [DELETE_EMPTY_TABLE]: 0,
+      },
+      TABLE_NAME,
+      (_, tableName) =>
+        setAdd(managedTableNames, tableName) && tableName == valuesTable,
+    ),
+    valuesConfig,
+  ];
+  return [0, autoLoadIntervalSeconds, tabularConfig, managedTableNames];
+};
+
 const PRAGMA = 'pragma ';
 const DATA_VERSION = 'data_version';
 const SCHEMA_VERSION = 'schema_version';
@@ -612,17 +656,17 @@ const createSqlitePersister = (
   store,
   configOrStoreTableName,
   cmd,
-  addPersisterLocalListener,
-  delPersisterLocalListener,
+  addUpdateListener,
+  delUpdateListener,
 ) => {
-  const config = objMerge(
-    DEFAULT_CONFIG,
-    isString(configOrStoreTableName)
-      ? {storeTableName: configOrStoreTableName}
-      : configOrStoreTableName ?? {},
-  );
   let dataVersion;
   let schemaVersion;
+  const [
+    isJson,
+    autoLoadIntervalSeconds,
+    defaultedConfig,
+    managedTableNamesSet,
+  ] = getConfigStructures(configOrStoreTableName);
   const addPersisterListener = (listener) => [
     setInterval(async () => {
       try {
@@ -641,19 +685,24 @@ const createSqlitePersister = (
           schemaVersion = newSchemaVersion;
         }
       } catch {}
-    }, config[AUTO_LOAD_INTERVAL_SECONDS] * 1e3),
-    addPersisterLocalListener(listener),
+    }, autoLoadIntervalSeconds * 1e3),
+    addUpdateListener((tableName) =>
+      managedTableNamesSet.has(tableName) ? listener() : 0,
+    ),
   ];
   const delPersisterListener = ([interval, listeningHandle]) => {
     clearInterval(interval);
     dataVersion = schemaVersion = null;
-    delPersisterLocalListener(listeningHandle);
+    delUpdateListener(listeningHandle);
   };
-  return (
-    config.mode == JSON$1
-      ? createJsonSqlitePersister
-      : createTabularSqlitePersister
-  )(store, cmd, addPersisterListener, delPersisterListener, config);
+  return (isJson ? createJsonSqlitePersister : createTabularSqlitePersister)(
+    store,
+    cmd,
+    addPersisterListener,
+    delPersisterListener,
+    defaultedConfig,
+    collValues(managedTableNamesSet),
+  );
 };
 
 const createSqliteWasmPersister = (
@@ -669,7 +718,12 @@ const createSqliteWasmPersister = (
       db
         .exec(sql, {bind: args, rowMode: 'object', returnValue: 'resultRows'})
         .map((row) => ({...row})),
-    (listener) => sqlite3.capi.sqlite3_update_hook(db, () => listener(), 0),
+    (listener) =>
+      sqlite3.capi.sqlite3_update_hook(
+        db,
+        (_, _2, _3, tableName) => listener(tableName),
+        0,
+      ),
     () => sqlite3.capi.sqlite3_update_hook(db, () => 0, 0),
   );