chore: initial commit — monorepo ReadaBook (API NestJS, web PWA, Docker)

apps/web/src/api/client.ts

@@ -0,0 +1,140 @@
+import type {
+  BookDto,
+  BookQueryDto,
+  BootstrapAdminDto,
+  CreateLibraryDto,
+  JobDto,
+  LibraryDto,
+  LoginDto,
+  ProgressDto,
+  UpdateProgressDto,
+  UserDto
+} from "@readabook/shared";
+import { mockBooks, mockContinue, mockJobs, mockLibraries, mockProgress, mockUser } from "./mockData";
+import type { ContinueItem, Session } from "./types";
+
+const API_BASE = import.meta.env.VITE_API_BASE_URL ?? "";
+
+type RequestOptions = RequestInit & {
+  fallback?: unknown;
+};
+
+export class ApiFallbackError extends Error {
+  constructor(
+    message: string,
+    public readonly fallback: unknown
+  ) {
+    super(message);
+  }
+}
+
+async function request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+  try {
+    const response = await fetch(`${API_BASE}${path}`, {
+      ...options,
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+
+    if (!response.ok) {
+      const detail = await response.text();
+      throw new Error(detail || `${response.status} ${response.statusText}`);
+    }
+
+    return (await response.json()) as T;
+  } catch (error) {
+    if (options.fallback !== undefined) {
+      throw new ApiFallbackError(error instanceof Error ? error.message : String(error), options.fallback);
+    }
+    throw error;
+  }
+}
+
+function queryString(query: Partial<BookQueryDto>): string {
+  const params = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => {
+    if (value !== undefined && value !== null && value !== "") params.set(key, String(value));
+  });
+  const value = params.toString();
+  return value ? `?${value}` : "";
+}
+
+export const api = {
+  async session(): Promise<Session> {
+    try {
+      const result = await request<{ user: UserDto }>("/auth/me");
+      return { user: result.user, degraded: false };
+    } catch {
+      return { user: null, degraded: false };
+    }
+  },
+  async bootstrap(input: BootstrapAdminDto): Promise<UserDto> {
+    const result = await request<UserDto>("/auth/bootstrap", { method: "POST", body: JSON.stringify(input) });
+    return result;
+  },
+  async login(input: LoginDto): Promise<UserDto> {
+    const result = await request<{ user: UserDto }>("/auth/login", { method: "POST", body: JSON.stringify(input) });
+    return result.user;
+  },
+  async logout(): Promise<void> {
+    await request<{ ok: true }>("/auth/logout", { method: "POST" });
+  },
+  async books(query: Partial<BookQueryDto> = {}): Promise<BookDto[]> {
+    return request<BookDto[]>(`/books${queryString({ limit: 50, offset: 0, ...query })}`, { fallback: mockBooks });
+  },
+  async search(query: string): Promise<BookDto[]> {
+    return request<BookDto[]>(`/books/search${queryString({ q: query, limit: 50, offset: 0 })}`, { fallback: mockBooks });
+  },
+  async book(id: number): Promise<BookDto> {
+    const fallback = mockBooks.find((book) => book.id === id) ?? mockBooks[0];
+    return request<BookDto>(`/books/${id}`, { fallback });
+  },
+  bookFileUrl(id: number): string {
+    return `${API_BASE}/books/${id}/file`;
+  },
+  bookCoverUrl(id: number): string {
+    return `${API_BASE}/books/${id}/cover`;
+  },
+  async progress(bookId: number): Promise<ProgressDto | null> {
+    try {
+      return await request<ProgressDto>(`/progress/${bookId}`, {
+        fallback: mockProgress.find((progress) => progress.bookId === bookId) ?? null
+      });
+    } catch (error) {
+      if (error instanceof ApiFallbackError) return error.fallback as ProgressDto | null;
+      return null;
+    }
+  },
+  async saveProgress(bookId: number, input: UpdateProgressDto): Promise<ProgressDto> {
+    return request<ProgressDto>(`/progress/${bookId}`, {
+      method: "PUT",
+      body: JSON.stringify(input),
+      fallback: { bookId, ...input, updatedAt: new Date().toISOString() }
+    });
+  },
+  async continueReading(): Promise<ContinueItem[]> {
+    return request<ContinueItem[]>("/progress/continue", { fallback: mockContinue });
+  },
+  async libraries(): Promise<LibraryDto[]> {
+    return request<LibraryDto[]>("/admin/libraries", { fallback: mockLibraries });
+  },
+  async createLibrary(input: CreateLibraryDto): Promise<LibraryDto> {
+    return request<LibraryDto>("/admin/libraries", {
+      method: "POST",
+      body: JSON.stringify(input),
+      fallback: { id: Date.now(), createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), ...input }
+    });
+  },
+  async scanLibrary(id: number): Promise<JobDto> {
+    return request<JobDto>(`/admin/libraries/${id}/scan`, { method: "POST", fallback: mockJobs[0] });
+  },
+  async jobs(): Promise<JobDto[]> {
+    return request<JobDto[]>("/admin/jobs", { fallback: mockJobs });
+  },
+  async users(): Promise<UserDto[]> {
+    return request<UserDto[]>("/admin/users", { fallback: [mockUser] });
+  }
+};