[common] tryCatch throughout project

Author: jamesgpearce

src/common/other.ts

@@ -85,16 +85,16 @@ export const errorNew = (message: string) => {
   throw new Error(message);
 };
 
-export const tryCatch = async (
-  action: () => unknown | Promise<unknown>,
-  onIgnoredError?: (error: any) => void,
-  then?: () => unknown,
-): Promise<void> => {
+export const tryCatch = async <Return>(
+  action: () => Return | Promise<Return>,
+  then1?: (error: any) => void,
+  then2?: (error: any) => void,
+): Promise<Return | void> => {
   try {
-    await action();
+    return await action();
   } catch (error) {
     /*! istanbul ignore next */
-    onIgnoredError?.(error);
-    then?.();
+    then1?.(error);
+    then2?.(error);
   }
 };

src/persisters/common/database/commands.ts

@@ -26,7 +26,7 @@ import {
   objToArray,
   objValues,
 } from '../../../common/obj.ts';
-import {isUndefined, promiseAll} from '../../../common/other.ts';
+import {isUndefined, promiseAll, tryCatch} from '../../../common/other.ts';
 import {IdSet2, setAdd, setNew} from '../../../common/set.ts';
 import {COMMA, TRUE} from '../../../common/strings.ts';
 import {
@@ -309,11 +309,7 @@ export const getCommandFunctions = (
   ): Promise<Return> => {
     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 as Return;
   };

src/persisters/common/database/sqlite.ts

@@ -9,7 +9,7 @@ import type {
 } from '../../../@types/persisters/index.d.ts';
 import {collValues} from '../../../common/coll.ts';
 import {IdObj} from '../../../common/obj.ts';
-import {startInterval, stopInterval} from '../../../common/other.ts';
+import {startInterval, stopInterval, tryCatch} from '../../../common/other.ts';
 import {EMPTY_STRING} from '../../../common/strings.ts';
 import {
   DATA_VERSION,
@@ -62,23 +62,25 @@ export const createCustomSqlitePersister = <
     let interval: NodeJS.Timeout;
 
     const startPolling = () =>
-      (interval = startInterval(async () => {
-        try {
-          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}`,
-          )) as [IdObj<number>];
-          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}`,
+            )) as [IdObj<number>];
+            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 as number));
+          }),
+        autoLoadIntervalSeconds as number,
+      ));
 
     const stopPolling = () => {
       dataVersion = schemaVersion = totalChanges = null;

src/persisters/persister-browser/index.ts

@@ -6,18 +6,18 @@ import type {
   Persists as PersistsType,
 } from '../../@types/persisters/index.d.ts';
 import type {
-  LocalPersister,
-  SessionPersister,
   createLocalPersister as createLocalPersisterDecl,
   createSessionPersister as createSessionPersisterDecl,
+  LocalPersister,
+  SessionPersister,
 } from '../../@types/persisters/persister-browser/index.d.ts';
 import type {Store} from '../../@types/store/index.d.ts';
 import {
   jsonParse,
   jsonParseWithUndefined,
   jsonStringWithUndefined,
 } from '../../common/json.ts';
-import {WINDOW} from '../../common/other.ts';
+import {tryCatch, WINDOW} from '../../common/other.ts';
 import {createCustomPersister} from '../common/create.ts';
 
 type StorageListener = (event: StorageEvent) => void;
@@ -43,11 +43,7 @@ const createStoragePersister = (
   ): StorageListener => {
     const storageListener = (event: StorageEvent): void => {
       if (event.storageArea === storage && event.key === storageName) {
-        try {
-          listener(jsonParse(event.newValue as string));
-        } catch {
-          listener();
-        }
+        tryCatch(() => listener(jsonParse(event.newValue as string)), listener);
       }
     };
     WINDOW.addEventListener(STORAGE, storageListener);

src/persisters/persister-indexed-db/index.ts

@@ -13,6 +13,7 @@ import {
   promiseNew,
   startInterval,
   stopInterval,
+  tryCatch,
 } from '../../common/other.ts';
 import {T, V} from '../../common/strings.ts';
 import {createCustomPersister} from '../common/create.ts';
@@ -64,34 +65,36 @@ export const createIndexedDbPersister = ((
       );
       request.onupgradeneeded = () =>
         create &&
-        arrayMap(OBJECT_STORE_NAMES, (objectStoreName) => {
-          try {
-            request.result.createObjectStore(objectStoreName, KEY_PATH);
-          } catch {}
-        });
-      request.onsuccess = async () => {
-        try {
-          const transaction = request.result.transaction(
-            OBJECT_STORE_NAMES,
-            'readwrite',
-          );
-          const result = await promiseAll(
-            arrayMap(
+        arrayMap(OBJECT_STORE_NAMES, (objectStoreName) =>
+          tryCatch(() =>
+            request.result.createObjectStore(objectStoreName, KEY_PATH),
+          ),
+        );
+      request.onsuccess = () =>
+        tryCatch(
+          async () => {
+            const transaction = request.result.transaction(
               OBJECT_STORE_NAMES,
-              async (objectStoreName, index) =>
-                await forObjectStore(
-                  transaction.objectStore(objectStoreName),
-                  params[index],
-                ),
-            ),
-          );
-          request.result.close();
-          resolve(result as [any, any]);
-        } catch (e) {
-          request.result.close();
-          reject(e);
-        }
-      };
+              'readwrite',
+            );
+            const result = await promiseAll(
+              arrayMap(
+                OBJECT_STORE_NAMES,
+                async (objectStoreName, index) =>
+                  await forObjectStore(
+                    transaction.objectStore(objectStoreName),
+                    params[index],
+                  ),
+              ),
+            );
+            request.result.close();
+            resolve(result as [any, any]);
+          },
+          (error) => {
+            request.result.close();
+            reject(error);
+          },
+        );
       request.onerror = () => reject('indexedDB.open error');
     });
 

src/persisters/persister-pglite/index.ts

@@ -10,7 +10,7 @@ import type {
 } from '../../@types/persisters/persister-pglite/index.d.ts';
 import type {Store} from '../../@types/store/index.d.ts';
 import {IdObj} from '../../common/obj.ts';
-import {noop} from '../../common/other.ts';
+import {noop, tryCatch} from '../../common/other.ts';
 import {createCustomPostgreSqlPersister} from '../common/database/postgresql.ts';
 
 export const createPglitePersister = (async (
@@ -29,13 +29,7 @@ export const createPglitePersister = (async (
       channel: string,
       listener: DatabaseChangeListener,
     ): Promise<() => Promise<void>> => await pglite.listen(channel, listener),
-    async (unlisten: () => Promise<void>) => {
-      try {
-        await unlisten();
-      } catch (e) {
-        onIgnoredError?.(e);
-      }
-    },
+    (unlisten: () => Promise<void>) => tryCatch(unlisten, onIgnoredError),
     onSqlCommand,
     onIgnoredError,
     noop,

src/persisters/persister-postgres/index.ts

@@ -9,6 +9,7 @@ import type {
   createPostgresPersister as createPostgresPersisterDecl,
 } from '../../@types/persisters/persister-postgres/index.d.ts';
 import type {Store} from '../../@types/store/index.d.ts';
+import {tryCatch} from '../../common/other.ts';
 import {createCustomPostgreSqlPersister} from '../common/database/postgresql.ts';
 
 export const createPostgresPersister = (async (
@@ -28,13 +29,8 @@ export const createPostgresPersister = (async (
       channel: string,
       listener: DatabaseChangeListener,
     ): Promise<ListenMeta> => sql.listen(channel, listener),
-    async (notifyListener: ListenMeta) => {
-      try {
-        await notifyListener.unlisten();
-      } catch (e) {
-        onIgnoredError?.(e);
-      }
-    },
+    (notifyListener: ListenMeta) =>
+      tryCatch(notifyListener.unlisten, onIgnoredError),
     onSqlCommand,
     onIgnoredError,
     () => commandSql?.release?.(),

src/store/index.ts

@@ -101,6 +101,7 @@ import {
   isTypeStringOrBoolean,
   isUndefined,
   slice,
+  tryCatch,
 } from '../common/other.ts';
 import {
   Pair,
@@ -1221,29 +1222,26 @@ export const createStore: typeof createStoreDecl = (): Store => {
     });
 
   const setTablesJson = (tablesJson: Json): Store => {
-    try {
-      setOrDelTables(jsonParse(tablesJson));
-    } catch {}
+    tryCatch(() => setOrDelTables(jsonParse(tablesJson)));
     return store;
   };
 
   const setValuesJson = (valuesJson: Json): Store => {
-    try {
-      setOrDelValues(jsonParse(valuesJson));
-    } catch {}
+    tryCatch(() => setOrDelValues(jsonParse(valuesJson)));
     return store;
   };
 
   const setJson = (tablesAndValuesJson: Json): Store =>
-    fluentTransaction(() => {
-      try {
-        const [tables, values] = jsonParse(tablesAndValuesJson);
-        setOrDelTables(tables);
-        setOrDelValues(values);
-      } catch {
-        setTablesJson(tablesAndValuesJson);
-      }
-    });
+    fluentTransaction(() =>
+      tryCatch(
+        () => {
+          const [tables, values] = jsonParse(tablesAndValuesJson);
+          setOrDelTables(tables);
+          setOrDelValues(values);
+        },
+        () => setTablesJson(tablesAndValuesJson),
+      ),
+    );
 
   const setTablesSchema = (tablesSchema: TablesSchema): Store =>
     fluentTransaction(() => {

src/synchronizers/index.ts

@@ -31,6 +31,7 @@ import {
   isUndefined,
   promiseNew,
   startTimeout,
+  tryCatch,
 } from '../common/other.ts';
 import {getLatestTime, stampNew, stampNewObj} from '../common/stamps.ts';
 import {EMPTY_STRING} from '../common/strings.ts';
@@ -151,12 +152,12 @@ export const createCustomSynchronizer = (
     tablesStamp[1] = getLatestTime(tablesStamp[1], tablesTime2);
   };
 
-  const getChangesFromOtherStore = async (
+  const getChangesFromOtherStore = (
     otherClientId: IdOrNull = null,
     otherContentHashes?: ContentHashes,
     transactionId: Id = getTransactionId(),
-  ): Promise<MergeableChanges | void> => {
-    try {
+  ): Promise<MergeableChanges | void> =>
+    tryCatch(async () => {
       if (isUndefined(otherContentHashes)) {
         [otherContentHashes, otherClientId, transactionId] =
           await request<ContentHashes>(
@@ -220,10 +221,7 @@ export const createCustomSynchronizer = (
             )[0],
         1,
       ];
-    } catch (error) {
-      onIgnoredError?.(error);
-    }
-  };
+    }, onIgnoredError);
 
   const getPersisted = async (): Promise<MergeableContent | undefined> => {
     const changes = (await getChangesFromOtherStore()) as any;