abbot-http-client 0.0.1

package/README.md

@@ -0,0 +1,113 @@
+
+# ABBOT-HTTP-CLIENT
+
+This package will provide you an Axios-like experience with customized request and response interceptors. Right now, we only have 2 modified methods available, which are POST and GET, and 1 customized method, which is uploadFile.
+
+
+
+
+## Installation
+
+Install abbot-http-client with npm
+
+```bash
+  npm install abbot-http-client
+```
+
+Install abbot-http-client with yarn
+
+```bash
+  yarn add abbot-http-client
+```
+    
+## Run locally
+
+Clone the project
+
+```bash
+  git clone git@gitlabsvr.abbot.tech:module/abbot-http-client.git
+```
+
+Go to the project directory
+
+```bash
+  cd abbot-http-client
+```
+
+Install dependencies with yarn
+
+```bash
+  yarn
+```
+
+Create locally packe link with yarn
+
+```bash
+  yarn link
+```
+
+Link this package to your project to test
+
+```bash
+  cd ./your/project/path
+
+  yarn link abbot-http-client
+```
+
+
+## Usage and Examples
+
+Create instance
+```javascript
+// config.js
+// config.ts
+import { create } from "abbot-http-client";
+
+// you can use dotenv package in this file
+
+const coreHttp = create({
+    axios: {
+        baseUrl: "", // your baseUrl
+        timeout: 5000,
+    },
+    app: {
+        timezone: "Asia/Bangkok", // your timezone
+        apiKey: "", // your API Key
+    }
+})
+
+export default coreHttp
+```
+
+Use instance in Your class
+```typescript
+// restHandler.ts
+import coreHttp from "./path/to/your/config.ts";
+
+...
+
+// get user credential from your store provider
+// user object has to contain key and token
+// key means encryption key
+// token means authorization token (Bearer token)
+// this uer object can be null
+const { user } = getState()
+
+try {
+    const response = await coreHttp.post<ResType>(user, url, parameter)
+    return response
+} catch(err: any) {
+    // err will have type of AxiosError with response
+    console.error(err)
+}
+
+...
+```
+## Deployment (not supported yet)
+
+To publish this project to NPM run
+
+```bash
+  npm run publish
+```
+

package/dist/index.cjs

