@bariskuran/base 0.0.0-stage → 0.0.1

package/src/libs/baseFetch/_tools.js

@@ -0,0 +1,232 @@
+import { baseStore } from "../baseStore";
+import { byPath } from "../byPath";
+import { API_RESPONSE_CODES } from "../../constants/API_RESPONSE_CODES";
+import { getText } from "../getText";
+
+const DEFAULT_ERROR_CODE = 500;
+
+export const pickErrorMessageFromPaths = (data, paths = []) => {
+    if (!data || typeof data !== "object") return null;
+    if (!Array.isArray(paths) || paths.length === 0) return null;
+
+    for (const p of paths) {
+        if (!p || typeof p !== "string") continue;
+        const v = byPath.get(data, p);
+        if (typeof v === "string" && v.trim()) return v.trim();
+    }
+
+    return null;
+};
+
+export const findStatusCodeUpToDepth3 = (data) => {
+    const norm = (x) => {
+        const n = Number(x);
+        return Number.isFinite(n) ? n : null;
+    };
+
+    if (!data || typeof data !== "object") return null;
+    if ("status" in data) {
+        const c = norm(data.status);
+        if (c != null) return c;
+    }
+
+    const level1 = Object.values(data).filter((v) => v && typeof v === "object");
+    for (const v1 of level1) {
+        if ("status" in v1) {
+            const c = norm(v1.status);
+            if (c != null) return c;
+        }
+
+        const level2 = Object.values(v1).filter((v) => v && typeof v === "object");
+        for (const v2 of level2) {
+            if ("status" in v2) {
+                const c = norm(v2.status);
+                if (c != null) return c;
+            }
+
+            const level3 = Object.values(v2).filter((v) => v && typeof v === "object");
+            for (const v3 of level3) {
+                if ("status" in v3) {
+                    const c = norm(v3.status);
+                    if (c != null) return c;
+                }
+            }
+        }
+    }
+    return null;
+};
+
+export const getI18nMessageFromStatusCode = (code) => {
+    const meta =
+        API_RESPONSE_CODES?.[code] ||
+        API_RESPONSE_CODES?.unknown ||
+        API_RESPONSE_CODES?.[DEFAULT_ERROR_CODE];
+    const descEntry = meta?.description;
+    const titleEntry = meta?.title;
+    const msg =
+        (descEntry ? getText(descEntry) : "") ||
+        (titleEntry ? getText(titleEntry) : "") ||
+        `HTTP ${code}`;
+    return msg;
+};
+
+export const resolveErrorMessage = ({ err, data, responseErrorPaths }) => {
+    const fromPaths = pickErrorMessageFromPaths(data, responseErrorPaths);
+    if (fromPaths) return fromPaths;
+    const statusFromData = findStatusCodeUpToDepth3(data);
+    if (statusFromData != null) return getI18nMessageFromStatusCode(statusFromData);
+    const m = typeof err?.message === "string" ? err.message.trim() : "";
+    if (m) return m;
+    return getI18nMessageFromStatusCode(DEFAULT_ERROR_CODE);
+};
+
+export const isAbsoluteUrl = (url = "") => /^https?:\/\//i.test(String(url || "").trim());
+
+export const joinUrl = (base, path) => {
+    const b = String(base || "")
+        .trim()
+        .replace(/\/+$/, "");
+    const p = String(path || "")
+        .trim()
+        .replace(/^\/+/, "");
+    if (!b) return `/${p}`;
+    if (!p) return b;
+    return `${b}/${p}`;
+};
+
+export const applyEnvUrl = (url, envUrl) => {
+    const u = String(url || "").trim();
+    if (!u) return u;
+    if (isAbsoluteUrl(u)) return u;
+    const base = String(envUrl || "").trim();
+    return joinUrl(base, u);
+};
+
+export const resolvePayload = (payloadAdaptor, prevResults = []) => {
+    if (typeof payloadAdaptor === "function") {
+        return payloadAdaptor(...prevResults);
+    }
+    return payloadAdaptor;
+};
+
+export const normalizeMethod = (m) => String(m || "GET").toUpperCase();
+
+export const buildHeaders = (headers) => {
+    const h = headers && typeof headers === "object" ? { ...headers } : {};
+    if (!h.Accept) h.Accept = "application/json";
+    return h;
+};
+
+export const checkCallProps = (call = {}) => {
+    const errors = [];
+
+    const url = String(call.url || "").trim();
+    if (!url) errors.push("No url provided.");
+
+    const method = normalizeMethod(call.method);
+    const allowed = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+    if (!allowed.includes(method)) errors.push(`Invalid method "${method}".`);
+
+    const credentials = call.credentials ?? "include";
+    const credAllowed = ["include", "same-origin", "omit"];
+    if (!credAllowed.includes(credentials)) errors.push(`Invalid credentials "${credentials}".`);
+
+    return { ok: errors.length === 0, errors };
+};
+
+const LS_KEY = "baseResponses";
+const MAX_BYTES = 5 * 1024 * 1024;
+
+const safeParse = (s) => {
+    try {
+        return JSON.parse(s);
+    } catch {
+        return null;
+    }
+};
+
+export const getCacheStore = () => {
+    const raw = localStorage.getItem(LS_KEY);
+    const parsed = safeParse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+};
+
+export const setCacheStore = (obj) => {
+    localStorage.setItem(LS_KEY, JSON.stringify(obj || {}));
+};
+
+export const bytesOfJson = (v) => {
+    try {
+        const str = typeof v === "string" ? v : JSON.stringify(v);
+        if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(str).length;
+        return unescape(encodeURIComponent(str)).length;
+    } catch {
+        return Infinity;
+    }
+};
+
+export const pruneExpiredCache = (store, nowTs) => {
+    const out = {};
+    for (const [k, v] of Object.entries(store || {})) {
+        const exp = Number(v?.expiresAt || 0);
+        if (exp && exp > nowTs) out[k] = v;
+    }
+    return out;
+};
+
+export const makeCacheKey = ({ url, method = "GET", body } = {}) => {
+    let b = "";
+    if (body != null) {
+        try {
+            b = typeof body === "string" ? body : JSON.stringify(body);
+        } catch {
+            b = String(body);
+        }
+    }
+    return `${normalizeMethod(method)}::${url}::${b}`;
+};
+
+export const getFromCache = ({ cacheKey, nowTs }) => {
+    const store = pruneExpiredCache(getCacheStore(), nowTs);
+    setCacheStore(store);
+
+    const hit = store[cacheKey];
+    if (!hit) return null;
+
+    return hit.data;
+};
+
+export const addToCache = ({ cacheKey, data, ttlMs }) => {
+    const nowTs = Date.now();
+    const store = pruneExpiredCache(getCacheStore(), nowTs);
+
+    const itemBytes = bytesOfJson({ data, expiresAt: nowTs + ttlMs });
+    if (itemBytes > MAX_BYTES) {
+        return { ok: false, reason: "CACHE_ITEM_TOO_LARGE" };
+    }
+
+    store[cacheKey] = { data, expiresAt: nowTs + ttlMs };
+
+    const nextBytes = bytesOfJson(store);
+    if (nextBytes > MAX_BYTES) {
+        setCacheStore({});
+        return { ok: false, reason: "CACHE_CAPACITY_EXCEEDED_CLEARED" };
+    }
+
+    setCacheStore(store);
+    return { ok: true };
+};
+
+export const resolveToken = async ({ disableAuth, token, getTokenFrom }) => {
+    if (disableAuth) return null;
+    if (token) return token;
+    if (typeof getTokenFrom === "function") {
+        try {
+            const t = await getTokenFrom(baseStore);
+            return t || null;
+        } catch {
+            return null;
+        }
+    }
+    return null;
+};

