api-hub-client 1.0.0

package/README.md

@@ -0,0 +1,180 @@
+<h1 align="center">api-hub-client</h1>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"/>
+  <img src="https://img.shields.io/badge/npm-v1.0.0-blue.svg" alt="npm version"/>
+  <img src="https://img.shields.io/badge/build-passing-brightgreen.svg" alt="build status"/>
+  <img src="https://img.shields.io/badge/coverage-95%25-yellow.svg" alt="coverage"/>
+  
+</p>
+
+<p align="center">
+  A TypeScript client library for consuming the API Hub backend with full type support.
+</p>
+
+<p align="center">
+  <em>Companion package to <strong>api-hub</strong> in the monorepo</em>
+</p>
+
+---
+
+## Overview
+
+`api-hub-client` provides a **developer-friendly TypeScript interface** to interact with the `api-hub` server.  
+It simplifies API calls by handling requests, responses, and type definitions automatically, enabling **type-safe and maintainable integration** in frontend or Node.js applications.
+
+---
+
+## Features
+
+- Fully typed TypeScript API for IntelliSense and compile-time safety  
+- Async/await interface for all requests  
+- Supports all endpoints exposed by the `api-hub` server  
+- Easy configuration with `baseUrl`  
+- Handles errors and responses consistently
+
+---
+
+## Supported API Endpoints 
+
+| Module      | Endpoint | Description | Example Method |
+|------------|----------|------------|----------------|
+| [GitHub](../api-hub/src/routes/github.ts) | `/github/repos/:username` | Fetch GitHub repositories for a given username | `client.github.getRepos(username)` |
+| [YouTube](../api-hub/src/routes/youtube.ts) | `/youtube/search/:query` | Search YouTube videos by query | `client.youtube.search(query)` |
+| [TheMealDB](../api-hub/src/routes/mealdb.ts) | `/mealdb/search/:query` | Search for meals and recipes | `client.mealdb.search(query)` |
+| [NewsAPI](../api-hub/src/routes/newsapi.ts) | `/newsapi/top-headlines` | Fetch latest news articles | `client.newsapi.topHeadlines(country)` |
+| [Weather](../api-hub/src/routes/weather.ts) | `/weather/current/:city` | Get current weather info for a city | `client.weather.getCurrent(city)` |
+
+> Click the module name to view the corresponding backend route implementation.
+
+---
+
+## Project Structure
+
+```text
+api-hub-client/
+├── src/
+│   ├── index.ts         # Entry point exporting ApiHubClient class
+│   ├── client.ts        # HTTP client implementation
+│   └── types/           # TypeScript types for requests and responses
+├── package.json
+├── tsconfig.json
+├── README.md
+└── .env.example
+````
+
+---
+
+## Prerequisites
+
+* Node.js **v18 or later**
+* npm, yarn, or pnpm
+* Access to a running `api-hub` server
+
+---
+
+## Installation
+
+Install the package in your project:
+
+```bash
+npm install api-hub-client
+# or
+yarn add api-hub-client
+```
+
+---
+
+## Configuration
+
+Create an instance of the client with your API Hub server base URL:
+
+```ts
+import { ApiHubClient } from "api-hub-client";
+
+const client = new ApiHubClient({
+  baseUrl: "http://localhost:8080",
+});
+```
+
+---
+
+## Usage Examples
+
+### Fetch GitHub Repositories
+
+```ts
+const repos = await client.github.getRepos("facebook");
+console.log(repos);
+```
+
+### Search TheMealDB
+
+```ts
+const recipes = await client.mealdb.search("carbonara");
+console.log(recipes);
+```
+
+### Search YouTube
+
+```ts
+const videos = await client.youtube.search("nextjs tutorial");
+console.log(videos);
+```
+
+---
+
+## TypeScript Support
+
+Provides types for:
+
+* Request parameters
+* API responses
+* Error handling
+* Optional pagination helpers
+
+This ensures **full IntelliSense and compile-time safety**.
+
+---
+
+## Development
+
+```bash
+cd api-hub-client
+npm install
+npm run build
+```
+
+Link the client locally for testing:
+
+```bash
+npm link
+```
+
+> Ensure the `api-hub` server is running for real-time testing.
+
+---
+
+## Scripts
+
+| Command         | Description                       |
+| --------------- | --------------------------------- |
+| `npm run dev`   | Start development with watch mode |
+| `npm run build` | Compile TypeScript to JavaScript  |
+| `npm test`      | Run unit tests (if available)     |
+
+---
+
+## Contributing
+
+This package follows the monorepo contribution guidelines.
+
+Please review [`CONTRIBUTING.md`](../CONTRIBUTING.md) before submitting a pull request.
+
+---
+
+## License
+
+MIT
+
+

package/dist/index.d.ts

@@ -0,0 +1,184 @@
+type FlixquestProvider = "showbox" | "vidsrcto";
+
+declare class ApiHubClient {
+    github: {
+        getUser(username: string): Promise<any>;
+        getRepo(username: string, repository: string): Promise<any>;
+        searchUsers(username: string): Promise<any>;
+        searchRepos(repository: string): Promise<any>;
+    };
+    crypto: {
+        getMarket(): Promise<any>;
+    };
+    flixquest: {
+        getMovieStreamingLinks(tmdbID: string, provider?: FlixquestProvider): Promise<any>;
+        getTvEpisodeStreamingLinks(tmdbID: string, season: string | number, episode: string | number, provider?: FlixquestProvider): Promise<any>;
+    };
+    googlebooks: {
+        search(book: string): Promise<any>;
+        getVolume(id: string): Promise<any>;
+        searchAdvanced(params: {
+            q: string;
+            startIndex?: number;
+            maxResults?: number;
+            orderBy?: string;
+            langRestrict?: string;
+            printType?: string;
+            projection?: string;
+        }): Promise<any>;
+    };
+    hackernews: {
+        newStories(limit?: number): Promise<any>;
+        topStories(limit?: number): Promise<any>;
+        bestStories(limit?: number): Promise<any>;
+        askStories(limit?: number): Promise<any>;
+        showStories(limit?: number): Promise<any>;
+        jobStories(limit?: number): Promise<any>;
+        getItem(id: string): Promise<any>;
+        getUser(id: string): Promise<any>;
+        updates(): Promise<any>;
+        maxItem(): Promise<any>;
+    };
+    jsonplaceholder: {
+        getPosts(page?: number, limit?: number): Promise<any>;
+        getPost(id: number | string): Promise<any>;
+        getPostComments(id: number | string): Promise<any>;
+        getComments(): Promise<any>;
+        getAlbums(page?: number, limit?: number): Promise<any>;
+        getAlbum(id: number | string): Promise<any>;
+        getAlbumPhotos(id: number | string): Promise<any>;
+        getPhotos(page?: number, limit?: number): Promise<any>;
+        getPhoto(id: number | string): Promise<any>;
+        getTodos(): Promise<any>;
+        getUsers(page?: number, limit?: number): Promise<any>;
+        getUser(id: number | string): Promise<any>;
+        getUserPosts(id: number | string): Promise<any>;
+        getUserTodos(id: number | string): Promise<any>;
+        getUserAlbums(id: number | string): Promise<any>;
+    };
+    youtube: {
+        search(videoTitle: string): Promise<any>;
+    };
+    apicagent: {
+        getUserAgent(): Promise<any>;
+    };
+    apotd: {
+        getToday(): Promise<any>;
+        getRandom(amount: number): Promise<any>;
+        getWeekly(): Promise<any>;
+        getMonthly(): Promise<any>;
+        getSpecific(year: number | string, month: number | string, day: number | string): Promise<any>;
+    };
+    bible: {
+        getBooks(): Promise<any>;
+        getChapter(book: string, chapter: number | string): Promise<any>;
+        getVerses(book: string, chapter: number | string, from: number | string, to: number | string): Promise<any>;
+        getVerse(book: string, chapter: number | string, verse: number | string): Promise<any>;
+    };
+    chucknorris: {
+        getRandom(): Promise<any>;
+        getCategories(): Promise<any>;
+        getRandomByCategory(category: string): Promise<any>;
+        search(query: string): Promise<any>;
+    };
+    randomuser: {
+        getUser(): Promise<any>;
+        getUserNoInfo(): Promise<any>;
+        getUsers(count: number): Promise<any>;
+        getByGender(gender: string): Promise<any>;
+        getByNat(nat: string): Promise<any>;
+        exclude(fields: string): Promise<any>;
+        include(fields: string): Promise<any>;
+        format(fmt: string): Promise<any>;
+        password(strength: string): Promise<any>;
+    };
+    lyrics: {
+        getLyrics(artist: string, title: string): Promise<any>;
+    };
+    mealdb: {
+        search(searchQuery: string): Promise<any>;
+        getMeal(mealID: string): Promise<any>;
+        getCategories(): Promise<any>;
+        getByCategory(category: string): Promise<any>;
+    };
+    moviedb: {
+        discoverMovies(page?: number): Promise<any>;
+        searchMovies(title: string, year?: string, page?: number): Promise<any>;
+        getMovieDetails(movieId: string): Promise<any>;
+        getTrendingMovies(page?: number): Promise<any>;
+        getTopRatedMovies(page?: number): Promise<any>;
+        discoverTV(page?: number): Promise<any>;
+        searchTV(title: string, year?: string, page?: number): Promise<any>;
+        getTVDetails(id: string): Promise<any>;
+        getTVSeasonDetails(id: string, seasonNumber: string): Promise<any>;
+        getTVEpisodeDetails(id: string, seasonNumber: string, episodeNumber?: string): Promise<any>;
+        getTrendingTV(page?: number): Promise<any>;
+        getTopRatedTV(page?: number): Promise<any>;
+    };
+    news: {
+        search(term: string): Promise<any>;
+        getHeadlines(category?: string, country?: string): Promise<any>;
+    };
+    newyorktimes: {
+        getArchive(year: number, month: number): Promise<any>;
+        searchArticles(q: string, options?: {
+            fq?: string;
+            begin_date?: string;
+            end_date?: string;
+            facet?: string;
+            facet_fields?: string;
+            facet_filter?: string;
+            sort?: string;
+            fl?: string;
+            page?: string;
+        }): Promise<any>;
+        getBestsellerBooks(listName: string, options?: {
+            bestsellers_date?: string;
+            published_date?: string;
+            offset?: string;
+        }): Promise<any>;
+        getBestsellerBooksByDate(bestsellerDate: string, listName: string, offset?: string): Promise<any>;
+        getBestsellerListNames(): Promise<any>;
+        getBooksOverview(publishedDate?: string): Promise<any>;
+        getTop5BestsellerBooks(publishedDate?: string): Promise<any>;
+        getPopularViewed(period: string): Promise<any>;
+        getPopularShared(period: string): Promise<any>;
+        getPopularSharedBySource(period: string, source: string): Promise<any>;
+        getTopStories(section: string): Promise<any>;
+    };
+    restcountries: {
+        getAll(): Promise<any>;
+        getByName(name: string): Promise<any>;
+        getByCode(code: string): Promise<any>;
+        getByCodes(codes: string): Promise<any>;
+        getByCurrency(currency: string): Promise<any>;
+        getByLanguage(language: string): Promise<any>;
+        getByCapital(capital: string): Promise<any>;
+        getByRegion(region: string): Promise<any>;
+        getBySubregion(subregion: string): Promise<any>;
+    };
+    tvmaze: {
+        searchShows(query: string): Promise<any>;
+        getShow(showId: number): Promise<any>;
+        getSeasons(showId: number): Promise<any>;
+        getSeasonEpisodes(seasonId: number): Promise<any>;
+        getEpisode(episodeId: number): Promise<any>;
+    };
+    weather: {
+        forecastByLocation(location: string, days: number): Promise<any>;
+        forecastByCoords(latitude: number, longitude: number): Promise<any>;
+        search(location: string): Promise<any>;
+    };
+    reddit: {
+        getSubreddit(subreddit: string, options?: {
+            listing?: "new" | "hot" | "rising" | "best" | "random" | "top";
+            time?: "hour" | "day" | "week" | "month" | "year" | "all";
+            limit?: number;
+        }): Promise<any>;
+    };
+    constructor({ baseUrl }: {
+        baseUrl: string;
+    });
+}
+
+export { ApiHubClient };

package/dist/index.js

@@ -0,0 +1,752 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiHubClient: () => ApiHubClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/httpClient.ts
+var HttpClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async request(path, options) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        "Content-Type": "application/json"
+      },
+      ...options
+    });
+    if (!res.ok) {
+      const error = await res.text();
+      throw new Error(error || "API request failed");
+    }
+    return res.json();
+  }
+  get(path) {
+    return this.request(path);
+  }
+};
+
+// src/github.ts
+var githubApi = (client) => ({
+  /**
+   * Get GitHub user profile + repositories
+   */
+  getUser(username) {
+    return client.get(`/github/user/${username}`);
+  },
+  /**
+   * Get a specific GitHub repository
+   */
+  getRepo(username, repository) {
+    return client.get(`/github/repo/${username}/${repository}`);
+  },
+  /**
+   * Search GitHub users
+   */
+  searchUsers(username) {
+    return client.get(`/github/search/users/${username}`);
+  },
+  /**
+   * Search GitHub repositories
+   */
+  searchRepos(repository) {
+    return client.get(`/github/search/repos/${repository}`);
+  }
+});
+
+// src/crypto.ts
+var cryptoApi = (client) => ({
+  /**
+   * Get current crypto market prices (USD)
+   */
+  getMarket() {
+    return client.get("/crypto/market");
+  }
+});
+
+// src/youtube.ts
+var youtubeApi = (client) => ({
+  /**
+   * Search YouTube videos by title
+   */
+  search(videoTitle) {
+    return client.get(`/youtube/search/${encodeURIComponent(videoTitle)}`);
+  }
+});
+
+// src/apicagent.ts
+var apicagentApi = (client) => ({
+  /**
+   * Get user-agent information as seen by the server
+   */
+  getUserAgent() {
+    return client.get(`/apicagent/user-agent`);
+  }
+});
+
+// src/apotd.ts
+var apotdApi = (client) => ({
+  getToday() {
+    return client.get(`/apotd/today`);
+  },
+  getRandom(amount) {
+    return client.get(`/apotd/random/${amount}`);
+  },
+  getWeekly() {
+    return client.get(`/apotd/weekly`);
+  },
+  getMonthly() {
+    return client.get(`/apotd/monthly`);
+  },
+  getSpecific(year, month, day) {
+    return client.get(`/apotd/specific/${year}/${month}/${day}`);
+  }
+});
+
+// src/bible.ts
+var bibleApi = (client) => ({
+  getBooks() {
+    return client.get(`/bible/books`);
+  },
+  getChapter(book, chapter) {
+    return client.get(`/bible/${encodeURIComponent(book)}/${chapter}`);
+  },
+  getVerses(book, chapter, from, to) {
+    return client.get(`/bible/${encodeURIComponent(book)}/${chapter}/${from}/${to}`);
+  },
+  getVerse(book, chapter, verse) {
+    return client.get(`/bible/${encodeURIComponent(book)}/${chapter}/${verse}`);
+  }
+});
+
+// src/chucknorris.ts
+var chucknorrisApi = (client) => ({
+  getRandom() {
+    return client.get(`/chucknorris/jokes/random`);
+  },
+  getCategories() {
+    return client.get(`/chucknorris/jokes/categories`);
+  },
+  getRandomByCategory(category) {
+    return client.get(`/chucknorris/jokes/random/${encodeURIComponent(category)}`);
+  },
+  search(query) {
+    return client.get(`/chucknorris/jokes/search/${encodeURIComponent(query)}`);
+  }
+});
+
+// src/randomuser.ts
+var randomuserApi = (client) => ({
+  getUser() {
+    return client.get(`/randomuser/user`);
+  },
+  getUserNoInfo() {
+    return client.get(`/randomuser/user/data`);
+  },
+  getUsers(count) {
+    return client.get(`/randomuser/users/${count}`);
+  },
+  getByGender(gender) {
+    return client.get(`/randomuser/user/${encodeURIComponent(gender)}`);
+  },
+  getByNat(nat) {
+    return client.get(`/randomuser/country/${encodeURIComponent(nat)}`);
+  },
+  exclude(fields) {
+    return client.get(`/randomuser/exclude/${encodeURIComponent(fields)}`);
+  },
+  include(fields) {
+    return client.get(`/randomuser/include/${encodeURIComponent(fields)}`);
+  },
+  format(fmt) {
+    return client.get(`/randomuser/format/${encodeURIComponent(fmt)}`);
+  },
+  password(strength) {
+    return client.get(`/randomuser/password/${encodeURIComponent(strength)}`);
+  }
+});
+
+// src/lyrics.ts
+var lyricsApi = (client) => ({
+  /**
+   * Get lyrics for a song by artist and title
+   */
+  getLyrics(artist, title) {
+    return client.get(`/lyrics/${encodeURIComponent(artist)}/${encodeURIComponent(title)}`);
+  }
+});
+
+// src/mealdb.ts
+var mealdbApi = (client) => ({
+  /**
+   * Search for meals by query
+   */
+  search(searchQuery) {
+    return client.get(`/mealdb/search/${encodeURIComponent(searchQuery)}`);
+  },
+  /**
+   * Get a specific meal by ID
+   */
+  getMeal(mealID) {
+    return client.get(`/mealdb/meal/${encodeURIComponent(mealID)}`);
+  },
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    return client.get("/mealdb/categories");
+  },
+  /**
+   * Get meals by category
+   */
+  getByCategory(category) {
+    return client.get(`/mealdb/category/${encodeURIComponent(category)}`);
+  }
+});
+
+// src/moviedb.ts
+var moviedbApi = (client) => ({
+  /**
+   * Discover movies
+   */
+  discoverMovies(page) {
+    const path = page ? `/moviedb/movies/discover/${page}` : "/moviedb/movies/discover";
+    return client.get(path);
+  },
+  /**
+   * Search movies by title
+   */
+  searchMovies(title, year, page) {
+    let path = `/moviedb/movies/search/${encodeURIComponent(title)}`;
+    if (year) path += `/${encodeURIComponent(year)}`;
+    if (page) path += `/${page}`;
+    return client.get(path);
+  },
+  /**
+   * Get movie details by ID
+   */
+  getMovieDetails(movieId) {
+    return client.get(`/moviedb/movies/details/${encodeURIComponent(movieId)}`);
+  },
+  /**
+   * Get trending movies
+   */
+  getTrendingMovies(page) {
+    const path = page ? `/moviedb/movies/trending/${page}` : "/moviedb/movies/trending";
+    return client.get(path);
+  },
+  /**
+   * Get top-rated movies
+   */
+  getTopRatedMovies(page) {
+    const path = page ? `/moviedb/movies/top-rated/${page}` : "/moviedb/movies/top-rated";
+    return client.get(path);
+  },
+  /**
+   * Discover TV shows
+   */
+  discoverTV(page) {
+    const path = page ? `/moviedb/tv/discover/${page}` : "/moviedb/tv/discover";
+    return client.get(path);
+  },
+  /**
+   * Search TV shows by title
+   */
+  searchTV(title, year, page) {
+    let path = `/moviedb/tv/search/${encodeURIComponent(title)}`;
+    if (year) path += `/${encodeURIComponent(year)}`;
+    if (page) path += `/${page}`;
+    return client.get(path);
+  },
+  /**
+   * Get TV show details by ID
+   */
+  getTVDetails(id) {
+    return client.get(`/moviedb/tv/details/${encodeURIComponent(id)}`);
+  },
+  /**
+   * Get TV season details
+   */
+  getTVSeasonDetails(id, seasonNumber) {
+    return client.get(`/moviedb/tv/details/${encodeURIComponent(id)}/season/${encodeURIComponent(seasonNumber)}`);
+  },
+  /**
+   * Get TV episode details
+   */
+  getTVEpisodeDetails(id, seasonNumber, episodeNumber) {
+    let path = `/moviedb/tv/details/${encodeURIComponent(id)}/season/${encodeURIComponent(seasonNumber)}/episode`;
+    if (episodeNumber) path += `/${encodeURIComponent(episodeNumber)}`;
+    return client.get(path);
+  },
+  /**
+   * Get trending TV shows
+   */
+  getTrendingTV(page) {
+    const path = page ? `/moviedb/tv/trending/${page}` : "/moviedb/tv/trending";
+    return client.get(path);
+  },
+  /**
+   * Get top-rated TV shows
+   */
+  getTopRatedTV(page) {
+    const path = page ? `/moviedb/tv/top-rated/${page}` : "/moviedb/tv/top-rated";
+    return client.get(path);
+  }
+});
+
+// src/news.ts
+var newsApi = (client) => ({
+  /**
+   * Search for news articles by term
+   */
+  search(term) {
+    return client.get(`/news/search/${encodeURIComponent(term)}`);
+  },
+  /**
+   * Get headlines by category and country
+   */
+  getHeadlines(category, country) {
+    let path = "/news/headlines";
+    if (category) path += `/${encodeURIComponent(category)}`;
+    if (country) path += `/${encodeURIComponent(country)}`;
+    return client.get(path);
+  }
+});
+
+// src/newyorktimes.ts
+var newyorktimesApi = (client) => ({
+  /**
+   * Get archived articles by year and month
+   */
+  getArchive(year, month) {
+    return client.get(`/newyorktimes/archive/${year}/${month}`);
+  },
+  /**
+   * Search articles with optional filters
+   */
+  searchArticles(q, options) {
+    let path = `/newyorktimes/articles/search/${encodeURIComponent(q)}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.fq) params.append("fq", options.fq);
+      if (options.begin_date) params.append("begin_date", options.begin_date);
+      if (options.end_date) params.append("end_date", options.end_date);
+      if (options.facet) params.append("facet", options.facet);
+      if (options.facet_fields) params.append("facet_fields", options.facet_fields);
+      if (options.facet_filter) params.append("facet_filter", options.facet_filter);
+      if (options.sort) params.append("sort", options.sort);
+      if (options.fl) params.append("fl", options.fl);
+      if (options.page) params.append("page", options.page);
+      const queryString = params.toString();
+      if (queryString) path += `?${queryString}`;
+    }
+    return client.get(path);
+  },
+  /**
+   * Get bestseller books by list name
+   */
+  getBestsellerBooks(listName, options) {
+    let path = `/newyorktimes/bestsellers/books/${encodeURIComponent(listName)}`;
+    if (options) {
+      const params = new URLSearchParams();
+      if (options.bestsellers_date) params.append("bestsellers-date", options.bestsellers_date);
+      if (options.published_date) params.append("published-date", options.published_date);
+      if (options.offset) params.append("offset", options.offset);
+      const queryString = params.toString();
+      if (queryString) path += `?${queryString}`;
+    }
+    return client.get(path);
+  },
+  /**
+   * Get bestseller books by date and list name
+   */
+  getBestsellerBooksByDate(bestsellerDate, listName, offset) {
+    let path = `/newyorktimes/bestsellers/books/${encodeURIComponent(bestsellerDate)}/${encodeURIComponent(listName)}`;
+    if (offset) {
+      path += `?offset=${encodeURIComponent(offset)}`;
+    }
+    return client.get(path);
+  },
+  /**
+   * Get bestseller list names
+   */
+  getBestsellerListNames() {
+    return client.get("/newyorktimes/bestsellers/books/names");
+  },
+  /**
+   * Get books overview by published date
+   */
+  getBooksOverview(publishedDate) {
+    let path = "/newyorktimes/bestsellers/books/overview";
+    if (publishedDate) {
+      path += `?published-date=${encodeURIComponent(publishedDate)}`;
+    }
+    return client.get(path);
+  },
+  /**
+   * Get top 5 bestseller books
+   */
+  getTop5BestsellerBooks(publishedDate) {
+    let path = "/newyorktimes/bestsellers/books/overview/top5";
+    if (publishedDate) {
+      path += `?published-date=${encodeURIComponent(publishedDate)}`;
+    }
+    return client.get(path);
+  },
+  /**
+   * Get popular articles based on views
+   */
+  getPopularViewed(period) {
+    return client.get(`/newyorktimes/popular/viewed/${encodeURIComponent(period)}`);
+  },
+  /**
+   * Get popular articles based on shares
+   */
+  getPopularShared(period) {
+    return client.get(`/newyorktimes/popular/shared/${encodeURIComponent(period)}`);
+  },
+  /**
+   * Get popular articles shared via specific social media
+   */
+  getPopularSharedBySource(period, source) {
+    return client.get(`/newyorktimes/popular/shared/${encodeURIComponent(period)}/${encodeURIComponent(source)}`);
+  },
+  /**
+   * Get top stories by section
+   */
+  getTopStories(section) {
+    return client.get(`/newyorktimes/topstories/${encodeURIComponent(section)}`);
+  }
+});
+
+// src/flixquest.ts
+var flixquestApi = (client) => ({
+  getMovieStreamingLinks(tmdbID, provider) {
+    const p = provider ?? "showbox";
+    return client.get(`/flixquest/movie/${encodeURIComponent(tmdbID)}/${encodeURIComponent(p)}`);
+  },
+  getTvEpisodeStreamingLinks(tmdbID, season, episode, provider) {
+    const p = provider ?? "showbox";
+    return client.get(
+      `/flixquest/tv/${encodeURIComponent(tmdbID)}/${encodeURIComponent(String(season))}/${encodeURIComponent(String(episode))}/${encodeURIComponent(p)}`
+    );
+  }
+});
+
+// src/googlebooks.ts
+var googlebooksApi = (client) => ({
+  search(book) {
+    return client.get(`/googlebooks/search/${encodeURIComponent(book)}`);
+  },
+  getVolume(id) {
+    return client.get(`/googlebooks/volumes/${encodeURIComponent(id)}`);
+  },
+  searchAdvanced(params) {
+    const qs = new URLSearchParams();
+    qs.set("q", params.q);
+    if (params.startIndex !== void 0) qs.set("startIndex", String(params.startIndex));
+    if (params.maxResults !== void 0) qs.set("maxResults", String(params.maxResults));
+    if (params.orderBy) qs.set("orderBy", params.orderBy);
+    if (params.langRestrict) qs.set("langRestrict", params.langRestrict);
+    if (params.printType) qs.set("printType", params.printType);
+    if (params.projection) qs.set("projection", params.projection);
+    return client.get(`/googlebooks/search-advanced/results?${qs.toString()}`);
+  }
+});
+
+// src/hackernews.ts
+var hackernewsApi = (client) => ({
+  newStories(limit) {
+    const path = limit ? `/hackernews/newstories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/newstories";
+    return client.get(path);
+  },
+  topStories(limit) {
+    const path = limit ? `/hackernews/topstories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/topstories";
+    return client.get(path);
+  },
+  bestStories(limit) {
+    const path = limit ? `/hackernews/beststories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/beststories";
+    return client.get(path);
+  },
+  askStories(limit) {
+    const path = limit ? `/hackernews/askstories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/askstories";
+    return client.get(path);
+  },
+  showStories(limit) {
+    const path = limit ? `/hackernews/showstories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/showstories";
+    return client.get(path);
+  },
+  jobStories(limit) {
+    const path = limit ? `/hackernews/jobstories?limit=${encodeURIComponent(String(limit))}` : "/hackernews/jobstories";
+    return client.get(path);
+  },
+  getItem(id) {
+    return client.get(`/hackernews/item/${encodeURIComponent(id)}`);
+  },
+  getUser(id) {
+    return client.get(`/hackernews/user/${encodeURIComponent(id)}`);
+  },
+  updates() {
+    return client.get("/hackernews/updates");
+  },
+  maxItem() {
+    return client.get("/hackernews/maxitem");
+  }
+});
+
+// src/jsonplaceholder.ts
+var jsonplaceholderApi = (client) => ({
+  getPosts(page, limit) {
+    if (page !== void 0 || limit !== void 0) {
+      const p = page ?? 1;
+      const l = limit ?? 5;
+      return client.get(`/jsonplaceholder/posts/${p}/${l}`);
+    }
+    return client.get("/jsonplaceholder/posts");
+  },
+  getPost(id) {
+    return client.get(`/jsonplaceholder/post/${encodeURIComponent(String(id))}`);
+  },
+  getPostComments(id) {
+    return client.get(`/jsonplaceholder/post/${encodeURIComponent(String(id))}/comments`);
+  },
+  getComments() {
+    return client.get("/jsonplaceholder/comments");
+  },
+  getAlbums(page, limit) {
+    if (page !== void 0 || limit !== void 0) {
+      const p = page ?? 1;
+      const l = limit ?? 5;
+      return client.get(`/jsonplaceholder/albums/${p}/${l}`);
+    }
+    return client.get("/jsonplaceholder/albums");
+  },
+  getAlbum(id) {
+    return client.get(`/jsonplaceholder/album/${encodeURIComponent(String(id))}`);
+  },
+  getAlbumPhotos(id) {
+    return client.get(`/jsonplaceholder/album/${encodeURIComponent(String(id))}/photos`);
+  },
+  getPhotos(page, limit) {
+    if (page !== void 0 || limit !== void 0) {
+      const p = page ?? 1;
+      const l = limit ?? 5;
+      return client.get(`/jsonplaceholder/photos/${p}/${l}`);
+    }
+    return client.get("/jsonplaceholder/photos");
+  },
+  getPhoto(id) {
+    return client.get(`/jsonplaceholder/photo/${encodeURIComponent(String(id))}`);
+  },
+  getTodos() {
+    return client.get("/jsonplaceholder/todos");
+  },
+  getUsers(page, limit) {
+    if (page !== void 0 || limit !== void 0) {
+      const p = page ?? 1;
+      const l = limit ?? 5;
+      return client.get(`/jsonplaceholder/users/${p}/${l}`);
+    }
+    return client.get("/jsonplaceholder/users");
+  },
+  getUser(id) {
+    return client.get(`/jsonplaceholder/user/${encodeURIComponent(String(id))}`);
+  },
+  getUserPosts(id) {
+    return client.get(`/jsonplaceholder/user/${encodeURIComponent(String(id))}/posts`);
+  },
+  getUserTodos(id) {
+    return client.get(`/jsonplaceholder/user/${encodeURIComponent(String(id))}/todos`);
+  },
+  getUserAlbums(id) {
+    return client.get(`/jsonplaceholder/user/${encodeURIComponent(String(id))}/albums`);
+  }
+});
+
+// src/restcountries.ts
+var restCountriesApi = (client) => ({
+  /**
+   * Fetch all countries
+   */
+  getAll() {
+    return client.get("/restcountries/all");
+  },
+  /**
+   * Fetch country by name
+   */
+  getByName(name) {
+    return client.get(`/restcountries/${encodeURIComponent(name)}`);
+  },
+  /**
+   * Fetch country by ISO code
+   */
+  getByCode(code) {
+    return client.get(`/restcountries/code/${encodeURIComponent(code)}`);
+  },
+  /**
+   * Fetch multiple countries by codes (comma-separated)
+   */
+  getByCodes(codes) {
+    return client.get(`/restcountries/codes/${encodeURIComponent(codes)}`);
+  },
+  /**
+   * Fetch countries by currency
+   */
+  getByCurrency(currency) {
+    return client.get(`/restcountries/currency/${encodeURIComponent(currency)}`);
+  },
+  /**
+   * Fetch countries by language
+   */
+  getByLanguage(language) {
+    return client.get(`/restcountries/language/${encodeURIComponent(language)}`);
+  },
+  /**
+   * Fetch countries by capital city
+   */
+  getByCapital(capital) {
+    return client.get(`/restcountries/capital/${encodeURIComponent(capital)}`);
+  },
+  /**
+   * Fetch countries by region
+   */
+  getByRegion(region) {
+    return client.get(`/restcountries/region/${encodeURIComponent(region)}`);
+  },
+  /**
+   * Fetch countries by subregion
+   */
+  getBySubregion(subregion) {
+    return client.get(`/restcountries/subregion/${encodeURIComponent(subregion)}`);
+  }
+});
+
+// src/tvmaze.ts
+var tvMazeApi = (client) => ({
+  /**
+   * Search TV shows by name
+   */
+  searchShows(query) {
+    return client.get(`/tvmaze/shows/search/${encodeURIComponent(query)}`);
+  },
+  /**
+   * Get show details by show ID
+   */
+  getShow(showId) {
+    return client.get(`/tvmaze/shows/${showId}`);
+  },
+  /**
+   * Get seasons of a show
+   */
+  getSeasons(showId) {
+    return client.get(`/tvmaze/shows/${showId}/seasons`);
+  },
+  /**
+   * Get episodes of a season
+   */
+  getSeasonEpisodes(seasonId) {
+    return client.get(`/tvmaze/seasons/${seasonId}/episodes`);
+  },
+  /**
+   * Get episode details by episode ID
+   */
+  getEpisode(episodeId) {
+    return client.get(`/tvmaze/episodes/${episodeId}`);
+  }
+});
+
+// src/weather.ts
+var weatherApi = (client) => ({
+  /**
+   * Get weather forecast by city/location name
+   */
+  forecastByLocation(location, days) {
+    return client.get(
+      `/weather/forecast/${encodeURIComponent(location)}/${days}`
+    );
+  },
+  /**
+   * Get weather forecast by latitude & longitude
+   */
+  forecastByCoords(latitude, longitude) {
+    return client.get(
+      `/weather/forecast/${latitude}/${longitude}`
+    );
+  },
+  /**
+   * Search for a location
+   */
+  search(location) {
+    return client.get(
+      `/weather/search/${encodeURIComponent(location)}`
+    );
+  }
+});
+
+// src/reddit.ts
+var redditApi = (client) => ({
+  /**
+   * Fetch subreddit data
+   */
+  getSubreddit(subreddit, options) {
+    const listing = options?.listing ?? "top";
+    const time = options?.time ?? "week";
+    const limit = options?.limit ?? 20;
+    return client.get(
+      `/reddit/${encodeURIComponent(subreddit)}/${listing}/${time}/${limit}`
+    );
+  }
+});
+
+// src/index.ts
+var ApiHubClient = class {
+  constructor({ baseUrl }) {
+    const client = new HttpClient(baseUrl);
+    this.github = githubApi(client);
+    this.crypto = cryptoApi(client);
+    this.flixquest = flixquestApi(client);
+    this.googlebooks = googlebooksApi(client);
+    this.hackernews = hackernewsApi(client);
+    this.jsonplaceholder = jsonplaceholderApi(client);
+    this.youtube = youtubeApi(client);
+    this.apicagent = apicagentApi(client);
+    this.apotd = apotdApi(client);
+    this.bible = bibleApi(client);
+    this.chucknorris = chucknorrisApi(client);
+    this.randomuser = randomuserApi(client);
+    this.lyrics = lyricsApi(client);
+    this.mealdb = mealdbApi(client);
+    this.moviedb = moviedbApi(client);
+    this.news = newsApi(client);
+    this.newyorktimes = newyorktimesApi(client);
+    this.restcountries = restCountriesApi(client);
+    this.tvmaze = tvMazeApi(client);
+    this.weather = weatherApi(client);
+    this.reddit = redditApi(client);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiHubClient
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "api-hub-client",
+  "version": "1.0.0",
+  "description": "This is a API Hub client for the API routes",
+  "license": "MIT",
+  "author": "Biruk Lemma",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsup src/index.ts --dts"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}