@@ -0,0 +1,384 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  catchError: () => catchError,
+  create: () => create
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/catchError.ts
+async function catchError(promise, errorToCatch) {
+  return promise.then((data) => [void 0, data]).catch((error) => {
+    if (errorToCatch === void 0) return [error];
+    if (errorToCatch.some((e) => error instanceof e)) return [error];
+    throw error;
+  });
+}
+
+// src/http.ts
+var import_axios2 = require("axios");
+
+// src/encryption/secure.ts
+var Secure = class {
+  static keySize = 16;
+  static a = 5;
+  static b = 9;
+  static char = "0123456789";
+  static createId = () => {
+    const keyId = Array(this.keySize).fill("").map(() => {
+      const value = Math.floor(Math.random() * 10);
+      return this.char[value];
+    });
+    return keyId.join("");
+  };
+  static createKey = (keyId) => {
+    const crKey = Array(this.keySize).fill("").map((_, i) => Number(this.a ** Number(keyId[i]) % this.b));
+    return crKey.join("");
+  };
+  static toBase64Length16 = (text) => {
+    if (text && text.length) {
+      const b64 = Buffer.from(encodeURI(text)).toString("base64");
+      return b64.substring(0, 16);
+    }
+    return "";
+  };
+};
+
+// src/encryption/cryp.ts
+var import_crypto_ts = require("crypto-ts");
+
+// src/encryption/es.ts
+var ES = class {
+  static e(value) {
+    return Array.from(value).map((c) => c.charCodeAt(0)).reverse().map((e, i) => i % 2 === 0 ? e + 1 : e - 1).map((e, i) => i % 3 === 0 ? e * 2 : e);
+  }
+  static d(value) {
+    const result = value.map((e, i) => i % 3 === 0 ? Math.round(e / 2) : e).map((e, i) => i % 2 === 0 ? e - 1 : e + 1);
+    return String.fromCharCode.apply(null, result.reverse());
+  }
+  static a2b(value) {
+    const charactors = "abcdefghijklmnopqrstuvwxyz";
+    const randomChar = (max) => Math.floor(Math.random() * max);
+    const result = value.map(
+      (e, i) => `${String(e)}${i === value.length - 1 ? "" : charactors[randomChar(26)]}`
+    ).join("");
+    return result;
+  }
+  static b2a(value) {
+    if (!value) return [];
+    const result = value.split(/[a-z]/);
+    return result.map((e) => Number(e));
+  }
+};
+
+// src/encryption/cryp.ts
+var Cryp = class {
+  ivText;
+  key;
+  keyBuffer;
+  iv;
+  algConfig;
+  constructor(cryptProps) {
+    this.ivText = cryptProps.iv;
+    this.key = cryptProps.keyValue ? cryptProps.keyValue : ES.d(ES.b2a(getConfig().app?.apiKey));
+    this.keyBuffer = import_crypto_ts.enc.Utf8.parse(this.key);
+    this.iv = import_crypto_ts.enc.Utf8.parse(this.ivText);
+    this.algConfig = { mode: import_crypto_ts.mode.CBC, padding: import_crypto_ts.pad.PKCS7, iv: this.iv };
+  }
+  encrypt(textValue) {
+    if (!textValue) return "";
+    if (!textValue.length) return textValue;
+    const cipher = import_crypto_ts.AES.encrypt(textValue, this.keyBuffer, this.algConfig);
+    return cipher.toString();
+  }
+  decrypt(encryptedValue) {
+    try {
+      if (!encryptedValue || !encryptedValue.length) return null;
+      const decryptValue = import_crypto_ts.AES.decrypt(
+        encryptedValue,
+        this.keyBuffer,
+        this.algConfig
+      );
+      const decryptData = decryptValue.toString(import_crypto_ts.enc.Utf8);
+      const jsonData = JSON.parse(decryptData);
+      return jsonData;
+    } catch (err) {
+      console.error(err);
+      return null;
+    }
+  }
+};
+
+// src/config/axiosFn.ts
+var import_axios = __toESM(require("axios"), 1);
+function axiosConf(cfg2) {
+  const axiosObj = import_axios.default.create({
+    baseURL: cfg2.axios?.baseUrl,
+    headers: {
+      common: {
+        Accept: cfg2.axios?.headers?.accept,
+        "Accept-Language": cfg2.axios?.headers?.lang
+      },
+      post: {
+        "Content-Type": cfg2.axios?.headers?.post?.contentType
+      }
+    },
+    timeout: cfg2.axios?.timeout,
+    withCredentials: true
+  });
+  return axiosObj;
+}
+
+// src/http.ts
+var CoreHttp = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  createAxiosInstance(user) {
+    const axios2 = axiosConf(this.config);
+    const iv = Secure.createId();
+    const cryp = new Cryp({
+      iv,
+      keyValue: user.key
+    });
+    axios2.interceptors.request.use(
+      (config) => {
+        const req = { ...config };
+        if (config.method && config.method.toLowerCase() === "post") {
+          if (config.data) {
+            if (config.data instanceof FormData) {
+              if (config.data.get("param")) {
+                config.data.set(
+                  "param",
+                  cryp.encrypt(config.data.get("param")?.toString())
+                );
+              }
+            } else {
+              const payload = {};
+              payload.param = cryp.encrypt(JSON.stringify(config.data));
+              const body = payload ? new URLSearchParams(payload).toString() : "";
+              req.data = body;
+              req.headers.setContentType("application/x-www-form-urlencoded");
+            }
+          }
+        }
+        req.headers.set("data-code", iv);
+        if (user.token) {
+          req.headers.setAuthorization(`Bearer ${user.token}`);
+        }
+        return req;
+      },
+      (error) => Promise.reject(error)
+    );
+    axios2.interceptors.response.use(
+      (response) => {
+        const res = { ...response };
+        res.data = cryp.decrypt(response.data);
+        return res.data;
+      },
+      (error) => {
+        const err = {
+          message: error.message,
+          code: error.code,
+          config: error.config,
+          request: error.request
+        };
+        if (error.response) {
+          if (error.response.data) {
+            const response = cryp.decrypt(error.response.data);
+            err.response = response;
+            return Promise.reject(
+              new import_axios2.AxiosError(
+                err.message,
+                err.code,
+                err.config,
+                err.request,
+                err.response
+              )
+            );
+          } else {
+            err.response = {
+              status: "error",
+              code: error.response.status,
+              message: error.message,
+              data: null
+            };
+            return Promise.reject(
+              new import_axios2.AxiosError(
+                err.message,
+                err.code,
+                err.config,
+                err.request,
+                err.response
+              )
+            );
+          }
+        } else if (error.request) {
+          err.response = {
+            status: "error",
+            code: 0,
+            message: "No response received",
+            data: null
+          };
+          return Promise.reject(
+            new import_axios2.AxiosError(
+              err.message,
+              err.code,
+              err.config,
+              err.request,
+              err.response
+            )
+          );
+        } else {
+          err.response = {
+            status: "error",
+            code: 0,
+            message: error.message,
+            data: null
+          };
+          return Promise.reject(
+            new import_axios2.AxiosError(
+              err.message,
+              err.code,
+              err.config,
+              err.request,
+              err.response
+            )
+          );
+        }
+      }
+    );
+    return axios2;
+  }
+  async post(param1, url, param) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const response = await axios2.post(url, param);
+    return response;
+  }
+  async get(param1, url) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const response = await axios2.get(url);
+    return response;
+  }
+  async uploadFile(param1, url, file, param2, param3) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const formData = new FormData();
+    if (param2 instanceof Array) {
+      if (file instanceof Array) {
+        param2.forEach((k, i) => {
+          formData.append(k, file[i]);
+        });
+      } else {
+        formData.append("file", file);
+      }
+    } else {
+      if (param2) {
+        formData.append("param", JSON.stringify(param2));
+      }
+    }
+    if (param3) {
+      formData.append("param", JSON.stringify(param3));
+    }
+    const response = await axios2.post(url, formData);
+    return response;
+  }
+};
+
+// src/config/core.ts
+var cfg = {
+  axios: {
+    baseUrl: "",
+    timeout: 5e3,
+    headers: {
+      accept: "*/*",
+      lang: "TH",
+      post: {
+        contentType: "application/x-www-form-urlencoded"
+      }
+    }
+  },
+  app: {
+    redirectUrl: "/login",
+    apiKey: "",
+    timezone: "Asia/Bangkok"
+  }
+};
+function getConfig() {
+  return cfg;
+}
+function create(config) {
+  cfg = { ...cfg, ...config };
+  const http = new CoreHttp(cfg);
+  return http;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  catchError,
+  create
+});

