snapshot of https://github.com/toeverything/AFFiNE.git (canary, 2026-09-16; blobs > 131072B omitted)

packages/frontend/apps/mobile-shared/src/auth/channel.ts

@@ -0,0 +1,137 @@
+import type { AuthRequestProvider } from './request';
+
+type AuthOperation = 'get-valid' | 'refresh';
+
+type AuthRequest = {
+  id: string;
+  operation: AuthOperation;
+  endpoint: string;
+};
+
+type AuthResponse = {
+  id: string;
+  token?: string | null;
+  error?: string;
+};
+
+const terminalAuthErrors = new Set([
+  'ACCESS_TOKEN_INVALID',
+  'AUTH_SESSION_EXPIRED',
+  'AUTH_SESSION_REVOKED',
+  'REFRESH_TOKEN_INVALID',
+  'REFRESH_TOKEN_REUSED',
+  'UNSUPPORTED_CLIENT_VERSION',
+  'AUTH_SESSION_EMPTY',
+]);
+
+const temporaryAuthError = 'AUTH_SESSION_TEMPORARILY_UNAVAILABLE';
+
+function errorCode(error: unknown) {
+  return typeof error === 'object' &&
+    error &&
+    'code' in error &&
+    typeof error.code === 'string'
+    ? error.code
+    : temporaryAuthError;
+}
+
+export function serveAuthRequests(
+  port: MessagePort,
+  provider: AuthRequestProvider
+) {
+  port.addEventListener('message', event => {
+    const { id, operation, endpoint } = event.data as Partial<AuthRequest>;
+    if (
+      !id ||
+      (operation !== 'get-valid' && operation !== 'refresh') ||
+      !endpoint
+    ) {
+      return;
+    }
+
+    const request =
+      operation === 'refresh'
+        ? provider.refreshAccessToken(endpoint)
+        : provider.getValidAccessToken(endpoint);
+    request.then(
+      token => port.postMessage({ id, token } satisfies AuthResponse),
+      error =>
+        port.postMessage({
+          id,
+          error: errorCode(error),
+        } satisfies AuthResponse)
+    );
+  });
+  port.start();
+}
+
+export class MessagePortAuthProvider implements AuthRequestProvider {
+  private port?: MessagePort;
+  private nextRequestId = 0;
+  private readonly pending = new Map<
+    string,
+    {
+      resolve: (token: string | null) => void;
+      reject: (error: Error) => void;
+    }
+  >();
+
+  setPort(port: MessagePort) {
+    this.port = port;
+    port.addEventListener('message', event => {
+      const { id, token, error } = event.data as Partial<AuthResponse>;
+      if (!id) return;
+      const pending = this.pending.get(id);
+      if (!pending) return;
+
+      if (error) {
+        pending.reject(new Error(error));
+      } else {
+        pending.resolve(token ?? null);
+      }
+      this.pending.delete(id);
+    });
+    port.start();
+  }
+
+  async getValidAccessToken(endpoint: string) {
+    try {
+      return await this.request('get-valid', endpoint);
+    } catch (error) {
+      if (error instanceof Error && terminalAuthErrors.has(error.message)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async refreshAccessToken(endpoint: string) {
+    const token = await this.request('refresh', endpoint);
+    if (!token) throw new Error(temporaryAuthError);
+    return token;
+  }
+
+  private request(operation: AuthOperation, endpoint: string) {
+    const port = this.port;
+    if (!port) return Promise.reject(new Error(temporaryAuthError));
+
+    const id = String(++this.nextRequestId);
+    return new Promise<string | null>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(temporaryAuthError));
+      }, 5000);
+      this.pending.set(id, {
+        resolve: token => {
+          clearTimeout(timeout);
+          resolve(token);
+        },
+        reject: error => {
+          clearTimeout(timeout);
+          reject(error);
+        },
+      });
+      port.postMessage({ id, operation, endpoint } satisfies AuthRequest);
+    });
+  }
+}