tinybase 6.1.0-beta.4 → 6.1.0-beta.5

package/persisters/persister-postgres/index.js

@@ -3,10 +3,14 @@ const TINYBASE = 'tinybase';
 const EMPTY_STRING = '';
 const COMMA = ',';
 const STRING = getTypeOf(EMPTY_STRING);
+const TRUE = 'true';
 const UNDEFINED = '\uFFFC';
 const strMatch = (str, regex) => str?.match(regex);
+const strReplace = (str, searchValue, replaceValue) =>
+  str.replace(searchValue, replaceValue);
 
 const promise = Promise;
+const GLOBAL = globalThis;
 const isUndefined = (thing) => thing == void 0;
 const ifNotUndefined = (value, then, otherwise) =>
   isUndefined(value) ? otherwise?.() : then(value);
@@ -19,6 +23,14 @@ const promiseAll = async (promises) => promise.all(promises);
 const errorNew = (message) => {
   throw new Error(message);
 };
+const tryCatch = async (action, then1, then2) => {
+  try {
+    return await action();
+  } catch (error) {
+    /* istanbul ignore next */
+    then1?.(error);
+  }
+};
 
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
@@ -37,6 +49,17 @@ const collClear = (coll) => coll.clear();
 const collForEach = (coll, cb) => coll?.forEach(cb);
 const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
+const textEncoder = /* @__PURE__ */ new GLOBAL.TextEncoder();
+const getHash = (value) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(value), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
@@ -75,32 +98,10 @@ const jsonStringWithUndefined = (obj) =>
 const jsonParseWithUndefined = (str) =>
   jsonParse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
 
-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 getWrappedCommand = (executeCommand, onSqlCommand) =>
-  onSqlCommand
-    ? async (sql, params) => {
-        onSqlCommand(sql, params);
-        return await executeCommand(sql, params);
-      }
-    : executeCommand;
-const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
-const escapeColumnNames = (...columnNames) =>
-  arrayJoin(arrayMap(columnNames, escapeId), COMMA);
-const getPlaceholders = (array, offset = [1]) =>
-  arrayJoin(
-    arrayMap(array, () => '$' + offset[0]++),
-    COMMA,
-  );
-
 const mapNew = (entries) => new Map(entries);
 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) =>
@@ -135,6 +136,43 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
+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 = '$tableName';
+const getWrappedCommand = (executeCommand, onSqlCommand) =>
+  onSqlCommand
+    ? async (sql, params) => {
+        onSqlCommand(sql, params);
+        return await executeCommand(sql, params);
+      }
+    : executeCommand;
+const escapeId = (str) => `"${strReplace(str, /"/g, '""')}"`;
+const escapeIds = (...ids) => escapeId(arrayJoin(ids, '_'));
+const escapeColumnNames = (...columnNames) =>
+  arrayJoin(arrayMap(columnNames, escapeId), COMMA);
+const getPlaceholders = (array, offset = [1]) =>
+  arrayJoin(
+    arrayMap(array, () => '$' + offset[0]++),
+    COMMA,
+  );
+const getWhereCondition = (tableName, condition = TRUE) =>
+  WHERE +
+  `(${strReplace(condition, TABLE_NAME_PLACEHOLDER, escapeId(tableName))})`;
+
 const setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -155,6 +193,7 @@ 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,
@@ -222,29 +261,42 @@ const getConfigStructures = (configOrStoreTableName) => {
   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,
+  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,
   ];
-  return [0, autoLoadIntervalSeconds, tabularConfig, managedTableNames];
 };
 
 const INTEGER = /^\d+$/;
