celestya 0.1.0 → 0.3.0

package/README.md

@@ -136,6 +136,10 @@ const Home = async () => {
 export default Navbar;
 ```
 
+## How to upload to npm
+
+
+
 ## Todo
 
 - [x]: Change returns at error
@@ -143,6 +147,6 @@ export default Navbar;
 - [x]: POST request with auth
 - [x]: Fix issue with getSession serverside and config set at layout (If used at api/\_/route.tsx)
 - [x]: Fix issue with api endpoints if no layout has been loaded (if accessing api directly)
+- [X]: Refresh logic
+- [X]: Fix Response types
 - [ ]: Upload request with worker as helper (?)
-- [ ]: Refresh logic
-- [ ]: Fix Response types

package/dist/client/index.d.mts

@@ -1,5 +1,62 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
+type BaseError = {
+    error: string;
+    message: string;
+};
+type Success<S> = {
+    data: S;
+};
+/**
+ * A Result type that represents either a successful value (Ok) or an error (Err).
+ * This is a discriminated union type that helps handle errors in a type-safe way.
+ *
+ * @template T - The type of the successful value
+ * @template E - The type of the error, must extend BaseError
+ */
+type Result<T, E extends BaseError> = Ok<T, E> | Err<T, E>;
+type IResult<T, E extends BaseError> = {
+    /**
+     * Checks if the `Result` is an `Ok` instance
+     */
+    isOk: () => this is Ok<T, E>;
+    /**
+     * Checks if the `Result` is an `Err` instance.
+     */
+    isErr: () => this is Err<T, E>;
+};
+/**
+ * Represents a successful `Result` value.
+ *
+ * @template T - The type of the successful value.
+ * @template E - The type of the error, must extend `BaseError`.
+ */
+declare class Ok<T, E extends BaseError> implements IResult<T, E> {
+    value: Success<T>;
+    constructor(value: Success<T>);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+}
+/**
+ * Represents an error `Result` value.
+ *
+ * @template T - The type of the successful value.
+ * @template E - The type of the error, must extend `BaseError`.
+ */
+declare class Err<T, E extends BaseError> implements IResult<T, E> {
+    error: E;
+    constructor(error: E);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+}
+
+type CallbackOptions = {
+    method: "GET" | "POST" | "DELETE";
+    url: string;
+    body?: object;
+};
+type WrapperFunction = <T>(data: CallbackOptions) => Promise<Result<T, BaseError>>;
+
 declare module "iron-session" {
     interface IronSessionData<U, T> {
         user?: U;
@@ -26,15 +83,6 @@ interface IOAuthData {
     oAuthUrl: string;
     onErrorUrl?: string;
 }
-interface IResponseError {
-    error: string;
-    message: string;
-}
-interface IResponseSuccess<T, U> {
-    error: null;
-    data: T;
-    details: U;
-}
 interface IAuthContext<U> {
     isLoggedIn: boolean;
     ready: boolean;
@@ -44,9 +92,21 @@ interface IAuthContext<U> {
     oAuth: (data: IOAuthData) => Promise<string>;
     logout: () => Promise<string>;
     refreshUser: (force?: boolean) => Promise<void>;
-    get: <T, U = any>(url: string) => Promise<ResponseType<T, U>>;
-    post: <T, U = any>(url: string, body: any) => Promise<ResponseType<T, U>>;
-    del: <T, U = any>(url: string) => Promise<ResponseType<T, U>>;
+    get: <T>(props: {
+        url: string;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    post: <T>(props: {
+        url: string;
+        body: object;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    del: <T>(props: {
+        url: string;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    setHeader: (key: string, value: string) => void;
+    removeHeader: (key: string) => void;
 }
 interface IAuthContextOptions {
     children: React.ReactNode;
@@ -55,12 +115,14 @@ interface IAuthContextOptions {
 interface IChildProps {
     children?: React.ReactNode;
 }
-type ResponseType<T, U = any> = IResponseError | IResponseSuccess<T, U>;
 
-type LogoutProps = React.FC<React.ComponentProps<'div'> & IChildProps>;
+type LogoutProps = React.FC<React.ComponentProps<"div"> & IChildProps>;
+
+declare const useAuth: () => IAuthContext<any>;
+
+declare const APIWrapper: <T>(wrapperFunction: (cb: WrapperFunction) => T) => () => T;
 
 declare const AuthProvider: <IU>({ children, routePrefix, }: IAuthContextOptions) => react_jsx_runtime.JSX.Element;
 declare const Logout: LogoutProps;
-declare const useAuth: () => IAuthContext<any>;
 
-export { AuthProvider, Logout, useAuth };
+export { APIWrapper, AuthProvider, Logout, useAuth };

package/dist/client/index.d.ts

@@ -1,5 +1,62 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
+type BaseError = {
+    error: string;
+    message: string;
+};
+type Success<S> = {
+    data: S;
+};
+/**
+ * A Result type that represents either a successful value (Ok) or an error (Err).
+ * This is a discriminated union type that helps handle errors in a type-safe way.
+ *
+ * @template T - The type of the successful value
+ * @template E - The type of the error, must extend BaseError
+ */
+type Result<T, E extends BaseError> = Ok<T, E> | Err<T, E>;
+type IResult<T, E extends BaseError> = {
+    /**
+     * Checks if the `Result` is an `Ok` instance
+     */
+    isOk: () => this is Ok<T, E>;
+    /**
+     * Checks if the `Result` is an `Err` instance.
+     */
+    isErr: () => this is Err<T, E>;
+};
+/**
+ * Represents a successful `Result` value.
+ *
+ * @template T - The type of the successful value.
+ * @template E - The type of the error, must extend `BaseError`.
+ */
+declare class Ok<T, E extends BaseError> implements IResult<T, E> {
+    value: Success<T>;
+    constructor(value: Success<T>);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+}
+/**
+ * Represents an error `Result` value.
+ *
+ * @template T - The type of the successful value.
+ * @template E - The type of the error, must extend `BaseError`.
+ */
+declare class Err<T, E extends BaseError> implements IResult<T, E> {
+    error: E;
+    constructor(error: E);
+    isOk(): this is Ok<T, E>;
+    isErr(): this is Err<T, E>;
+}
+
+type CallbackOptions = {
+    method: "GET" | "POST" | "DELETE";
+    url: string;
+    body?: object;
+};
+type WrapperFunction = <T>(data: CallbackOptions) => Promise<Result<T, BaseError>>;
+
 declare module "iron-session" {
     interface IronSessionData<U, T> {
         user?: U;
@@ -26,15 +83,6 @@ interface IOAuthData {
     oAuthUrl: string;
     onErrorUrl?: string;
 }
-interface IResponseError {
-    error: string;
-    message: string;
-}
-interface IResponseSuccess<T, U> {
-    error: null;
-    data: T;
-    details: U;
-}
 interface IAuthContext<U> {
     isLoggedIn: boolean;
     ready: boolean;
@@ -44,9 +92,21 @@ interface IAuthContext<U> {
     oAuth: (data: IOAuthData) => Promise<string>;
     logout: () => Promise<string>;
     refreshUser: (force?: boolean) => Promise<void>;
-    get: <T, U = any>(url: string) => Promise<ResponseType<T, U>>;
-    post: <T, U = any>(url: string, body: any) => Promise<ResponseType<T, U>>;
-    del: <T, U = any>(url: string) => Promise<ResponseType<T, U>>;
+    get: <T>(props: {
+        url: string;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    post: <T>(props: {
+        url: string;
+        body: object;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    del: <T>(props: {
+        url: string;
+        headers?: Record<string, string>;
+    }) => Promise<Result<T, BaseError>>;
+    setHeader: (key: string, value: string) => void;
+    removeHeader: (key: string) => void;
 }
 interface IAuthContextOptions {
     children: React.ReactNode;
@@ -55,12 +115,14 @@ interface IAuthContextOptions {
 interface IChildProps {
     children?: React.ReactNode;
 }
-type ResponseType<T, U = any> = IResponseError | IResponseSuccess<T, U>;
 
-type LogoutProps = React.FC<React.ComponentProps<'div'> & IChildProps>;
+type LogoutProps = React.FC<React.ComponentProps<"div"> & IChildProps>;
+
+declare const useAuth: () => IAuthContext<any>;
+
+declare const APIWrapper: <T>(wrapperFunction: (cb: WrapperFunction) => T) => () => T;
 
 declare const AuthProvider: <IU>({ children, routePrefix, }: IAuthContextOptions) => react_jsx_runtime.JSX.Element;
 declare const Logout: LogoutProps;
-declare const useAuth: () => IAuthContext<any>;
 
-export { AuthProvider, Logout, useAuth };
+export { APIWrapper, AuthProvider, Logout, useAuth };

package/dist/client/index.js

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client/index.ts
 var client_exports = {};
 __export(client_exports, {
+  APIWrapper: () => APIWrapper,
   AuthProvider: () => AuthProvider,
   Logout: () => Logout,
   useAuth: () => useAuth
@@ -30,38 +31,86 @@ module.exports = __toCommonJS(client_exports);
 // src/client/contextProvider.tsx
 var import_react = require("react");
 
-// src/client/request.ts
-async function gFetch({
-  url,
-  options
-}) {
-  const response = await fetch(url, {
-    method: "GET",
-    ...options
-  });
-  return await response.json();
+// src/types/response.ts
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return false;
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return true;
+  }
+};
+function ok(value) {
+  return new Ok(value);
 }
-async function pFetch({
-  url,
-  body
-}) {
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  return await response.json();
+function err(error) {
+  return new Err(error);
 }
-async function dFetch({
+
+// src/client/request.ts
+var clientSideFetch = async ({
   url,
-  options
-}) {
-  const response = await fetch(url, {
-    method: "DELETE",
+  method = "GET",
+  body,
+  ...options
+}) => {
+  const opts = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    },
     ...options
-  });
-  return await response.json();
-}
+  };
+  try {
+    if (body) opts.body = JSON.stringify(body);
+  } catch (e) {
+    return err({
+      error: "PARSE_ERROR",
+      message: "Failed to parse request body as JSON"
+    });
+  }
+  try {
+    const response = await fetch(url, opts);
+    if (!response.ok) {
+      return err({
+        error: "RESPONSE_ERROR",
+        message: `HTTP error! status: ${response.status}`
+      });
+    }
+    try {
+      const res = await response.json();
+      if (res.error !== void 0) {
+        return err(res);
+      }
+      return ok(res);
+    } catch (e) {
+      return err({
+        error: "PARSE_ERROR",
+        message: "Failed to parse response as JSON"
+      });
+    }
+  } catch (e) {
+    return err({
+      error: "FETCH_ERROR",
+      message: "Failed to fetch the resource: " + String(e)
+    });
+  }
+};
 
 // src/client/contextProvider.tsx
 var import_navigation = require("next/navigation");
@@ -75,6 +124,13 @@ var AuthContextProvider = ({
   const [ready, setReady] = (0, import_react.useState)(false);
   const [user, setUser] = (0, import_react.useState)({});
   const router = (0, import_navigation.useRouter)();
+  const customHeaders = (0, import_react.useRef)({});
+  const setHeader = (0, import_react.useCallback)((key, value) => {
+    customHeaders.current[key] = value;
+  }, []);
+  const removeHeader = (0, import_react.useCallback)((key) => {
+    delete customHeaders.current[key];
+  }, []);
   const loginRoute = routePrefix + "/login";
   const registerRoute = routePrefix + "/register";
   const logoutRoute = routePrefix + "/logout";
@@ -82,104 +138,98 @@ var AuthContextProvider = ({
   const oAuthRoute = routePrefix + "/oauth";
   const proxyRoute = routePrefix + "/proxy";
   const login = async (loginData) => {
-    try {
-      const res = await pFetch({
-        url: loginRoute,
-        body: loginData.data
-      });
-      setIsLoggedIn(true);
-      if (res.error) throw new Error(res.message);
-      return loginData.redirect || "/";
-    } catch (e) {
-      return `${loginData.onErrorUrl || "/"}?error=${e.message}`;
+    const res = await clientSideFetch({
+      url: loginRoute,
+      body: loginData.data
+    });
+    if (res.isErr()) {
+      return `${loginData.onErrorUrl || "/"}?error=${res.error.error}`;
     }
+    setIsLoggedIn(true);
+    return loginData.redirect || "/";
   };
   const register = async (registerData) => {
-    try {
-      const res = await pFetch({
-        url: registerRoute,
-        body: registerData.data
-      });
-      if (res.error) throw new Error(res.message);
-      return `${registerData.redirect || "/"}?success=true`;
-    } catch (e) {
-      return `${registerData.onErrorUrl || "/"}?error=${e.message}`;
+    const res = await clientSideFetch({
+      url: registerRoute,
+      body: registerData.data
+    });
+    if (res.isErr()) {
+      return `${registerData.onErrorUrl || "/"}?error=${res.error.error}`;
     }
+    return `${registerData.redirect || "/"}?success=true`;
   };
   const oAuth = async ({
     state,
     oAuthUrl,
     onErrorUrl
   }) => {
-    try {
-      const url = new URL(oAuthRoute, "http://localhost/");
-      url.searchParams.set("authUrl", oAuthUrl);
-      if (state && state !== "/") url.searchParams.set("state", state);
-      const response = await gFetch({ url: url.pathname + url.search });
-      return response.data;
-    } catch (e) {
-      return `${onErrorUrl || "/"}?error=${e.message}`;
+    const url = new URL(oAuthRoute, "http://localhost/");
+    url.searchParams.set("authUrl", oAuthUrl);
+    if (state && state !== "/") url.searchParams.set("state", state);
+    const response = await clientSideFetch({
+      url: url.pathname + url.search
+    });
+    if (response.isErr()) {
+      return `${onErrorUrl || "/"}?error=${response.error.message}`;
     }
+    return response.value.data;
   };
   const logout = async () => {
-    try {
-      const data = await gFetch({
-        url: logoutRoute,
-        options: { cache: "no-store" }
-      });
-      setIsLoggedIn(false);
-      setUser({});
-      return data.data;
-    } catch (e) {
-      console.log(e);
+    const data = await clientSideFetch({
+      url: logoutRoute,
+      cache: "no-store"
+    });
+    if (data.isErr()) {
       return "/";
     }
+    setIsLoggedIn(false);
+    setUser({});
+    return data.value.data;
   };
   const refreshUser = async (force) => {
-    try {
-      const data = await gFetch({
-        url: `${userRoute}${force ? "?force=true" : ""}`,
-        options: { cache: "no-store" }
-      });
-      if (!data.error) {
-        setUser(data.data);
-        setIsLoggedIn(true);
-      } else {
-        setUser({});
-        setIsLoggedIn(false);
-      }
-      setReady(true);
-      router.refresh();
-    } catch (e) {
-      console.log("refreshUser error: ", e);
+    const data = await clientSideFetch({
+      url: `${userRoute}${force ? "?force=true" : ""}`,
+      cache: "no-store"
+    });
+    if (data.isErr()) {
+      setUser({});
+      setIsLoggedIn(false);
+    } else {
+      setUser(data.value.data);
     }
+    setReady(true);
+    router.refresh();
   };
-  const get = async (url) => {
-    try {
-      const r = await gFetch({ url: `${proxyRoute}${url}` });
-      return r;
-    } catch (e) {
-      return { error: "getRequestError", message: e.message };
-    }
+  const get = async ({
+    url,
+    headers
+  }) => {
+    return clientSideFetch({
+      url: `${proxyRoute}${url}`,
+      headers: { ...customHeaders.current, ...headers }
+    });
   };
-  const post = async (url, body) => {
-    try {
-      const r = await pFetch({
-        url: `${proxyRoute}${url}`,
-        body
-      });
-      return r;
-    } catch (e) {
-      return { error: "getRequestError", message: e.message };
-    }
+  const post = async ({
+    url,
+    body,
+    headers
+  }) => {
+    return clientSideFetch({
+      method: "POST",
+      url: `${proxyRoute}${url}`,
+      body,
+      headers: { ...customHeaders.current, ...headers }
+    });
   };
-  const del = async (url) => {
-    try {
-      const r = await dFetch({ url: `${proxyRoute}${url}` });
-      return r;
-    } catch (e) {
-      return { error: "getRequestError", message: e.message };
-    }
+  const del = async ({
+    url,
+    headers
+  }) => {
+    return clientSideFetch({
+      method: "DELETE",
+      url: `${proxyRoute}${url}`,
+      headers: { ...customHeaders.current, ...headers }
+    });
   };
   (0, import_react.useEffect)(() => {
     if (!ready) refreshUser();
@@ -195,24 +245,19 @@ var AuthContextProvider = ({
     oAuth,
     get,
     post,
-    del
+    del,
+    setHeader,
+    removeHeader
     /* upload, */
   };
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: provider, children });
 };
 var contextProvider_default = AuthContextProvider;
 
-// src/client/useAuth.ts
-var import_react2 = require("react");
-var useAuthContext = () => {
-  return (0, import_react2.useContext)(AuthContext);
-};
-var useAuth_default = useAuthContext;
-
 // src/client/Logout.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var LogoutComponent = ({ children, ...props }) => {
-  const { logout } = useAuth_default();
+  const { logout } = useAuth();
   const handleLogout = async (e) => {
     e.preventDefault();
     await logout();
@@ -221,12 +266,39 @@ var LogoutComponent = ({ children, ...props }) => {
 };
 var Logout_default = LogoutComponent;
 
+// src/client/useAuth.ts
+var import_react2 = require("react");
+var useAuth = () => {
+  return (0, import_react2.useContext)(AuthContext);
+};
+
+// src/client/useAPIWrapper.tsx
+var import_react3 = require("react");
+var APIWrapper = (wrapperFunction) => {
+  return () => {
+    const { get, post, del } = (0, import_react3.useContext)(AuthContext);
+    return wrapperFunction(async (data) => {
+      const { method, url, body } = data;
+      switch (method) {
+        case "GET":
+          return get({ url });
+        case "POST":
+          return post({ url, body: body != null ? body : {} });
+        case "DELETE":
+          return del({ url });
+        default:
+          throw new Error("Unsupported method type");
+      }
+    });
+  };
+};
+
 // src/client/index.ts
 var AuthProvider = contextProvider_default;
 var Logout = Logout_default;
-var useAuth = useAuth_default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIWrapper,
   AuthProvider,
   Logout,
   useAuth