tinybase 5.2.0-beta.4 → 5.2.0

package/umd/persisters/with-schemas/index.js

@@ -9,21 +9,44 @@
 })(this, function (exports) {
   'use strict';
 
+  const getTypeOf = (thing) => typeof thing;
+  const TINYBASE = 'tinybase';
+  const EMPTY_STRING = '';
+  const COMMA = ',';
+  const STRING = getTypeOf(EMPTY_STRING);
+  const UNDEFINED = '\uFFFC';
+  const strMatch = (str, regex) => str?.match(regex);
+
+  const promise = Promise;
+  const startInterval = (callback, sec, immediate) => {
+    return setInterval(callback, sec * 1e3);
+  };
+  const stopInterval = clearInterval;
   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 errorNew = (message) => {
     throw new Error(message);
   };
 
+  const arrayNew = (size2, cb) =>
+    arrayMap(new Array(size2).fill(0), (_, index) => cb(index));
+  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 arrayClear = (array, to) => array.splice(0, to);
   const arrayPush = (array, ...values) => array.push(...values);
   const arrayShift = (array) => array.shift();
 
   const object = Object;
   const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+  const objEntries = object.entries;
   const isObject = (obj) =>
     !isUndefined(obj) &&
     ifNotUndefined(
@@ -37,14 +60,30 @@
     );
   const objIds = object.keys;
   const objFreeze = object.freeze;
+  const objNew = (entries = []) => object.fromEntries(entries);
+  const objMerge = (...objs) => object.assign({}, ...objs);
+  const objHas = (obj, id) => id in obj;
+  const objDel = (obj, id) => {
+    delete obj[id];
+    return obj;
+  };
+  const objToArray = (obj, cb) =>
+    arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+  const objMap = (obj, cb) =>
+    objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
+  const objValues = (obj) => object.values(obj);
   const objSize = (obj) => size(objIds(obj));
   const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
   const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+  const collValues = (coll) => [...(coll?.values() ?? [])];
+  const collClear = (coll) => coll.clear();
   const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
   const mapNew = (entries) => new Map(entries);
   const mapGet = (map, key) => map?.get(key);
+  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, hadExistingValue) => {
@@ -253,6 +292,802 @@
     return objFreeze(persister);
   };
 
+  const SINGLE_ROW_ID = '_';
+  const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
+  const SELECT = 'SELECT';
+  const WHERE = 'WHERE';
+  const TABLE = 'TABLE';
+  const ALTER_TABLE = 'ALTER ' + TABLE;
+  const DELETE_FROM = 'DELETE FROM';
+  const SELECT_STAR_FROM = SELECT + '*FROM';
+  const PRAGMA = 'pragma_';
+  const DATA_VERSION = 'data_version';
+  const SCHEMA_VERSION = 'schema_version';
+  const FROM = 'FROM ';
+  const PRAGMA_TABLE = 'pragma_table_';
+  const getWrappedCommand = (executeCommand, onSqlCommand) =>
+    onSqlCommand
+      ? async (sql, params) => {
+          onSqlCommand(sql, params);
+          return await executeCommand(sql, params);
+        }
+      : executeCommand;
+  const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
+  const getPlaceholders = (array) =>
+    arrayJoin(
+      arrayMap(array, (_, index) => '$' + (index + 1)),
+      COMMA,
+    );
+
+  const jsonString = JSON.stringify;
+  const jsonParse = JSON.parse;
+  const jsonStringWithUndefined = (obj) =>
+    jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
+  const jsonParseWithUndefined = (str) =>
+    jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
+
+  const setNew = (entryOrEntries) =>
+    new Set(
+      isArray(entryOrEntries) || isUndefined(entryOrEntries)
+        ? entryOrEntries
+        : [entryOrEntries],
+    );
+  const setAdd = (set, value) => set?.add(value);
+
+  const getCommandFunctions = (
+    databaseExecuteCommand,
+    managedTableNames,
+    querySchema,
+    onIgnoredError,
+    columnType,
+    orReplace,
+    encode,
+    decode,
+  ) => {
+    const schemaMap = mapNew();
+    const canSelect = (tableName, rowIdColumnName) =>
+      collHas(mapGet(schemaMap, tableName), rowIdColumnName);
+    const refreshSchema = async () => {
+      collClear(schemaMap);
+      arrayMap(
+        await querySchema(databaseExecuteCommand, managedTableNames),
+        ({tn, cn}) => setAdd(mapEnsure(schemaMap, tn, setNew), cn),
+      );
+    };
+    const loadTable = async (tableName, rowIdColumnName) =>
+      canSelect(tableName, rowIdColumnName)
+        ? objNew(
+            arrayFilter(
+              arrayMap(
+                await databaseExecuteCommand(
+                  SELECT_STAR_FROM + escapeId(tableName),
+                ),
+                (row) => [
+                  row[rowIdColumnName],
+                  decode
+                    ? objMap(objDel(row, rowIdColumnName), decode)
+                    : objDel(row, rowIdColumnName),
+                ],
+              ),
+              ([rowId, row]) => !isUndefined(rowId) && !objIsEmpty(row),
+            ),
+          )
+        : {};
+    const saveTable = async (
+      tableName,
+      rowIdColumnName,
+      content,
+      deleteEmptyColumns,
+      deleteEmptyTable,
+      partial = false,
+    ) => {
+      const tableCellOrValueIds = setNew();
+      objToArray(content ?? {}, (contentRow) =>
+        arrayMap(objIds(contentRow ?? {}), (cellOrValueId) =>
+          setAdd(tableCellOrValueIds, cellOrValueId),
+        ),
+      );
+      const tableColumnNames = collValues(tableCellOrValueIds);
+      if (
+        !partial &&
+        deleteEmptyTable &&
+        arrayIsEmpty(tableColumnNames) &&
+        collHas(schemaMap, tableName)
+      ) {
+        await databaseExecuteCommand('DROP ' + TABLE + escapeId(tableName));
+        mapSet(schemaMap, tableName);
+        return;
+      }
+      const tableSchemaColumns = mapGet(schemaMap, tableName);
+      const currentColumnNames = setNew(collValues(tableSchemaColumns));
+      if (!arrayIsEmpty(tableColumnNames)) {
+        if (!collHas(schemaMap, tableName)) {
+          await databaseExecuteCommand(
+            'CREATE ' +
+              TABLE +
+              escapeId(tableName) +
+              `(${escapeId(rowIdColumnName)}${columnType} PRIMARY KEY${arrayJoin(
+                arrayMap(
+                  tableColumnNames,
+                  (columnName) => COMMA + escapeId(columnName) + columnType,
+                ),
+              )});`,
+          );
+          mapSet(
+            schemaMap,
+            tableName,
+            setNew([rowIdColumnName, ...tableColumnNames]),
+          );
+        } else {
+          await promiseAll(
+            arrayMap(
+              [rowIdColumnName, ...tableColumnNames],
+              async (columnName, index) => {
+                if (!collDel(currentColumnNames, columnName)) {
+                  await databaseExecuteCommand(
+                    ALTER_TABLE +
+                      escapeId(tableName) +
+                      'ADD' +
+                      escapeId(columnName) +
+                      columnType,
+                  );
+                  if (index == 0) {
+                    await databaseExecuteCommand(
+                      'CREATE UNIQUE INDEX pk ON ' +
+                        escapeId(tableName) +
+                        `(${escapeId(rowIdColumnName)})`,
+                    );
+                  }
+                  setAdd(tableSchemaColumns, columnName);
+                }
+              },
+            ),
+          );
+        }
+      }
+      await promiseAll([
+        ...(!partial && deleteEmptyColumns
+          ? arrayMap(collValues(currentColumnNames), async (columnName) => {
+              if (columnName != rowIdColumnName) {
+                await databaseExecuteCommand(
+                  ALTER_TABLE +
+                    escapeId(tableName) +
+                    'DROP' +
+                    escapeId(columnName),
+                );
+                collDel(tableSchemaColumns, columnName);
+              }
+            })
+          : []),
+      ]);
+      if (partial) {
+        if (isUndefined(content)) {
+          await databaseExecuteCommand(
+            DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+          );
+        } else {
+          await promiseAll(
+            objToArray(content, async (row, rowId) => {
+              if (isUndefined(row)) {
+                await databaseExecuteCommand(
+                  DELETE_FROM +
+                    escapeId(tableName) +
+                    WHERE +
+                    escapeId(rowIdColumnName) +
+                    '=$1',
+                  [rowId],
+                );
+              } else if (!arrayIsEmpty(tableColumnNames)) {
+                await upsert(
+                  databaseExecuteCommand,
+                  tableName,
+                  rowIdColumnName,
+                  objIds(row),
+                  [
+                    rowId,
+                    ...(encode
+                      ? arrayMap(objValues(row), encode)
+                      : objValues(row)),
+                  ],
+                  orReplace,
+                );
+              }
+            }),
+          );
+        }
+      } else {
+        if (!arrayIsEmpty(tableColumnNames)) {
+          const changingColumnNames = arrayFilter(
+            collValues(mapGet(schemaMap, tableName)),
+            (columnName) => columnName != rowIdColumnName,
+          );
+          const params = [];
+          const deleteRowIds = [];
+          objToArray(content ?? {}, (row, rowId) => {
+            arrayPush(
+              params,
+              rowId,
+              ...arrayMap(changingColumnNames, (cellId) =>
+                encode ? encode(row?.[cellId]) : row?.[cellId],
+              ),
+            );
+            arrayPush(deleteRowIds, rowId);
+          });
+          await upsert(
+            databaseExecuteCommand,
+            tableName,
+            rowIdColumnName,
+            changingColumnNames,
+            params,
+            orReplace,
+          );
+          await databaseExecuteCommand(
+            DELETE_FROM +
+              escapeId(tableName) +
+              WHERE +
+              escapeId(rowIdColumnName) +
+              `NOT IN(${getPlaceholders(deleteRowIds)})`,
+            deleteRowIds,
+          );
+        } else if (collHas(schemaMap, tableName)) {
+          await databaseExecuteCommand(
+            DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+          );
+        }
+      }
+    };
+    const transaction = async (actions) => {
+      let result;
+      await databaseExecuteCommand('BEGIN');
+      try {
+        result = await actions();
+      } catch (error) {
+        onIgnoredError?.(error);
+      }
+      await databaseExecuteCommand('END');
+      return result;
+    };
+    return [refreshSchema, loadTable, saveTable, transaction];
+  };
+  const upsert = async (
+    executeCommand,
+    tableName,
+    rowIdColumnName,
+    changingColumnNames,
+    params,
+    orReplace = 0,
+  ) =>
+    await executeCommand(
+      'INSERT ' +
+        (orReplace ? 'OR REPLACE ' : EMPTY_STRING) +
+        'INTO' +
+        escapeId(tableName) +
+        '(' +
+        escapeId(rowIdColumnName) +
+        arrayJoin(
+          arrayMap(
+            changingColumnNames,
+            (columnName) => COMMA + escapeId(columnName),
+          ),
+        ) +
+        ')VALUES' +
+        getUpsertPlaceholders(params, size(changingColumnNames) + 1) +
+        (orReplace
+          ? EMPTY_STRING
+          : 'ON CONFLICT(' +
+            escapeId(rowIdColumnName) +
+            ')DO UPDATE SET' +
+            arrayJoin(
+              arrayMap(
+                changingColumnNames,
+                (columnName) =>
+                  escapeId(columnName) + '=excluded.' + escapeId(columnName),
+              ),
+              COMMA,
+            )),
+      arrayMap(params, (param) => param ?? null),
+    );
+  const getUpsertPlaceholders = (array, columnCount) =>
+    arrayJoin(
+      arrayNew(
+        size(array) / columnCount,
+        (row) =>
+          '(' +
+          arrayJoin(
+            arrayNew(
+              columnCount,
+              (column) => '$' + (row * columnCount + column + 1),
+            ),
+            COMMA,
+          ) +
+          ')',
+      ),
+      COMMA,
+    );
+
+  const createJsonPersister = (
+    store,
+    executeCommand,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    destroyImpl,
+    persist,
+    [storeTableName, storeIdColumnName, storeColumnName],
+    managedTableNames,
+    querySchema,
+    thing,
+    getThing,
+    columnType,
+    orReplace,
+  ) => {
+    const [refreshSchema, loadTable, saveTable, transaction] =
+      getCommandFunctions(
+        executeCommand,
+        managedTableNames,
+        querySchema,
+        onIgnoredError,
+        columnType,
+        orReplace,
+      );
+    const getPersisted = async () =>
+      await transaction(async () => {
+        await refreshSchema();
+        return jsonParseWithUndefined(
+          (await loadTable(storeTableName, storeIdColumnName))[SINGLE_ROW_ID]?.[
+            storeColumnName
+          ] ?? 'null',
+        );
+      });
+    const setPersisted = async (getContent) =>
+      await transaction(async () => {
+        await refreshSchema();
+        await saveTable(
+          storeTableName,
+          storeIdColumnName,
+          {
+            [SINGLE_ROW_ID]: {
+              [storeColumnName]: jsonStringWithUndefined(getContent() ?? null),
+            },
+          },
+          true,
+          true,
+        );
+      });
+    const destroy = () => {
+      persister.stopAutoLoad().stopAutoSave();
+      destroyImpl();
+      return persister;
+    };
+    const persister = createCustomPersister(
+      store,
+      getPersisted,
+      setPersisted,
+      addPersisterListener,
+      delPersisterListener,
+      onIgnoredError,
+      persist,
+      {[getThing]: () => thing, destroy},
+      thing,
+    );
+    return persister;
+  };
+
+  const createTabularPersister = (
+    store,
+    executeCommand,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    destroyImpl,
+    persist,
+    [
+      tablesLoadConfig,
+      tablesSaveConfig,
+      [valuesLoad, valuesSave, valuesTableName],
+    ],
+    managedTableNames,
+    querySchema,
+    thing,
+    getThing,
+    columnType,
+    orReplace,
+    encode,
+    decode,
+  ) => {
+    const [refreshSchema, loadTable, saveTable, transaction] =
+      getCommandFunctions(
+        executeCommand,
+        managedTableNames,
+        querySchema,
+        onIgnoredError,
+        columnType,
+        orReplace,
+        encode,
+        decode,
+      );
+    const saveTables = async (tables, partial) =>
+      await promiseAll(
+        mapMap(
+          tablesSaveConfig,
+          async (
+            [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
+            tableId,
+          ) => {
+            if (!partial || objHas(tables, tableId)) {
+              await saveTable(
+                tableName,
+                rowIdColumnName,
+                tables[tableId],
+                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, changes) =>
+      await transaction(async () => {
+        await refreshSchema();
+        if (!isUndefined(changes)) {
+          await saveTables(changes[0], true);
+          await saveValues(changes[1], true);
+        } else {
+          const [tables, values] = getContent();
+          await saveTables(tables);
+          await saveValues(values);
+        }
+      });
+    const destroy = () => {
+      persister.stopAutoLoad().stopAutoSave();
+      destroyImpl();
+      return persister;
+    };
+    const persister = createCustomPersister(
+      store,
+      getPersisted,
+      setPersisted,
+      addPersisterListener,
+      delPersisterListener,
+      onIgnoredError,
+      persist,
+      {[getThing]: () => thing, destroy},
+      thing,
+    );
+    return persister;
+  };
+
+  const COLUMN_NAME = 'ColumnName';
+  const STORE = 'store';
+  const JSON$1 = 'json';
+  const STORE_TABLE_NAME = STORE + 'TableName';
+  const STORE_ID_COLUMN_NAME = STORE + 'Id' + COLUMN_NAME;
+  const STORE_COLUMN_NAME = STORE + COLUMN_NAME;
+  const AUTO_LOAD_INTERVAL_SECONDS = 'autoLoadIntervalSeconds';
+  const ROW_ID_COLUMN_NAME = 'rowId' + COLUMN_NAME;
+  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,
+    exclude,
+    then,
+  ) => {
+    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]) &&
+        !exclude(id, defaultedConfig[0])
+      ) {
+        then(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 = config[STORE_TABLE_NAME] ?? TINYBASE;
+      return [
+        1,
+        autoLoadIntervalSeconds,
+        [
+          storeTableName,
+          config[STORE_ID_COLUMN_NAME] ?? DEFAULT_ROW_ID_COLUMN_NAME,
+          config[STORE_COLUMN_NAME] ?? STORE,
+        ],
+        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 excludedTableNames = setNew(valuesTable);
+    const tabularConfig = [
+      getDefaultedTabularConfigMap(
+        load,
+        {[TABLE_ID]: null, [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME},
+        TABLE_ID,
+        (tableName) => collHas(excludedTableNames, tableName),
+        (tableName) => setAdd(managedTableNames, tableName),
+      ),
+      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) => collHas(excludedTableNames, tableName),
+        (_, tableName) => setAdd(managedTableNames, tableName),
+      ),
+      valuesConfig,
+    ];
+    return [0, autoLoadIntervalSeconds, tabularConfig, managedTableNames];
+  };
+
+  const createCustomSqlitePersister = (
+    store,
+    configOrStoreTableName,
+    rawExecuteCommand,
+    addChangeListener,
+    delChangeListener,
+    onSqlCommand,
+    onIgnoredError,
+    destroy,
+    persist,
+    thing,
+    getThing = 'getDb',
+    orReplace,
+  ) => {
+    let dataVersion;
+    let schemaVersion;
+    let totalChanges;
+    const executeCommand = getWrappedCommand(rawExecuteCommand, onSqlCommand);
+    const [
+      isJson,
+      autoLoadIntervalSeconds,
+      defaultedConfig,
+      managedTableNamesSet,
+    ] = getConfigStructures(configOrStoreTableName);
+    const addPersisterListener = (listener) => {
+      let interval;
+      const startPolling = () =>
+        (interval = startInterval(async () => {
+          try {
+            const [{d, s, c}] = await executeCommand(
+              // eslint-disable-next-line max-len
+              `${SELECT} ${DATA_VERSION} d,${SCHEMA_VERSION} s,TOTAL_CHANGES() c FROM ${PRAGMA}${DATA_VERSION} JOIN ${PRAGMA}${SCHEMA_VERSION}`,
+            );
+            if (d != dataVersion || s != schemaVersion || c != totalChanges) {
+              if (dataVersion != null) {
+                listener();
+              }
+              dataVersion = d;
+              schemaVersion = s;
+              totalChanges = c;
+            }
+          } catch {}
+        }, autoLoadIntervalSeconds));
+      const stopPolling = () => {
+        dataVersion = schemaVersion = totalChanges = null;
+        stopInterval(interval);
+      };
+      const listeningHandle = addChangeListener((tableName) => {
+        if (managedTableNamesSet.has(tableName)) {
+          stopPolling();
+          listener();
+          startPolling();
+        }
+      });
+      startPolling();
+      return () => {
+        stopPolling();
+        delChangeListener(listeningHandle);
+      };
+    };
+    const delPersisterListener = (stopPollingAndDelUpdateListener) =>
+      stopPollingAndDelUpdateListener();
+    return (isJson ? createJsonPersister : createTabularPersister)(
+      store,
+      executeCommand,
+      addPersisterListener,
+      delPersisterListener,
+      onIgnoredError,
+      destroy,
+      persist,
+      defaultedConfig,
+      collValues(managedTableNamesSet),
+      async (executeCommand2, managedTableNames) =>
+        await executeCommand2(
+          // eslint-disable-next-line max-len
+          `${SELECT} t.name tn,c.name cn ${FROM}${PRAGMA_TABLE}list()t,${PRAGMA_TABLE}info(t.name)c ${WHERE} t.schema='main'AND t.type IN('table','view')AND t.name IN(${getPlaceholders(managedTableNames)})ORDER BY t.name,c.name`,
+          managedTableNames,
+        ),
+      thing,
+      getThing,
+      EMPTY_STRING,
+      orReplace,
+      (cellOrValue) =>
+        cellOrValue === true ? 1 : cellOrValue === false ? 0 : cellOrValue,
+      void 0,
+    );
+  };
+
+  const EVENT_CHANNEL = TINYBASE;
+  const EVENT_REGEX = /^([cd]:)(.+)/;
+  const CHANGE_DATA_TRIGGER = TINYBASE + '_data';
+  const CREATE_TABLE_TRIGGER = TINYBASE + '_table';
+  const createCustomPostgreSqlPersister = (
+    store,
+    configOrStoreTableName,
+    rawExecuteCommand,
+    addChangeListener,
+    delChangeListener,
+    onSqlCommand,
+    onIgnoredError,
+    destroy,
+    persist,
+    thing,
+    getThing = 'getDb',
+  ) => {
+    const executeCommand = getWrappedCommand(rawExecuteCommand, onSqlCommand);
+    const [isJson, , defaultedConfig, managedTableNamesSet] =
+      getConfigStructures(configOrStoreTableName);
+    const addDataTrigger = async (tableName) => {
+      await executeCommand(
+        // eslint-disable-next-line max-len
+        `CREATE OR REPLACE TRIGGER ${escapeId(CHANGE_DATA_TRIGGER + '_' + tableName)} AFTER INSERT OR UPDATE OR DELETE ON ${escapeId(tableName)} EXECUTE FUNCTION ${CHANGE_DATA_TRIGGER}()`,
+      );
+    };
+    const addPersisterListener = async (listener) => {
+      await executeCommand(
+        // eslint-disable-next-line max-len
+        `CREATE OR REPLACE FUNCTION ${CREATE_TABLE_TRIGGER}()RETURNS event_trigger AS $t2$ DECLARE row record; BEGIN FOR row IN SELECT object_identity FROM pg_event_trigger_ddl_commands()WHERE command_tag='CREATE TABLE' LOOP PERFORM pg_notify('${EVENT_CHANNEL}','c:'||SPLIT_PART(row.object_identity,'.',2));END LOOP;END;$t2$ LANGUAGE plpgsql;`,
+      );
+      try {
+        await executeCommand(
+          // eslint-disable-next-line max-len
+          `CREATE EVENT TRIGGER ${CREATE_TABLE_TRIGGER} ON ddl_command_end WHEN TAG IN('CREATE TABLE')EXECUTE FUNCTION ${CREATE_TABLE_TRIGGER}();`,
+        );
+      } catch {}
+      await executeCommand(
+        // eslint-disable-next-line max-len
+        `CREATE OR REPLACE FUNCTION ${CHANGE_DATA_TRIGGER}()RETURNS trigger AS $t1$ BEGIN PERFORM pg_notify('${EVENT_CHANNEL}','d:'||TG_TABLE_NAME);RETURN NULL;END;$t1$ LANGUAGE plpgsql;`,
+      );
+      await promiseAll(
+        arrayMap(collValues(managedTableNamesSet), async (tableName) => {
+          await executeCommand(
+            // eslint-disable-next-line max-len
+            `CREATE TABLE IF NOT EXISTS ${escapeId(tableName)}("_id"text PRIMARY KEY)`,
+          );
+          await addDataTrigger(tableName);
+        }),
+      );
+      return await addChangeListener(
+        EVENT_CHANNEL,
+        async (prefixAndTableName) =>
+          await ifNotUndefined(
+            strMatch(prefixAndTableName, EVENT_REGEX),
+            async ([, eventType, tableName]) => {
+              if (collHas(managedTableNamesSet, tableName)) {
+                if (eventType == 'c:') {
+                  await addDataTrigger(tableName);
+                }
+                listener();
+              }
+            },
+          ),
+      );
+    };
+    const delPersisterListener = delChangeListener;
+    return (isJson ? createJsonPersister : createTabularPersister)(
+      store,
+      executeCommand,
+      addPersisterListener,
+      delPersisterListener,
+      onIgnoredError,
+      destroy,
+      persist,
+      defaultedConfig,
+      collValues(managedTableNamesSet),
+      async (executeCommand2, managedTableNames) =>
+        await executeCommand2(
+          // eslint-disable-next-line max-len
+          `${SELECT} table_name tn,column_name cn FROM information_schema.columns ${WHERE} table_schema='public'AND table_name IN(${getPlaceholders(managedTableNames)})`,
+          managedTableNames,
+        ),
+      thing,
+      getThing,
+      'text',
+      0,
+      (cellOrValue) => jsonString(cellOrValue),
+      (field) => jsonParse(field),
+    );
+  };
+
   exports.Persists = Persists;
   exports.createCustomPersister = createCustomPersister;
+  exports.createCustomPostgreSqlPersister = createCustomPostgreSqlPersister;
+  exports.createCustomSqlitePersister = createCustomSqlitePersister;
 });