API Service example

// api.ts
import axios, { AxiosInstance, AxiosResponse } from "axios";

interface User {
  id: number;
  name: string;
  email: string;
}

interface Post {
  id: number;
  userId: number;
  title: string;
  body: string;
}

interface ApiResponse<T> {
  data: T | null;
  error: string | null;
  success: boolean;
}

interface TokenResponse {
  token: string;
  refreshToken: string;
  expiresIn: number; // Token expiration in seconds
}

interface IApiService {
  getUsers(): Promise<ApiResponse<User[]>>;
  getUser(id: number): Promise<ApiResponse<User>>;
  getPosts(): Promise<ApiResponse<Post[]>>;
  createPost(title: string, body: string): Promise<ApiResponse<Post>>;
  authenticate(username: string, password: string): Promise<ApiResponse<void>>;
}

// Simple in-memory storage for tokens (replace with a persistent storage in a real application)
let storedToken: string | null = null;
let storedRefreshToken: string | null = null;
let tokenExpiration: number | null = null;

class ApiService implements IApiService {
  private api: AxiosInstance;
  private baseURL: string; // Store base URL

  constructor(baseURL: string) {
    this.baseURL = baseURL;
    this.api = axios.create({
      baseURL: baseURL,
      headers: {
        "Content-Type": "application/json",
      },
    });
    this.api.interceptors.request.use(async (config) => {
      const token = await this.getToken(); // Get token from storage
      if (token) {
        config.headers.Authorization = `Bearer ${token}`;
      }
      return config;
    });
  }

  private async getToken(): Promise<string | null> {
    if (storedToken && tokenExpiration && Date.now() < tokenExpiration * 1000) {
      // Token is still valid, return it
      return storedToken;
    }

    if (storedRefreshToken) {
      const refreshResult = await this.refreshAccessToken();
      if (refreshResult.success) {
        return storedToken;
      }
    }
    return null; // No valid token, need to authenticate
  }

  private async refreshAccessToken(): Promise<ApiResponse<void>> {
    try {
      if (!storedRefreshToken) {
        return {
          data: null,
          error: "No refresh token available",
          success: false,
        };
      }
      const refreshResponse: AxiosResponse<TokenResponse> = await this.api.post(
        "/auth/refresh", // Refresh token endpoint (adjust to your API)
        { refreshToken: storedRefreshToken }
      );
      const { token, refreshToken, expiresIn } = refreshResponse.data;
      this.setTokenData(token, refreshToken, expiresIn);
      return { data: null, error: null, success: true };
    } catch (error: any) {
      this.clearTokenData(); // clear token and refresh token because refresh token is invalid
      return { data: null, error: error.message, success: false };
    }
  }

  async authenticate(
    username: string,
    password: string
  ): Promise<ApiResponse<void>> {
    try {
      const authResponse: AxiosResponse<TokenResponse> = await this.api.post(
        "/auth/login",
        {
          username,
          password,
        }
      );

      const { token, refreshToken, expiresIn } = authResponse.data;
      this.setTokenData(token, refreshToken, expiresIn);
      return { data: null, error: null, success: true };
    } catch (error: any) {
      return { data: null, error: error.message, success: false };
    }
  }

  private setTokenData(token: string, refreshToken: string, expiresIn: number) {
    storedToken = token;
    storedRefreshToken = refreshToken;
    tokenExpiration = Date.now() / 1000 + expiresIn;
  }

  private clearTokenData() {
    storedToken = null;
    storedRefreshToken = null;
    tokenExpiration = null;
  }

  async getUsers(): Promise<ApiResponse<User[]>> {
    try {
      const response: AxiosResponse<User[]> = await this.api.get("/users");
      return { data: response.data, error: null, success: true };
    } catch (error: any) {
      return { data: null, error: error.message, success: false };
    }
  }

  async getUser(id: number): Promise<ApiResponse<User>> {
    try {
      const response: AxiosResponse<User> = await this.api.get(`/users/${id}`);
      return { data: response.data, error: null, success: true };
    } catch (error: any) {
      return { data: null, error: error.message, success: false };
    }
  }

  async getPosts(): Promise<ApiResponse<Post[]>> {
    try {
      const response: AxiosResponse<Post[]> = await this.api.get("/posts");
      return { data: response.data, error: null, success: true };
    } catch (error: any) {
      return { data: null, error: error.message, success: false };
    }
  }

  async createPost(title: string, body: string): Promise<ApiResponse<Post>> {
    try {
      const response: AxiosResponse<Post> = await this.api.post("/posts", {
        title,
        body,
      });
      return { data: response.data, error: null, success: true };
    } catch (error: any) {
      return { data: null, error: error.message, success: false };
    }
  }
}

export { ApiService, IApiService, ApiResponse };

// test_api.ts

import { ApiService, IApiService, ApiResponse } from "./api";

const baseURL = "https://your-api-url.com"; // Replace with your actual API endpoint
const apiService: IApiService = new ApiService(baseURL);

async function testApi() {
  //Authenticate the user
  const authResponse = await apiService.authenticate(
    "your_username",
    "your_password"
  );

  if (authResponse.success) {
    console.log("Authentication successful!");

    //Get Users
    const usersResponse: ApiResponse<any> = await apiService.getUsers();
    if (usersResponse.success && usersResponse.data) {
      console.log("Users:", usersResponse.data);
    } else if (usersResponse.error) {
      console.error("Error getting users", usersResponse.error);
    }

    //Get a user
    const userResponse: ApiResponse<any> = await apiService.getUser(1);
    if (userResponse.success && userResponse.data) {
      console.log("User:", userResponse.data);
    } else if (userResponse.error) {
      console.error("Error getting user", userResponse.error);
    }

    //Get Posts
    const postsResponse: ApiResponse<any> = await apiService.getPosts();
    if (postsResponse.success && postsResponse.data) {
      console.log("Posts:", postsResponse.data);
    } else if (postsResponse.error) {
      console.error("Error getting posts", postsResponse.error);
    }

    // Create a Post
    const createPostResponse: ApiResponse<any> = await apiService.createPost(
      "My new title",
      "My new Body"
    );
    if (createPostResponse.success && createPostResponse.data) {
      console.log("New Post created:", createPostResponse.data);
    } else if (createPostResponse.error) {
      console.error("Error creating a post", createPostResponse.error);
    }
  } else {
    console.error("Authentication failed:", authResponse.error);
  }
}

testApi();