mirror of
https://github.com/MODSetter/SurfSense.git
synced 2026-04-25 08:46:22 +02:00
358 lines
9.6 KiB
TypeScript
358 lines
9.6 KiB
TypeScript
import posthog from "posthog-js";
|
|
import type { ZodType } from "zod";
|
|
import { getBearerToken, handleUnauthorized, refreshAccessToken } from "../auth-utils";
|
|
import { AppError, AuthenticationError, AuthorizationError, NotFoundError } from "../error";
|
|
|
|
enum ResponseType {
|
|
JSON = "json",
|
|
TEXT = "text",
|
|
BLOB = "blob",
|
|
ARRAY_BUFFER = "arrayBuffer",
|
|
// Add more response types as needed
|
|
}
|
|
|
|
export type RequestOptions = {
|
|
method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
|
|
headers?: Record<string, string>;
|
|
contentType?: "application/json" | "application/x-www-form-urlencoded";
|
|
signal?: AbortSignal;
|
|
body?: any;
|
|
responseType?: ResponseType;
|
|
_isRetry?: boolean; // Internal flag to prevent infinite retry loops
|
|
// Add more options as needed
|
|
};
|
|
|
|
class BaseApiService {
|
|
baseUrl: string;
|
|
|
|
noAuthEndpoints: string[] = ["/auth/jwt/login", "/auth/register", "/auth/refresh"];
|
|
|
|
// Prefixes that don't require auth (checked with startsWith)
|
|
noAuthPrefixes: string[] = ["/api/v1/public/"];
|
|
|
|
// Use a getter to always read fresh token from localStorage
|
|
// This ensures the token is always up-to-date after login/logout
|
|
get bearerToken(): string {
|
|
return typeof window !== "undefined" ? getBearerToken() || "" : "";
|
|
}
|
|
|
|
constructor(baseUrl: string) {
|
|
this.baseUrl = baseUrl;
|
|
}
|
|
|
|
// Keep for backward compatibility, but token is now always read from localStorage
|
|
setBearerToken(_bearerToken: string) {
|
|
// No-op: token is now always read fresh from localStorage via the getter
|
|
}
|
|
|
|
async request<T, R extends ResponseType = ResponseType.JSON>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: RequestOptions & { responseType?: R }
|
|
): Promise<
|
|
R extends ResponseType.JSON
|
|
? T
|
|
: R extends ResponseType.TEXT
|
|
? string
|
|
: R extends ResponseType.BLOB
|
|
? Blob
|
|
: R extends ResponseType.ARRAY_BUFFER
|
|
? ArrayBuffer
|
|
: unknown
|
|
> {
|
|
try {
|
|
/**
|
|
* ----------
|
|
* REQUEST
|
|
* ----------
|
|
*/
|
|
const defaultOptions: RequestOptions = {
|
|
headers: {
|
|
Authorization: `Bearer ${this.bearerToken || ""}`,
|
|
},
|
|
method: "GET",
|
|
responseType: ResponseType.JSON,
|
|
};
|
|
|
|
const mergedOptions: RequestOptions = {
|
|
...defaultOptions,
|
|
...(options ?? {}),
|
|
headers: {
|
|
...defaultOptions.headers,
|
|
...(options?.headers ?? {}),
|
|
},
|
|
};
|
|
|
|
// Validate the base URL
|
|
if (!this.baseUrl) {
|
|
throw new AppError("Base URL is not set.");
|
|
}
|
|
|
|
// Validate the bearer token
|
|
const isNoAuthEndpoint =
|
|
this.noAuthEndpoints.includes(url) ||
|
|
this.noAuthPrefixes.some((prefix) => url.startsWith(prefix)) ||
|
|
/^\/api\/v1\/invites\/[^/]+\/info$/.test(url);
|
|
if (!this.bearerToken && !isNoAuthEndpoint) {
|
|
throw new AuthenticationError("You are not authenticated. Please login again.");
|
|
}
|
|
|
|
// Construct the full URL
|
|
const fullUrl = new URL(url, this.baseUrl).toString();
|
|
|
|
// Prepare fetch options
|
|
const fetchOptions: RequestInit = {
|
|
method: mergedOptions.method,
|
|
headers: mergedOptions.headers,
|
|
signal: mergedOptions.signal,
|
|
};
|
|
|
|
// Automatically stringify body if Content-Type is application/json and body is an object
|
|
if (mergedOptions.body !== undefined) {
|
|
const contentType = mergedOptions.headers?.["Content-Type"];
|
|
if (contentType === "application/json" && typeof mergedOptions.body === "object") {
|
|
fetchOptions.body = JSON.stringify(mergedOptions.body);
|
|
} else {
|
|
// Pass body as-is for other content types (e.g., form data, already stringified)
|
|
fetchOptions.body = mergedOptions.body;
|
|
}
|
|
}
|
|
|
|
const response = await fetch(fullUrl, fetchOptions);
|
|
|
|
/**
|
|
* ----------
|
|
* RESPONSE
|
|
* ----------
|
|
*/
|
|
|
|
// Handle errors
|
|
if (!response.ok) {
|
|
// biome-ignore lint/suspicious: Unknown
|
|
let data;
|
|
|
|
try {
|
|
data = await response.json();
|
|
} catch (error) {
|
|
console.error("Failed to parse response as JSON: ", JSON.stringify(error));
|
|
throw new AppError("Failed to parse response", response.status, response.statusText);
|
|
}
|
|
|
|
// Handle 401 - try to refresh token first (only once)
|
|
if (response.status === 401) {
|
|
if (!options?._isRetry) {
|
|
const newToken = await refreshAccessToken();
|
|
if (newToken) {
|
|
// Retry the request with the new token
|
|
return this.request(url, responseSchema, {
|
|
...mergedOptions,
|
|
headers: {
|
|
...mergedOptions.headers,
|
|
Authorization: `Bearer ${newToken}`,
|
|
},
|
|
_isRetry: true,
|
|
} as RequestOptions & { responseType?: R });
|
|
}
|
|
}
|
|
// Refresh failed or retry failed, redirect to login
|
|
handleUnauthorized();
|
|
throw new AuthenticationError(
|
|
typeof data === "object" && "detail" in data
|
|
? data.detail
|
|
: "You are not authenticated. Please login again.",
|
|
response.status,
|
|
response.statusText
|
|
);
|
|
}
|
|
|
|
// For fastapi errors response
|
|
if (typeof data === "object" && "detail" in data) {
|
|
throw new AppError(data.detail, response.status, response.statusText);
|
|
}
|
|
|
|
switch (response.status) {
|
|
case 403:
|
|
throw new AuthorizationError(
|
|
"You don't have permission to access this resource.",
|
|
response.status,
|
|
response.statusText
|
|
);
|
|
case 404:
|
|
throw new NotFoundError("Resource not found", response.status, response.statusText);
|
|
// Add more cases as needed
|
|
default:
|
|
throw new AppError("Something went wrong", response.status, response.statusText);
|
|
}
|
|
}
|
|
|
|
// biome-ignore lint/suspicious: Unknown
|
|
let data;
|
|
const responseType = mergedOptions.responseType;
|
|
|
|
try {
|
|
switch (responseType) {
|
|
case ResponseType.JSON:
|
|
data = await response.json();
|
|
break;
|
|
case ResponseType.TEXT:
|
|
data = await response.text();
|
|
break;
|
|
case ResponseType.BLOB:
|
|
data = await response.blob();
|
|
break;
|
|
case ResponseType.ARRAY_BUFFER:
|
|
data = await response.arrayBuffer();
|
|
break;
|
|
// Add more cases as needed
|
|
default:
|
|
data = await response.json();
|
|
}
|
|
} catch (error) {
|
|
console.error("Failed to parse response as JSON:", error);
|
|
throw new AppError("Failed to parse response", response.status, response.statusText);
|
|
}
|
|
|
|
// Validate response
|
|
if (responseType === ResponseType.JSON) {
|
|
if (!responseSchema) {
|
|
return data;
|
|
}
|
|
const parsedData = responseSchema.safeParse(data);
|
|
|
|
if (!parsedData.success) {
|
|
/** The request was successful, but the response data does not match the expected schema.
|
|
* This is a client side error, and should be fixed by updating the responseSchema to keep things typed.
|
|
* This error should not be shown to the user , it is for dev only.
|
|
*/
|
|
console.error(`Invalid API response schema - ${url} :`, JSON.stringify(parsedData.error));
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
return data;
|
|
} catch (error) {
|
|
console.error("Request failed:", JSON.stringify(error));
|
|
if (!(error instanceof AuthenticationError)) {
|
|
try {
|
|
posthog.captureException(error, {
|
|
api_url: url,
|
|
api_method: options?.method ?? "GET",
|
|
...(error instanceof AppError && {
|
|
status_code: error.status,
|
|
status_text: error.statusText,
|
|
}),
|
|
});
|
|
} catch {
|
|
// PostHog capture failed — don't block the error flow
|
|
}
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async get<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType">
|
|
) {
|
|
return this.request(url, responseSchema, {
|
|
method: "GET",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
...options,
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
|
|
async post<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType">
|
|
) {
|
|
return this.request(url, responseSchema, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
...options,
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
|
|
async put<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType">
|
|
) {
|
|
return this.request(url, responseSchema, {
|
|
method: "PUT",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
...options,
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
|
|
async delete<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType">
|
|
) {
|
|
return this.request(url, responseSchema, {
|
|
method: "DELETE",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
...options,
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
|
|
async patch<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType">
|
|
) {
|
|
return this.request(url, responseSchema, {
|
|
method: "PATCH",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
...options,
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
|
|
async getBlob(url: string, options?: Omit<RequestOptions, "method" | "responseType">) {
|
|
return this.request(url, undefined, {
|
|
...options,
|
|
method: "GET",
|
|
responseType: ResponseType.BLOB,
|
|
});
|
|
}
|
|
|
|
async postFormData<T>(
|
|
url: string,
|
|
responseSchema?: ZodType<T>,
|
|
options?: Omit<RequestOptions, "method" | "responseType" | "body"> & { body: FormData }
|
|
) {
|
|
// Remove Content-Type from options headers if present
|
|
const { "Content-Type": _, ...headersWithoutContentType } = options?.headers ?? {};
|
|
|
|
return this.request(url, responseSchema, {
|
|
method: "POST",
|
|
...options,
|
|
headers: {
|
|
// Don't set Content-Type - let browser set it with multipart boundary
|
|
Authorization: `Bearer ${this.bearerToken}`,
|
|
...headersWithoutContentType,
|
|
},
|
|
responseType: ResponseType.JSON,
|
|
});
|
|
}
|
|
}
|
|
|
|
export const baseApiService = new BaseApiService(process.env.NEXT_PUBLIC_FASTAPI_BACKEND_URL || "");
|