supaapps-api-kit-client 0.4.0 → 0.5.0

package/.github/workflows/build.yml

@@ -24,6 +24,9 @@ jobs:
       - name: Install dependencies
         run: npm install
 
+      - name: Test
+        run: npm test
+
       - name: Build
         run: npm run build
         env:

package/.github/workflows/publish-to-npm.yml

@@ -21,6 +21,9 @@ jobs:
       - name: Install dependencies
         run: npm install
 
+      - name: Test
+        run: npm test
+
       - name: Build
         run: npm run build
 

package/README.md

@@ -1,6 +1,6 @@
 # supaapps-api-kit-client
 
-A versatile, type-safe API client designed for TypeScript applications. It simplifies making HTTP requests and handling responses with built-in support for authorization and automatic handling of unauthorized access scenarios.
+A versatile, type-safe API client designed for TypeScript applications. It simplifies making HTTP requests and handling responses with built-in support for authorization and automatic handling of unauthorized access scenarios, integrates with `supaapps-auth` to handle <b>Automatic Token Refresh</b> and <b>Callbacks</b> when auth fails.
 
 ## Features
 
@@ -42,10 +42,31 @@ const useAuth: boolean = // Optional: default is false, use true if you want to
 // in case of using auth
 ApiKitClient.initialize(BASE_URL, authTokenCallback, unauthorizationCallback, true);
 
+
 // in case of not using auth
 ApiKitClient.initialize(BASE_URL);
