[feat] Initial code

src/api/_APITool/Header.ts

@@ -0,0 +1,24 @@
+import { HeaderContent } from './types';
+
+class Header {
+  public header: HeaderContent;
+
+  constructor() {
+    this.header = {};
+  }
+
+  updateToken(token: string): void {
+    this.header = {
+      ...this.header,
+      Authorization: `Bearer ${token}`,
+    };
+  }
+
+  removeToken(): void {
+    if ('Authorization' in this.header) {
+      delete this.header.Authorization;
+    }
+  }
+}
+
+export default Header;

src/api/_APITool/index.ts

@@ -0,0 +1,5 @@
+import axios, { AxiosInstance } from 'axios';
+
+export const createAxios = ({ host }: { host: string }): AxiosInstance => axios.create({
+    baseURL: host,
+  });

src/api/_APITool/types.d.ts

@@ -0,0 +1,3 @@
+export interface HeaderContent {
+  Authorization?: string;
+}

src/api/index.ts

@@ -0,0 +1,49 @@
+import { AxiosInstance } from 'axios';
+import { getIsJwtToken, getIsJwtTokenExpire } from '@Tools/utility';
+import Header from './_APITool/Header';
+import { createAxios } from './_APITool';
+import { CreatUserAPI } from './user-apis';
+import { UserAPIProps } from './user-apis/types';
+import { APIParams } from './types';
+
+class API {
+  private axios: AxiosInstance;
+
+  public baseHeader: Header;
+
+  public baseToken: string;
+
+  public user: UserAPIProps;
+
+  constructor({ host }: APIParams) {
+    this.axios = createAxios({ host });
+    this.baseHeader = new Header();
+    this.baseToken = '';
+    this.user = CreatUserAPI({ axios: this.axios, header: this.baseHeader });
+  }
+
+  updateAccessToken = (token: string): void => {
+    this.baseHeader.updateToken(token);
+    this.baseToken = token;
+  };
+
+  removeAccessToken = (): void => {
+    this.baseHeader.removeToken();
+    this.baseToken = '';
+  };
+
+  checkAccessTokenValid = async (): Promise<boolean> => {
+    const isJwtToken = await getIsJwtToken(this.baseToken);
+    return isJwtToken;
+  };
+
+  checkAccessTokenExpired = async (expiredTime = 0): Promise<boolean> => {
+    const isJwtToken = await this.checkAccessTokenValid();
+    if (isJwtToken) {
+      return getIsJwtTokenExpire(this.baseToken, expiredTime);
+    }
+    return true;
+  };
+}
+
+export default API;

src/api/types.d.ts

@@ -0,0 +1,3 @@
+export interface APIParams {
+  host: string;
+}

src/api/user-apis/index.ts

@@ -0,0 +1,79 @@
+import { AxiosInstance } from 'axios';
+import Header from '../_APITool/Header';
+import {
+  UserAPIProps,
+  PostUserRefreshAPIPromise,
+  GetUserSingleSignInAPIPromise,
+  GetUserAccountInfoAPIPromise,
+  PostUserSignOutAPIPromise,
+} from './types';
+
+export function CreatUserAPI({ axios, header }: { axios: AxiosInstance; header: Header }): UserAPIProps {
+  return {
+    getUserSSO: async (backUrl: string): Promise<GetUserSingleSignInAPIPromise> => {
+      try {
+        const res = await axios.get('/account/login/sso', {
+          params: {
+            back_url: backUrl,
+          },
+        });
+        return res.data;
+      } catch (error) {
+        const errorMessage = {
+          url: '',
+          error: error.response?.data,
+        } as GetUserSingleSignInAPIPromise;
+        return errorMessage;
+      }
+    },
+    postUserRefreshToken: async (): Promise<PostUserRefreshAPIPromise> => {
+      try {
+        const res = await axios.post('/account/refresh_token', undefined, {
+          headers: { ...header.header },
+        });
+        return res.data;
+      } catch (error) {
+        const errorMessage = {
+          token: '',
+          error: error.response?.data,
+        };
+        return errorMessage;
+      }
+    },
+    getUserAccountInfo: async (): Promise<GetUserAccountInfoAPIPromise> => {
+      try {
+        const res = await axios.get('/account', {
+          headers: { ...header.header },
+        });
+        return res.data;
+      } catch (error) {
+        const errorMessage = {
+          account: {
+            _id: '',
+            username: '',
+            email: '',
+            display_name: '',
+            createdAt: '',
+            updatedAt: '',
+            error: error.response?.data,
+          },
+        };
+        return errorMessage;
+      }
+    },
+    postUserSignOut: async (): Promise<PostUserSignOutAPIPromise> => {
+      try {
+        const res = await axios.post('/account/logout', undefined, {
+          headers: { ...header.header },
+        });
+        return res.data;
+      } catch (error) {
+        const errorMessage = {
+          url: '',
+          error: error.response?.data,
+        };
+        return errorMessage;
+      }
+    },
+  };
+}

src/api/user-apis/types.d.ts

@@ -0,0 +1,27 @@
+import { APIError } from '@Models/GeneralTypes';
+import {
+  UserTokenInfo,
+  UserSignInInfo,
+  UserOAuthUrl,
+  UserSignOutUrl,
+} from '@Models/Redux/User/types';
+
+export interface GetUserSingleSignInAPIPromise extends UserOAuthUrl {
+  error?: APIError;
+}
+export interface PostUserRefreshAPIPromise extends UserTokenInfo {
+  error?: APIError;
+}
+export interface GetUserAccountInfoAPIPromise extends UserSignInInfo {
+  error?: APIError;
+}
+export interface PostUserSignOutAPIPromise extends UserSignOutUrl {
+  error?: APIError;
+}
+
+export interface UserAPIProps {
+  getUserSSO: (backUrl: string) => Promise<GetUserSingleSignInAPIPromise>;
+  postUserRefreshToken: () => Promise<PostUserRefreshAPIPromise>;
+  getUserAccountInfo: () => Promise<GetUserAccountInfoAPIPromise>;
+  postUserSignOut: () => Promise<PostUserSignOutAPIPromise>;
+}