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

package/persisters/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 THOUSAND = 1e3;
 const startInterval = (callback, sec, immediate) => {
   return setInterval(callback, sec * THOUSAND);
@@ -24,6 +28,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);
@@ -75,6 +87,8 @@ const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 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) =>
@@ -283,12 +297,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);
     }
@@ -308,21 +317,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 */);
       });
     }
@@ -331,29 +342,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;
@@ -365,12 +380,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 */);
       });
     }
@@ -387,7 +397,7 @@ const createCustomPersister = (
     });
     return persister;
   };
-  const stopAutoSave = () => {
+  const stopAutoSave = async () => {
     if (autoSaveListenerId) {
       store.delListener(autoSaveListenerId);
       autoSaveListenerId = void 0;
@@ -408,9 +418,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 = {
@@ -434,6 +445,17 @@ const createCustomPersister = (
   return objFreeze(persister);
 };
 
+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 jsonString = JSON.stringify;
 const jsonParse = JSON.parse;
 const jsonStringWithUndefined = (obj) =>
@@ -446,14 +468,22 @@ 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 DELETE_FROM = 'DELETE FROM';
-const SELECT_STAR_FROM = SELECT + '*FROM';
+const FROM = 'FROM';
+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 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) => {
@@ -461,7 +491,8 @@ const getWrappedCommand = (executeCommand, onSqlCommand) =>
         return await executeCommand(sql, params);
       }
     : executeCommand;
-const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
+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]) =>
@@ -469,6 +500,9 @@ const getPlaceholders = (array, offset = [1]) =>
     arrayMap(array, () => '$' + offset[0]++),
     COMMA,
   );
+const getWhereCondition = (tableName, condition = TRUE) =>
+  WHERE +
+  `(${strReplace(condition, TABLE_NAME_PLACEHOLDER, escapeId(tableName))})`;
 
 const COLUMN_NAME = 'ColumnName';
 const STORE = 'store';
@@ -482,6 +516,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,
@@ -549,29 +584,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 getCommandFunctions = (
@@ -594,13 +642,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],
@@ -620,6 +670,7 @@ const getCommandFunctions = (
     deleteEmptyColumns,
     deleteEmptyTable,
     partial = false,
+    condition = TRUE,
   ) => {
     const settingColumnNameSet = setNew();
     objMap(content ?? {}, (contentRow) =>
@@ -631,6 +682,7 @@ const getCommandFunctions = (
     if (
       !partial &&
       deleteEmptyTable &&
+      condition == TRUE &&
       arrayIsEmpty(settingColumnNames) &&
       collHas(schemaMap, tableName)
     ) {
@@ -643,8 +695,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(
@@ -707,7 +758,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(
@@ -716,9 +769,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)) {
@@ -762,14 +814,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),
         );
       }
     }
@@ -777,11 +830,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;
   };
@@ -796,7 +845,8 @@ const defaultUpsert = async (
 ) => {
   const offset = [1];
   await executeCommand(
-    'INSERT INTO' +
+    INSERT +
+      ' INTO' +
       escapeId(tableName) +
       '(' +
       escapeColumnNames(rowIdColumnName, ...changingColumnNames) +
@@ -811,7 +861,7 @@ const defaultUpsert = async (
       ) +
       'ON CONFLICT(' +
       escapeId(rowIdColumnName) +
-      ')DO UPDATE SET' +
+      `)DO ${UPDATE} SET` +
       arrayJoin(
         arrayMap(
           changingColumnNames,
@@ -833,7 +883,7 @@ const createJsonPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  destroyImpl,
+  extraDestroy,
   persist,
   [storeTableName, storeIdColumnName, storeColumnName],
   managedTableNames,
@@ -852,8 +902,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]?.[
@@ -861,8 +911,8 @@ const createJsonPersister = (
         ] ?? 'null',
       );
     });
-  const setPersisted = async (getContent) =>
-    await transaction(async () => {
+  const setPersisted = (getContent) =>
+    transaction(async () => {
       await refreshSchema();
       await saveTable(
         storeTableName,
@@ -876,9 +926,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(
@@ -902,7 +953,7 @@ const createTabularPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  destroyImpl,
+  extraDestroy,
   persist,
   [
     tablesLoadConfig,
@@ -929,12 +980,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)) {
@@ -945,6 +1002,7 @@ const createTabularPersister = (
               deleteEmptyColumns,
               deleteEmptyTable,
               partial,
+              condition,
             );
           }
         },
@@ -967,9 +1025,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),
             ],
           ),
         ),
@@ -982,8 +1040,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();
@@ -991,8 +1049,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);
@@ -1003,9 +1061,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(
@@ -1023,10 +1082,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,
@@ -1044,53 +1102,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,
@@ -1103,8 +1233,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,
@@ -1143,22 +1273,24 @@ const createCustomSqlitePersister = (
   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();
+      (interval = startInterval(
+        () =>
+          tryCatch(async () => {
+            const [{d, s, c}] = await executeCommand(
+              SELECT + // eslint-disable-next-line max-len
+                ` ${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;
             }
-            dataVersion = d;
-            schemaVersion = s;
-            totalChanges = c;
-          }
-        } catch {}
-      }, autoLoadIntervalSeconds));
+          }),
+        autoLoadIntervalSeconds,
+      ));
     const stopPolling = () => {
       dataVersion = schemaVersion = totalChanges = null;
       stopInterval(interval);
@@ -1190,8 +1322,8 @@ const createCustomSqlitePersister = (
     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`,
+        SELECT + // eslint-disable-next-line max-len
+          ` 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,