@thalorlabs/jokeapi 1.0.1 → 1.1.0

package/dist/JokeApiClient.d.ts

@@ -1,3 +1,4 @@
+import { BaseHttpClient } from '@thalorlabs/api';
 import { TLJoke, EJokeType, EJokeCategory } from '@thalorlabs/types';
 export interface JokeApiClientConfig {
     baseURL?: string;
@@ -11,16 +12,13 @@ export interface JokeApiQueryParams {
 /**
  * HTTP adapter for v2.jokeapi.dev.
  *
- * Calls the external API and normalises the raw response to TLJoke.
- * Supports both single and twopart jokes, category filtering, and safe mode.
+ * Extends BaseHttpClient for retry logic, exponential backoff, and
+ * observability. Supports both single and twopart jokes, category
+ * filtering, and safe mode. Normalises the raw response to TLJoke.
  * No DB, no cache, no logging — pure HTTP adapter.
- *
- * When @thalorlabs/api is available, this should extend BaseHttpClient
- * instead of managing its own axios instance.
  */
-export declare class JokeApiClient {
+export declare class JokeApiClient extends BaseHttpClient {
     readonly serviceName = "jokeapi";
-    private readonly axiosInstance;
     constructor(config?: JokeApiClientConfig);
     getJoke(params?: JokeApiQueryParams): Promise<TLJoke>;
     private normalise;

package/dist/JokeApiClient.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JokeApiClient = void 0;
-const axios_1 = __importDefault(require("axios"));
 const crypto_1 = require("crypto");
+const api_1 = require("@thalorlabs/api");
 const types_1 = require("@thalorlabs/types");
 /** Maps TL categories to JokeAPI v2 category strings. */
 const CATEGORY_MAP = {
@@ -29,23 +26,20 @@ const REVERSE_CATEGORY_MAP = {
 /**
  * HTTP adapter for v2.jokeapi.dev.
  *
- * Calls the external API and normalises the raw response to TLJoke.
- * Supports both single and twopart jokes, category filtering, and safe mode.
+ * Extends BaseHttpClient for retry logic, exponential backoff, and
+ * observability. Supports both single and twopart jokes, category
+ * filtering, and safe mode. Normalises the raw response to TLJoke.
  * No DB, no cache, no logging — pure HTTP adapter.
- *
- * When @thalorlabs/api is available, this should extend BaseHttpClient
- * instead of managing its own axios instance.
  */
-class JokeApiClient {
+class JokeApiClient extends api_1.BaseHttpClient {
     constructor(config = {}) {
-        this.serviceName = 'jokeapi';
-        this.axiosInstance = axios_1.default.create({
+        super({
             baseURL: config.baseURL ?? 'https://v2.jokeapi.dev',
+            serviceName: 'jokeapi',
+            retries: 3,
             timeout: config.timeout ?? 10000,
-            headers: {
-                Accept: 'application/json',
-            },
         });
+        this.serviceName = 'jokeapi';
     }
     async getJoke(params = {}) {
         const category = params.category
@@ -59,7 +53,9 @@ class JokeApiClient {
         if (params.safe) {
             queryParams.safe = 'true';
         }
-        const { data } = await this.axiosInstance.get(`/joke/${category}`, { params: queryParams });
+        const url = `/joke/${category}`;
+        const { response } = await this.handleRequest({ method: 'GET', url, params: queryParams }, { method: 'GET', url, requestId: (0, crypto_1.randomUUID)() });
+        const data = response.data;
         if (data.error) {
             throw new Error(`JokeAPI error: ${data.message}`);
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@thalorlabs/jokeapi",
   "author": "ThalorLabs",
   "private": false,
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Provider adapter for v2.jokeapi.dev — returns TLJoke",
   "homepage": "https://github.com/ThalorLabs/jokeapi#readme",
   "bugs": {
@@ -40,7 +40,7 @@
     "vitest": "^3.0.0"
   },
   "dependencies": {
-    "@thalorlabs/types": "^1.7.0",
-    "axios": "^1.7.0"
+    "@thalorlabs/api": "^1.0.0",
+    "@thalorlabs/types": "^1.7.0"
   }
 }

package/src/JokeApiClient.ts

@@ -1,5 +1,5 @@
-import axios, { AxiosInstance } from 'axios';
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
+import { BaseHttpClient } from '@thalorlabs/api';
 import { TLJoke, EJokeType, EJokeCategory } from '@thalorlabs/types';
 import { JokeApiRawResponse, JokeApiErrorResponse } from './JokeApiTypes';
 
@@ -38,24 +38,20 @@ const REVERSE_CATEGORY_MAP: Record<string, EJokeCategory> = {
 /**
  * HTTP adapter for v2.jokeapi.dev.
  *
- * Calls the external API and normalises the raw response to TLJoke.
- * Supports both single and twopart jokes, category filtering, and safe mode.
+ * Extends BaseHttpClient for retry logic, exponential backoff, and
+ * observability. Supports both single and twopart jokes, category
+ * filtering, and safe mode. Normalises the raw response to TLJoke.
  * No DB, no cache, no logging — pure HTTP adapter.
- *
- * When @thalorlabs/api is available, this should extend BaseHttpClient
- * instead of managing its own axios instance.
  */
-export class JokeApiClient {
+export class JokeApiClient extends BaseHttpClient {
   public readonly serviceName = 'jokeapi';
-  private readonly axiosInstance: AxiosInstance;
 
   constructor(config: JokeApiClientConfig = {}) {
-    this.axiosInstance = axios.create({
+    super({
       baseURL: config.baseURL ?? 'https://v2.jokeapi.dev',
+      serviceName: 'jokeapi',
+      retries: 3,
       timeout: config.timeout ?? 10000,
-      headers: {
-        Accept: 'application/json',
-      },
     });
   }
 
@@ -75,9 +71,15 @@ export class JokeApiClient {
       queryParams.safe = 'true';
     }
 
-    const { data } = await this.axiosInstance.get<
+    const url = `/joke/${category}`;
+    const { response } = await this.handleRequest<
       JokeApiRawResponse | JokeApiErrorResponse
-    >(`/joke/${category}`, { params: queryParams });
+    >(
+      { method: 'GET', url, params: queryParams },
+      { method: 'GET', url, requestId: randomUUID() }
+    );
+
+    const data = response.data;
 
     if (data.error) {
       throw new Error(

package/tests/JokeApiClient.test.ts

@@ -1,24 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { JokeApiClient } from '../src/JokeApiClient';
 import { EJokeType, EJokeCategory } from '@thalorlabs/types';
-import axios from 'axios';
-
-vi.mock('axios', () => {
-  const mockAxiosInstance = {
-    get: vi.fn(),
-  };
-  return {
-    default: {
-      create: vi.fn(() => mockAxiosInstance),
-    },
-  };
-});
+import { BaseHttpClient } from '@thalorlabs/api';
 
-function getMockAxios() {
-  const instance = (axios.create as ReturnType<typeof vi.fn>).mock.results[0]
-    .value;
-  return instance.get as ReturnType<typeof vi.fn>;
-}
+const mockHandleRequest = vi.fn();
+vi.spyOn(BaseHttpClient.prototype as any, 'handleRequest').mockImplementation(
+  mockHandleRequest
+);
 
 describe('JokeApiClient', () => {
   let client: JokeApiClient;
@@ -32,37 +20,24 @@ describe('JokeApiClient', () => {
     it('sets serviceName to jokeapi', () => {
       expect(client.serviceName).toBe('jokeapi');
     });
-
-    it('creates axios instance with default config', () => {
-      expect(axios.create).toHaveBeenCalledWith({
-        baseURL: 'https://v2.jokeapi.dev',
-        timeout: 10000,
-        headers: { Accept: 'application/json' },
-      });
-    });
   });
 
   describe('getJoke — single joke', () => {
     it('normalises a single joke to TLJoke', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: false,
-          category: 'Programming',
-          type: 'single',
-          joke: 'A SQL query walks into a bar, walks up to two tables and asks... can I join you?',
-          flags: {
-            nsfw: false,
-            religious: false,
-            political: false,
-            racist: false,
-            sexist: false,
-            explicit: false,
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: false,
+            category: 'Programming',
+            type: 'single',
+            joke: 'A SQL query walks into a bar.',
+            flags: { nsfw: false, religious: false, political: false, racist: false, sexist: false, explicit: false },
+            id: 42,
+            safe: true,
+            lang: 'en',
           },
-          id: 42,
-          safe: true,
-          lang: 'en',
         },
+        durationMs: 50,
       });
 
       const joke = await client.getJoke();
@@ -79,26 +54,21 @@ describe('JokeApiClient', () => {
 
   describe('getJoke — twopart joke', () => {
     it('normalises a twopart joke to TLJoke', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: false,
-          category: 'Programming',
-          type: 'twopart',
-          setup: 'Why do programmers prefer dark mode?',
-          delivery: 'Because light attracts bugs.',
-          flags: {
-            nsfw: false,
-            religious: false,
-            political: false,
-            racist: false,
-            sexist: false,
-            explicit: false,
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: false,
+            category: 'Programming',
+            type: 'twopart',
+            setup: 'Why do programmers prefer dark mode?',
+            delivery: 'Because light attracts bugs.',
+            flags: { nsfw: false, religious: false, political: false, racist: false, sexist: false, explicit: false },
+            id: 58,
+            safe: true,
+            lang: 'en',
           },
-          id: 58,
-          safe: true,
-          lang: 'en',
         },
+        durationMs: 50,
       });
 
       const joke = await client.getJoke();
@@ -114,104 +84,83 @@ describe('JokeApiClient', () => {
 
   describe('getJoke — category mapping', () => {
     it('maps PROGRAMMING category to Programming endpoint', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: false,
-          category: 'Programming',
-          type: 'single',
-          joke: 'A joke',
-          flags: {
-            nsfw: false,
-            religious: false,
-            political: false,
-            racist: false,
-            sexist: false,
-            explicit: false,
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: false, category: 'Programming', type: 'single', joke: 'A joke',
+            flags: { nsfw: false, religious: false, political: false, racist: false, sexist: false, explicit: false },
+            id: 1, safe: true, lang: 'en',
           },
-          id: 1,
-          safe: true,
-          lang: 'en',
         },
+        durationMs: 10,
       });
 
       await client.getJoke({ category: EJokeCategory.PROGRAMMING });
 
-      expect(mockGet).toHaveBeenCalledWith('/joke/Programming', { params: {} });
+      expect(mockHandleRequest).toHaveBeenCalledWith(
+        expect.objectContaining({ url: '/joke/Programming' }),
+        expect.objectContaining({ url: '/joke/Programming' })
+      );
     });
 
     it('uses Any when no category specified', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: false,
-          category: 'Misc',
-          type: 'single',
-          joke: 'A joke',
-          flags: {
-            nsfw: false,
-            religious: false,
-            political: false,
-            racist: false,
-            sexist: false,
-            explicit: false,
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: false, category: 'Misc', type: 'single', joke: 'A joke',
+            flags: { nsfw: false, religious: false, political: false, racist: false, sexist: false, explicit: false },
+            id: 1, safe: true, lang: 'en',
           },
-          id: 1,
-          safe: true,
-          lang: 'en',
         },
+        durationMs: 10,
       });
 
       await client.getJoke();
 
-      expect(mockGet).toHaveBeenCalledWith('/joke/Any', { params: {} });
+      expect(mockHandleRequest).toHaveBeenCalledWith(
+        expect.objectContaining({ url: '/joke/Any' }),
+        expect.objectContaining({ url: '/joke/Any' })
+      );
     });
   });
 
   describe('getJoke — safe mode', () => {
     it('passes safe=true query param when requested', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: false,
-          category: 'Misc',
-          type: 'single',
-          joke: 'A joke',
-          flags: {
-            nsfw: false,
-            religious: false,
-            political: false,
-            racist: false,
-            sexist: false,
-            explicit: false,
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: false, category: 'Misc', type: 'single', joke: 'A joke',
+            flags: { nsfw: false, religious: false, political: false, racist: false, sexist: false, explicit: false },
+            id: 1, safe: true, lang: 'en',
           },
-          id: 1,
-          safe: true,
-          lang: 'en',
         },
+        durationMs: 10,
       });
 
       await client.getJoke({ safe: true });
 
-      expect(mockGet).toHaveBeenCalledWith('/joke/Any', {
-        params: { safe: 'true' },
-      });
+      expect(mockHandleRequest).toHaveBeenCalledWith(
+        expect.objectContaining({ params: { safe: 'true' } }),
+        expect.anything()
+      );
     });
   });
 
   describe('getJoke — error handling', () => {
     it('throws on JokeAPI error response', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockResolvedValueOnce({
-        data: {
-          error: true,
-          internalError: false,
-          code: 106,
-          message: 'No matching joke found',
-          causedBy: ['No jokes found'],
-          additionalInfo: '',
-          timestamp: Date.now(),
+      mockHandleRequest.mockResolvedValueOnce({
+        response: {
+          data: {
+            error: true,
+            internalError: false,
+            code: 106,
+            message: 'No matching joke found',
+            causedBy: ['No jokes found'],
+            additionalInfo: '',
+            timestamp: Date.now(),
+          },
         },
+        durationMs: 10,
       });
 
       await expect(client.getJoke()).rejects.toThrow(
@@ -219,9 +168,8 @@ describe('JokeApiClient', () => {
       );
     });
 
-    it('propagates network errors', async () => {
-      const mockGet = getMockAxios();
-      mockGet.mockRejectedValueOnce(new Error('Network error'));
+    it('propagates errors from handleRequest', async () => {
+      mockHandleRequest.mockRejectedValueOnce(new Error('Network error'));
 
       await expect(client.getJoke()).rejects.toThrow('Network error');
     });