tinybase 5.0.0-beta.2 → 5.0.0-beta.21

package/lib/debug/persisters/persister-electric-sql.js

@@ -1,858 +0,0 @@
-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 promise = Promise;
-const startInterval = (callback, sec, immediate) => {
-  immediate && callback();
-  return setInterval(callback, sec * 1e3);
-};
-const stopInterval = clearInterval;
-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 slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-const size = (arrayOrString) => arrayOrString.length;
-const promiseAll = async (promises) => promise.all(promises);
-
-const SINGLE_ROW_ID = '_';
-const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
-const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
-const SELECT = 'SELECT';
-
-const arrayForEach = (array, cb) => array.forEach(cb);
-const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
-const arrayMap = (array, cb) => array.map(cb);
-const arrayIsEmpty = (array) => size(array) == 0;
-const arrayFilter = (array, cb) => array.filter(cb);
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayShift = (array) => array.shift();
-
-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 getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objEntries = object.entries;
-const objIds = object.keys;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  !isUndefined(obj) &&
-  ifNotUndefined(
-    getPrototypeOf(obj),
-    (objPrototype) =>
-      objPrototype == object.prototype ||
-      isUndefined(getPrototypeOf(objPrototype)),
-    /* istanbul ignore next */
-    () => true,
-  );
-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 objToArray = (obj, cb) =>
-  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
-const objValues = (obj) => object.values(obj);
-const objSize = (obj) => size(objIds(obj));
-const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
-
-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) => {
-  objToArray(obj, (value, id) => set(map, id, value));
-  mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
-  return map;
-};
-
-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 getCommandFunctions = (cmd, managedTableNames, onIgnoredError) => {
-  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 schema='main'AND type='table'AND name IN(` +
-                getPlaceholders(managedTableNames) +
-                `)ORDER BY name`,
-              managedTableNames,
-            ),
-            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 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),
-          ),
-        )
-      : {};
-  const saveTable = async (
-    tableName,
-    rowIdColumnName,
-    table,
-    deleteEmptyColumns,
-    deleteEmptyTable,
-    partial = false,
-  ) => {
-    const tableCellIds = setNew();
-    objToArray(table ?? {}, (row) =>
-      arrayMap(objIds(row ?? {}), (cellId) => setAdd(tableCellIds, cellId)),
-    );
-    const tableColumnNames = collValues(tableCellIds);
-    if (
-      !partial &&
-      deleteEmptyTable &&
-      arrayIsEmpty(tableColumnNames) &&
-      collHas(schemaMap, 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)),
-        )});`,
-      );
-      mapSet(
-        schemaMap,
-        tableName,
-        mapNew([
-          [rowIdColumnName, EMPTY_STRING],
-          ...arrayMap(tableColumnNames, (columnName) => [
-            columnName,
-            EMPTY_STRING,
-          ]),
-        ]),
-      );
-    } else {
-      const tableSchemaMap = mapGet(schemaMap, tableName);
-      const columnNamesAccountedFor = setNew(mapKeys(tableSchemaMap));
-      await promiseAll([
-        ...arrayMap(tableColumnNames, async (columnName) => {
-          if (!collDel(columnNamesAccountedFor, columnName)) {
-            await cmd(
-              `ALTER TABLE${escapeId(tableName)}ADD${escapeId(columnName)}`,
-            );
-            mapSet(tableSchemaMap, columnName, EMPTY_STRING);
-          }
-        }),
-        ...(!partial && deleteEmptyColumns
-          ? arrayMap(
-              collValues(columnNamesAccountedFor),
-              async (columnName) => {
-                if (columnName != rowIdColumnName) {
-                  await cmd(
-                    `ALTER TABLE${escapeId(tableName)}DROP${escapeId(
-                      columnName,
-                    )}`,
-                  );
-                  mapSet(tableSchemaMap, columnName);
-                }
-              },
-            )
-          : []),
-      ]);
-    }
-    if (partial) {
-      if (isUndefined(table)) {
-        await cmd('DELETE FROM' + escapeId(tableName) + 'WHERE 1');
-      } else {
-        await promiseAll(
-          objToArray(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),
-              ]);
-            }
-          }),
-        );
-      }
-    } else {
-      if (!arrayIsEmpty(tableColumnNames)) {
-        const changingColumnNames = arrayFilter(
-          mapKeys(mapGet(schemaMap, tableName)),
-          (columnName) => columnName != rowIdColumnName,
-        );
-        const args = [];
-        const deleteRowIds = [];
-        objToArray(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');
-      }
-    }
-  };
-  const transaction = async (actions) => {
-    let result;
-    await cmd('BEGIN');
-    try {
-      result = await actions();
-    } catch (error) {
-      onIgnoredError?.(error);
-    }
-    await cmd('END');
-    return result;
-  };
-  return [refreshSchema, loadTable, saveTable, transaction];
-};
-const upsert = async (
-  cmd,
-  tableName,
-  rowIdColumnName,
-  changingColumnNames,
-  args,
-) =>
-  await cmd(
-    'INSERT INTO' +
-      escapeId(tableName) +
-      '(' +
-      escapeId(rowIdColumnName) +
-      arrayJoin(
-        arrayMap(
-          changingColumnNames,
-          (columnName) => COMMA + escapeId(columnName),
-        ),
-      ) +
-      ')VALUES' +
-      slice(
-        strRepeat(
-          `,(?${strRepeat(',?', size(changingColumnNames))})`,
-          size(args) / (size(changingColumnNames) + 1),
-        ),
-        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 scheduleRunning = mapNew();
-const scheduleActions = mapNew();
-const createCustomPersister = (
-  store,
-  getPersisted,
-  setPersisted,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  [getThing, thing] = [],
-  scheduleId = [],
-) => {
-  let listenerId;
-  let loadSave = 0;
-  let loads = 0;
-  let saves = 0;
-  let listening = 0;
-  let action;
-  let listeningHandle;
-  mapEnsure(scheduleRunning, scheduleId, () => 0);
-  mapEnsure(scheduleActions, scheduleId, () => []);
-  const run = async () => {
-    /* istanbul ignore else */
-    if (!mapGet(scheduleRunning, scheduleId)) {
-      mapSet(scheduleRunning, scheduleId, 1);
-      while (
-        !isUndefined((action = arrayShift(mapGet(scheduleActions, scheduleId))))
-      ) {
-        try {
-          await action();
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
-      }
-      mapSet(scheduleRunning, scheduleId, 0);
-    }
-  };
-  const loadLock = async (actions) => {
-    /* istanbul ignore else */
-    if (loadSave != 2) {
-      loadSave = 1;
-      {
-        loads++;
-      }
-      await persister.schedule(async () => {
-        await actions();
-        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);
-              }
-            });
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
-      }
-      return persister;
-    },
-    save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
-        }
-        await persister.schedule(async () => {
-          try {
-            await setPersisted(store.getContent, getTransactionChanges);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          loadSave = 0;
-        });
-      }
-      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}),
-  };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
-  return objFreeze(persister);
-};
-
-const STORE_COLUMN = 'store';
-const createJsonSqlitePersister = (
-  store,
-  cmd,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  [storeTableName],
-  managedTableNames,
-  db,
-  getThing,
-) => {
-  const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError);
-  const getPersisted = async () =>
-    await transaction(async () => {
-      await refreshSchema();
-      return jsonParse(
-        (await loadTable(storeTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
-          SINGLE_ROW_ID
-        ]?.[STORE_COLUMN] ?? 'null',
-      );
-    });
-  const setPersisted = async (getContent) =>
-    await transaction(async () => {
-      await refreshSchema();
-      await saveTable(
-        storeTableName,
-        DEFAULT_ROW_ID_COLUMN_NAME,
-        {
-          [SINGLE_ROW_ID]: {[STORE_COLUMN]: jsonString(getContent() ?? null)},
-        },
-        true,
-        true,
-      );
-    });
-  const persister = createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    [getThing, db],
-    db,
-  );
-  return persister;
-};
-
-const createTabularSqlitePersister = (
-  store,
-  cmd,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  [
-    tablesLoadConfig,
-    tablesSaveConfig,
-    [valuesLoad, valuesSave, valuesTableName],
-  ],
-  managedTableNames,
-  db,
-  getThing,
-) => {
-  const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError);
-  const saveTables = async (tables, partial) =>
-    await promiseAll(
-      mapMap(
-        tablesSaveConfig,
-        async (
-          [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
-          tableId,
-        ) => {
-          const table = tables[tableId];
-          if (!partial || table !== void 0) {
-            await saveTable(
-              tableName,
-              rowIdColumnName,
-              table,
-              deleteEmptyColumns,
-              deleteEmptyTable,
-              partial,
-            );
-          }
-        },
-      ),
-    );
-  const saveValues = async (values, partial) =>
-    valuesSave
-      ? await saveTable(
-          valuesTableName,
-          DEFAULT_ROW_ID_COLUMN_NAME,
-          {[SINGLE_ROW_ID]: values},
-          true,
-          true,
-          partial,
-        )
-      : null;
-  const loadTables = async () =>
-    objNew(
-      arrayFilter(
-        await promiseAll(
-          mapMap(
-            tablesLoadConfig,
-            async ([tableId, rowIdColumnName], tableName) => [
-              tableId,
-              await loadTable(tableName, rowIdColumnName),
-            ],
-          ),
-        ),
-        (pair) => !objIsEmpty(pair[1]),
-      ),
-    );
-  const loadValues = async () =>
-    valuesLoad
-      ? (await loadTable(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
-          SINGLE_ROW_ID
-        ]
-      : {};
-  const getPersisted = async () =>
-    await transaction(async () => {
-      await refreshSchema();
-      const tables = await loadTables();
-      const values = await loadValues();
-      return !objIsEmpty(tables) || !isUndefined(values)
-        ? [tables, values]
-        : void 0;
-    });
-  const setPersisted = async (getContent, getTransactionChanges) =>
-    await transaction(async () => {
-      await refreshSchema();
-      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,
-    getPersisted,
-    setPersisted,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    [getThing, db],
-    db,
-  );
-  return persister;
-};
-
-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();
-  objToArray(configsObj, (configObj, id) => {
-    const defaultedConfig = slice(
-      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 = slice(
-    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';
-const createSqlitePersister = (
-  store,
-  configOrStoreTableName,
-  cmd,
-  addUpdateListener,
-  delUpdateListener,
-  onSqlCommand,
-  onIgnoredError,
-  db,
-  getThing = 'getDb',
-) => {
-  let dataVersion;
-  let schemaVersion;
-  let totalChanges;
-  const CHANGES_COLUMN = 'c';
-  const [
-    isJson,
-    autoLoadIntervalSeconds,
-    defaultedConfig,
-    managedTableNamesSet,
-  ] = getConfigStructures(configOrStoreTableName);
-  const addPersisterListener = (listener) => [
-    startInterval(
-      async () => {
-        try {
-          const newDataVersion = (await cmd(PRAGMA + DATA_VERSION))[0][
-            DATA_VERSION
-          ];
-          const newSchemaVersion = (await cmd(PRAGMA + SCHEMA_VERSION))[0][
-            SCHEMA_VERSION
-          ];
-          const newTotalChanges = (
-            await cmd(SELECT + ' TOTAL_CHANGES() ' + CHANGES_COLUMN)
-          )[0][CHANGES_COLUMN];
-          if (
-            newDataVersion != (dataVersion ??= newDataVersion) ||
-            newSchemaVersion != (schemaVersion ??= newSchemaVersion) ||
-            newTotalChanges != (totalChanges ??= newTotalChanges)
-          ) {
-            listener();
-            dataVersion = newDataVersion;
-            schemaVersion = newSchemaVersion;
-          }
-        } catch {}
-      },
-      autoLoadIntervalSeconds,
-      1,
-    ),
-    addUpdateListener((tableName) =>
-      managedTableNamesSet.has(tableName) ? listener() : 0,
-    ),
-  ];
-  const delPersisterListener = ([interval, listeningHandle]) => {
-    stopInterval(interval);
-    dataVersion = schemaVersion = null;
-    delUpdateListener(listeningHandle);
-  };
-  return (isJson ? createJsonSqlitePersister : createTabularSqlitePersister)(
-    store,
-    onSqlCommand
-      ? async (sql, args) => {
-          onSqlCommand(sql, args);
-          return await cmd(sql, args);
-        }
-      : cmd,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    defaultedConfig,
-    collValues(managedTableNamesSet),
-    db,
-    getThing,
-  );
-};
-
-const createElectricSqlPersister = (
-  store,
-  electricClient,
-  configOrStoreTableName,
-  onSqlCommand,
-  onIgnoredError,
-) =>
-  createSqlitePersister(
-    store,
-    configOrStoreTableName,
-    async (sql, args = []) => await electricClient.db.raw({sql, args}),
-    (listener) =>
-      electricClient.notifier.subscribeToDataChanges((notification) =>
-        arrayForEach(
-          electricClient.notifier.alias(notification),
-          ({tablename}) => listener(tablename),
-        ),
-      ),
-    (unsubscribeFunction) => unsubscribeFunction(),
-    onSqlCommand,
-    onIgnoredError,
-    electricClient,
-    'getElectricClient',
-  );
-
-export {createElectricSqlPersister};