✨ add Hono RPC foundation

apps/expo/features/auth/README.md

@@ -33,6 +33,19 @@ When a user's session expires (access token and refresh token both expire), the
 - `atoms/authAtoms.ts`: Jotai atoms for authentication state including re-auth flags
 - `hooks/useAuthActions.ts`: Actions for sign-in, sign-out, and state management
 - `lib/api/client.ts`: Axios interceptor handling token refresh and re-auth triggering
+- `lib/api/rpcTransport.ts`: Hono RPC fetch adapter mirroring the same refresh and re-auth behavior
+- `lib/api/rpcClient.ts`: Shared Expo RPC client entry point backed by `@packrat/api-client`
+
+## RPC Migration Status
+
+The app is currently in a coexistence period:
+
+- Legacy feature modules still use `lib/api/client.ts` and `axiosInstance`
+- New Hono RPC infrastructure lives in `lib/api/rpcTransport.ts` and `lib/api/rpcClient.ts`
+- The RPC transport is intended to preserve the same auth contract as axios:
+  bearer token attachment, refresh retry queueing, and `needsReauthAtom` on hard failure
+
+Until feature consumers are migrated, both transport layers may exist side-by-side. Changes to auth behavior should keep them aligned.
 
 ### Example Flow
 

apps/expo/lib/api/rpcClient.ts

@@ -0,0 +1,7 @@
+import { createApiClient } from '@packrat/api-client';
+import { clientEnvs } from '@packrat/env/expo-client';
+import { createRpcFetch } from './rpcTransport';
+
+export const rpcClient = createApiClient(clientEnvs.EXPO_PUBLIC_API_URL, {
+  fetch: createRpcFetch(),
+});

apps/expo/lib/api/rpcTransport.ts

@@ -0,0 +1,168 @@
+import { clientEnvs } from '@packrat/env/expo-client';
+import { store } from 'expo-app/atoms/store';
+import {
+  needsReauthAtom,
+  refreshTokenAtom,
+  tokenAtom,
+} from 'expo-app/features/auth/atoms/authAtoms';
+import Storage from 'expo-sqlite/kv-store';
+
+type FetchLike = typeof fetch;
+
+type QueuedRequest = {
+  input: RequestInfo | URL;
+  init?: RequestInit;
+  resolve: (value: Response | PromiseLike<Response>) => void;
+  reject: (reason?: unknown) => void;
+};
+
+const defaultBaseUrl = clientEnvs.EXPO_PUBLIC_API_URL;
+
+let isRefreshing = false;
+let failedQueue: QueuedRequest[] = [];
+
+const cloneInit = (init?: RequestInit): RequestInit | undefined => {
+  if (!init) {
+    return undefined;
+  }
+
+  return {
+    ...init,
+    headers: init.headers ? new Headers(init.headers) : undefined,
+  };
+};
+
+const withAuthHeaders = async (
+  init?: RequestInit,
+  tokenOverride?: string | null,
+): Promise<RequestInit> => {
+  const headers = new Headers(init?.headers);
+
+  if (!headers.has('Accept')) {
+    headers.set('Accept', 'application/json');
+  }
+
+  const token = tokenOverride ?? (await Storage.getItem('access_token'));
+  if (token) {
+    headers.set('Authorization', `Bearer ${token}`);
+  }
+
+  return {
+    ...init,
+    headers,
+  };
+};
+
+const processQueue = async (
+  { error, token }: { error: Error | null; token: string | null },
+  fetchImpl: FetchLike,
+) => {
+  const pending = failedQueue;
+  failedQueue = [];
+
+  for (const request of pending) {
+    if (error) {
+      request.reject(error);
+      continue;
+    }
+
+    try {
+      const retryHeaders = new Headers(request.init?.headers);
+      retryHeaders.set('x-packrat-rpc-retry', 'true');
+      const retryInit = await withAuthHeaders({ ...request.init, headers: retryHeaders }, token);
+      request.resolve(fetchImpl(request.input, retryInit));
+    } catch (retryError) {
+      request.reject(retryError);
+    }
+  }
+};
+
+const refreshAccessToken = async (fetchImpl: FetchLike, baseUrl: string) => {
+  const refreshToken = await Storage.getItem('refresh_token');
+
+  const response = await fetchImpl(`${baseUrl}/api/auth/refresh`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    },
+    body: JSON.stringify({ refreshToken }),
+  });
+
+  const data = (await response.json()) as {
+    success?: boolean;
+    accessToken?: string;
+    refreshToken?: string;
+  };
+
+  if (!response.ok || !data.success || !data.accessToken || !data.refreshToken) {
+    throw new Error('Token refresh failed');
+  }
+
+  await store.set(tokenAtom, data.accessToken);
+  await store.set(refreshTokenAtom, data.refreshToken);
+
+  return data.accessToken;
+};
+
+export const createRpcFetch = (options: { baseUrl?: string; fetchImpl?: FetchLike } = {}) => {
+  const baseUrl = options.baseUrl ?? defaultBaseUrl;
+  const fetchImpl = options.fetchImpl ?? fetch;
+
+  const rpcFetch = Object.assign(
+    async (input: Parameters<FetchLike>[0], init?: Parameters<FetchLike>[1]) => {
+      const authedInit = await withAuthHeaders(init);
+      const response = await fetchImpl(input, authedInit);
+
+      if (response.status !== 401) {
+        return response;
+      }
+
+      const retried = new Headers(init?.headers).get('x-packrat-rpc-retry');
+      if (retried === 'true') {
+        return response;
+      }
+
+      if (isRefreshing) {
+        return await new Promise<Response>((resolve, reject) => {
+          failedQueue.push({
+            input,
+            init: cloneInit(init),
+            resolve,
+            reject,
+          });
+        });
+      }
+
+      isRefreshing = true;
+
+      try {
+        const nextToken = await refreshAccessToken(fetchImpl, baseUrl);
+        await processQueue({ error: null, token: nextToken }, fetchImpl);
+
+        const retryHeaders = new Headers(init?.headers);
+        retryHeaders.set('x-packrat-rpc-retry', 'true');
+
+        return await fetchImpl(
+          input,
+          await withAuthHeaders(
+            {
+              ...cloneInit(init),
+              headers: retryHeaders,
+            },
+            nextToken,
+          ),
+        );
+      } catch (error) {
+        await store.set(needsReauthAtom, true);
+        await processQueue({ error: error as Error, token: null }, fetchImpl);
+        throw error;
+      } finally {
+        isRefreshing = false;
+      }
+    },
+    fetchImpl,
+  ) satisfies FetchLike;
+
+  return rpcFetch;
+};

