Enforce explicit async error boundaries

eslint.config.js

@@ -2,6 +2,7 @@
 const eslint = require("@eslint/js");
 const tseslint = require("typescript-eslint");
 const angular = require("angular-eslint");
+const rdlabo = require("@rdlabo/eslint-plugin-rules");
 
 module.exports = tseslint.config(
   {
@@ -13,6 +14,15 @@ module.exports = tseslint.config(
       ...angular.configs.tsRecommended,
     ],
     processor: angular.processInlineTemplates,
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: __dirname,
+      },
+    },
+    plugins: {
+      "@rdlabo/rules": rdlabo,
+    },
     rules: {
       "@typescript-eslint/no-empty-function": "off",
       "@typescript-eslint/no-unused-vars": "off",
@@ -25,6 +35,16 @@ module.exports = tseslint.config(
       "@angular-eslint/no-empty-lifecycle-method": "off",
       "@angular-eslint/directive-selector": "off",
       "@angular-eslint/component-selector": "off",
+      "@rdlabo/rules/restrict-try-block": [
+        "error",
+        {
+          allowPromise: false,
+          allowPromiseResolve: false,
+          allowRxjs: false,
+          allowInSignal: false,
+          maxLines: 3,
+        },
+      ],
     },
   },
   {

package.json

@@ -80,6 +80,7 @@
     "@ionic/storage-angular": "^4.0.0",
     "@playwright/test": "^1.57.0",
     "@rdlabo/capacitor-brotherprint": "^8.1.1",
+    "@rdlabo/eslint-plugin-rules": "^21.2.6",
     "angular-eslint": "21.4.0",
     "child_process": "^1.0.2",
     "dom-to-image-more": "^3.10.0",

projects/kit/app-update/src/lib/kit-app-update.provider.spec.ts

@@ -80,9 +80,10 @@ describe('provideKitAppUpdate', () => {
 });
 
 function setup(result: boolean | Error | Promise<boolean>, isEnabled = true, isControlled = true) {
-  const checkForUpdate = vi.fn(() =>
-    result instanceof Promise ? result : result instanceof Error ? Promise.reject(result) : Promise.resolve(result),
-  );
+  const checkForUpdate = vi.fn(async () => {
+    if (result instanceof Error) throw result;
+    return result;
+  });
   const reload = vi.fn();
   TestBed.configureTestingModule({
     providers: [

projects/kit/app-update/src/lib/kit-app-update.provider.ts

@@ -22,14 +22,12 @@ export class KitAppUpdateService {
     if (!this.#updates.isEnabled || !this.#document.defaultView?.navigator.serviceWorker?.controller) {
       return;
     }
-    try {
-      const available = await withTimeout(this.#updates.checkForUpdate(), UPDATE_CHECK_TIMEOUT_MS);
-      if (available) {
-        this.#document.location?.reload();
-      }
-    } catch (error) {
-      console.error('Angular service-worker update check failed', error);
-    }
+    const checkForUpdate = async (): Promise<boolean | undefined> => withTimeout(this.#updates.checkForUpdate(), UPDATE_CHECK_TIMEOUT_MS);
+    await checkForUpdate()
+      .then((available) => {
+        if (available) this.#document.location?.reload();
+      })
+      .catch((error: unknown) => console.error('Angular service-worker update check failed', error));
   }
 }
 
@@ -42,9 +40,7 @@ export class KitAppUpdateService {
  * rolling out because code already running in older application versions cannot gain this behavior retroactively.
  */
 export function provideKitAppUpdate(): EnvironmentProviders {
-  return makeEnvironmentProviders([
-    provideAppInitializer(() => inject(KitAppUpdateService).initialize()),
-  ]);
+  return makeEnvironmentProviders([provideAppInitializer(() => inject(KitAppUpdateService).initialize())]);
 }
 
 function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | undefined> {

projects/kit/auth-firebase/social/src/kit-social.ts

@@ -91,6 +91,17 @@ const classifyOAuthError = (e: unknown): KitOAuthErrorCategory => {
   return 'other';
 };
 
+type Settled<T> = { status: 'fulfilled'; value: T } | { status: 'rejected'; reason: unknown };
+
+/** Convert a possibly synchronously-throwing Promise producer into an explicit result. */
+const settle = <T>(operation: () => Promise<T>): Promise<Settled<T>> => {
+  const execute = async (): Promise<T> => operation();
+  return execute().then(
+    (value) => ({ status: 'fulfilled', value }),
+    (reason: unknown) => ({ status: 'rejected', reason }),
+  );
+};
+
 /**
  * The shared 3-mode credential state machine (internal).
  *
@@ -109,7 +120,7 @@ const applyOAuthCredential = async (
     error: (category: KitOAuthErrorCategory, error: unknown) => void | Promise<unknown>;
   },
 ): Promise<boolean> => {
-  try {
+  const result = await settle(async () => {
     if (mode.mode === 'new') {
       await signInWithCredential(auth, credential);
     } else {
@@ -124,8 +135,9 @@ const applyOAuthCredential = async (
         await linkWithCredential(user, EmailAuthProvider.credential(mode.emailLogin.email, mode.emailLogin.password));
       }
     }
-  } catch (e) {
-    await effects.error(classifyOAuthError(e), e);
+  });
+  if (result.status === 'rejected') {
+    await effects.error(classifyOAuthError(result.reason), result.reason);
     return false;
   }
   await effects.success();
@@ -164,27 +176,17 @@ const isFacebookCancellation = (error: unknown): boolean => {
  * hooks).
  */
 export const kitFacebookLogin = async (auth: Auth, options: KitFacebookLoginOptions): Promise<{ status: boolean }> => {
-  try {
+  const execute = async (): Promise<{ status: boolean }> => {
     await options.before?.();
     const nonce = generateNonce();
-    let pluginFailed = false;
-    let pluginError: unknown;
-    const event = await FacebookLogin.login({ permissions: options.permissions, nonce }).catch((error: unknown) => {
-      pluginFailed = true;
-      pluginError = error;
-      return undefined;
-    });
+    const login = await settle(() => FacebookLogin.login({ permissions: options.permissions, nonce }));
     await nextFrame();
-    if (pluginFailed) {
-      if (isFacebookCancellation(pluginError)) {
-        return { status: false };
-      }
-      await options.error?.('other', pluginError);
-      return { status: false };
-    }
-    if (!event || !event.accessToken?.token) {
+    if (login.status === 'rejected') {
+      if (!isFacebookCancellation(login.reason)) await options.error?.('other', login.reason);
       return { status: false };
     }
+    const event = login.value;
+    if (!event?.accessToken?.token) return { status: false };
     const accessToken = event.accessToken.token;
     const credential: AuthCredential =
       Capacitor.isNativePlatform() && Capacitor.getPlatform() === 'ios'
@@ -196,9 +198,8 @@ export const kitFacebookLogin = async (auth: Auth, options: KitFacebookLoginOpti
       error: (category, error) => options.error?.(category, error),
     });
     return { status };
-  } finally {
-    await options.finally?.();
-  }
+  };
+  return execute().finally(() => options.finally?.());
 };
 
 /**
@@ -231,13 +232,11 @@ export const kitFacebookLogout = async (): Promise<void> => {
  * Every failure path (including popup errors) is routed through `onError`.
  */
 export const kitAppleLogin = async (auth: Auth, options: KitAppleLoginOptions): Promise<{ status: boolean }> => {
-  try {
+  const execute = async (): Promise<{ status: boolean }> => {
     await options.before?.();
     if (Capacitor.isNativePlatform()) {
       const authorize = await SignInWithApple.authorize().catch(() => undefined);
-      if (!authorize) {
-        return { status: false };
-      }
+      if (!authorize) return { status: false };
       const r = authorize.response;
       const response: KitAppleResponse = {
         user: r.user ?? null,
@@ -261,28 +260,27 @@ export const kitAppleLogin = async (auth: Auth, options: KitAppleLoginOptions):
     provider.addScope('name');
 
     if (options.mode === 'credential') {
-      const user = auth.currentUser;
-      try {
-        if (!user) {
-          throw new Error('kit social: no signed-in user to re-authenticate');
-        }
+      const operation = await settle(async () => {
+        const user = requireUser(auth);
         await reauthenticateWithPopup(user, provider);
         await linkWithCredential(user, EmailAuthProvider.credential(options.emailLogin.email, options.emailLogin.password));
-      } catch (e) {
-        await options.error?.(classifyOAuthError(e), e);
+      });
+      if (operation.status === 'rejected') {
+        await options.error?.(classifyOAuthError(operation.reason), operation.reason);
         return { status: false };
       }
       await options.success?.({ response: emptyAppleResponse(), mode: 'credential' });
       return { status: true };
     }
 
-    let result;
-    try {
-      result = options.mode === 'new' ? await signInWithPopup(auth, provider) : await linkWithPopup(requireUser(auth), provider);
-    } catch (e) {
-      await options.error?.(classifyOAuthError(e), e);
+    const popup = await settle(() =>
+      options.mode === 'new' ? signInWithPopup(auth, provider) : linkWithPopup(requireUser(auth), provider),
+    );
+    if (popup.status === 'rejected') {
+      await options.error?.(classifyOAuthError(popup.reason), popup.reason);
       return { status: false };
     }
+    const result = popup.value;
     const credential = OAuthProvider.credentialFromResult(result);
     const response: KitAppleResponse = {
       ...emptyAppleResponse(),
@@ -292,9 +290,8 @@ export const kitAppleLogin = async (auth: Auth, options: KitAppleLoginOptions):
     };
     await options.success?.({ response, mode: options.mode });
     return { status: true };
-  } finally {
-    await options.finally?.();
-  }
+  };
+  return execute().finally(() => options.finally?.());
 };
 
 const emptyAppleResponse = (): KitAppleResponse => ({