tinybase 4.0.0-beta.3 → 4.0.0-beta.5

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

@@ -0,0 +1,665 @@
+const getTypeOf = (thing) => typeof thing;
+const TINYBASE = 'tinybase';
+const EMPTY_STRING = '';
+const COMMA = ',';
+const STRING = getTypeOf(EMPTY_STRING);
+const strRepeat = (str, count) => str.repeat(count);
+
+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) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+const promiseAll = async (promises) => promise.all(promises);
+
+const object = Object;
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+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 objDel = (obj, id) => {
+  delete obj[id];
+  return obj;
+};
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
+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);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+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) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+const mapMatch = (map, obj, set, del = mapSet) => {
+  objMap(obj, (value, id) => set(map, id, value));
+  mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
+  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)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+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 schemaMap = mapNew();
+  const canSelect = (tableName, rowIdColumnName) =>
+    !isUndefined(mapGet(mapGet(schemaMap, tableName), rowIdColumnName));
+  const refreshSchema = async () =>
+    mapMatch(
+      schemaMap,
+      objNew(
+        await promiseAll(
+          arrayMap(
+            await cmd(
+              'SELECT name ' + FROM_PRAGMA_TABLE + 'list ' + WHERE_MAIN_TABLE,
+            ),
+            async ({name: tableName}) => [
+              tableName,
+              objNew(
+                arrayMap(
+                  await cmd(
+                    'SELECT name,type ' + FROM_PRAGMA_TABLE + 'info(?)',
+                    [tableName],
+                  ),
+                  ({name: columnName, type}) => [columnName, type],
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+      (_, tableName, tableSchema) =>
+        mapSet(
+          schemaMap,
+          tableName,
+          mapMatch(
+            mapEnsure(schemaMap, tableName, mapNew),
+            tableSchema,
+            (tableSchemaMap, columnName, value) => {
+              if (value != mapGet(tableSchemaMap, columnName)) {
+                mapSet(tableSchemaMap, columnName, value);
+              }
+            },
+            (tableSchema2, columnName) => mapSet(tableSchema2, columnName),
+          ),
+        ),
+      (_, 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(
+          arrayFilter(
+            arrayMap(
+              await cmd(SELECT_STAR_FROM + escapeId(tableName)),
+              (row) => [row[rowIdColumnName], objDel(row, rowIdColumnName)],
+            ),
+            ([rowId, row]) => !isUndefined(rowId) && !objIsEmpty(row),
+          ),
+        )
+      : null;
+  const saveTable = async (
+    tableName,
+    rowIdColumnName,
+    deleteEmptyColumns,
+    deleteEmptyTable,
+    table,
+  ) => {
+    const cellIds = setNew();
+    objMap(table ?? {}, (row) =>
+      arrayMap(objIds(row), (cellId) => setAdd(cellIds, cellId)),
+    );
+    const columnNames = collValues(cellIds);
+    if (
+      arrayIsEmpty(columnNames) &&
+      collHas(schemaMap, tableName) &&
+      deleteEmptyTable
+    ) {
+      await cmd('DROP TABLE' + escapeId(tableName));
+      mapSet(schemaMap, tableName);
+      return;
+    }
+    if (!arrayIsEmpty(columnNames) && !collHas(schemaMap, tableName)) {
+      await cmd(
+        `CREATE TABLE${escapeId(tableName)}(${escapeId(
+          rowIdColumnName,
+        )} PRIMARY KEY ON CONFLICT REPLACE${arrayJoin(
+          arrayMap(columnNames, (cellId) => COMMA + escapeId(cellId)),
+        )});`,
+      );
+      mapSet(
+        schemaMap,
+        tableName,
+        mapNew([
+          [rowIdColumnName, EMPTY_STRING],
+          ...arrayMap(columnNames, (columnName) => [columnName, EMPTY_STRING]),
+        ]),
+      );
+    } else {
+      const tableSchemaMap = mapGet(schemaMap, tableName);
+      const columnNamesAccountedFor = setNew(mapKeys(tableSchemaMap));
+      await promiseAll([
+        ...arrayMap(columnNames, async (columnName) => {
+          if (!collDel(columnNamesAccountedFor, columnName)) {
+            await cmd(
+              `ALTER TABLE${escapeId(tableName)}ADD${escapeId(columnName)}`,
+            );
+            mapSet(tableSchemaMap, columnName, EMPTY_STRING);
+          }
+        }),
+        ...(deleteEmptyColumns
+          ? arrayMap(
+              collValues(columnNamesAccountedFor),
+              async (columnName) => {
+                if (columnName != rowIdColumnName) {
+                  await cmd(
+                    `ALTER TABLE${escapeId(tableName)}DROP${escapeId(
+                      columnName,
+                    )}`,
+                  );
+                  mapSet(tableSchemaMap, columnName);
+                }
+              },
+            )
+          : []),
+      ]);
+    }
+    if (!arrayIsEmpty(columnNames)) {
+      const insertSlots = [];
+      const insertBinds = [];
+      const deleteRowIds = [];
+      objMap(table, (row, rowId) => {
+        arrayPush(
+          insertSlots,
+          `(?${strRepeat(',?', arrayLength(columnNames))})`,
+        );
+        arrayPush(
+          insertBinds,
+          rowId,
+          ...arrayMap(columnNames, (cellId) => row[cellId]),
+        );
+        arrayPush(deleteRowIds, rowId);
+      });
+      await cmd(
+        'INSERT INTO' +
+          escapeId(tableName) +
+          '(' +
+          escapeId(rowIdColumnName) +
+          arrayJoin(
+            arrayMap(columnNames, (columnName) => COMMA + escapeId(columnName)),
+          ) +
+          ')VALUES' +
+          arrayJoin(insertSlots, COMMA),
+        insertBinds,
+      );
+      await cmd(
+        'DELETE FROM' +
+          escapeId(tableName) +
+          WHERE +
+          escapeId(rowIdColumnName) +
+          'NOT IN(' +
+          arrayJoin(
+            arrayMap(deleteRowIds, () => '?'),
+            COMMA,
+          ) +
+          ')',
+        deleteRowIds,
+      );
+    } else {
+      await cmd('DELETE FROM' + escapeId(tableName));
+    }
+  };
+  return [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable];
+};
+
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+) => {
+  let listenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let running = 0;
+  let listening = 0;
+  let action;
+  let listeningHandle;
+  const scheduledActions = [];
+  const run = async () => {
+    /* istanbul ignore else */
+    if (!running) {
+      running = 1;
+      while (!isUndefined((action = arrayShift(scheduledActions)))) {
+        try {
+          await action();
+        } catch {}
+      }
+      running = 0;
+    }
+  };
+  const loadLock = async (actions) => {
+    /* istanbul ignore else */
+    if (loadSave != 2) {
+      loadSave = 1;
+      {
+        loads++;
+      }
+      await actions();
+      loadSave = 0;
+    }
+  };
+  const persister = {
+    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) => {
+          await loadLock(async () => {
+            if (getTransactionChanges) {
+              store.setTransactionChanges(getTransactionChanges());
+            } else {
+              try {
+                store.setContent(getContent?.() ?? (await getPersisted()));
+              } catch {}
+            }
+          });
+        },
+      );
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (listening) {
+        delPersisterListener(listeningHandle);
+        listeningHandle = void 0;
+        listening = 0;
+      }
+      return persister;
+    },
+    save: async (getTransactionChanges) => {
+      await persister.schedule(async () => {
+        /* istanbul ignore else */
+        if (loadSave != 1) {
+          loadSave = 2;
+          {
+            saves++;
+          }
+          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);
+        },
+      );
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(listenerId, store.delListener);
+      return persister;
+    },
+    schedule: async (...actions) => {
+      arrayPush(scheduledActions, ...actions);
+      await run();
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const STORE_COLUMN = 'store';
+const createJsonSqlitePersister = (
+  store,
+  cmd,
+  addPersisterListener,
+  delPersisterListener,
+  {storeTableName = TINYBASE},
+) => {
+  const [refreshSchema, loadSingleRow, saveSingleRow] =
+    getCommandFunctions(cmd);
+  const getPersisted = async () => {
+    await refreshSchema();
+    return jsonParse(
+      ((await loadSingleRow(storeTableName, DEFAULT_ROW_ID_COLUMN_NAME)) ?? {})[
+        STORE_COLUMN
+      ],
+    );
+  };
+  const setPersisted = async (getContent) =>
+    persister.schedule(refreshSchema, async () => {
+      await saveSingleRow(
+        storeTableName,
+        DEFAULT_ROW_ID_COLUMN_NAME,
+        SINGLE_ROW_ID,
+        {[STORE_COLUMN]: jsonString(getContent())},
+      );
+    });
+  const persister = createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+  );
+  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);
+  const [refreshSchema, loadSingleRow, saveSingleRow, loadTable, saveTable] =
+    getCommandFunctions(cmd);
+  const getSaveTablesActions = (tables) =>
+    mapMap(
+      tablesSaveConfig,
+      (
+          [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
+          tableId,
+        ) =>
+        async () =>
+          await saveTable(
+            tableName,
+            rowIdColumnName,
+            deleteEmptyColumns,
+            deleteEmptyTable,
+            tables[tableId],
+          ),
+    );
+  const getSaveValuesAction = (values) =>
+    valuesSave
+      ? async () =>
+          await saveSingleRow(
+            valuesTableName,
+            DEFAULT_ROW_ID_COLUMN_NAME,
+            SINGLE_ROW_ID,
+            values,
+          )
+      : null;
+  const loadTables = async () =>
+    objNew(
+      arrayFilter(
+        await promiseAll(
+          mapMap(
+            tablesLoadConfig,
+            async ([tableId, rowIdColumnName], tableName) => [
+              tableId,
+              await loadTable(tableName, rowIdColumnName),
+            ],
+          ),
+        ),
+        (pair) => pair[1],
+      ),
+    );
+  const loadValues = async () =>
+    valuesLoad
+      ? await loadSingleRow(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME)
+      : {};
+  const getPersisted = async () => {
+    await refreshSchema();
+    const tables = await loadTables();
+    const values = await loadValues();
+    return !objIsEmpty(tables) || !isUndefined(values)
+      ? [tables, values]
+      : void 0;
+  };
+  const setPersisted = async (getContent) => {
+    const [tables, values] = getContent();
+    persister.schedule(
+      refreshSchema,
+      ...getSaveTablesActions(tables),
+      getSaveValuesAction(values),
+    );
+  };
+  const persister = createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+  );
+  return persister;
+};
+
+const JSON$1 = 'json';
+const AUTO_LOAD_INTERVAL_SECONDS = 'autoLoadIntervalSeconds';
+const DEFAULT_CONFIG = {
+  mode: JSON$1,
+  [AUTO_LOAD_INTERVAL_SECONDS]: 1,
+};
+const PRAGMA = 'pragma ';
+const DATA_VERSION = 'data_version';
+const SCHEMA_VERSION = 'schema_version';
+const createSqlitePersister = (
+  store,
+  configOrStoreTableName,
+  cmd,
+  addPersisterLocalListener,
+  delPersisterLocalListener,
+) => {
+  const config = objMerge(
+    DEFAULT_CONFIG,
+    isString(configOrStoreTableName)
+      ? {storeTableName: configOrStoreTableName}
+      : configOrStoreTableName ?? {},
+  );
+  let dataVersion;
+  let schemaVersion;
+  const addPersisterListener = (listener) => [
+    setInterval(async () => {
+      try {
+        const newDataVersion = (await cmd(PRAGMA + DATA_VERSION))[0][
+          DATA_VERSION
+        ];
+        const newSchemaVersion = (await cmd(PRAGMA + SCHEMA_VERSION))[0][
+          SCHEMA_VERSION
+        ];
+        if (
+          newDataVersion != (dataVersion ??= newDataVersion) ||
+          newSchemaVersion != (schemaVersion ??= newSchemaVersion)
+        ) {
+          listener();
+          dataVersion = newDataVersion;
+          schemaVersion = newSchemaVersion;
+        }
+      } catch {}
+    }, config[AUTO_LOAD_INTERVAL_SECONDS] * 1e3),
+    addPersisterLocalListener(listener),
+  ];
+  const delPersisterListener = ([interval, listeningHandle]) => {
+    clearInterval(interval);
+    dataVersion = schemaVersion = null;
+    delPersisterLocalListener(listeningHandle);
+  };
+  return (
+    config.mode == JSON$1
+      ? createJsonSqlitePersister
+      : createTabularSqlitePersister
+  )(store, cmd, addPersisterListener, delPersisterListener, config);
+};
+
+const createCrSqliteWasmPersister = (store, db, configOrStoreTableName) =>
+  createSqlitePersister(
+    store,
+    configOrStoreTableName,
+    async (sql, args = []) => await db.execO(sql, args),
+    (listener) => db.onUpdate(() => listener()),
+    (removeListener) => removeListener(),
+  );
+
+export {createCrSqliteWasmPersister};