@kyro-cms/admin 0.3.1 → 0.3.4

package/src/lib/api.ts

@@ -1,75 +1,136 @@
-export interface ApiResponse<T = any> {
+import { apiPath, adminPath, resolveApi, resolveAdmin, resolveMedia } from "./paths";
+import { toast } from "./stores";
+
+export interface ApiResponse<T = unknown> {
   docs?: T[];
   doc?: T;
   totalDocs?: number;
   error?: string;
 }
 
-export async function apiGet<T = any>(
+export { resolveApi as resolveApi, resolveAdmin as resolveAdminUrl, resolveApi as resolveUrl, resolveMedia as resolveMedia };
+
+const API_BASE = apiPath;
+const ADMIN_BASE = adminPath;
+
+const TOKEN_REFRESH_URL = "/api/auth/refresh";
+
+async function refreshToken(): Promise<boolean> {
+  try {
+    const response = await fetch(resolveApi(TOKEN_REFRESH_URL), {
+      method: "POST",
+      credentials: "include",
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function fetchWithAuth(
   url: string,
-  options?: RequestInit,
-): Promise<T> {
-  const response = await fetch(url, {
+  options: RequestInit = {},
+): Promise<Response> {
+  const headers: Record<string, string> = {};
+  if (!(options.body instanceof FormData)) {
+    headers["Content-Type"] = "application/json";
+  }
+  Object.assign(headers, options.headers as Record<string, string> | undefined);
+
+  const response = await fetch(resolveApi(url), {
     ...options,
     credentials: "include",
+    headers,
   });
+
+  if (response.status === 401) {
+    const refreshed = await refreshToken();
+    if (refreshed) {
+      const retryHeaders: Record<string, string> = {};
+      if (!(options.body instanceof FormData)) {
+        retryHeaders["Content-Type"] = "application/json";
+      }
+      Object.assign(retryHeaders, options.headers as Record<string, string> | undefined);
+      const retryResponse = await fetch(resolveApi(url), {
+        ...options,
+        credentials: "include",
+        headers: retryHeaders,
+      });
+      return retryResponse;
+    }
+    window.location.href = "/admin/login";
+  }
+
+  return response;
+}
+
+export async function apiGet<T = unknown>(
+  url: string,
+  options?: RequestInit & { autoToast?: boolean },
+): Promise<T> {
+  const { autoToast = true, ...fetchOptions } = options || {};
+  const response = await fetchWithAuth(url, fetchOptions);
   if (!response.ok) {
-    throw new Error(`API Error: ${response.status}`);
+    const errorMsg = `GET Failed: ${response.status}`;
+    if (autoToast) toast.error(errorMsg);
+    throw new Error(errorMsg);
   }
   return response.json();
 }
 
-export async function apiPost<T = any>(
+export async function apiPost<T = unknown>(
   url: string,
-  body?: any,
-  options?: RequestInit,
+  body?: unknown,
+  options?: RequestInit & { autoToast?: boolean },
 ): Promise<T> {
-  const response = await fetch(url, {
+  const { autoToast = true, ...fetchOptions } = options || {};
+  const response = await fetchWithAuth(url, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers,
-    },
     body: body ? JSON.stringify(body) : undefined,
-    credentials: "include",
-    ...options,
+    ...fetchOptions,
   });
   if (!response.ok) {
-    throw new Error(`API Error: ${response.status}`);
+    let errorMessage = `POST Failed: ${response.status}`;
+    try {
+      const errorData = await response.json();
+      if (errorData.error) errorMessage = errorData.error;
+    } catch {}
+    if (autoToast) toast.error(errorMessage);
+    throw new Error(errorMessage);
   }
   return response.json();
 }
 
-export async function apiPatch<T = any>(
+export async function apiPatch<T = unknown>(
   url: string,
-  body?: any,
-  options?: RequestInit,
+  body?: unknown,
+  options?: RequestInit & { autoToast?: boolean },
 ): Promise<T> {
-  const response = await fetch(url, {
+  const { autoToast = true, ...fetchOptions } = options || {};
+  const response = await fetchWithAuth(url, {
     method: "PATCH",
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.headers,
-    },
     body: body ? JSON.stringify(body) : undefined,
-    credentials: "include",
-    ...options,
+    ...fetchOptions,
   });
   if (!response.ok) {
-    throw new Error(`API Error: ${response.status}`);
+    let errorMessage = `Update Failed: ${response.status}`;
+    try {
+      const errorData = await response.json();
+      if (errorData.error) errorMessage = errorData.error;
+    } catch {}
+    if (autoToast) toast.error(errorMessage);
+    throw new Error(errorMessage);
   }
   return response.json();
 }
 
-export async function apiPatchNoThrow<T = any>(
+export async function apiPatchNoThrow<T = unknown>(
   url: string,
-  body?: any,
+  body?: unknown,
 ): Promise<{ ok: boolean; data?: T; error?: string }> {
-  const response = await fetch(url, {
+  const response = await fetchWithAuth(url, {
     method: "PATCH",
-    headers: { "Content-Type": "application/json" },
     body: body ? JSON.stringify(body) : undefined,
-    credentials: "include",
   });
   if (!response.ok) {
     return { ok: false, error: `Error: ${response.status}` };
@@ -78,22 +139,30 @@ export async function apiPatchNoThrow<T = any>(
   return { ok: true, data };
 }
 
-export async function apiDelete<T = any>(
+export async function apiDelete<T = unknown>(
   url: string,
-  options?: RequestInit,
+  options?: RequestInit & { autoToast?: boolean },
 ): Promise<T> {
-  const response = await fetch(url, {
+  const { autoToast = true, ...fetchOptions } = options || {};
+  const response = await fetchWithAuth(url, {
     method: "DELETE",
-    credentials: "include",
-    ...options,
+    ...fetchOptions,
   });
   if (!response.ok) {
-    throw new Error(`API Error: ${response.status}`);
+    let errorMessage = `Delete Failed: ${response.status}`;
+    try {
+      const errorData = await response.json();
+      if (errorData.error) errorMessage = errorData.error;
+    } catch {}
+    if (autoToast) toast.error(errorMessage);
+    throw new Error(errorMessage);
   }
-  return response.json();
+  const text = await response.text();
+  if (!text) return {} as T;
+  return JSON.parse(text);
 }
 
-export function buildQueryString(params: Record<string, any>): string {
+export function buildQueryString(params: Record<string, unknown>): string {
   const urlParams = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
     if (value !== undefined && value !== null && value !== "") {
@@ -124,9 +193,9 @@ export function buildSearchQuery(
 
 export function buildCollectionUrl(
   collection: string,
-  params?: Record<string, any>,
+  params?: Record<string, unknown>,
 ): string {
-  let url = `/api/${collection}`;
+  let url = `${API_BASE}/${collection}`;
   if (params) {
     const query = buildQueryString(params);
     if (query) url += `?${query}`;
@@ -137,9 +206,9 @@ export function buildCollectionUrl(
 export function buildDocumentUrl(
   collection: string,
   id: string,
-  params?: Record<string, any>,
+  params?: Record<string, unknown>,
 ): string {
-  let url = `/api/${collection}/${id}`;
+  let url = `${API_BASE}/${collection}/${id}`;
   if (params) {
     const query = buildQueryString(params);
     if (query) url += `?${query}`;
@@ -147,17 +216,68 @@ export function buildDocumentUrl(
   return url;
 }
 
-export async function apiUpload<T = any>(
+export async function apiUpload<T = unknown>(
   url: string,
   body: FormData,
+  onProgress?: (percent: number) => void,
 ): Promise<T> {
-  const response = await fetch(url, {
-    method: "POST",
-    body,
-    credentials: "include",
-  });
-  if (!response.ok) {
-    throw new Error(`Upload Error: ${response.status}`);
+  if (!onProgress) {
+    // Fast path: no progress tracking needed
+    const response = await fetchWithAuth(url, {
+      method: "POST",
+      body,
+    });
+    if (!response.ok) {
+      throw new Error(`Upload Error: ${response.status}`);
+    }
+    return response.json();
   }
-  return response.json();
-}
+
+  // Use XHR for upload progress events
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", resolveApi(url));
+    xhr.withCredentials = true;
+
+    xhr.upload.addEventListener("progress", (e) => {
+      if (e.lengthComputable) {
+        onProgress(Math.round((e.loaded / e.total) * 100));
+      }
+    });
+
+    xhr.addEventListener("load", () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          resolve(JSON.parse(xhr.responseText));
+        } catch {
+          reject(new Error("Invalid JSON response"));
+        }
+      } else if (xhr.status === 401) {
+        // Attempt token refresh then retry once
+        refreshToken().then((refreshed) => {
+          if (!refreshed) { reject(new Error(`Upload Error: ${xhr.status}`)); return; }
+          const xhr2 = new XMLHttpRequest();
+          xhr2.open("POST", resolveApi(url));
+          xhr2.withCredentials = true;
+          xhr2.upload.addEventListener("progress", (e) => {
+            if (e.lengthComputable) onProgress(Math.round((e.loaded / e.total) * 100));
+          });
+          xhr2.addEventListener("load", () => {
+            if (xhr2.status >= 200 && xhr2.status < 300) {
+              try { resolve(JSON.parse(xhr2.responseText)); } catch { reject(new Error("Invalid JSON")); }
+            } else {
+              reject(new Error(`Upload Error: ${xhr2.status}`));
+            }
+          });
+          xhr2.addEventListener("error", () => reject(new Error("Network error")));
+          xhr2.send(body);
+        });
+      } else {
+        reject(new Error(`Upload Error: ${xhr.status}`));
+      }
+    });
+
+    xhr.addEventListener("error", () => reject(new Error("Network error during upload")));
+    xhr.send(body);
+  });
+}