154 lines
3.6 KiB
TypeScript
154 lines
3.6 KiB
TypeScript
"use server";
|
|
import { retrieveAccessToken } from "@/apifetchers/mutual/cookies/token";
|
|
import {
|
|
DEFAULT_RESPONSE,
|
|
defaultHeaders,
|
|
FetchOptions,
|
|
HttpMethod,
|
|
ApiResponse,
|
|
DEFAULT_TIMEOUT,
|
|
} from "./basics";
|
|
|
|
/**
|
|
* Creates a promise that rejects after a specified timeout
|
|
* @param ms Timeout in milliseconds
|
|
* @param controller AbortController to abort the fetch request
|
|
* @returns A promise that rejects after the timeout
|
|
*/
|
|
const createTimeoutPromise = (
|
|
ms: number,
|
|
controller: AbortController
|
|
): Promise<never> => {
|
|
return new Promise((_, reject) => {
|
|
setTimeout(() => {
|
|
controller.abort();
|
|
reject(new Error(`Request timed out after ${ms}ms`));
|
|
}, ms);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Core fetch function with timeout and error handling
|
|
* @param url The URL to fetch
|
|
* @param options Fetch options
|
|
* @param headers Request headers
|
|
* @param payload Request payload
|
|
* @returns API response
|
|
*/
|
|
async function coreFetch<T>(
|
|
url: string,
|
|
options: FetchOptions = {},
|
|
headers: Record<string, string> = defaultHeaders,
|
|
payload?: any
|
|
): Promise<ApiResponse<T>> {
|
|
const { method = "POST", cache = false, timeout = DEFAULT_TIMEOUT } = options;
|
|
|
|
try {
|
|
// Setup controller for timeout handling
|
|
const controller = new AbortController();
|
|
|
|
// Prepare fetch options
|
|
const fetchOptions: RequestInit = {
|
|
method,
|
|
headers,
|
|
cache: cache ? "force-cache" : "no-cache",
|
|
signal: controller.signal,
|
|
};
|
|
|
|
// Add body for non-GET requests with payload
|
|
if (method !== "GET" && payload) {
|
|
fetchOptions.body = JSON.stringify(
|
|
payload.payload ? payload.payload : payload
|
|
);
|
|
}
|
|
|
|
// Create timeout promise
|
|
const timeoutPromise = createTimeoutPromise(timeout, controller);
|
|
|
|
// Execute request with timeout
|
|
const response = await Promise.race([
|
|
fetch(url, fetchOptions),
|
|
timeoutPromise,
|
|
]);
|
|
|
|
// Parse response
|
|
const responseData = await response.json();
|
|
|
|
// Return standardized response
|
|
return {
|
|
status: response.status,
|
|
data: responseData || ({} as T),
|
|
};
|
|
} catch (error) {
|
|
console.error(`API Error (${url}):`, error);
|
|
return {
|
|
...DEFAULT_RESPONSE,
|
|
error: error instanceof Error ? error.message : "Network error",
|
|
} as ApiResponse<T>;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetch data without authentication
|
|
*/
|
|
async function fetchData<T>(
|
|
endpoint: string,
|
|
payload?: any,
|
|
method: HttpMethod = "POST",
|
|
cache: boolean = false,
|
|
timeout: number = DEFAULT_TIMEOUT
|
|
): Promise<ApiResponse<T>> {
|
|
return coreFetch<T>(
|
|
endpoint,
|
|
{ method, cache, timeout },
|
|
defaultHeaders,
|
|
payload
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Fetch data with authentication token
|
|
*/
|
|
async function fetchDataWithToken<T>(
|
|
endpoint: string,
|
|
payload?: any,
|
|
method: HttpMethod = "POST",
|
|
cache: boolean = false,
|
|
timeout: number = DEFAULT_TIMEOUT
|
|
): Promise<ApiResponse<T>> {
|
|
const accessToken = (await retrieveAccessToken()) || "";
|
|
const headers = {
|
|
...defaultHeaders,
|
|
"eys-acs-tkn": accessToken,
|
|
};
|
|
|
|
return coreFetch<T>(endpoint, { method, cache, timeout }, headers, payload);
|
|
}
|
|
|
|
/**
|
|
* Update data with authentication token and UUID
|
|
*/
|
|
async function updateDataWithToken<T>(
|
|
endpoint: string,
|
|
uuid: string,
|
|
payload?: any,
|
|
method: HttpMethod = "POST",
|
|
cache: boolean = false,
|
|
timeout: number = DEFAULT_TIMEOUT
|
|
): Promise<ApiResponse<T>> {
|
|
const accessToken = (await retrieveAccessToken()) || "";
|
|
const headers = {
|
|
...defaultHeaders,
|
|
"eys-acs-tkn": accessToken,
|
|
};
|
|
|
|
return coreFetch<T>(
|
|
`${endpoint}/${uuid}`,
|
|
{ method, cache, timeout },
|
|
headers,
|
|
payload
|
|
);
|
|
}
|
|
|
|
export { fetchData, fetchDataWithToken, updateDataWithToken };
|