+
+```
+
+You can initialize multiple ApiClient instances with different configurations if needed.
+here is ways to initialize multiple instances
+
+```ts
+
+import {ApiKitClient} from "./ApiKitClient";
+
+const apiClient1 = (new ApiKitClient()).initialize(BASE_URL); // this initialize apiClient with key 'default'
+const apiClient2 = (new ApiKitClient('default')).initialize(BASE_URL); // this initialize apiClient with 'default' as well
+const apiClient3 = (new ApiKitClient('public')).initialize(BASE_URL); // this initialize apiClient with 'public'
+
+// set key with method
+const apiClient4 = ApiKitClient.i('public').initialize(BASE_URL); // this initialize apiClient with 'public' key
+
+const apiClient5 = ApiKitClient.i('billing').initialize(BASE_URL, authTokenCallback, unauthorizationCallback, true); // this initialize apiClient with 'billing' key
+
 ```
 
+
 ## Making Requests
 
 Use the `ApiKitClient` instance to make API requests. Here are some examples:

package/dist/ApiKitClient.d.ts

@@ -1,19 +1,35 @@
-import { AxiosResponse } from 'axios';
+import { AxiosInstance, AxiosResponse } from 'axios';
 import { PaginatedResponse } from './types';
-type UnauthorizationCallback = () => void;
+type UnAuthorizedCallback = () => void;
 type AuthTokenCallback = () => Promise<string>;
+type ApiClient = {
+    baseURL: string;
+    authTokenCallback?: AuthTokenCallback;
+    unauthorizedCallback?: UnAuthorizedCallback;
+    useAuth: boolean;
+    axiosInstance: AxiosInstance;
+};
 export declare class ApiKitClient {
-    private static instance;
-    private static authTokenCallback?;
-    private static unauthorizationCallback?;
-    private static useAuth;
-    static initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizationCallback?: UnauthorizationCallback, useAuth?: boolean): void;
-    private static setupInterceptors;
+    private apiClientKey;
+    static apiClients: Record<string, ApiClient>;
+    static i(configInstance: string): ApiKitClient;
+    private constructor();
+    initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizedCallback?: UnAuthorizedCallback, useAuth?: boolean): void;
+    private setupInterceptors;
+    private checkInitialization;
     private static checkInitialization;
+    get<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>>;
+    getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>>;
+    getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>>;
+    post<T>(endpoint: string, data?: T): Promise<AxiosResponse<T>>;
+    put<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>>;
+    patch<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>>;
+    delete<T>(endpoint: string): Promise<AxiosResponse<T>>;
+    static initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizedCallback?: UnAuthorizedCallback, useAuth?: boolean): void;
     static get<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>>;
     static getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>>;
     static getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>>;
-    static post<T>(endpoint: string, data: T): Promise<AxiosResponse<T>>;
+    static post<T>(endpoint: string, data?: T): Promise<AxiosResponse<T>>;
     static put<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>>;
     static patch<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>>;
     static delete<T>(endpoint: string): Promise<AxiosResponse<T>>;

package/dist/ApiKitClient.js

@@ -12,79 +12,140 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiKitClient = void 0;
 const axios_1 = require("axios");
 class ApiKitClient {
-    static initialize(baseURL, authTokenCallback, unauthorizationCallback, useAuth = false) {
+    static i(configInstance) {
+        return new ApiKitClient(configInstance);
+    }
+    constructor(apiClientKey = 'default') {
+        this.apiClientKey = apiClientKey;
+    }
+    initialize(baseURL, authTokenCallback, unauthorizedCallback, useAuth = false) {
         if (useAuth && !authTokenCallback) {
             throw new Error("authTokenCallback must be provided if useAuth is true.");
         }
-        this.authTokenCallback = authTokenCallback;
-        this.unauthorizationCallback = unauthorizationCallback;
-        this.useAuth = useAuth;
-        this.instance = axios_1.default.create({ baseURL });
-        this.setupInterceptors();
-    }
-    static setupInterceptors() {
-        this.instance.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
-            if (this.useAuth && this.authTokenCallback) {
-                const authToken = yield this.authTokenCallback();
+        ApiKitClient.apiClients[this.apiClientKey] = {
+            baseURL,
+            authTokenCallback,
+            unauthorizedCallback: unauthorizedCallback,
+            useAuth,
+            axiosInstance: axios_1.default.create({ baseURL }),
+        };
+        (new ApiKitClient(this.apiClientKey)).setupInterceptors();
+    }
+    setupInterceptors() {
+        const apiClient = ApiKitClient.apiClients[this.apiClientKey];
+        apiClient.axiosInstance.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
+            if (apiClient.useAuth && apiClient.authTokenCallback) {
+                const authToken = yield apiClient.authTokenCallback();
                 config.headers.Authorization = `Bearer ${authToken}`;
             }
             return config;
         }));
-        this.instance.interceptors.response.use((response) => response, (error) => {
+        apiClient.axiosInstance.interceptors.response.use((response) => response, (error) => {
             var _a;
-            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && this.unauthorizationCallback) {
-                this.unauthorizationCallback();
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && apiClient.unauthorizedCallback) {
+                apiClient.unauthorizedCallback();
             }
             return Promise.reject(error);
         });
     }
+    checkInitialization() {
+        if (!ApiKitClient.apiClients[this.apiClientKey]) {
+            throw new Error(`ApiKitClient has not been initialized for '${this.apiClientKey}' apiClientKey . Please call ApiKitClient.i('${this.apiClientKey}').initialize() before making requests.`);
+        }
+    }
     static checkInitialization() {
-        if (!this.instance) {
+        if (!this.apiClients.default) {
             throw new Error("ApiKitClient has not been initialized. Please call ApiKitClient.initialize() before making requests.");
         }
     }
-    static get(endpoint, params) {
+    get(endpoint, params) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.get(endpoint, { params });
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.get(endpoint, { params });
         });
     }
-    static getOne(endpoint, params) {
+    getOne(endpoint, params) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.get(endpoint, { params });
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.get(endpoint, { params });
         });
     }
-    static getPaginated(endpoint, params) {
+    getPaginated(endpoint, params) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.get(endpoint, { params });
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.get(endpoint, { params });
         });
     }
-    static post(endpoint, data) {
+    post(endpoint, data) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.post(endpoint, data);
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.post(endpoint, data);
         });
     }
-    static put(endpoint, data) {
+    put(endpoint, data) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.put(endpoint, data);
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.put(endpoint, data);
         });
     }
-    static patch(endpoint, data) {
+    patch(endpoint, data) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.patch(endpoint, data);
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.patch(endpoint, data);
         });
     }
-    static delete(endpoint) {
+    delete(endpoint) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkInitialization();
-            return this.instance.delete(endpoint);
+            const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+            return axiosInstance.delete(endpoint);
+        });
+    }
+    // backward compatible methods
+    static initialize(baseURL, authTokenCallback, unauthorizedCallback, useAuth = false) {
+        new ApiKitClient('default').initialize(baseURL, authTokenCallback, unauthorizedCallback, useAuth);
+    }
+    static get(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).get(endpoint, params);
+        });
+    }
+    static getOne(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).getOne(endpoint, params);
+        });
+    }
+    static getPaginated(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).getPaginated(endpoint, params);
+        });
+    }
+    static post(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).post(endpoint, data);
+        });
+    }
+    static put(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).put(endpoint, data);
+        });
+    }
+    static patch(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).patch(endpoint, data);
+        });
+    }
+    static delete(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (new ApiKitClient('default')).delete(endpoint);
         });
     }
 }
 exports.ApiKitClient = ApiKitClient;
-ApiKitClient.useAuth = false;
+ApiKitClient.apiClients = {};

package/jest.config.ts

@@ -0,0 +1,205 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+import type {Config} from 'jest';
+
+const config: Config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/_m/mvw8154d7jl5gjvxw7j66wn00000gn/T/jest_dx",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  preset: 'ts-jest',
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  testEnvironment: "jsdom",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+  moduleFileExtensions: ['ts', 'js'], // Recognize .ts and .js files
+  transform: {
+    '^.+\\.ts$': 'ts-jest', // Transform TypeScript files using ts-jest
+  },
+  transformIgnorePatterns: ['/node_modules/'], // Ignore node_modules by default
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+export default config;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "supaapps-api-kit-client",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A versatile, type-safe API kit client designed for TypeScript applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
     "build": "tsc"
   },
   "author": "Supaapps GmbH",
@@ -15,7 +15,13 @@
   },
   "devDependencies": {
     "@types/axios": "^0.14.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.11.17",
-    "typescript": "^5.3.3"
+    "axios-mock-adapter": "^2.1.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.3"
   }
 }

package/src/ApiKitClient.ts

@@ -1,84 +1,153 @@
 import axios, { AxiosInstance, AxiosResponse, AxiosError } from 'axios';
 import { PaginatedResponse } from './types';
 
-type UnauthorizationCallback = () => void;
+type UnAuthorizedCallback = () => void;
 type AuthTokenCallback = () => Promise<string>;
+type ApiClient = {
+    baseURL: string;
+    authTokenCallback?: AuthTokenCallback;
+    unauthorizedCallback?: UnAuthorizedCallback;
+    useAuth: boolean;
+    axiosInstance: AxiosInstance;
+};
+
 
 export class ApiKitClient {
-  private static instance: AxiosInstance;
-  private static authTokenCallback?: AuthTokenCallback;
-  private static unauthorizationCallback?: UnauthorizationCallback;
-  private static useAuth: boolean = false;
-
-  public static initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizationCallback?: UnauthorizationCallback, useAuth: boolean = false): void {
-    if (useAuth && !authTokenCallback) {
-      throw new Error("authTokenCallback must be provided if useAuth is true.");
+  private apiClientKey: string;
+  public static apiClients: Record<string, ApiClient> = {};
+
+  public static i(configInstance: string): ApiKitClient {
+    return new ApiKitClient(configInstance);
+  }
+
+    private constructor(apiClientKey: string = 'default') {
+        this.apiClientKey = apiClientKey;
     }
 
-    this.authTokenCallback = authTokenCallback;
-    this.unauthorizationCallback = unauthorizationCallback;
-    this.useAuth = useAuth;
 
-    this.instance = axios.create({ baseURL });
+    public initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizedCallback?: UnAuthorizedCallback, useAuth: boolean = false): void {
+        if (useAuth && !authTokenCallback) {
+            throw new Error("authTokenCallback must be provided if useAuth is true.");
+        }
 
-    this.setupInterceptors();
-  }
+        ApiKitClient.apiClients[this.apiClientKey] = {
+            baseURL,
+            authTokenCallback,
+            unauthorizedCallback: unauthorizedCallback,
+            useAuth,
+            axiosInstance: axios.create({ baseURL }),
+        };
+      (new ApiKitClient(this.apiClientKey)).setupInterceptors();
 
-  private static setupInterceptors(): void {
-    this.instance.interceptors.request.use(async (config) => {
-      if (this.useAuth && this.authTokenCallback) {
-        const authToken = await this.authTokenCallback();
+    }
+
+
+
+  private setupInterceptors(): void {
+    const apiClient = ApiKitClient.apiClients[this.apiClientKey];
+    apiClient.axiosInstance.interceptors.request.use(async (config) => {
+      if (apiClient.useAuth && apiClient.authTokenCallback) {
+        const authToken = await apiClient.authTokenCallback();
         config.headers.Authorization = `Bearer ${authToken}`;
       }
       return config;
     });
 
-    this.instance.interceptors.response.use((response: AxiosResponse) => response, (error: AxiosError) => {
-      if (error.response?.status === 401 && this.unauthorizationCallback) {
-        this.unauthorizationCallback();
+    apiClient.axiosInstance.interceptors.response.use((response: AxiosResponse) => response, (error: AxiosError) => {
+      if (error.response?.status === 401 && apiClient.unauthorizedCallback) {
+        apiClient.unauthorizedCallback();
       }
       return Promise.reject(error);
     });
   }
 
+  private checkInitialization(): void {
+    if (!ApiKitClient.apiClients[this.apiClientKey]) {
+      throw new Error(`ApiKitClient has not been initialized for '${this.apiClientKey}' apiClientKey . Please call ApiKitClient.i('${this.apiClientKey}').initialize() before making requests.`);
+    }
+  }
+
   private static checkInitialization(): void {
-    if (!this.instance) {
+    if (!this.apiClients.default) {
       throw new Error("ApiKitClient has not been initialized. Please call ApiKitClient.initialize() before making requests.");
     }
   }
 
-  public static async get<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
+
+  public async get<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.get<T>(endpoint, { params });
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.get<T>(endpoint, { params });
   }
 
-  public static async getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
+  public async getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.get<T>(endpoint, { params });
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.get<T>(endpoint, { params });
   }
 
-  public static async getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>> {
+  public async getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>> {
     this.checkInitialization();
-    return this.instance!.get<PaginatedResponse<T>>(endpoint, { params });
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.get<PaginatedResponse<T>>(endpoint, { params });
   }
 
-  public static async post<T>(endpoint: string, data: T): Promise<AxiosResponse<T>> {
+  public async post<T>(endpoint: string, data?: T): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.post<T>(endpoint, data);
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.post<T>(endpoint, data);
   }
 
-  public static async put<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
+  public async put<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.put<T>(endpoint, data);
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.put<T>(endpoint, data);
   }
 
-  public static async patch<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
+  public async patch<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.patch<T>(endpoint, data);
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.patch<T>(endpoint, data);
   }
 
-  public static async delete<T>(endpoint: string): Promise<AxiosResponse<T>> {
+  public async delete<T>(endpoint: string): Promise<AxiosResponse<T>> {
     this.checkInitialization();
-    return this.instance!.delete<T>(endpoint);
+    const axiosInstance = ApiKitClient.apiClients[this.apiClientKey].axiosInstance;
+    return axiosInstance!.delete<T>(endpoint);
+  }
+
+
+  // backward compatible methods
+
+  public static initialize(baseURL: string, authTokenCallback?: AuthTokenCallback, unauthorizedCallback?: UnAuthorizedCallback, useAuth: boolean = false): void {
+    new ApiKitClient('default').initialize(baseURL, authTokenCallback, unauthorizedCallback, useAuth);
+  }
+
+  public static async get<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).get<T>(endpoint, params);
+  }
+
+  public static async getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).getOne<T>(endpoint, params);
+  }
+
+  public static async getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>> {
+    return (new ApiKitClient('default')).getPaginated<T>(endpoint, params);
+  }
+
+  public static async post<T>(endpoint: string, data?: T): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).post<T>(endpoint, data);
+  }
+
+  public static async put<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).put<T>(endpoint, data);
+  }
+
+  public static async patch<T>(endpoint: string, data: Partial<T>): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).patch<T>(endpoint, data);
+  }
+
+  public static async delete<T>(endpoint: string): Promise<AxiosResponse<T>> {
+    return (new ApiKitClient('default')).delete<T>(endpoint);
   }
 }

package/tests/ApiKitClient.test.ts

@@ -0,0 +1,91 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { ApiKitClient } from '../src/ApiKitClient';
+
+describe('ApiKitClient', () => {
+    // @ts-ignore
+    let mockAxios;
+
+    beforeEach(() => {
+        // Initialize mock for Axios
+        mockAxios = new MockAdapter(axios);
+    });
+
+    afterEach(() => {
+        mockAxios.reset();
+    });
+
+    it('should initialize the client with correct configuration', () => {
+        const baseURL = 'https://api.example.com';
+        const authTokenCallback = jest.fn(() => Promise.resolve('fake-token'));
+        const unauthorizedCallback = jest.fn();
+
+        const client = ApiKitClient.i('testClient');
+        client.initialize(baseURL, authTokenCallback, unauthorizedCallback, true);
+
+        const apiClient = ApiKitClient.apiClients['testClient'];
+        expect(apiClient.baseURL).toBe(baseURL);
+        expect(apiClient.authTokenCallback).toBe(authTokenCallback);
+        expect(apiClient.unauthorizedCallback).toBe(unauthorizedCallback);
+        expect(apiClient.useAuth).toBe(true);
+    });
+
+    it('should throw an error if authTokenCallback is not provided when useAuth is true', () => {
+        const baseURL = 'https://api.example.com';
+        const client = ApiKitClient.i('testClient');
+        expect(() => client.initialize(baseURL, undefined, undefined, true)).toThrowError(
+            'authTokenCallback must be provided if useAuth is true.'
+        );
+    });
+
+    it('should make a GET request successfully', async () => {
+        const baseURL = 'https://api.example.com';
+        const endpoint = '/test-endpoint';
+        const responseData = { success: true };
+
+        mockAxios.onGet(`${baseURL}${endpoint}`).reply(200, responseData);
+
+        const client = ApiKitClient.i('testClient');
+        client.initialize(baseURL);
+
+        const response = await client.get(endpoint);
+        expect(response.data).toEqual(responseData);
+    });
+
+    it('should add Authorization header when useAuth is true', async () => {
+        const baseURL = 'https://api.example.com';
+        const endpoint = '/auth-endpoint';
+        const authToken = 'test-token';
+        const responseData = { authorized: true };
+
+        mockAxios.onGet(`${baseURL}${endpoint}`).reply(200, responseData);
+
+        const authTokenCallback = jest.fn(() => Promise.resolve(authToken));
+        const client = ApiKitClient.i('authClient');
+        client.initialize(baseURL, authTokenCallback, undefined, true);
+
+        const response = await client.get(endpoint);
+
+        expect(authTokenCallback).toHaveBeenCalled();
+        expect(mockAxios.history.get[0].headers.Authorization).toBe(`Bearer ${authToken}`);
+        expect(response.data).toEqual(responseData);
+    });
+
+    it('should call unauthorizedCallback on 401 response', async () => {
+        const baseURL = 'https://api.example.com';
+        const endpoint = '/unauthorized-endpoint';
+
+        mockAxios.onGet(`${baseURL}${endpoint}`).reply(401);
+
+        const unauthorizedCallback = jest.fn();
+        const client = ApiKitClient.i('unauthorizedClient');
+        client.initialize(baseURL, undefined, unauthorizedCallback);
+
+        try {
+            await client.get(endpoint);
+        } catch (error) {
+            // Ensure unauthorizedCallback is called
+            expect(unauthorizedCallback).toHaveBeenCalled();
+        }
+    });
+});