supaapps-api-kit-client 0.1.0

package/.github/workflows/build.yml

@@ -0,0 +1,30 @@
+name: Build
+
+on:
+  push:
+    branches: 
+      - '**'
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+            node-version: lts/*
+            registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

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

@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+            node-version: lts/*
+            registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Notice:  While this software is open-source under the MIT License, the "Supaapps" name, branding, and logo are proprietary and copyrighted by Supaapps GmbH. Any use, reproduction, or distribution of the "Supaapps" brand assets without explicit permission is strictly prohibited.
+
+Copyright (c) 2024 Supaapps GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# 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.
+
+## Features
+
+- **Type Safety**: Leverages TypeScript for ensuring type safety in requests and responses.
+- **Authorization Support**: Automatically includes authorization tokens in requests.
+- **Customizable Unauthorized Access Handling**: Executes a callback function when encountering a 401 Unauthorized response, allowing for custom reaction strategies such as redirecting to a login page.
+- **Simplified API Requests**: Offers methods for common HTTP requests (`GET`, `POST`, `PUT`, `PATCH`, `DELETE`) with a straightforward, promise-based API.
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install supaapps-api-kit-client
+# or
+yarn add supaapps-api-kit-client
+```
+
+## Setup
+
+Before making any requests, initialize the `ApiKitClient` with your API's base URL, an authorization token, and a callback function for handling unauthorized access.
+
+
+```ts
+import { ApiKitClient } from 'supaapps-api-kit-client';
+
+const BASE_URL = 'https://api.example.com'
+
+const authTokenCallback = () => {
+  // Implement authToken logic here
+};
+
+const unauthorizationCallback = () => {
+  // Implement redirection to login page here
+};
+
+ApiKitClient.initialize(BASE_URL, authTokenCallback, unauthorizationCallback);
+```
+
+## Making Requests
+
+Use the `ApiKitClient` instance to make API requests. Here are some examples:
+
+### Fetching Data
+
+Fetch a list of resources:
+
+```ts
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+ApiKitClient.get<User[]>('/users')
+  .then(response => console.log(response.data)) // Expected to be of type User[]
+  .catch(error => console.error(error));
+```
+
+Fetch a single resource:
+
+```ts
+ApiKitClient.getOne<User>('/users/1')
+  .then(response => console.log(response.data)) // Expected to be of type User
+  .catch(error => console.error(error));
+```
+
+Fetch a paginated resource:
+
+```ts
+ApiKitClient.getPaginated<User>('/users')
+  .then(response => console.log(response)) // Expected to be of type PaginatedResponse<User>
+  .catch(error => console.error(error));
+```
+
+### Creating Data
+
+```ts
+// Create a new user
+const newUser: User = {
+  id: 1,
+  name: 'John Doe',
+  email: 'john@example.com',
+};
+
+ApiKitClient.post<User>('/users', newUser)
+  .then(response => console.log(response.data)) // Expected to be of type User
+  .catch(error => console.error(error));
+```
+
+### Updating Data
+
+```ts
+// Update a user's information
+const updatedUser: User = {
+  id: 1,
+  name: 'Jane Doe',
+  email: 'jane@example.com',
+};
+
+const updatedUser2: User = {
+  name: 'Jane Doe',
+};
+
+ApiKitClient.put<User>('/users/1', updatedUser)
+  .then(response => console.log(response.data)) // Expected to be of type User
+  .catch(error => console.error(error));
+
+ApiKitClient.patch<User>('/users/1', updatedUser2)
+  .then(response => console.log(response.data)) // Expected to be of type User
+  .catch(error => console.error(error));
+```
+
+### Deleting Data
+
+```ts
+// Delete a user
+ApiKitClient.delete('/users/1')
+  .then(() => console.log('User deleted'))
+  .catch(error => console.error(error));
+```
+
+## Handling Unauthorized Access
+The unauthorized access callback provided during initialization will be called automatically for any request that receives a 401 Unauthorized response, allowing you to handle such scenarios globally (e.g., redirecting the user to a login page).

package/dist/ApiKitClient.d.ts

@@ -0,0 +1,20 @@
+import { AxiosResponse } from 'axios';
+import { PaginatedResponse } from './types';
+type UnauthorizationCallback = () => void;
+type AuthTokenCallback = () => Promise<string>;
+export declare class ApiKitClient {
+    private static instance;
+    private static authTokenCallback;
+    private static unauthorizationCallback;
+    static initialize(baseURL: string, authTokenCallback: AuthTokenCallback, unauthorizationCallback?: UnauthorizationCallback): void;
+    private static setupInterceptors;
+    private static checkInitialization;
+    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 put<T>(endpoint: string, data: T): Promise<AxiosResponse<T>>;
+    static patch<T>(endpoint: string, data: T): Promise<AxiosResponse<T>>;
+    static delete<T>(endpoint: string): Promise<AxiosResponse<T>>;
+}
+export {};

package/dist/ApiKitClient.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKitClient = void 0;
+const axios_1 = require("axios");
+class ApiKitClient {
+    static initialize(baseURL, authTokenCallback, unauthorizationCallback) {
+        this.authTokenCallback = authTokenCallback;
+        this.unauthorizationCallback = unauthorizationCallback;
+        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.authTokenCallback) {
+                const authToken = yield this.authTokenCallback();
+                config.headers.Authorization = `Bearer ${authToken}`;
+            }
+            return config;
+        }));
+        this.instance.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();
+            }
+            return Promise.reject(error);
+        });
+    }
+    static checkInitialization() {
+        if (!this.instance) {
+            throw new Error("ApiKitClient has not been initialized. Please call ApiKitClient.initialize() before making requests.");
+        }
+    }
+    static get(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.get(endpoint, { params });
+        });
+    }
+    static getOne(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.get(endpoint, { params });
+        });
+    }
+    static getPaginated(endpoint, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.get(endpoint, { params });
+        });
+    }
+    static post(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.post(endpoint, data);
+        });
+    }
+    static put(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.put(endpoint, data);
+        });
+    }
+    static patch(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.patch(endpoint, data);
+        });
+    }
+    static delete(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialization();
+            return this.instance.delete(endpoint);
+        });
+    }
+}
+exports.ApiKitClient = ApiKitClient;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { ApiKitClient } from './ApiKitClient';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKitClient = void 0;
+var ApiKitClient_1 = require("./ApiKitClient");
+Object.defineProperty(exports, "ApiKitClient", { enumerable: true, get: function () { return ApiKitClient_1.ApiKitClient; } });

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export interface PaginationLink {
+    url: string | null;
+    label: string;
+    active: boolean;
+}
+export interface PaginatedResponse<T> {
+    current_page: number;
+    data: T[];
+    first_page_url: string;
+    from: number;
+    last_page: number;
+    last_page_url: string;
+    links: PaginationLink[];
+    next_page_url: string | null;
+    path: string;
+    per_page: number;
+    prev_page_url: string | null;
+    to: number;
+    total: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "supaapps-api-kit-client",
+  "version": "0.1.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",
+    "build": "tsc"
+  },
+  "author": "Supaapps GmbH",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.7"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/node": "^20.11.17",
+    "typescript": "^5.3.3"
+  }
+}

package/src/ApiKitClient.ts

@@ -0,0 +1,78 @@
+import axios, { AxiosInstance, AxiosResponse, AxiosError } from 'axios';
+import { PaginatedResponse } from './types';
+
+type UnauthorizationCallback = () => void;
+type AuthTokenCallback = () => Promise<string>;
+
+export class ApiKitClient {
+  private static instance: AxiosInstance;
+  private static authTokenCallback: AuthTokenCallback;
+  private static unauthorizationCallback: UnauthorizationCallback;
+
+  public static initialize(baseURL: string, authTokenCallback: AuthTokenCallback, unauthorizationCallback?: UnauthorizationCallback): void {
+    this.authTokenCallback = authTokenCallback;
+    this.unauthorizationCallback = unauthorizationCallback;
+
+    this.instance = axios.create({ baseURL });
+
+    this.setupInterceptors();
+  }
+
+  private static setupInterceptors(): void {
+    this.instance.interceptors.request.use(async (config) => {
+      if (this.authTokenCallback) {
+        const authToken = await this.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();
+      }
+      return Promise.reject(error);
+    });
+  }
+
+  private static checkInitialization(): void {
+    if (!this.instance) {
+      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>> {
+    this.checkInitialization();
+    return this.instance!.get<T>(endpoint, { params });
+  }
+    
+  public static async getOne<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<T>> {
+    this.checkInitialization();
+    return this.instance!.get<T>(endpoint, { params });
+  }
+
+  public static async getPaginated<T>(endpoint: string, params?: URLSearchParams): Promise<AxiosResponse<PaginatedResponse<T>>> {
+    this.checkInitialization();
+    return this.instance!.get<PaginatedResponse<T>>(endpoint, { params });
+  }
+
+  public static async post<T>(endpoint: string, data: T): Promise<AxiosResponse<T>> {
+    this.checkInitialization();
+    return this.instance!.post<T>(endpoint, data);
+  }
+
+  public static async put<T>(endpoint: string, data: T): Promise<AxiosResponse<T>> {
+    this.checkInitialization();
+    return this.instance!.put<T>(endpoint, data);
+  }
+
+  public static async patch<T>(endpoint: string, data: T): Promise<AxiosResponse<T>> {
+    this.checkInitialization();
+    return this.instance!.patch<T>(endpoint, data);
+  }
+
+  public static async delete<T>(endpoint: string): Promise<AxiosResponse<T>> {
+    this.checkInitialization();
+    return this.instance!.delete<T>(endpoint);
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { ApiKitClient } from './ApiKitClient';

package/src/types.ts

@@ -0,0 +1,21 @@
+export interface PaginationLink {
+  url: string | null;
+  label: string;
+  active: boolean;
+}
+
+export interface PaginatedResponse<T> {
+  current_page: number;
+  data: T[];
+  first_page_url: string;
+  from: number;
+  last_page: number;
+  last_page_url: string;
+  links: PaginationLink[];
+  next_page_url: string | null;
+  path: string;
+  per_page: number;
+  prev_page_url: string | null;
+  to: number;
+  total: number;
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+        "outDir": "./dist",
+        "declaration": true,
+        "module": "commonjs",
+        "target": "ES6"
+    },
+    "include": ["src/**/*.ts"]
+}