tinybase 9.5.0 → 9.6.0-beta.1

package/persisters/persister-pg/index.js

@@ -0,0 +1,1905 @@
+const getTypeOf = (thing) => typeof thing;
+const TINYBASE = 'tinybase';
+const EMPTY_STRING = '';
+const COMMA = ',';
+const DOT = '.';
+const STRING = getTypeOf(EMPTY_STRING);
+const TRUE = 'true';
+const UNDEFINED = '\uFFFC';
+const strMatch = (str, regex) => str?.match(regex);
+const strSplit = (str, separator = EMPTY_STRING, limit) =>
+  str.split(separator, limit);
+const strReplace = (str, searchValue, replaceValue) =>
+  str.replace(searchValue, replaceValue);
+
+const promise = Promise;
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value)
+    ? /* istanbul ignore next */
+      otherwise?.()
+    : then(value);
+const GLOBAL = globalThis;
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const isNull = (thing) => thing === null;
+const isTrue = (thing) => thing === true;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
+const size = (thing) => thing.length;
+const isEmpty = (thing) => size(thing) == 0;
+const test = (regex, subject) => regex.test(subject);
+const noop = () => {};
+const promiseNew = (resolver) => new promise(resolver);
+const promiseAll = async (promises) => promise.all(promises);
+const promiseResolve = () => promise.resolve();
+
+const ERROR_STORE_TYPE = 0;
+const ERROR_CONTENT = 1;
+const errorNew = (code, details) =>
+  new Error(
+    TINYBASE +
+      ':' +
+      code +
+      (isUndefined(details)
+        ? EMPTY_STRING
+        : /* istanbul ignore next */
+          ':' + details),
+  );
+const errorThrow = (code, details) => {
+  throw errorNew(code, details);
+};
+const tryCatch = async (action, onError) => {
+  try {
+    return await action();
+  } catch (error) {
+    /* istanbul ignore next */
+    onError?.(error);
+  }
+};
+const tryCatchIgnore = (action, onIgnoredError) =>
+  tryCatch(action, (error) => void tryCatch(() => onIgnoredError?.(error)));
+const tryCatchSync = (action, onError) => {
+  try {
+    return action();
+  } catch (error) {
+    onError?.(error);
+  }
+};
+const tryFinally = (action, finallyAction) => {
+  try {
+    return action();
+  } finally {
+    finallyAction();
+  }
+};
+const tryFinallyAsync = async (action, finallyAction) => {
+  try {
+    return await action();
+  } finally {
+    await finallyAction();
+  }
+};
+
+const arrayHas = (array, value) => array.includes(value);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayFilter = (array, cb) => array.filter(cb);
+const arrayClear = (array, to = size(array)) => array.splice(0, to);
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+const SINGLE_ROW_ID = '_';
+const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
+const SELECT = 'SELECT';
+const WHERE = 'WHERE';
+const TABLE = 'TABLE';
+const INSERT = 'INSERT';
+const DELETE = 'DELETE';
+const UPDATE = 'UPDATE';
+const ALTER_TABLE = 'ALTER ' + TABLE;
+const FROM = 'FROM';
+const DELETE_FROM = DELETE + ' ' + FROM;
+const SELECT_STAR_FROM = SELECT + '*' + FROM;
+const CREATE = 'CREATE ';
+const CREATE_TABLE = CREATE + TABLE;
+const OR_REPLACE = 'OR REPLACE ';
+const FUNCTION = 'FUNCTION';
+const TABLE_NAME_PLACEHOLDER_REGEX = /\$tableName/g;
+const getWrappedCommand = (executeCommand, onSqlCommand) =>
+  onSqlCommand
+    ? async (sql, params) => {
+        onSqlCommand(sql, params);
+        return await executeCommand(sql, params);
+      }
+    : executeCommand;
+const escapeId = (str) =>
+  arrayJoin(
+    arrayMap(strSplit(str, DOT), (part) => `"${strReplace(part, /"/g, '""')}"`),
+    DOT,
+  );
+const escapeIds = (...ids) => escapeId(arrayJoin(ids, '_'));
+const escapeColumnNames = (...columnNames) =>
+  arrayJoin(arrayMap(columnNames, escapeId), COMMA);
+const numberedPlaceholder = (offset) => '$' + offset[0]++;
+const getPlaceholders = (array, getPlaceholder, offset = [1]) =>
+  arrayJoin(
+    arrayMap(array, () => getPlaceholder(offset)),
+    COMMA,
+  );
+const getWhereCondition = (tableName, condition = TRUE) =>
+  WHERE + `(${replaceTableName(condition, escapeId(tableName))})`;
+const replaceTableName = (condition, tableName) =>
+  strReplace(condition, TABLE_NAME_PLACEHOLDER_REGEX, tableName);
+
+const collSize = (coll) => coll?.size ?? 0;
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+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 isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objMerge = (...objs) => object.assign(object.create(null), ...objs);
+const objHas = (obj, id) => object.hasOwn(obj, id);
+const objSet = (obj, id, value) => {
+  object.defineProperty(obj, id, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+  return value;
+};
+const objNew = (entries = []) => {
+  const obj = object.create(null);
+  arrayForEach(entries, ([id, value]) => objSet(obj, id, value));
+  return obj;
+};
+const objDel = (obj, id) => {
+  delete obj[id];
+  return obj;
+};
+const objForEach = (obj, cb) =>
+  arrayForEach(objIds(obj), (id) => cb(obj[id], id));
+const objToArray = (obj, cb) =>
+  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objMap = (obj, cb) => {
+  const mapped = objNew();
+  objForEach(obj, (value, id) => objSet(mapped, id, cb(value, id)));
+  return mapped;
+};
+const objValues = (obj) => object.values(obj);
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithUndefined = (obj) =>
+  jsonString(obj, (_key, value) => (isUndefined(value) ? UNDEFINED : value));
+const jsonParseWithUndefined = (str) =>
+  // JSON.parse reviver removes properties with undefined values
+  replaceUndefinedString(jsonParse(str));
+const replaceUndefinedString = (obj) =>
+  obj === UNDEFINED
+    ? void 0
+    : isArray(obj)
+      ? arrayMap(obj, replaceUndefinedString)
+      : isObject(obj)
+        ? objMap(obj, replaceUndefinedString)
+        : obj;
+
+const textEncoder = new GLOBAL.TextEncoder();
+const getHash = (string) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(string), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
+const mapForEach = (map2, cb) =>
+  collForEach(map2, (value, key) => cb(key, value));
+const mapMap = (coll, cb) => {
+  const mapped = [];
+  mapForEach(coll, (key, value) => arrayPush(mapped, cb(value, key)));
+  return mapped;
+};
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  let value = mapGet(map2, key);
+  if (collHas(map2, key)) {
+    hadExistingValue?.(value);
+  } else {
+    mapSet(map2, key, (value = getDefaultValue()));
+  }
+  return value;
+};
+const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+  ifNotUndefined(
+    (ensureLeaf ? mapEnsure : mapGet)(
+      node,
+      path[p],
+      p > size(path) - 2 ? ensureLeaf : mapNew,
+    ),
+    (nodeOrLeaf) => {
+      if (p > size(path) - 2) {
+        if (pruneLeaf?.(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return nodeOrLeaf;
+      }
+      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+      if (collIsEmpty(nodeOrLeaf)) {
+        mapSet(node, path[p]);
+      }
+      return leaf;
+    },
+  );
+
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
+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 CONDITION = 'condition';
+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 getValuesIn = (config) => (isArray(config) ? config : void 0);
+const hasValues = (config) => isTrue(config) || isArray(config);
+const getDefaultedConfig = (configOrStoreTableName) =>
+  objMerge(
+    DEFAULT_CONFIG,
+    isString(configOrStoreTableName)
+      ? {[STORE_TABLE_NAME]: configOrStoreTableName}
+      : (configOrStoreTableName ?? {}),
+  );
+const getDefaultedTabularConfigMap = (
+  configsObj,
+  defaultObj,
+  tableField,
+  exclude,
+  then,
+) => {
+  const configMap = mapNew();
+  objForEach(configsObj, (configObj, id) => {
+    const defaultedConfig = slice(
+      objValues(
+        objMerge(
+          defaultObj,
+          isString(configObj) ? {[tableField]: configObj} : configObj,
+        ),
+      ),
+      0,
+      objSize(defaultObj),
+    );
+    if (!isNull(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 valuesConfigObj = objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values);
+  const {load: valuesLoad, save: valuesSave} = valuesConfigObj;
+  const valuesConfig = [
+    hasValues(valuesLoad),
+    hasValues(valuesSave),
+    valuesConfigObj[TABLE_NAME],
+    getValuesIn(valuesLoad),
+    getValuesIn(valuesSave),
+  ];
+  const valuesTable = valuesConfig[2];
+  const managedTableNames = setNew(valuesTable);
+  const excludedTableNames = setNew(valuesTable);
+  const tablesLoadConfig = getDefaultedTabularConfigMap(
+    load,
+    {
+      [TABLE_ID]: null,
+      [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
+      [CONDITION]: TRUE,
+    },
+    TABLE_ID,
+    (tableName) => collHas(excludedTableNames, tableName),
+    (tableName) => setAdd(managedTableNames, tableName),
+  );
+  const tablesSaveConfig = getDefaultedTabularConfigMap(
+    save,
+    {
+      [TABLE_NAME]: null,
+      [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
+      [DELETE_EMPTY_COLUMNS]: 0,
+      [DELETE_EMPTY_TABLE]: 0,
+      [CONDITION]: null,
+    },
+    TABLE_NAME,
+    (_, tableName) => collHas(excludedTableNames, tableName),
+    (_, tableName) => setAdd(managedTableNames, tableName),
+  );
+  mapForEach(
+    tablesSaveConfig,
+    (_, tableSaveConfig) =>
+      (tableSaveConfig[4] ??=
+        mapGet(tablesLoadConfig, tableSaveConfig[0])?.[2] ?? TRUE),
+  );
+  return [
+    0,
+    autoLoadIntervalSeconds,
+    [tablesLoadConfig, tablesSaveConfig, valuesConfig],
+    managedTableNames,
+  ];
+};
+
+const INTEGER = /^\d+$/;
+const getPoolFunctions = () => {
+  const pool = [];
+  let nextId = 0;
+  return [
+    (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
+    (id) => {
+      if (test(INTEGER, id) && size(pool) < 1e3) {
+        arrayPush(pool, id);
+      }
+    },
+  ];
+};
+
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const leaves = [];
+  const deep = (node, p) =>
+    p == size(path)
+      ? arrayPush(leaves, node)
+      : isNull(path[p])
+        ? collForEach(node, (node2) => deep(node2, p + 1))
+        : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
+  deep(deepIdSet, 0);
+  return leaves;
+};
+const getListenerFunctions = (getThing) => {
+  let thing;
+  const [getId, releaseId] = getPoolFunctions();
+  const allListeners = mapNew();
+  const addListener = (
+    listener,
+    idSetNode,
+    path,
+    pathGetters = [],
+    extraArgsGetter = () => [],
+  ) => {
+    thing ??= getThing();
+    const id = getId(1);
+    mapSet(allListeners, id, [
+      listener,
+      idSetNode,
+      path,
+      pathGetters,
+      extraArgsGetter,
+    ]);
+    setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
+    return id;
+  };
+  const callListenersImpl = (continueAfterError, idSetNode, ids, extraArgs) => {
+    let errorToThrow;
+    let failed = false;
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) => {
+        const callListener2 = () =>
+          mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs);
+        if (continueAfterError) {
+          tryCatchSync(callListener2, (error) => {
+            if (!failed) {
+              errorToThrow = error;
+            }
+            failed = true;
+          });
+        } else {
+          callListener2();
+        }
+      }),
+    );
+    if (failed) {
+      throw errorToThrow;
+    }
+  };
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    callListenersImpl(false, idSetNode, ids, extraArgs);
+  const callListenersThenThrow = (idSetNode, ids, ...extraArgs) =>
+    callListenersImpl(true, idSetNode, ids, extraArgs);
+  const delListener = (id) =>
+    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+      visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
+        collDel(idSet, id);
+        return collIsEmpty(idSet) ? 1 : 0;
+      });
+      mapSet(allListeners, id);
+      releaseId(id);
+      return idOrNulls;
+    });
+  const callListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([listener, , path = [], pathGetters, extraArgsGetter]) => {
+        const callWithIds = (...ids) => {
+          const index = size(ids);
+          if (index == size(path)) {
+            listener(thing, ...ids, ...extraArgsGetter(ids));
+          } else if (isNull(path[index])) {
+            arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
+              callWithIds(...ids, id2),
+            );
+          } else {
+            callWithIds(...ids, path[index]);
+          }
+        };
+        callWithIds();
+      },
+    );
+  return [
+    addListener,
+    callListeners,
+    delListener,
+    callListener,
+    callListenersThenThrow,
+  ];
+};
+
+const scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const scheduleReferences = mapNew();
+const getStoreFunctions = (
+  persist = 1 /* StoreOnly */,
+  store,
+  isSynchronizer,
+) =>
+  persist != 1 /* StoreOnly */ && store.isMergeable()
+    ? [
+        1,
+        store.__[1],
+        () => store.__[2](!isSynchronizer),
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : persist != 2 /* MergeableStoreOnly */
+      ? [
+          0,
+          store._[7],
+          store._[8],
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : errorThrow(ERROR_STORE_TYPE);
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  persist,
+  extra = {},
+  isSynchronizer = 0,
+  scheduleId = [],
+) => {
+  let status = 0; /* Idle */
+  let loads = 0;
+  let saves = 0;
+  let autoLoadHandle;
+  let autoLoadPromise;
+  let autoLoadGeneration = 0;
+  let pendingAutoLoads = 0;
+  let pendingScheduledAutoLoads = 0;
+  let autoLoadAfterSaveGeneration = 0;
+  let autoSaveListenerId;
+  let autoSaveGeneration = 0;
+  let destroyed = 0;
+  let destroying;
+  let activeAction;
+  const scheduleOwner = {};
+  const extraDestroy = extra.destroy;
+  mapEnsure(scheduleRunning, scheduleId, () => 0);
+  mapEnsure(scheduleActions, scheduleId, () => []);
+  mapSet(
+    scheduleReferences,
+    scheduleId,
+    (mapGet(scheduleReferences, scheduleId) ?? 0) + 1,
+  );
+  const statusListeners = mapNew();
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(persist, store, isSynchronizer);
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => persister,
+  );
+  const setStatus = (newStatus) => {
+    if (newStatus != status) {
+      status = newStatus;
+      callListeners(statusListeners, void 0, status);
+    }
+  };
+  const run = async () => {
+    /* istanbul ignore else */
+    if (!mapGet(scheduleRunning, scheduleId)) {
+      mapSet(scheduleRunning, scheduleId, 1);
+      const scheduledActions = mapGet(scheduleActions, scheduleId);
+      let actionIndex = 0;
+      await tryFinallyAsync(
+        async () => {
+          while (actionIndex < size(scheduledActions)) {
+            const scheduledAction = scheduledActions[actionIndex++];
+            scheduledAction[2] = void 0;
+            await scheduledAction[0]();
+          }
+        },
+        () => {
+          arrayClear(scheduledActions, actionIndex);
+          mapSet(scheduleRunning, scheduleId, 0);
+          pruneSchedule();
+        },
+      );
+    }
+  };
+  const pruneSchedule = () => {
+    if (
+      !mapGet(scheduleReferences, scheduleId) &&
+      !mapGet(scheduleRunning, scheduleId) &&
+      isEmpty(mapGet(scheduleActions, scheduleId) ?? [])
+    ) {
+      mapSet(scheduleRunning, scheduleId);
+      mapSet(scheduleActions, scheduleId);
+      mapSet(scheduleReferences, scheduleId);
+    }
+  };
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.__[4]
+        : store.__[3]
+      : contentOrChanges?.[2] === 1
+        ? store._[10]
+        : store._[9])(contentOrChanges);
+  };
+  const saveAfterMutated = async () => {
+    if (isAutoSaving() && store.__?.[0]?.()) {
+      await save();
+    }
+  };
+  const trackAutoLoadPromise = (newAutoLoadPromise) =>
+    tryFinallyAsync(
+      () => (autoLoadPromise = newAutoLoadPromise),
+      () => {
+        if (autoLoadPromise == newAutoLoadPromise) {
+          autoLoadPromise = void 0;
+        }
+      },
+    );
+  const load = async (initialContent) => {
+    /* istanbul ignore else */
+    if (status != 2 /* Saving */) {
+      await tryFinallyAsync(
+        async () => {
+          setStatus(1 /* Loading */);
+          loads++;
+          await schedule(() =>
+            tryCatch(
+              async () => {
+                const content = await getPersisted();
+                if (isArray(content)) {
+                  setContentOrChanges(content);
+                } else if (isUndefined(content) && initialContent) {
+                  setDefaultContent(initialContent);
+                } else if (!isUndefined(content)) {
+                  errorThrow(ERROR_CONTENT, content);
+                }
+              },
+              (error) => {
+                onIgnoredError?.(error);
+                if (initialContent) {
+                  setDefaultContent(initialContent);
+                }
+              },
+            ),
+          );
+        },
+        () => setStatus(0 /* Idle */),
+      );
+      await saveAfterMutated();
+    }
+    return persister;
+  };
+  const runAutoLoadAfterSave = async () => {
+    const generation = autoLoadAfterSaveGeneration;
+    autoLoadAfterSaveGeneration = 0;
+    if (generation && generation == autoLoadGeneration && !destroyed) {
+      if (status == 2 /* Saving */) {
+        autoLoadAfterSaveGeneration = generation;
+      } else {
+        await load();
+      }
+    }
+  };
+  const startAutoLoad = async (initialContent) => {
+    const generation = ++autoLoadGeneration;
+    let initialLoadPending = true;
+    await stopAutoLoad(true);
+    if (generation == autoLoadGeneration && !destroyed) {
+      const listenerPromise = tryCatch(async () => {
+        const handle = await addPersisterListener(async (content, changes) => {
+          if (generation == autoLoadGeneration && !destroyed) {
+            if (changes || content) {
+              const shouldSchedule =
+                initialLoadPending ||
+                status == 2 /* Saving */ ||
+                !!pendingScheduledAutoLoads;
+              pendingAutoLoads++;
+              if (shouldSchedule) {
+                pendingScheduledAutoLoads++;
+              }
+              await tryFinallyAsync(
+                async () => {
+                  setStatus(1 /* Loading */);
+                  loads++;
+                  await (shouldSchedule
+                    ? schedule(() => setContentOrChanges(changes ?? content))
+                    : tryFinally(
+                        () => setContentOrChanges(changes ?? content),
+                        () => setStatus(0 /* Idle */),
+                      ));
+                },
+                () => {
+                  if (shouldSchedule) {
+                    pendingScheduledAutoLoads--;
+                  }
+                  if (!--pendingAutoLoads) {
+                    setStatus(0 /* Idle */);
+                  }
+                },
+              );
+              if (!pendingAutoLoads) {
+                await saveAfterMutated();
+              }
+            } else if (status == 2 /* Saving */) {
+              autoLoadAfterSaveGeneration = generation;
+            } else {
+              await load();
+            }
+          }
+        });
+        if (generation == autoLoadGeneration && !destroyed) {
+          autoLoadHandle = handle;
+        } else if (!isUndefined(handle)) {
+          await delPersisterListener(handle);
+        }
+      }, onIgnoredError);
+      await trackAutoLoadPromise(listenerPromise);
+      if (generation == autoLoadGeneration && !destroyed) {
+        await tryFinallyAsync(
+          () => load(initialContent),
+          () => {
+            initialLoadPending = false;
+          },
+        );
+      }
+    }
+    return persister;
+  };
+  const stopAutoLoad = async (keepGeneration = false) => {
+    autoLoadAfterSaveGeneration = 0;
+    if (!keepGeneration) {
+      autoLoadGeneration++;
+    }
+    const listenerPromise = autoLoadPromise;
+    const handle = autoLoadHandle;
+    autoLoadHandle = void 0;
+    await trackAutoLoadPromise(
+      tryFinallyAsync(
+        async () => {
+          await listenerPromise;
+        },
+        async () => {
+          if (!isUndefined(handle)) {
+            await tryCatch(() => delPersisterListener(handle), onIgnoredError);
+          }
+        },
+      ),
+    );
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (status != 1 /* Loading */) {
+      await tryFinallyAsync(
+        () =>
+          tryFinallyAsync(
+            async () => {
+              setStatus(2 /* Saving */);
+              saves++;
+              await schedule(() =>
+                tryCatch(
+                  () => setPersisted(getContent, changes),
+                  onIgnoredError,
+                ),
+              );
+            },
+            () => setStatus(0 /* Idle */),
+          ),
+        runAutoLoadAfterSave,
+      );
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    const generation = ++autoSaveGeneration;
+    await stopAutoSave(true);
+    if (generation == autoSaveGeneration && !destroyed) {
+      await save();
+      if (generation == autoSaveGeneration && !destroyed) {
+        autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+          if (generation == autoSaveGeneration && !destroyed) {
+            const changes = getChanges();
+            if (hasChanges(changes)) {
+              void tryCatch(() => save(changes));
+            }
+          }
+        });
+      }
+    }
+    return persister;
+  };
+  const stopAutoSave = async (keepGeneration = false) => {
+    if (!keepGeneration) {
+      autoSaveGeneration++;
+    }
+    const listenerId = autoSaveListenerId;
+    autoSaveListenerId = void 0;
+    if (!isUndefined(listenerId)) {
+      store.delListener(listenerId);
+    }
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const startAutoPersisting = async (
+    initialContent,
+    startSaveFirst = false,
+  ) => {
+    const [call1, call2, stop1, stop2] = startSaveFirst
+      ? [startAutoSave, startAutoLoad, stopAutoSave, stopAutoLoad]
+      : [startAutoLoad, startAutoSave, stopAutoLoad, stopAutoSave];
+    const start1 = call1(initialContent);
+    const generation1 = startSaveFirst
+      ? autoSaveGeneration
+      : autoLoadGeneration;
+    await start1;
+    const start2 = call2(initialContent);
+    const generation2 = startSaveFirst
+      ? autoLoadGeneration
+      : autoSaveGeneration;
+    try {
+      await start2;
+    } catch (error) {
+      if (
+        generation2 ==
+        (startSaveFirst ? autoLoadGeneration : autoSaveGeneration)
+      ) {
+        await tryCatchIgnore(stop2);
+      }
+      if (
+        generation1 ==
+        (startSaveFirst ? autoSaveGeneration : autoLoadGeneration)
+      ) {
+        await tryCatchIgnore(stop1);
+      }
+      throw error;
+    }
+    return persister;
+  };
+  const stopAutoPersisting = async (stopSaveFirst = false) => {
+    const [call1, call2] = stopSaveFirst
+      ? [stopAutoSave, stopAutoLoad]
+      : [stopAutoLoad, stopAutoSave];
+    await tryFinallyAsync(
+      () => call1(),
+      async () => {
+        await call2();
+      },
+    );
+    return persister;
+  };
+  const getStatus = () => status;
+  const addStatusListener = (listener) =>
+    addListener(listener, statusListeners);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return store;
+  };
+  const schedule = async (...actions) => {
+    let failed = false;
+    let firstError;
+    const completion = promiseNew((resolve) =>
+      !isEmpty(actions)
+        ? arrayPush(
+            mapGet(scheduleActions, scheduleId),
+            ...arrayMap(actions, (action, index) => {
+              const last = index == size(actions) - 1;
+              return [
+                async () => {
+                  let completeActiveAction;
+                  activeAction = promiseNew(
+                    (resolve2) => (completeActiveAction = resolve2),
+                  );
+                  await tryFinallyAsync(
+                    async () => {
+                      try {
+                        await tryCatch(action, onIgnoredError);
+                      } catch (error) {
+                        if (!failed) {
+                          failed = true;
+                          firstError = error;
+                        }
+                      }
+                      if (last) {
+                        resolve();
+                      }
+                    },
+                    () => {
+                      activeAction = void 0;
+                      completeActiveAction();
+                    },
+                  );
+                },
+                last ? resolve : void 0,
+                scheduleOwner,
+              ];
+            }),
+          )
+        : resolve(),
+    );
+    await run();
+    await completion;
+    if (failed) {
+      throw firstError;
+    }
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = async () => {
+    if (isUndefined(destroying)) {
+      destroyed = 1;
+      destroying = (async () => {
+        const scheduledActions = mapGet(scheduleActions, scheduleId);
+        const remainingActions = arrayFilter(
+          scheduledActions,
+          ([, complete, owner]) => {
+            if (owner == scheduleOwner) {
+              complete?.();
+              return false;
+            }
+            return true;
+          },
+        );
+        const actionToAwait = activeAction;
+        arrayClear(scheduledActions);
+        arrayPush(scheduledActions, ...remainingActions);
+        await tryFinallyAsync(
+          () =>
+            tryFinallyAsync(
+              () => tryFinallyAsync(stopAutoPersisting, () => actionToAwait),
+              () => extraDestroy?.(),
+            ),
+          () => {
+            const references =
+              (mapGet(scheduleReferences, scheduleId) ?? 1) - 1;
+            mapSet(scheduleReferences, scheduleId, references || void 0);
+            pruneSchedule();
+          },
+        );
+      })();
+    }
+    await destroying;
+    return persister;
+  };
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    startAutoPersisting,
+    stopAutoPersisting,
+    getStatus,
+    addStatusListener,
+    delListener,
+    schedule,
+    getStore,
+    getStats,
+    ...extra,
+    destroy,
+  };
+  return objFreeze(persister);
+};
+
+const getCommandFunctions = (
+  databaseExecuteCommand,
+  managedTableNames,
+  querySchema,
+  columnType,
+  getPlaceholder,
+  upsert = defaultUpsert,
+  encode,
+  decode,
+  executeTransaction,
+) => {
+  const schemaMap = mapNew();
+  const uniqueSchemaMap = mapNew();
+  let executeCommand = databaseExecuteCommand;
+  const canSelect = (tableName, rowIdColumnName) =>
+    collHas(mapGet(schemaMap, tableName), rowIdColumnName);
+  const refreshSchema = async () => {
+    collClear(schemaMap);
+    collClear(uniqueSchemaMap);
+    arrayForEach(
+      await querySchema(executeCommand, managedTableNames),
+      ({tn, cn, uq}) => {
+        setAdd(mapEnsure(schemaMap, tn, setNew), cn);
+        if (uq) {
+          setAdd(mapEnsure(uniqueSchemaMap, tn, setNew), cn);
+        }
+      },
+    );
+  };
+  const loadTable = async (
+    tableName,
+    rowIdColumnName,
+    condition,
+    contentSubIds,
+  ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
+    return canSelect(tableName, rowIdColumnName)
+      ? objNew(
+          arrayFilter(
+            arrayMap(
+              await executeCommand(
+                SELECT_STAR_FROM +
+                  escapeId(tableName) +
+                  getWhereCondition(tableName, condition),
+              ),
+              (row) => {
+                const rowId = row[rowIdColumnName];
+                const rowContent = decode
+                  ? objMap(objDel(row, rowIdColumnName), decode)
+                  : objDel(row, rowIdColumnName);
+                return [
+                  rowId,
+                  isUndefined(contentSubIdSet)
+                    ? rowContent
+                    : objNew(
+                        arrayFilter(
+                          objToArray(
+                            rowContent,
+                            (cellOrValue, contentSubId) => [
+                              contentSubId,
+                              cellOrValue,
+                            ],
+                          ),
+                          ([contentSubId]) => includeContentSubId(contentSubId),
+                        ),
+                      ),
+                ];
+              },
+            ),
+            (entry) => !isUndefined(entry[0]) && !objIsEmpty(entry[1]),
+          ),
+        )
+      : {};
+  };
+  const saveTable = async (
+    tableName,
+    rowIdColumnName,
+    content,
+    deleteEmptyColumns,
+    deleteEmptyTable,
+    partial = false,
+    condition = TRUE,
+    contentSubIds,
+  ) => {
+    const contentSubIdSet = isUndefined(contentSubIds)
+      ? void 0
+      : setNew(contentSubIds);
+    const includeContentSubId = (contentSubId) =>
+      isUndefined(contentSubIdSet) || collHas(contentSubIdSet, contentSubId);
+    const settingColumnNameSet = setNew();
+    objForEach(content ?? {}, (contentRow) =>
+      arrayForEach(
+        arrayFilter(objIds(contentRow ?? {}), includeContentSubId),
+        (cellOrValueId) => setAdd(settingColumnNameSet, cellOrValueId),
+      ),
+    );
+    const settingColumnNames = collValues(settingColumnNameSet);
+    if (
+      isUndefined(contentSubIdSet) &&
+      !partial &&
+      deleteEmptyTable &&
+      condition == TRUE &&
+      isEmpty(settingColumnNames) &&
+      collHas(schemaMap, tableName)
+    ) {
+      await executeCommand('DROP ' + TABLE + escapeId(tableName));
+      mapSet(schemaMap, tableName);
+      mapSet(uniqueSchemaMap, tableName);
+      return;
+    }
+    const currentColumnNames = mapGet(schemaMap, tableName);
+    const unaccountedColumnNames = setNew(
+      arrayFilter(
+        collValues(currentColumnNames),
+        (columnName) =>
+          columnName == rowIdColumnName || includeContentSubId(columnName),
+      ),
+    );
+    if (!isEmpty(settingColumnNames)) {
+      if (!collHas(schemaMap, tableName)) {
+        await executeCommand(
+          CREATE_TABLE +
+            escapeId(tableName) +
+            `(${escapeId(rowIdColumnName)}${columnType} PRIMARY KEY${arrayJoin(
+              arrayMap(
+                settingColumnNames,
+                (settingColumnName) =>
+                  COMMA + escapeId(settingColumnName) + columnType,
+              ),
+            )});`,
+        );
+        mapSet(
+          schemaMap,
+          tableName,
+          setNew([rowIdColumnName, ...settingColumnNames]),
+        );
+        mapSet(uniqueSchemaMap, tableName, setNew([rowIdColumnName]));
+      } else {
+        await promiseAll(
+          arrayMap(
+            [rowIdColumnName, ...settingColumnNames],
+            async (settingColumnName) => {
+              if (!collDel(unaccountedColumnNames, settingColumnName)) {
+                await executeCommand(
+                  ALTER_TABLE +
+                    escapeId(tableName) +
+                    'ADD' +
+                    escapeId(settingColumnName) +
+                    columnType,
+                );
+                setAdd(currentColumnNames, settingColumnName);
+              }
+            },
+          ),
+        );
+        if (
+          upsert == defaultUpsert &&
+          !collHas(mapGet(uniqueSchemaMap, tableName), rowIdColumnName)
+        ) {
+          const indexName =
+            TINYBASE +
+            '_pk_' +
+            getHash(jsonString([tableName, rowIdColumnName]));
+          await executeCommand(
+            'CREATE UNIQUE INDEX IF NOT EXISTS' +
+              escapeId(indexName) +
+              'ON' +
+              escapeId(tableName) +
+              `(${escapeId(rowIdColumnName)})`,
+          );
+          setAdd(
+            mapEnsure(uniqueSchemaMap, tableName, setNew),
+            rowIdColumnName,
+          );
+        }
+      }
+    }
+    await promiseAll([
+      ...(!partial && deleteEmptyColumns
+        ? arrayMap(
+            collValues(unaccountedColumnNames),
+            async (unaccountedColumnName) => {
+              if (unaccountedColumnName != rowIdColumnName) {
+                await executeCommand(
+                  ALTER_TABLE +
+                    escapeId(tableName) +
+                    'DROP' +
+                    escapeId(unaccountedColumnName),
+                );
+                collDel(currentColumnNames, unaccountedColumnName);
+              }
+            },
+          )
+        : []),
+    ]);
+    if (partial) {
+      if (isUndefined(content)) {
+        if (isUndefined(contentSubIdSet)) {
+          await executeCommand(
+            DELETE_FROM +
+              escapeId(tableName) +
+              getWhereCondition(tableName, condition),
+          );
+        }
+      } else {
+        await promiseAll(
+          objToArray(content, async (row, rowId) => {
+            if (isUndefined(row)) {
+              await executeCommand(
+                DELETE_FROM +
+                  escapeId(tableName) +
+                  getWhereCondition(tableName, condition) +
+                  `AND(${escapeId(rowIdColumnName)}=${getPlaceholder([1])})`,
+                [rowId],
+              );
+            } else if (!isEmpty(settingColumnNames)) {
+              const changingColumnNames = arrayFilter(
+                objIds(row),
+                includeContentSubId,
+              );
+              if (!isEmpty(changingColumnNames)) {
+                await upsert(
+                  executeCommand,
+                  tableName,
+                  rowIdColumnName,
+                  changingColumnNames,
+                  {
+                    [rowId]: arrayMap(changingColumnNames, (cellId) =>
+                      encode ? encode(row[cellId]) : row[cellId],
+                    ),
+                  },
+                  getPlaceholder,
+                  currentColumnNames,
+                );
+              }
+            }
+          }),
+        );
+      }
+    } else {
+      if (!isEmpty(settingColumnNames)) {
+        const changingColumnNames = arrayFilter(
+          collValues(mapGet(schemaMap, tableName)),
+          (changingColumnName) =>
+            changingColumnName != rowIdColumnName &&
+            includeContentSubId(changingColumnName),
+        );
+        const rows = objNew();
+        const deleteRowIds = [];
+        objForEach(content ?? {}, (row, rowId) => {
+          objSet(
+            rows,
+            rowId,
+            arrayMap(changingColumnNames, (cellId) =>
+              encode ? encode(row?.[cellId]) : row?.[cellId],
+            ),
+          );
+          arrayPush(deleteRowIds, rowId);
+        });
+        await upsert(
+          executeCommand,
+          tableName,
+          rowIdColumnName,
+          changingColumnNames,
+          rows,
+          getPlaceholder,
+          currentColumnNames,
+        );
+        await executeCommand(
+          DELETE_FROM +
+            escapeId(tableName) +
+            getWhereCondition(tableName, condition) + // eslint-disable-next-line max-len
+            `AND${escapeId(rowIdColumnName)}NOT IN(${getPlaceholders(deleteRowIds, getPlaceholder)})`,
+          deleteRowIds,
+        );
+      } else if (
+        isUndefined(contentSubIdSet) &&
+        collHas(schemaMap, tableName)
+      ) {
+        await executeCommand(
+          DELETE_FROM +
+            escapeId(tableName) +
+            getWhereCondition(tableName, condition),
+        );
+      }
+    }
+  };
+  const transaction = async (actions) => {
+    if (executeTransaction) {
+      return await executeTransaction(async (transactionExecuteCommand) => {
+        const executeCommandWas = executeCommand;
+        executeCommand = transactionExecuteCommand;
+        return await tryFinallyAsync(actions, () => {
+          executeCommand = executeCommandWas;
+        });
+      });
+    }
+    await databaseExecuteCommand('BEGIN');
+    try {
+      const result = await actions();
+      await databaseExecuteCommand('END');
+      return result;
+    } catch (error) {
+      await tryCatch(() => databaseExecuteCommand('ROLLBACK'));
+      throw error;
+    }
+  };
+  return [refreshSchema, loadTable, saveTable, transaction];
+};
+const defaultUpsert = async (
+  executeCommand,
+  tableName,
+  rowIdColumnName,
+  changingColumnNames,
+  rows,
+  getPlaceholder,
+) => {
+  const offset = [1];
+  await executeCommand(
+    INSERT +
+      ' INTO' +
+      escapeId(tableName) +
+      '(' +
+      escapeColumnNames(rowIdColumnName, ...changingColumnNames) +
+      ')VALUES' +
+      arrayJoin(
+        objToArray(
+          rows,
+          (row) =>
+            '(' +
+            getPlaceholder(offset) +
+            ',' +
+            getPlaceholders(row, getPlaceholder, offset) +
+            ')',
+        ),
+        COMMA,
+      ) +
+      'ON CONFLICT(' +
+      escapeId(rowIdColumnName) +
+      `)DO ${UPDATE} SET` +
+      arrayJoin(
+        arrayMap(
+          changingColumnNames,
+          (columnName) =>
+            escapeId(columnName) + '=excluded.' + escapeId(columnName),
+        ),
+        COMMA,
+      ),
+    objToArray(rows, (row, id) => [
+      id,
+      ...arrayMap(row, (value) => value ?? null),
+    ]).flat(),
+  );
+};
+
+const createJsonPersister = (
+  store,
+  executeCommand,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  extraDestroy,
+  persist,
+  [storeTableName, storeIdColumnName, storeColumnName],
+  managedTableNames,
+  querySchema,
+  thing,
+  getThing,
+  columnType,
+  getPlaceholder,
+  upsert,
+  _encode,
+  _decode,
+  executeTransaction,
+) => {
+  const [refreshSchema, loadTable, saveTable, transaction] =
+    getCommandFunctions(
+      executeCommand,
+      managedTableNames,
+      querySchema,
+      columnType,
+      getPlaceholder,
+      upsert,
+      void 0,
+      void 0,
+      executeTransaction,
+    );
+  const getPersisted = () =>
+    transaction(async () => {
+      await refreshSchema();
+      return jsonParseWithUndefined(
+        (await loadTable(storeTableName, storeIdColumnName))[SINGLE_ROW_ID]?.[
+          storeColumnName
+        ] ?? 'null',
+      );
+    });
+  const setPersisted = (getContent) =>
+    transaction(async () => {
+      await refreshSchema();
+      await saveTable(
+        storeTableName,
+        storeIdColumnName,
+        {
+          [SINGLE_ROW_ID]: {
+            [storeColumnName]: jsonStringWithUndefined(getContent() ?? null),
+          },
+        },
+        true,
+        true,
+      );
+    });
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    persist,
+    {[getThing]: () => thing, destroy: extraDestroy},
+    0,
+    thing,
+  );
+};
+
+const createTabularPersister = (
+  store,
+  executeCommand,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  extraDestroy,
+  persist,
+  [
+    tablesLoadConfig,
+    tablesSaveConfig,
+    [
+      valuesLoad,
+      valuesSave,
+      valuesTableName,
+      valuesLoadValueIds,
+      valuesSaveValueIds,
+    ],
+  ],
+  managedTableNames,
+  querySchema,
+  thing,
+  getThing,
+  columnType,
+  getPlaceholder,
+  upsert,
+  encode,
+  decode,
+  executeTransaction,
+) => {
+  const [refreshSchema, loadTable, saveTable, transaction] =
+    getCommandFunctions(
+      executeCommand,
+      managedTableNames,
+      querySchema,
+      columnType,
+      getPlaceholder,
+      upsert,
+      encode,
+      decode,
+      executeTransaction,
+    );
+  const saveTables = (tables, partial) =>
+    promiseAll(
+      mapMap(
+        tablesSaveConfig,
+        async (
+          [
+            tableName,
+            rowIdColumnName,
+            deleteEmptyColumns,
+            deleteEmptyTable,
+            condition,
+          ],
+          tableId,
+        ) => {
+          if (!partial || objHas(tables, tableId)) {
+            await saveTable(
+              tableName,
+              rowIdColumnName,
+              tables[tableId],
+              deleteEmptyColumns,
+              deleteEmptyTable,
+              partial,
+              condition,
+            );
+          }
+        },
+      ),
+    );
+  const getValuesSubset = (values, valueIds, partial) =>
+    objNew(
+      partial == true
+        ? arrayFilter(
+            objToArray(values, (value, valueId) => [valueId, value]),
+            ([valueId]) => arrayHas(valueIds, valueId),
+          )
+        : arrayFilter(
+            arrayMap(valueIds, (valueId) => [valueId, values[valueId]]),
+            ([, value]) => !isUndefined(value),
+          ),
+    );
+  const saveValues = async (values, partial) =>
+    valuesSave
+      ? await saveTable(
+          valuesTableName,
+          DEFAULT_ROW_ID_COLUMN_NAME,
+          {
+            [SINGLE_ROW_ID]: isUndefined(valuesSaveValueIds)
+              ? values
+              : getValuesSubset(values, valuesSaveValueIds, partial),
+          },
+          true,
+          true,
+          partial,
+          void 0,
+          valuesSaveValueIds,
+        )
+      : null;
+  const loadTables = async () =>
+    objNew(
+      arrayFilter(
+        await promiseAll(
+          mapMap(
+            tablesLoadConfig,
+            async ([tableId, rowIdColumnName, condition], tableName) => [
+              tableId,
+              await loadTable(tableName, rowIdColumnName, condition),
+            ],
+          ),
+        ),
+        (pair) => !objIsEmpty(pair[1]),
+      ),
+    );
+  const loadValues = async () =>
+    valuesLoad
+      ? (
+          await loadTable(
+            valuesTableName,
+            DEFAULT_ROW_ID_COLUMN_NAME,
+            void 0,
+            valuesLoadValueIds,
+          )
+        )[SINGLE_ROW_ID]
+      : {};
+  const getPersisted = () =>
+    transaction(async () => {
+      await refreshSchema();
+      const tables = await loadTables();
+      const values = await loadValues();
+      return !objIsEmpty(tables) || !isUndefined(values)
+        ? [tables, values]
+        : void 0;
+    });
+  const setPersisted = (getContent, changes) =>
+    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);
+      }
+    });
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    persist,
+    {[getThing]: () => thing, destroy: extraDestroy},
+    0,
+    thing,
+  );
+};
+
+const TABLE_CREATED = 'c';
+const DATA_CHANGED = 'd';
+const EVENT_REGEX = /^([cd]:)(.+)/;
+const SIMPLE_TABLE_NAME = /^[A-Za-z0-9_]+$/;
+const POSTGRES_IDENTIFIER_SIZE = 63;
+const listenerResourcesByThing = mapNew();
+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,
+  );
+  if (!isJson && store.isMergeable()) {
+    errorThrow(ERROR_STORE_TYPE);
+  }
+  const configHash =
+    EMPTY_STRING + getHash(jsonStringWithUndefined(defaultedConfig));
+  const channel = TINYBASE + '_' + configHash;
+  const resourceOwner = thing ?? rawExecuteCommand;
+  const createFunction = async (
+    name,
+    body,
+    returnPrefix = '',
+    declarations = '',
+  ) => {
+    const escapedFunctionName = escapeIds(TINYBASE, name, configHash);
+    await executeCommand(
+      CREATE +
+        OR_REPLACE +
+        FUNCTION +
+        escapedFunctionName +
+        `()RETURNS ${returnPrefix}trigger AS $$ ${declarations}BEGIN ${body}END;$$ LANGUAGE plpgsql;`,
+    );
+    return escapedFunctionName;
+  };
+  const createTrigger = async (
+    prefix,
+    escapedTriggerName,
+    body,
+    escapedFunctionName,
+  ) => {
+    await executeCommand(
+      CREATE +
+        prefix +
+        'TRIGGER' +
+        escapedTriggerName +
+        body +
+        'EXECUTE ' +
+        FUNCTION +
+        escapedFunctionName +
+        `()`,
+    );
+    return escapedTriggerName;
+  };
+  const notify = (message) => `PERFORM pg_notify('${channel}',${message});`;
+  const when = (tableName, newOrOldOrBoth) =>
+    isJson
+      ? TRUE
+      : newOrOldOrBoth === 2
+        ? when(tableName, 0) + ' OR ' + when(tableName, 1)
+        : replaceTableName(
+            mapGet(defaultedConfig[0], tableName)?.[2] ?? TRUE,
+            newOrOldOrBoth == 0 ? 'NEW' : 'OLD',
+          );
+  const addDataChangedTriggers = (tableName, dataChangedFunction) =>
+    promiseAll(
+      arrayMap([INSERT, DELETE, UPDATE], (action, newOrOldOrBoth) => {
+        const legacyTriggerId = arrayJoin(
+          [TINYBASE, DATA_CHANGED, configHash, tableName, action],
+          '_',
+        );
+        return createTrigger(
+          OR_REPLACE,
+          test(SIMPLE_TABLE_NAME, tableName) &&
+            size(legacyTriggerId) <= POSTGRES_IDENTIFIER_SIZE
+            ? escapeId(legacyTriggerId)
+            : escapeIds(
+                TINYBASE,
+                DATA_CHANGED,
+                configHash,
+                action,
+                EMPTY_STRING + getHash(tableName),
+              ),
+          `AFTER ${action} ON${escapeId(tableName)}FOR EACH ROW WHEN(${when(
+            tableName,
+            newOrOldOrBoth,
+          )})`,
+          dataChangedFunction,
+        );
+      }),
+    );
+  const dropFunctions = async (functionNames) => {
+    if (!isEmpty(functionNames)) {
+      await executeCommand(
+        `DROP FUNCTION IF EXISTS${arrayJoin(functionNames, ',')}CASCADE`,
+      );
+    }
+  };
+  const forgetListenerResources = (resourcesByHash, resources) => {
+    if (mapGet(resourcesByHash, configHash) === resources) {
+      mapSet(resourcesByHash, configHash);
+      if (
+        collIsEmpty(resourcesByHash) &&
+        mapGet(listenerResourcesByThing, resourceOwner) === resourcesByHash
+      ) {
+        mapSet(listenerResourcesByThing, resourceOwner);
+      }
+    }
+  };
+  const acquireListenerResources = async () => {
+    const resourcesByHash = mapEnsure(
+      listenerResourcesByThing,
+      resourceOwner,
+      () => mapNew(),
+    );
+    const existingResources = mapGet(resourcesByHash, configHash);
+    if (existingResources) {
+      await existingResources[1];
+      if (existingResources[0]) {
+        existingResources[0]++;
+        return existingResources;
+      }
+      await tryCatch(() => existingResources[4]);
+      return await acquireListenerResources();
+    }
+    const functionNames = [];
+    const resources = [1, void 0, functionNames];
+    mapSet(resourcesByHash, configHash, resources);
+    resources[1] = (async () => {
+      const tableCreatedFunctionName = await createFunction(
+        TABLE_CREATED,
+        // eslint-disable-next-line max-len
+        `FOR row IN SELECT object_identity FROM pg_event_trigger_ddl_commands()${WHERE} command_tag='${CREATE_TABLE}' LOOP ${notify(`'c:'||SPLIT_PART(row.object_identity,'.',2)`)}END LOOP;`,
+        'event_',
+        'DECLARE row record;',
+      );
+      arrayPush(functionNames, tableCreatedFunctionName);
+      await createTrigger(
+        'EVENT ',
+        escapeIds(TINYBASE, TABLE_CREATED, configHash),
+        `ON ddl_command_end WHEN TAG IN('${CREATE_TABLE}')`,
+        tableCreatedFunctionName,
+      );
+      const dataChangedFunctionName = await createFunction(
+        DATA_CHANGED,
+        notify(`'d:'||TG_TABLE_NAME`) + `RETURN NULL;`,
+      );
+      arrayPush(functionNames, dataChangedFunctionName);
+      resources[3] = dataChangedFunctionName;
+      await promiseAll(
+        arrayMap(collValues(managedTableNamesSet), async (tableName) => {
+          await executeCommand(
+            CREATE_TABLE +
+              ` IF NOT EXISTS${escapeId(tableName)}("_id"text PRIMARY KEY)`,
+          );
+          return await addDataChangedTriggers(
+            tableName,
+            dataChangedFunctionName,
+          );
+        }),
+      );
+    })();
+    try {
+      await resources[1];
+    } catch (error) {
+      resources[0] = 0;
+      resources[4] = tryFinallyAsync(
+        () => dropFunctions(functionNames),
+        () => forgetListenerResources(resourcesByHash, resources),
+      );
+      await tryCatch(() => resources[4]);
+      throw error;
+    }
+    return resources;
+  };
+  const releaseListenerResources = async (resources) => {
+    if (--resources[0] == 0) {
+      const resourcesByHash = mapGet(listenerResourcesByThing, resourceOwner);
+      resources[4] = tryFinallyAsync(
+        () => dropFunctions(resources[2]),
+        () => forgetListenerResources(resourcesByHash, resources),
+      );
+      await resources[4];
+    }
+  };
+  const addPersisterListener = async (listener) => {
+    const resources = await acquireListenerResources();
+    try {
+      const listenerHandle = await addChangeListener(
+        channel,
+        (prefixAndTableName) =>
+          void tryCatchIgnore(
+            () =>
+              ifNotUndefined(
+                strMatch(prefixAndTableName, EVENT_REGEX),
+                async ([, eventType, tableName]) => {
+                  if (collHas(managedTableNamesSet, tableName)) {
+                    if (eventType == 'c:') {
+                      await addDataChangedTriggers(tableName, resources[3]);
+                    }
+                    await listener();
+                  }
+                },
+              ),
+            onIgnoredError,
+          ),
+      );
+      return [listenerHandle, resources];
+    } catch (error) {
+      await tryCatchIgnore(
+        () => releaseListenerResources(resources),
+        onIgnoredError,
+      );
+      throw error;
+    }
+  };
+  const delPersisterListener = async ([listenerHandle, resources]) => {
+    await tryFinallyAsync(
+      () => delChangeListener(listenerHandle),
+      () => releaseListenerResources(resources),
+    );
+  };
+  return (isJson ? createJsonPersister : createTabularPersister)(
+    store,
+    executeCommand,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    destroy,
+    persist,
+    defaultedConfig,
+    collValues(managedTableNamesSet),
+    async (executeCommand2, managedTableNames) =>
+      await executeCommand2(
+        SELECT + // eslint-disable-next-line max-len
+          ` c.table_name tn,c.column_name cn,CASE WHEN tc.constraint_type IN('PRIMARY KEY','UNIQUE')AND(${SELECT} count(*) FROM information_schema.key_column_usage kcu2 ${WHERE} kcu2.constraint_schema=kcu.constraint_schema AND kcu2.constraint_name=kcu.constraint_name)=1 THEN 1 ELSE 0 END uq FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON kcu.table_schema=c.table_schema AND kcu.table_name=c.table_name AND kcu.column_name=c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_schema=kcu.constraint_schema AND tc.constraint_name=kcu.constraint_name ${WHERE} c.table_schema='public'AND c.table_name IN(${getPlaceholders(managedTableNames, numberedPlaceholder)})`,
+        managedTableNames,
+      ),
+    thing,
+    getThing,
+    'text',
+    numberedPlaceholder,
+    void 0,
+    (cellOrValue) => jsonString(cellOrValue),
+    (field) => jsonParse(field),
+  );
+};
+
+const isPool = (pg) => !isUndefined(pg?.idleCount);
+const reserveClient = async (pg, onIgnoredError) => {
+  if (isPool(pg)) {
+    const client = await pg.connect();
+    client.on('error', onIgnoredError ?? noop);
+    return [client, (discard) => client.release(discard)];
+  }
+  return [pg, noop];
+};
+const getSerializer = () => {
+  let chain = promiseResolve();
+  return (action) => (chain = chain.then(action, action));
+};
+const createPgPersister = async (
+  store,
+  pg,
+  configOrStoreTableName,
+  onSqlCommand,
+  onIgnoredError,
+) => {
+  const [commandClient, releaseCommandClient] = await reserveClient(
+    pg,
+    onIgnoredError,
+  );
+  const serialize = getSerializer();
+  try {
+    return createCustomPostgreSqlPersister(
+      store,
+      configOrStoreTableName,
+      (sql, params = []) =>
+        serialize(async () => (await commandClient.query(sql, params)).rows),
+      async (channel, listener) => {
+        const handler = (notification) =>
+          notification.channel == channel ? listener(notification.payload) : 0;
+        const listenSql = escapeId(channel);
+        const [client, release] = await reserveClient(pg, onIgnoredError);
+        client.on('notification', handler);
+        await client.query('LISTEN ' + listenSql);
+        return async () => {
+          client.off('notification', handler);
+          if (isPool(pg)) {
+            release(true);
+          } else {
+            await client.query('UNLISTEN ' + listenSql);
+          }
+        };
+      },
+      (unlisten) => tryCatch(unlisten, onIgnoredError),
+      onSqlCommand,
+      onIgnoredError,
+      releaseCommandClient,
+      3,
+      // StoreOrMergeableStore,
+      pg,
+      'getPg',
+    );
+  } catch (error) {
+    releaseCommandClient();
+    throw error;
+  }
+};
+
+export {createPgPersister};