apps/expo/package.json

@@ -51,6 +51,7 @@
     "@gorhom/bottom-sheet": "^5.1.2",
     "@legendapp/state": "^3.0.0-beta.30",
     "@packrat-ai/nativewindui": "^2.0.2",
+    "@packrat/api-client": "workspace:*",
     "@packrat/config": "workspace:*",
     "@packrat/env": "workspace:*",
     "@packrat/guards": "workspace:*",

apps/expo/test/rpc-client-proof.test.ts

@@ -0,0 +1,77 @@
+import { type ApiRequestOf, type ApiResponseOf, createApiClient } from '@packrat/api-client';
+import { expectTypeOf, test } from 'vitest';
+
+const client = createApiClient('https://packrat.test');
+const guideGetById = client.api.guides[':id'].$get;
+const catalogGetById = client.api.catalog[':id'].$get;
+const tripGetById = client.api.trips[':tripId'].$get;
+type GuideGetById = typeof guideGetById;
+type CatalogGetById = typeof catalogGetById;
+type TripGetById = typeof tripGetById;
+
+test('Expo can consume typed guide and catalog RPC requests', () => {
+  const guideRequest: ApiRequestOf<GuideGetById> = {
+    param: {
+      id: 'ultralight-backpacking',
+    },
+  };
+
+  const catalogQuery: ApiRequestOf<typeof client.api.catalog.$get> = {
+    query: {
+      q: 'sleeping bag',
+      page: '1',
+      limit: '10',
+    },
+  };
+
+  expectTypeOf(guideRequest.param.id).toEqualTypeOf<string>();
+  expectTypeOf(catalogQuery.query?.page).toEqualTypeOf<string | undefined>();
+});
+
+test('Expo can narrow typed RPC responses by route and status', () => {
+  type GuideResponse = ApiResponseOf<GuideGetById>;
+  type MissingCatalogItem = ApiResponseOf<CatalogGetById, 404>;
+
+  expectTypeOf<GuideResponse>().toMatchTypeOf<{
+    id: string;
+    title: string;
+    content: string;
+  }>();
+
+  expectTypeOf<MissingCatalogItem>().toMatchTypeOf<{
+    error: string;
+  }>();
+});
+
+test('Expo can consume typed trips RPC requests', () => {
+  const createRequest: ApiRequestOf<typeof client.api.trips.$post> = {
+    json: {
+      id: 't_123',
+      name: 'Pacific Crest Trail',
+      localCreatedAt: new Date().toISOString(),
+      localUpdatedAt: new Date().toISOString(),
+    },
+  };
+
+  const byIdRequest: ApiRequestOf<TripGetById> = {
+    param: { tripId: 't_123' },
+  };
+
+  expectTypeOf(createRequest.json.name).toEqualTypeOf<string>();
+  expectTypeOf(byIdRequest.param.tripId).toEqualTypeOf<string>();
+});
+
+test('Expo can narrow typed trips RPC responses by status', () => {
+  type TripResponse = ApiResponseOf<TripGetById>;
+  type MissingTrip = ApiResponseOf<TripGetById, 404>;
+
+  expectTypeOf<TripResponse>().toMatchTypeOf<{
+    id: string;
+    name: string;
+    userId: number;
+  }>();
+
+  expectTypeOf<MissingTrip>().toMatchTypeOf<{
+    error: string;
+  }>();
+});

apps/expo/tsconfig.json

@@ -1,11 +1,16 @@
 {
-  "extends": "expo/tsconfig.base",
+  "extends": "../../tsconfig.json",
   "compilerOptions": {
     "strict": true,
     "jsx": "react-jsx",
+    "customConditions": ["react-native"],
     "baseUrl": ".",
     "paths": {
-      "expo-app/*": ["./*"]
+      "expo-app/*": ["./*"],
+      "@packrat/api": ["../../packages/api/src/index.ts"],
+      "@packrat/api/*": ["../../packages/api/src/*"],
+      "@packrat/api-client": ["../../packages/api-client/src/index.ts"],
+      "@packrat/api-client/*": ["../../packages/api-client/src/*"]
     }
   },
   "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts", "nativewind-env.d.ts"],

apps/expo/vitest.types.config.ts

@@ -0,0 +1,20 @@
+import { resolve } from 'node:path';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      'expo-app': resolve(__dirname, '.'),
+      '@packrat/api': resolve(__dirname, '../../packages/api/src/index.ts'),
+      '@packrat/api-client': resolve(__dirname, '../../packages/api-client/src/index.ts'),
+    },
+  },
+  test: {
+    name: 'expo-rpc-types',
+    environment: 'node',
+    typecheck: {
+      enabled: true,
+    },
+    include: [resolve(__dirname, 'test/**/*.test.ts')],
+  },
+});