package/src/libs/baseFetch/index.js

@@ -0,0 +1,349 @@
+import { baseStore } from "../baseStore";
+import { queryConverter } from "../queryConverter";
+import {
+    applyEnvUrl,
+    buildHeaders,
+    checkCallProps,
+    makeCacheKey,
+    getFromCache,
+    addToCache,
+    normalizeMethod,
+    resolvePayload,
+    resolveToken,
+    resolveErrorMessage,
+    isAbsoluteUrl,
+} from "./_tools";
+
+export const baseFetch = (callOrCalls, jointSettings = {}) => {
+    const global = baseStore.globalData.get?.() || {};
+    const _baseFetchSettings = global._baseFetchSettings || {};
+
+    const {
+        disableLoadingApi: disableLoadingApiGlobal,
+        disableAuth: disableAuthGlobal,
+        getTokenFrom: getTokenFromGlobal,
+        token: tokenGlobal,
+        cacheTime: cacheTimeGlobal,
+        envUrl: envUrlGlobal,
+        responseErrorPaths: responseErrorPathsGlobal,
+    } = _baseFetchSettings;
+
+    const {
+        enableSynchronousCalls = false,
+        disableLoadingApi = disableLoadingApiGlobal || false,
+        onError,
+        onSuccess,
+        onCancel,
+        envUrl = envUrlGlobal || null,
+    } = jointSettings || {};
+
+    const controllers = [];
+    let cancelled = false;
+    let cancelReason = "canceled";
+    let cancelNotified = false;
+
+    const notifyCancelOnce = () => {
+        if (cancelNotified) return;
+        cancelNotified = true;
+        try {
+            onCancel?.({ reason: cancelReason, baseStore });
+        } catch (err) {
+            console.error("[baseFetch] onCancel callback error:", err);
+        }
+    };
+
+    const cancelFetch = (reason = "canceled") => {
+        cancelled = true;
+        cancelReason = reason || "canceled";
+
+        controllers.forEach((c) => {
+            try {
+                c.abort(cancelReason);
+            } catch (err) {
+                console.error("[baseFetch] Error in cancelFetch abort:", err);
+            }
+        });
+
+        notifyCancelOnce();
+    };
+
+    const promise = (async () => {
+        const calls = Array.isArray(callOrCalls) ? callOrCalls : [callOrCalls];
+
+        const validationErrors = [];
+        calls.forEach((c, i) => {
+            const { ok, errors } = checkCallProps(c || {});
+            if (!ok) validationErrors.push({ index: i, errors });
+        });
+
+        if (validationErrors.length) {
+            const res = {
+                isOk: false,
+                status: "error",
+                errors: validationErrors,
+            };
+            onError?.(res);
+            return res;
+        }
+
+        const results = [];
+        const responses = [];
+        const errors = [];
+
+        const runOneCall = async (call, index, prevResults) => {
+            const loadingApi = global._loadingManager?.api;
+
+            const {
+                url,
+                method = "GET",
+                body,
+                credentials,
+                headers,
+                useCache = false,
+                cacheTime = cacheTimeGlobal || 10,
+                payload,
+                payloadAdaptor,
+                disableAuth = disableAuthGlobal || false,
+                getTokenFrom = getTokenFromGlobal || null,
+                token = tokenGlobal || null,
+                onStart,
+                onEnd,
+                responseErrorPaths = responseErrorPathsGlobal || [],
+            } = call || {};
+
+            const isAbs = isAbsoluteUrl(url);
+            const resolvedCredentials = credentials ?? (isAbs ? "omit" : "include");
+            const finalMethod = normalizeMethod(method);
+            const payloadObj = payload ?? resolvePayload(payloadAdaptor, prevResults);
+            const fullUrlBase = applyEnvUrl(url, envUrl);
+            const fullUrl =
+                finalMethod === "GET" && payloadObj
+                    ? `${fullUrlBase}${queryConverter.export(payloadObj)}`
+                    : fullUrlBase;
+
+            const cacheKey = makeCacheKey({
+                url: fullUrl,
+                method: finalMethod,
+                body: body ?? payloadObj,
+            });
+
+            if (useCache) {
+                const cached = getFromCache({ cacheKey, nowTs: Date.now() });
+                if (cached !== null && cached !== undefined) {
+                    const handled =
+                        typeof onEnd === "function" ? await onEnd(cached, null) : cached;
+                    return { isOk: true, fromCache: true, data: handled, raw: cached };
+                }
+            }
+
+            let queueName = null;
+            if (!disableLoadingApi && loadingApi?.add) {
+                try {
+                    queueName = loadingApi.add({ url: fullUrl, method: finalMethod });
+                } catch (err) {
+                    console.error("[baseFetch] loadingApi.add error:", err);
+                }
+            }
+
+            try {
+                if (cancelled) {
+                    const err = new Error(cancelReason);
+                    err.name = "AbortError";
+                    throw err;
+                }
+
+                onStart?.({ index, url: fullUrl, method: finalMethod, baseStore });
+
+                const resolvedToken = await resolveToken({ disableAuth, token, getTokenFrom });
+
+                if (!disableAuth && !resolvedToken) {
+                    throw new Error("No token provided.");
+                }
+
+                const controller = new AbortController();
+                controllers.push(controller);
+
+                const h = buildHeaders(headers);
+
+                const init = {
+                    method: finalMethod,
+                    credentials: resolvedCredentials,
+                    signal: controller.signal,
+                    headers: h,
+                };
+
+                if (finalMethod !== "GET") {
+                    const finalBody = body ?? payloadObj;
+                    if (finalBody != null) {
+                        if (typeof finalBody === "string" || finalBody instanceof FormData) {
+                            init.body = finalBody;
+                            if (!(finalBody instanceof FormData) && !init.headers["Content-Type"]) {
+                                init.headers["Content-Type"] = "text/plain;charset=UTF-8";
+                            }
+                        } else {
+                            init.body = JSON.stringify(finalBody);
+                            if (!init.headers["Content-Type"]) {
+                                init.headers["Content-Type"] = "application/json";
+                            }
+                        }
+                    }
+                }
+
+                if (!disableAuth && resolvedToken) {
+                    if (!init.headers.Authorization) {
+                        init.headers.Authorization = `Bearer ${resolvedToken}`;
+                    }
+                }
+
+                const r = await fetch(fullUrl, init);
+
+                const ct = r.headers.get("content-type") || "";
+                let parsed;
+                if (ct.includes("application/json")) {
+                    parsed = await r.json().catch(() => null);
+                } else {
+                    parsed = await r.text().catch(() => "");
+                }
+
+                if (!r.ok) {
+                    const err = new Error(`HTTP ${r.status}`);
+                    err.status = r.status;
+                    err.data = parsed;
+                    throw err;
+                }
+
+                const handled = typeof onEnd === "function" ? await onEnd(parsed, null) : parsed;
+
+                if (useCache) {
+                    const ttlMs = Number(cacheTime || 0) * 60 * 1000;
+                    if (ttlMs > 0) addToCache({ cacheKey, data: handled, ttlMs });
+                }
+
+                return { isOk: true, fromCache: false, data: handled, raw: parsed };
+            } catch (err) {
+                const isAbort =
+                    cancelled ||
+                    err?.name === "AbortError" ||
+                    (typeof err?.message === "string" &&
+                        (err.message.includes("aborted") ||
+                            err.message.includes("canceled") ||
+                            err.message.includes("cancel")));
+
+                if (isAbort) {
+                    cancelled = true;
+                    if (!cancelReason) cancelReason = "canceled";
+                    notifyCancelOnce();
+                    return { isOk: false, cancelled: true, error: err };
+                }
+                try {
+                    const data = err?.data;
+                    const msg = resolveErrorMessage({
+                        err,
+                        data,
+                        responseErrorPaths,
+                    });
+
+                    if (msg && typeof msg === "string") {
+                        err.message = msg;
+                    }
+                    err._baseMessage = msg;
+                } catch (e) {
+                    console.error("[baseFetch] resolveErrorMessage failed:", e);
+                }
+
+                let handledErr = err;
+
+                if (typeof onEnd === "function") {
+                    try {
+                        const maybe = await onEnd(null, err);
+                        if (maybe !== undefined) handledErr = maybe;
+                    } catch (e2) {
+                        console.error("[baseFetch] onEnd error handler failed:", e2);
+                    }
+                }
+
+                return { isOk: false, error: handledErr };
+            } finally {
+                if (!disableLoadingApi && queueName && loadingApi?.remove) {
+                    try {
+                        loadingApi.remove(queueName);
+                    } catch (err) {
+                        console.error("[baseFetch] loadingApi.remove error:", err);
+                    }
+                }
+            }
+        };
+
+        const isSingle = calls.length === 1;
+
+        if (isSingle) {
+            const r = await runOneCall(calls[0], 0, []);
+
+            if (r.cancelled || cancelled) {
+                const res = { isOk: false, status: "canceled" };
+                return res;
+            }
+
+            if (r.isOk) {
+                const res = { isOk: true, status: "success", response: r.data };
+                onSuccess?.(res);
+                return res;
+            }
+
+            errors.push({ index: 0, error: r.error });
+            const res = { isOk: false, status: "error", response: null, errors };
+            onError?.(res);
+            return res;
+        }
+
+        if (enableSynchronousCalls) {
+            for (let i = 0; i < calls.length; i++) {
+                if (cancelled) break;
+
+                const r = await runOneCall(calls[i], i, results);
+
+                if (r.cancelled || cancelled) {
+                    cancelled = true;
+                    break;
+                }
+
+                if (r.isOk) {
+                    results.push(r.data);
+                    responses.push(r.data);
+                } else {
+                    errors.push({ index: i, error: r.error });
+                    break;
+                }
+            }
+        } else {
+            const all = await Promise.all(calls.map((c, i) => runOneCall(c, i, [])));
+
+            all.forEach((r, i) => {
+                if (r.cancelled) cancelled = true;
+                if (r.isOk) responses.push(r.data);
+                else if (!r.cancelled) errors.push({ index: i, error: r.error });
+            });
+        }
+
+        if (cancelled) {
+            const res = { isOk: false, status: "canceled" };
+            return res;
+        }
+
+        const isOk = errors.length === 0;
+
+        const finalRes = {
+            isOk,
+            status: isOk ? "success" : "error",
+            responses,
+            ...(errors.length ? { errors } : {}),
+        };
+
+        if (isOk) onSuccess?.(finalRes);
+        else onError?.(finalRes);
+
+        return finalRes;
+    })();
+
+    return { promise, cancelFetch };
+};

package/src/libs/baseForm/BaseForm.jsx

@@ -0,0 +1,19 @@
+import styled from "styled-components";
+
+const S = {
+    container: styled.div`
+        width: 100%;
+        height: 100%;
+        position: relative;
+        display: flex;
+        flex-direction: column;
+        gap: 10rem;
+    `,
+};
+
+export const BaseForm = ({ StyledContainer, children }) => {
+    const SelectedContainer = StyledContainer || S.container;
+
+    /* Return */
+    return <SelectedContainer>{children}</SelectedContainer>;
+};