@@ -403,12 +455,7 @@ const createCustomPersister = (
       while (
         !isUndefined((action = arrayShift(mapGet(scheduleActions, scheduleId))))
       ) {
-        try {
-          await action();
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
+        await tryCatch(action, onIgnoredError);
       }
       mapSet(scheduleRunning, scheduleId, 0);
     }
@@ -428,21 +475,23 @@ const createCustomPersister = (
       setStatus(1 /* Loading */);
       loads++;
       await schedule(async () => {
-        try {
-          const content = await getPersisted();
-          if (isArray(content)) {
-            setContentOrChanges(content);
-          } else if (initialContent) {
-            setDefaultContent(initialContent);
-          } else {
-            errorNew(`Content is not an array: ${content}`);
-          }
-        } catch (error) {
-          onIgnoredError?.(error);
-          if (initialContent) {
-            setDefaultContent(initialContent);
-          }
-        }
+        await tryCatch(
+          async () => {
+            const content = await getPersisted();
+            if (isArray(content)) {
+              setContentOrChanges(content);
+            } else if (initialContent) {
+              setDefaultContent(initialContent);
+            } else {
+              errorNew(`Content is not an array: ${content}`);
+            }
+          },
+          () => {
+            if (initialContent) {
+              setDefaultContent(initialContent);
+            }
+          },
+        );
         setStatus(0 /* Idle */);
       });
     }
@@ -451,29 +500,33 @@ const createCustomPersister = (
   const startAutoLoad = async (initialContent) => {
     stopAutoLoad();
     await load(initialContent);
-    try {
-      autoLoadHandle = await addPersisterListener(async (content, changes) => {
-        if (changes || content) {
-          /* istanbul ignore else */
-          if (status != 2 /* Saving */) {
-            setStatus(1 /* Loading */);
-            loads++;
-            setContentOrChanges(changes ?? content);
-            setStatus(0 /* Idle */);
-          }
-        } else {
-          await load();
-        }
-      });
-    } catch (error) {
-      /* istanbul ignore next */
-      onIgnoredError?.(error);
-    }
+    await tryCatch(
+      async () =>
+        (autoLoadHandle = await addPersisterListener(
+          async (content, changes) => {
+            if (changes || content) {
+              /* istanbul ignore else */
+              if (status != 2 /* Saving */) {
+                setStatus(1 /* Loading */);
+                loads++;
+                setContentOrChanges(changes ?? content);
+                setStatus(0 /* Idle */);
+              }
+            } else {
+              await load();
+            }
+          },
+        )),
+      onIgnoredError,
+    );
     return persister;
   };
-  const stopAutoLoad = () => {
+  const stopAutoLoad = async () => {
     if (autoLoadHandle) {
-      delPersisterListener(autoLoadHandle);
+      await tryCatch(
+        () => delPersisterListener(autoLoadHandle),
+        onIgnoredError,
+      );
       autoLoadHandle = void 0;
     }
     return persister;
@@ -485,12 +538,7 @@ const createCustomPersister = (
       setStatus(2 /* Saving */);
       saves++;
       await schedule(async () => {
-        try {
-          await setPersisted(getContent, changes);
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
+        await tryCatch(() => setPersisted(getContent, changes), onIgnoredError);
         setStatus(0 /* Idle */);
       });
     }
@@ -507,7 +555,7 @@ const createCustomPersister = (
     });
     return persister;
   };
-  const stopAutoSave = () => {
+  const stopAutoSave = async () => {
     if (autoSaveListenerId) {
       store.delListener(autoSaveListenerId);
       autoSaveListenerId = void 0;
@@ -528,9 +576,10 @@ const createCustomPersister = (
     return persister;
   };
   const getStore = () => store;
-  const destroy = () => {
+  const destroy = async () => {
     arrayClear(mapGet(scheduleActions, scheduleId));
-    return stopAutoLoad().stopAutoSave();
+    await persister.stopAutoLoad();
+    return await persister.stopAutoSave();
   };
   const getStats = () => ({loads, saves});
   const persister = {
@@ -574,13 +623,15 @@ const getCommandFunctions = (
       ({tn, cn}) => setAdd(mapEnsure(schemaMap, tn, setNew), cn),
     );
   };
-  const loadTable = async (tableName, rowIdColumnName) =>
+  const loadTable = async (tableName, rowIdColumnName, condition) =>
     canSelect(tableName, rowIdColumnName)
       ? objNew(
           arrayFilter(
             arrayMap(
               await databaseExecuteCommand(
-                SELECT_STAR_FROM + escapeId(tableName),
+                SELECT_STAR_FROM +
+                  escapeId(tableName) +
+                  getWhereCondition(tableName, condition),
               ),
               (row) => [
                 row[rowIdColumnName],
@@ -600,6 +651,7 @@ const getCommandFunctions = (
     deleteEmptyColumns,
     deleteEmptyTable,
     partial = false,
+    condition = TRUE,
   ) => {
     const settingColumnNameSet = setNew();
     objMap(content ?? {}, (contentRow) =>
@@ -611,6 +663,7 @@ const getCommandFunctions = (
     if (
       !partial &&
       deleteEmptyTable &&
+      condition == TRUE &&
       arrayIsEmpty(settingColumnNames) &&
       collHas(schemaMap, tableName)
     ) {
@@ -623,8 +676,7 @@ const getCommandFunctions = (
     if (!arrayIsEmpty(settingColumnNames)) {
       if (!collHas(schemaMap, tableName)) {
         await databaseExecuteCommand(
-          'CREATE ' +
-            TABLE +
+          CREATE_TABLE +
             escapeId(tableName) +
             `(${escapeId(rowIdColumnName)}${columnType} PRIMARY KEY${arrayJoin(
               arrayMap(
@@ -687,7 +739,9 @@ const getCommandFunctions = (
     if (partial) {
       if (isUndefined(content)) {
         await databaseExecuteCommand(
-          DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+          DELETE_FROM +
+            escapeId(tableName) +
+            getWhereCondition(tableName, condition),
         );
       } else {
         await promiseAll(
@@ -696,9 +750,8 @@ const getCommandFunctions = (
               await databaseExecuteCommand(
                 DELETE_FROM +
                   escapeId(tableName) +
-                  WHERE +
-                  escapeId(rowIdColumnName) +
-                  '=$1',
+                  getWhereCondition(tableName, condition) +
+                  `AND(${escapeId(rowIdColumnName)}=$1)`,
                 [rowId],
               );
             } else if (!arrayIsEmpty(settingColumnNames)) {
@@ -742,14 +795,15 @@ const getCommandFunctions = (
         await databaseExecuteCommand(
           DELETE_FROM +
             escapeId(tableName) +
-            WHERE +
-            escapeId(rowIdColumnName) +
-            `NOT IN(${getPlaceholders(deleteRowIds)})`,
+            getWhereCondition(tableName, condition) + // eslint-disable-next-line max-len
+            `AND${escapeId(rowIdColumnName)}NOT IN(${getPlaceholders(deleteRowIds)})`,
           deleteRowIds,
         );
       } else if (collHas(schemaMap, tableName)) {
         await databaseExecuteCommand(
-          DELETE_FROM + escapeId(tableName) + WHERE + ' true',
+          DELETE_FROM +
+            escapeId(tableName) +
+            getWhereCondition(tableName, condition),
         );
       }
     }
@@ -757,11 +811,7 @@ const getCommandFunctions = (
   const transaction = async (actions) => {
     let result;
     await databaseExecuteCommand('BEGIN');
-    try {
-      result = await actions();
-    } catch (error) {
-      onIgnoredError?.(error);
-    }
+    await tryCatch(async () => (result = await actions()), onIgnoredError);
     await databaseExecuteCommand('END');
     return result;
   };
@@ -776,7 +826,8 @@ const defaultUpsert = async (
 ) => {
   const offset = [1];
   await executeCommand(
-    'INSERT INTO' +
+    INSERT +
+      ' INTO' +
       escapeId(tableName) +
       '(' +
       escapeColumnNames(rowIdColumnName, ...changingColumnNames) +
@@ -791,7 +842,7 @@ const defaultUpsert = async (
       ) +
       'ON CONFLICT(' +
       escapeId(rowIdColumnName) +
-      ')DO UPDATE SET' +
+      `)DO ${UPDATE} SET` +
       arrayJoin(
         arrayMap(
           changingColumnNames,
@@ -813,7 +864,7 @@ const createJsonPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  destroyImpl,
+  extraDestroy,
   persist,
   [storeTableName, storeIdColumnName, storeColumnName],
   managedTableNames,
@@ -832,8 +883,8 @@ const createJsonPersister = (
       columnType,
       upsert,
     );
-  const getPersisted = async () =>
-    await transaction(async () => {
+  const getPersisted = () =>
+    transaction(async () => {
       await refreshSchema();
       return jsonParseWithUndefined(
         (await loadTable(storeTableName, storeIdColumnName))[SINGLE_ROW_ID]?.[
@@ -841,8 +892,8 @@ const createJsonPersister = (
         ] ?? 'null',
       );
     });
-  const setPersisted = async (getContent) =>
-    await transaction(async () => {
+  const setPersisted = (getContent) =>
+    transaction(async () => {
       await refreshSchema();
       await saveTable(
         storeTableName,
@@ -856,9 +907,10 @@ const createJsonPersister = (
         true,
       );
     });
-  const destroy = () => {
-    persister.stopAutoLoad().stopAutoSave();
-    destroyImpl();
+  const destroy = async () => {
+    await persister.stopAutoLoad();
+    await persister.stopAutoSave();
+    extraDestroy();
     return persister;
   };
   const persister = createCustomPersister(
@@ -882,7 +934,7 @@ const createTabularPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  destroyImpl,
+  extraDestroy,
   persist,
   [
     tablesLoadConfig,
@@ -909,12 +961,18 @@ const createTabularPersister = (
       encode,
       decode,
     );
-  const saveTables = async (tables, partial) =>
-    await promiseAll(
+  const saveTables = (tables, partial) =>
+    promiseAll(
       mapMap(
         tablesSaveConfig,
         async (
-          [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
+          [
+            tableName,
+            rowIdColumnName,
+            deleteEmptyColumns,
+            deleteEmptyTable,
+            condition,
+          ],
           tableId,
         ) => {
           if (!partial || objHas(tables, tableId)) {
@@ -925,6 +983,7 @@ const createTabularPersister = (
               deleteEmptyColumns,
               deleteEmptyTable,
               partial,
+              condition,
             );
           }
         },
@@ -947,9 +1006,9 @@ const createTabularPersister = (
         await promiseAll(
           mapMap(
             tablesLoadConfig,
-            async ([tableId, rowIdColumnName], tableName) => [
+            async ([tableId, rowIdColumnName, condition], tableName) => [
               tableId,
-              await loadTable(tableName, rowIdColumnName),
+              await loadTable(tableName, rowIdColumnName, condition),
             ],
           ),
         ),
@@ -962,8 +1021,8 @@ const createTabularPersister = (
           SINGLE_ROW_ID
         ]
       : {};
-  const getPersisted = async () =>
-    await transaction(async () => {
+  const getPersisted = () =>
+    transaction(async () => {
       await refreshSchema();
       const tables = await loadTables();
       const values = await loadValues();
@@ -971,8 +1030,8 @@ const createTabularPersister = (
         ? [tables, values]
         : void 0;
     });
-  const setPersisted = async (getContent, changes) =>
-    await transaction(async () => {
+  const setPersisted = (getContent, changes) =>
+    transaction(async () => {
       await refreshSchema();
       if (!isUndefined(changes)) {
         await saveTables(changes[0], true);
@@ -983,9 +1042,10 @@ const createTabularPersister = (
         await saveValues(values);
       }
     });
-  const destroy = () => {
-    persister.stopAutoLoad().stopAutoSave();
-    destroyImpl();
+  const destroy = async () => {
+    await persister.stopAutoLoad();
+    await persister.stopAutoSave();
+    extraDestroy();
     return persister;
   };
   const persister = createCustomPersister(
@@ -1003,10 +1063,9 @@ const createTabularPersister = (
   return persister;
 };
 
-const EVENT_CHANNEL = TINYBASE;
+const TABLE_CREATED = 'c';
+const DATA_CHANGED = 'd';
 const EVENT_REGEX = /^([cd]:)(.+)/;
-const CHANGE_DATA_TRIGGER = TINYBASE + '_data';
-const CREATE_TABLE_TRIGGER = TINYBASE + '_table';
 const createCustomPostgreSqlPersister = (
   store,
   configOrStoreTableName,
@@ -1024,53 +1083,125 @@ const createCustomPostgreSqlPersister = (
   const [isJson, , defaultedConfig, managedTableNamesSet] = getConfigStructures(
     configOrStoreTableName,
   );
-  const addDataTrigger = async (tableName) => {
+  const configHash =
+    EMPTY_STRING + getHash(jsonStringWithUndefined(defaultedConfig));
+  const channel = TINYBASE + '_' + configHash;
+  const createFunction = async (
+    name,
+    body,
+    returnPrefix = '',
+    declarations = '',
+  ) => {
+    const escapedFunctionName = escapeIds(TINYBASE, name, configHash);
     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}()`,
+      CREATE +
+        OR_REPLACE +
+        FUNCTION +
+        escapedFunctionName +
+        `()RETURNS ${returnPrefix}trigger AS $$ ${declarations}BEGIN ${body}END;$$ LANGUAGE plpgsql;`,
     );
+    return escapedFunctionName;
   };
-  const addPersisterListener = async (listener) => {
+  const createTrigger = async (
+    prefix,
+    escapedTriggerName,
+    body,
+    escapedFunctionName,
+  ) => {
     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;`,
+      CREATE +
+        prefix +
+        'TRIGGER' +
+        escapedTriggerName +
+        body +
+        'EXECUTE ' +
+        FUNCTION +
+        escapedFunctionName +
+        `()`,
     );
-    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(
+    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)
+        : strReplace(
+            mapGet(defaultedConfig[0], tableName)?.[2] ?? TRUE,
+            TABLE_NAME_PLACEHOLDER,
+            newOrOldOrBoth == 0 ? 'NEW' : 'OLD',
+          );
+  const addDataChangedTriggers = (tableName, dataChangedFunction) =>
+    promiseAll(
+      arrayMap([INSERT, DELETE, UPDATE], (action, newOrOldOrBoth) =>
+        createTrigger(
+          OR_REPLACE,
+          escapeIds(TINYBASE, DATA_CHANGED, configHash, tableName, action),
+          `AFTER ${action} ON${escapeId(tableName)}FOR EACH ROW WHEN(${when(
+            tableName,
+            newOrOldOrBoth,
+          )})`,
+          dataChangedFunction,
+        ),
+      ),
+    );
+  const addPersisterListener = async (listener) => {
+    const tableCreatedFunctionName = await createFunction(
+      TABLE_CREATED,
       // 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;`,
+      `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;',
+    );
+    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;`,
     );
     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)`,
+          CREATE_TABLE +
+            ` IF NOT EXISTS${escapeId(tableName)}("_id"text PRIMARY KEY)`,
         );
-        await addDataTrigger(tableName);
+        return await addDataChangedTriggers(tableName, dataChangedFunctionName);
       }),
     );
-    return await addChangeListener(
-      EVENT_CHANNEL,
-      async (prefixAndTableName) =>
-        await ifNotUndefined(
+    const listenerHandle = await addChangeListener(
+      channel,
+      (prefixAndTableName) =>
+        ifNotUndefined(
           strMatch(prefixAndTableName, EVENT_REGEX),
           async ([, eventType, tableName]) => {
             if (collHas(managedTableNamesSet, tableName)) {
               if (eventType == 'c:') {
-                await addDataTrigger(tableName);
+                await addDataChangedTriggers(
+                  tableName,
+                  dataChangedFunctionName,
+                );
               }
               listener();
             }
           },
         ),
     );
+    return [
+      listenerHandle,
+      [tableCreatedFunctionName, dataChangedFunctionName],
+    ];
+  };
+  const delPersisterListener = async ([listenerHandle, functionNames]) => {
+    delChangeListener(listenerHandle);
+    await executeCommand(
+      `DROP FUNCTION IF EXISTS${arrayJoin(functionNames, ',')}CASCADE`,
+    );
   };
-  const delPersisterListener = delChangeListener;
   return (isJson ? createJsonPersister : createTabularPersister)(
     store,
     executeCommand,
@@ -1083,8 +1214,8 @@ const createCustomPostgreSqlPersister = (
     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)})`,
+        SELECT + // eslint-disable-next-line max-len
+          ` table_name tn,column_name cn FROM information_schema.columns ${WHERE} table_schema='public'AND table_name IN(${getPlaceholders(managedTableNames)})`,
         managedTableNames,
       ),
     thing,
@@ -1109,13 +1240,7 @@ const createPostgresPersister = async (
     configOrStoreTableName,
     commandSql?.unsafe,
     async (channel, listener) => sql.listen(channel, listener),
-    async (notifyListener) => {
-      try {
-        await notifyListener.unlisten();
-      } catch (e) {
-        onIgnoredError?.(e);
-      }
-    },
+    (notifyListener) => tryCatch(notifyListener.unlisten, onIgnoredError),
     onSqlCommand,
     onIgnoredError,
     () => commandSql?.release?.(),