package/dist/index.d.cts

@@ -0,0 +1,43 @@
+import { AxiosResponse } from 'axios';
+
+declare function catchError<T, E extends new (err?: any) => Error>(promise: Promise<T>, errorToCatch?: E[]): Promise<[undefined, T] | [InstanceType<E>]>;
+
+interface credential {
+    key: string | undefined;
+    token: string | undefined;
+}
+declare class CoreHttp {
+    private config;
+    constructor(config: AbbotConfig);
+    private createAxiosInstance;
+    post<T, U extends credential = credential>(middleware: () => U | null, url: string, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    post<T, U extends credential = credential>(user: U | null, url: string, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    get<T, U extends credential = credential>(middleware: () => U | null, url: string): Promise<AxiosResponse<T>>;
+    get<T, U extends credential = credential>(user: U | null, url: string): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(middleware: () => U | null, url: string, file: File, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(middleware: () => U | null, url: string, file: File[], fileKeys: string[], param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(user: U | null, url: string, file: File, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(user: U | null, url: string, file: File[], fileKeys: string[], param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+}
+
+interface AbbotConfig {
+    axios?: {
+        baseUrl?: string;
+        headers?: {
+            accept?: string;
+            lang?: string;
+            post?: {
+                contentType?: string;
+            };
+        };
+        timeout?: number;
+    };
+    app?: {
+        redirectUrl?: string;
+        apiKey?: string;
+        timezone?: string;
+    };
+}
+declare function create(config: AbbotConfig): CoreHttp;
+
+export { type AbbotConfig, catchError, create };

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { AxiosResponse } from 'axios';
+
+declare function catchError<T, E extends new (err?: any) => Error>(promise: Promise<T>, errorToCatch?: E[]): Promise<[undefined, T] | [InstanceType<E>]>;
+
+interface credential {
+    key: string | undefined;
+    token: string | undefined;
+}
+declare class CoreHttp {
+    private config;
+    constructor(config: AbbotConfig);
+    private createAxiosInstance;
+    post<T, U extends credential = credential>(middleware: () => U | null, url: string, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    post<T, U extends credential = credential>(user: U | null, url: string, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    get<T, U extends credential = credential>(middleware: () => U | null, url: string): Promise<AxiosResponse<T>>;
+    get<T, U extends credential = credential>(user: U | null, url: string): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(middleware: () => U | null, url: string, file: File, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(middleware: () => U | null, url: string, file: File[], fileKeys: string[], param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(user: U | null, url: string, file: File, param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+    uploadFile<T, U extends credential = credential>(user: U | null, url: string, file: File[], fileKeys: string[], param?: Record<string, any> | null): Promise<AxiosResponse<T>>;
+}
+
+interface AbbotConfig {
+    axios?: {
+        baseUrl?: string;
+        headers?: {
+            accept?: string;
+            lang?: string;
+            post?: {
+                contentType?: string;
+            };
+        };
+        timeout?: number;
+    };
+    app?: {
+        redirectUrl?: string;
+        apiKey?: string;
+        timezone?: string;
+    };
+}
+declare function create(config: AbbotConfig): CoreHttp;
+
+export { type AbbotConfig, catchError, create };

package/dist/index.js

@@ -0,0 +1,346 @@
+// src/catchError.ts
+async function catchError(promise, errorToCatch) {
+  return promise.then((data) => [void 0, data]).catch((error) => {
+    if (errorToCatch === void 0) return [error];
+    if (errorToCatch.some((e) => error instanceof e)) return [error];
+    throw error;
+  });
+}
+
+// src/http.ts
+import { AxiosError } from "axios";
+
+// src/encryption/secure.ts
+var Secure = class {
+  static keySize = 16;
+  static a = 5;
+  static b = 9;
+  static char = "0123456789";
+  static createId = () => {
+    const keyId = Array(this.keySize).fill("").map(() => {
+      const value = Math.floor(Math.random() * 10);
+      return this.char[value];
+    });
+    return keyId.join("");
+  };
+  static createKey = (keyId) => {
+    const crKey = Array(this.keySize).fill("").map((_, i) => Number(this.a ** Number(keyId[i]) % this.b));
+    return crKey.join("");
+  };
+  static toBase64Length16 = (text) => {
+    if (text && text.length) {
+      const b64 = Buffer.from(encodeURI(text)).toString("base64");
+      return b64.substring(0, 16);
+    }
+    return "";
+  };
+};
+
+// src/encryption/cryp.ts
+import { AES, enc, mode, pad } from "crypto-ts";
+
+// src/encryption/es.ts
+var ES = class {
+  static e(value) {
+    return Array.from(value).map((c) => c.charCodeAt(0)).reverse().map((e, i) => i % 2 === 0 ? e + 1 : e - 1).map((e, i) => i % 3 === 0 ? e * 2 : e);
+  }
+  static d(value) {
+    const result = value.map((e, i) => i % 3 === 0 ? Math.round(e / 2) : e).map((e, i) => i % 2 === 0 ? e - 1 : e + 1);
+    return String.fromCharCode.apply(null, result.reverse());
+  }
+  static a2b(value) {
+    const charactors = "abcdefghijklmnopqrstuvwxyz";
+    const randomChar = (max) => Math.floor(Math.random() * max);
+    const result = value.map(
+      (e, i) => `${String(e)}${i === value.length - 1 ? "" : charactors[randomChar(26)]}`
+    ).join("");
+    return result;
+  }
+  static b2a(value) {
+    if (!value) return [];
+    const result = value.split(/[a-z]/);
+    return result.map((e) => Number(e));
+  }
+};
+
+// src/encryption/cryp.ts
+var Cryp = class {
+  ivText;
+  key;
+  keyBuffer;
+  iv;
+  algConfig;
+  constructor(cryptProps) {
+    this.ivText = cryptProps.iv;
+    this.key = cryptProps.keyValue ? cryptProps.keyValue : ES.d(ES.b2a(getConfig().app?.apiKey));
+    this.keyBuffer = enc.Utf8.parse(this.key);
+    this.iv = enc.Utf8.parse(this.ivText);
+    this.algConfig = { mode: mode.CBC, padding: pad.PKCS7, iv: this.iv };
+  }
+  encrypt(textValue) {
+    if (!textValue) return "";
+    if (!textValue.length) return textValue;
+    const cipher = AES.encrypt(textValue, this.keyBuffer, this.algConfig);
+    return cipher.toString();
+  }
+  decrypt(encryptedValue) {
+    try {
+      if (!encryptedValue || !encryptedValue.length) return null;
+      const decryptValue = AES.decrypt(
+        encryptedValue,
+        this.keyBuffer,
+        this.algConfig
+      );
+      const decryptData = decryptValue.toString(enc.Utf8);
+      const jsonData = JSON.parse(decryptData);
+      return jsonData;
+    } catch (err) {
+      console.error(err);
+      return null;
+    }
+  }
+};
+
+// src/config/axiosFn.ts
+import axios from "axios";
+function axiosConf(cfg2) {
+  const axiosObj = axios.create({
+    baseURL: cfg2.axios?.baseUrl,
+    headers: {
+      common: {
+        Accept: cfg2.axios?.headers?.accept,
+        "Accept-Language": cfg2.axios?.headers?.lang
+      },
+      post: {
+        "Content-Type": cfg2.axios?.headers?.post?.contentType
+      }
+    },
+    timeout: cfg2.axios?.timeout,
+    withCredentials: true
+  });
+  return axiosObj;
+}
+
+// src/http.ts
+var CoreHttp = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  createAxiosInstance(user) {
+    const axios2 = axiosConf(this.config);
+    const iv = Secure.createId();
+    const cryp = new Cryp({
+      iv,
+      keyValue: user.key
+    });
+    axios2.interceptors.request.use(
+      (config) => {
+        const req = { ...config };
+        if (config.method && config.method.toLowerCase() === "post") {
+          if (config.data) {
+            if (config.data instanceof FormData) {
+              if (config.data.get("param")) {
+                config.data.set(
+                  "param",
+                  cryp.encrypt(config.data.get("param")?.toString())
+                );
+              }
+            } else {
+              const payload = {};
+              payload.param = cryp.encrypt(JSON.stringify(config.data));
+              const body = payload ? new URLSearchParams(payload).toString() : "";
+              req.data = body;
+              req.headers.setContentType("application/x-www-form-urlencoded");
+            }
+          }
+        }
+        req.headers.set("data-code", iv);
+        if (user.token) {
+          req.headers.setAuthorization(`Bearer ${user.token}`);
+        }
+        return req;
+      },
+      (error) => Promise.reject(error)
+    );
+    axios2.interceptors.response.use(
+      (response) => {
+        const res = { ...response };
+        res.data = cryp.decrypt(response.data);
+        return res.data;
+      },
+      (error) => {
+        const err = {
+          message: error.message,
+          code: error.code,
+          config: error.config,
+          request: error.request
+        };
+        if (error.response) {
+          if (error.response.data) {
+            const response = cryp.decrypt(error.response.data);
+            err.response = response;
+            return Promise.reject(
+              new AxiosError(
+                err.message,
+                err.code,
+                err.config,
+                err.request,
+                err.response
+              )
+            );
+          } else {
+            err.response = {
+              status: "error",
+              code: error.response.status,
+              message: error.message,
+              data: null
+            };
+            return Promise.reject(
+              new AxiosError(
+                err.message,
+                err.code,
+                err.config,
+                err.request,
+                err.response
+              )
+            );
+          }
+        } else if (error.request) {
+          err.response = {
+            status: "error",
+            code: 0,
+            message: "No response received",
+            data: null
+          };
+          return Promise.reject(
+            new AxiosError(
+              err.message,
+              err.code,
+              err.config,
+              err.request,
+              err.response
+            )
+          );
+        } else {
+          err.response = {
+            status: "error",
+            code: 0,
+            message: error.message,
+            data: null
+          };
+          return Promise.reject(
+            new AxiosError(
+              err.message,
+              err.code,
+              err.config,
+              err.request,
+              err.response
+            )
+          );
+        }
+      }
+    );
+    return axios2;
+  }
+  async post(param1, url, param) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const response = await axios2.post(url, param);
+    return response;
+  }
+  async get(param1, url) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const response = await axios2.get(url);
+    return response;
+  }
+  async uploadFile(param1, url, file, param2, param3) {
+    let axios2;
+    if (typeof param1 === "function") {
+      const user = param1();
+      axios2 = this.createAxiosInstance({
+        key: user?.key,
+        token: user?.token
+      });
+    } else {
+      axios2 = this.createAxiosInstance({
+        key: param1?.key,
+        token: param1?.token
+      });
+    }
+    const formData = new FormData();
+    if (param2 instanceof Array) {
+      if (file instanceof Array) {
+        param2.forEach((k, i) => {
+          formData.append(k, file[i]);
+        });
+      } else {
+        formData.append("file", file);
+      }
+    } else {
+      if (param2) {
+        formData.append("param", JSON.stringify(param2));
+      }
+    }
+    if (param3) {
+      formData.append("param", JSON.stringify(param3));
+    }
+    const response = await axios2.post(url, formData);
+    return response;
+  }
+};
+
+// src/config/core.ts
+var cfg = {
+  axios: {
+    baseUrl: "",
+    timeout: 5e3,
+    headers: {
+      accept: "*/*",
+      lang: "TH",
+      post: {
+        contentType: "application/x-www-form-urlencoded"
+      }
+    }
+  },
+  app: {
+    redirectUrl: "/login",
+    apiKey: "",
+    timezone: "Asia/Bangkok"
+  }
+};
+function getConfig() {
+  return cfg;
+}
+function create(config) {
+  cfg = { ...cfg, ...config };
+  const http = new CoreHttp(cfg);
+  return http;
+}
+export {
+  catchError,
+  create
+};

package/eslint.config.mjs

@@ -0,0 +1,35 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import json from "@eslint/json";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+  },
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    languageOptions: { globals: globals.browser },
+  },
+  tseslint.configs.recommended,
+  {
+    files: ["**/*.json"],
+    plugins: { json },
+    language: "json/json",
+    extends: ["json/recommended"],
+  },
+  {
+    files: ["**/*.jsonc"],
+    plugins: { json },
+    language: "json/jsonc",
+    extends: ["json/recommended"],
+  },
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+    },
+  },
+]);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "abbot-http-client",
+  "version": "0.0.1",
+  "description": "This package helps Abbot team to handle all the axios requests.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "scripts": {
+    "build": "tsup"
+  },
+  "keywords": [
+    "HTTP requests",
+    "ABBOT"
+  ],
+  "author": "Sahasawat",
+  "license": "MIT",
+  "dependencies": {
+    "@types/node": "^24.0.1",
+    "axios": "^1.10.0",
+    "crypto-ts": "^1.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.28.0",
+    "@eslint/json": "^0.12.0",
+    "eslint": "^9.28.0",
+    "globals": "^16.2.0",
+    "tsup": "^8.5.0",
+    "typescript-eslint": "^8.34.0"
+  }
+}