@harkenapp/sdk-react-native 0.0.1-alpha.1 → 0.0.1-alpha.2

package/src/api/client.ts

@@ -1,20 +1,20 @@
-import type { components } from '../types/index.js';
-import { HarkenApiError, HarkenNetworkError } from './errors';
-import { withRetry } from './retry';
-import type { RetryConfig } from './retry';
+import type { components } from "../types/index.js";
+import { HarkenApiError, HarkenNetworkError } from "./errors";
+import { withRetry } from "./retry";
+import type { RetryConfig } from "./retry";
 
 // Re-export types from contracts for convenience
-type FeedbackSubmission = components['schemas']['FeedbackSubmission'];
-type FeedbackSubmissionResponse = components['schemas']['FeedbackSubmissionResponse'];
-type ErrorResponse = components['schemas']['ErrorResponse'];
+type FeedbackSubmission = components["schemas"]["FeedbackSubmission"];
+type FeedbackSubmissionResponse = components["schemas"]["FeedbackSubmissionResponse"];
+type ErrorResponse = components["schemas"]["ErrorResponse"];
 
 // Attachment types
-type AttachmentPresignRequest = components['schemas']['AttachmentPresignRequest'];
-type AttachmentPresignResponse = components['schemas']['AttachmentPresignResponse'];
-type AttachmentConfirmRequest = components['schemas']['AttachmentConfirmRequest'];
-type AttachmentStatusResponse = components['schemas']['AttachmentStatusResponse'];
+type AttachmentPresignRequest = components["schemas"]["AttachmentPresignRequest"];
+type AttachmentPresignResponse = components["schemas"]["AttachmentPresignResponse"];
+type AttachmentConfirmRequest = components["schemas"]["AttachmentConfirmRequest"];
+type AttachmentStatusResponse = components["schemas"]["AttachmentStatusResponse"];
 
-const DEFAULT_API_BASE_URL = 'https://api.harken.app';
+const DEFAULT_API_BASE_URL = "https://api.harken.app";
 
 export interface HarkenClientConfig {
   /** Publishable API key */
@@ -34,9 +34,9 @@ export interface HarkenClientConfig {
  */
 export class HarkenClient {
   private readonly config: Required<
-    Pick<HarkenClientConfig, 'publishableKey' | 'baseUrl' | 'timeout'>
+    Pick<HarkenClientConfig, "publishableKey" | "baseUrl" | "timeout">
   > &
-    Pick<HarkenClientConfig, 'userToken' | 'retry'>;
+    Pick<HarkenClientConfig, "userToken" | "retry">;
 
   constructor(config: HarkenClientConfig) {
     this.config = {
@@ -51,14 +51,13 @@ export class HarkenClient {
   /**
    * Submit feedback to the API.
    */
-  async submitFeedback(
-    submission: FeedbackSubmission
-  ): Promise<FeedbackSubmissionResponse> {
+  async submitFeedback(submission: FeedbackSubmission): Promise<FeedbackSubmissionResponse> {
     return withRetry(
-      () => this.request<FeedbackSubmissionResponse>('/v1/feedback', {
-        method: 'POST',
-        body: JSON.stringify(submission),
-      }),
+      () =>
+        this.request<FeedbackSubmissionResponse>("/v1/feedback", {
+          method: "POST",
+          body: JSON.stringify(submission),
+        }),
       this.config.retry
     );
   }
@@ -71,13 +70,10 @@ export class HarkenClient {
   ): Promise<AttachmentPresignResponse> {
     return withRetry(
       () =>
-        this.request<AttachmentPresignResponse>(
-          '/v1/feedback/attachments/presign',
-          {
-            method: 'POST',
-            body: JSON.stringify(request),
-          }
-        ),
+        this.request<AttachmentPresignResponse>("/v1/feedback/attachments/presign", {
+          method: "POST",
+          body: JSON.stringify(request),
+        }),
       this.config.retry
     );
   }
@@ -91,13 +87,10 @@ export class HarkenClient {
   ): Promise<AttachmentStatusResponse> {
     return withRetry(
       () =>
-        this.request<AttachmentStatusResponse>(
-          `/v1/feedback/attachments/${attachmentId}/confirm`,
-          {
-            method: 'POST',
-            body: request ? JSON.stringify(request) : undefined,
-          }
-        ),
+        this.request<AttachmentStatusResponse>(`/v1/feedback/attachments/${attachmentId}/confirm`, {
+          method: "POST",
+          body: request ? JSON.stringify(request) : undefined,
+        }),
       this.config.retry
     );
   }
@@ -110,43 +103,33 @@ export class HarkenClient {
     attachmentId: string,
     error?: string
   ): Promise<AttachmentStatusResponse> {
-    return this.request<AttachmentStatusResponse>(
-      `/v1/feedback/attachments/${attachmentId}/fail`,
-      {
-        method: 'POST',
-        body: error ? JSON.stringify({ error }) : undefined,
-      }
-    );
+    return this.request<AttachmentStatusResponse>(`/v1/feedback/attachments/${attachmentId}/fail`, {
+      method: "POST",
+      body: error ? JSON.stringify({ error }) : undefined,
+    });
   }
 
   /**
    * Get attachment status and download URLs.
    */
-  async getAttachmentStatus(
-    attachmentId: string
-  ): Promise<AttachmentStatusResponse> {
-    return this.request<AttachmentStatusResponse>(
-      `/v1/feedback/attachments/${attachmentId}`
-    );
+  async getAttachmentStatus(attachmentId: string): Promise<AttachmentStatusResponse> {
+    return this.request<AttachmentStatusResponse>(`/v1/feedback/attachments/${attachmentId}`);
   }
 
   /**
    * Make an authenticated request to the API.
    */
-  private async request<T>(
-    path: string,
-    options: RequestInit = {}
-  ): Promise<T> {
+  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
     const url = `${this.config.baseUrl}${path}`;
 
     const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'X-Publishable-Key': this.config.publishableKey,
+      "Content-Type": "application/json",
+      "X-Publishable-Key": this.config.publishableKey,
       ...(options.headers as Record<string, string>),
     };
 
     if (this.config.userToken) {
-      headers['X-User-Token'] = this.config.userToken;
+      headers["X-User-Token"] = this.config.userToken;
     }
 
     // Create abort controller for timeout
@@ -165,9 +148,7 @@ export class HarkenClient {
       if (!response.ok) {
         const errorBody = await this.parseErrorResponse(response);
         // Only parse Retry-After for 429 responses
-        const retryAfter = response.status === 429
-          ? this.parseRetryAfter(response)
-          : undefined;
+        const retryAfter = response.status === 429 ? this.parseRetryAfter(response) : undefined;
         throw new HarkenApiError(response.status, errorBody, { retryAfter });
       }
 
@@ -181,18 +162,18 @@ export class HarkenClient {
       }
 
       // Handle abort (timeout)
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new HarkenNetworkError('Request timed out', error);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new HarkenNetworkError("Request timed out", error);
       }
 
       // Handle other fetch errors (network issues)
       if (error instanceof TypeError) {
-        throw new HarkenNetworkError('Network request failed', error);
+        throw new HarkenNetworkError("Network request failed", error);
       }
 
       // Unknown error
       throw new HarkenNetworkError(
-        error instanceof Error ? error.message : 'Unknown error',
+        error instanceof Error ? error.message : "Unknown error",
         error instanceof Error ? error : undefined
       );
     }
@@ -209,7 +190,7 @@ export class HarkenClient {
       return {
         error: {
           code: `http_${response.status}`,
-          message: response.statusText || 'Request failed',
+          message: response.statusText || "Request failed",
         },
       };
     }
@@ -220,7 +201,7 @@ export class HarkenClient {
    * Supports both delta-seconds and HTTP-date formats.
    */
   private parseRetryAfter(response: Response): number | undefined {
-    const retryAfter = response.headers.get('Retry-After');
+    const retryAfter = response.headers.get("Retry-After");
     if (!retryAfter) {
       return undefined;
     }

package/src/api/errors.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect } from "vitest";
+import { HarkenError, HarkenApiError, HarkenNetworkError } from "./errors";
+
+describe("HarkenError", () => {
+  it("creates error with message", () => {
+    const error = new HarkenError("Something went wrong");
+    expect(error.message).toBe("Something went wrong");
+  });
+});
+
+describe("HarkenApiError", () => {
+  it("creates error with status, code, and message", () => {
+    const error = new HarkenApiError(400, {
+      error: {
+        code: "validation_error",
+        message: "Invalid input",
+      },
+    });
+
+    expect(error.status).toBe(400);
+    expect(error.code).toBe("validation_error");
+    expect(error.message).toBe("Invalid input");
+  });
+
+  it("includes error details when provided", () => {
+    const error = new HarkenApiError(400, {
+      error: {
+        code: "validation_error",
+        message: "Invalid input",
+        details: [
+          { field: "message", message: "Required field" },
+          { field: "category", message: "Invalid value" },
+        ],
+      },
+    });
+
+    expect(error.details).toHaveLength(2);
+    expect(error.details?.[0]).toEqual({
+      field: "message",
+      message: "Required field",
+    });
+  });
+
+  it("stores retryAfter when provided", () => {
+    const error = new HarkenApiError(
+      429,
+      { error: { code: "rate_limited", message: "Too many requests" } },
+      { retryAfter: 60 }
+    );
+
+    expect(error.retryAfter).toBe(60);
+  });
+
+  describe("isValidationError", () => {
+    it("returns true for 400 status", () => {
+      const error = new HarkenApiError(400, {
+        error: { code: "validation_error", message: "Invalid" },
+      });
+      expect(error.isValidationError).toBe(true);
+    });
+
+    it("returns false for other statuses", () => {
+      const error = new HarkenApiError(401, {
+        error: { code: "unauthorized", message: "Unauthorized" },
+      });
+      expect(error.isValidationError).toBe(false);
+    });
+  });
+
+  describe("isUnauthorized", () => {
+    it("returns true for 401 status", () => {
+      const error = new HarkenApiError(401, {
+        error: { code: "unauthorized", message: "Unauthorized" },
+      });
+      expect(error.isUnauthorized).toBe(true);
+    });
+
+    it("returns false for other statuses", () => {
+      const error = new HarkenApiError(403, {
+        error: { code: "forbidden", message: "Forbidden" },
+      });
+      expect(error.isUnauthorized).toBe(false);
+    });
+  });
+
+  describe("isRateLimited", () => {
+    it("returns true for 429 status", () => {
+      const error = new HarkenApiError(429, {
+        error: { code: "rate_limited", message: "Too many requests" },
+      });
+      expect(error.isRateLimited).toBe(true);
+    });
+
+    it("returns false for other statuses", () => {
+      const error = new HarkenApiError(400, {
+        error: { code: "validation_error", message: "Invalid" },
+      });
+      expect(error.isRateLimited).toBe(false);
+    });
+  });
+
+  describe("isServerError", () => {
+    it("returns true for 5xx statuses", () => {
+      expect(
+        new HarkenApiError(500, {
+          error: { code: "internal_error", message: "Server error" },
+        }).isServerError
+      ).toBe(true);
+
+      expect(
+        new HarkenApiError(502, {
+          error: { code: "bad_gateway", message: "Bad gateway" },
+        }).isServerError
+      ).toBe(true);
+
+      expect(
+        new HarkenApiError(503, {
+          error: { code: "service_unavailable", message: "Service unavailable" },
+        }).isServerError
+      ).toBe(true);
+    });
+
+    it("returns false for 4xx statuses", () => {
+      expect(
+        new HarkenApiError(400, {
+          error: { code: "validation_error", message: "Invalid" },
+        }).isServerError
+      ).toBe(false);
+
+      expect(
+        new HarkenApiError(429, {
+          error: { code: "rate_limited", message: "Rate limited" },
+        }).isServerError
+      ).toBe(false);
+    });
+  });
+
+  describe("isRetryable", () => {
+    it("returns true for 429 (rate limited)", () => {
+      const error = new HarkenApiError(429, {
+        error: { code: "rate_limited", message: "Too many requests" },
+      });
+      expect(error.isRetryable).toBe(true);
+    });
+
+    it("returns true for 5xx (server errors)", () => {
+      const error500 = new HarkenApiError(500, {
+        error: { code: "internal_error", message: "Server error" },
+      });
+      const error503 = new HarkenApiError(503, {
+        error: { code: "service_unavailable", message: "Unavailable" },
+      });
+
+      expect(error500.isRetryable).toBe(true);
+      expect(error503.isRetryable).toBe(true);
+    });
+
+    it("returns false for 4xx (client errors except 429)", () => {
+      const error400 = new HarkenApiError(400, {
+        error: { code: "validation_error", message: "Invalid" },
+      });
+      const error401 = new HarkenApiError(401, {
+        error: { code: "unauthorized", message: "Unauthorized" },
+      });
+      const error404 = new HarkenApiError(404, {
+        error: { code: "not_found", message: "Not found" },
+      });
+
+      expect(error400.isRetryable).toBe(false);
+      expect(error401.isRetryable).toBe(false);
+      expect(error404.isRetryable).toBe(false);
+    });
+  });
+});
+
+describe("HarkenNetworkError", () => {
+  it("creates error with message", () => {
+    const error = new HarkenNetworkError("Network request failed");
+    expect(error.message).toBe("Network request failed");
+  });
+
+  it("stores cause when provided", () => {
+    const cause = new TypeError("Failed to fetch");
+    const error = new HarkenNetworkError("Network request failed", cause);
+
+    expect(error.cause).toBe(cause);
+  });
+
+  it("isRetryable always returns true", () => {
+    const error = new HarkenNetworkError("Network failed");
+    expect(error.isRetryable).toBe(true);
+  });
+});

package/src/api/errors.ts

@@ -1,7 +1,7 @@
-import type { components } from '../types/index.js';
+import type { components } from "../types/index.js";
 
-type ErrorResponse = components['schemas']['ErrorResponse'];
-type ErrorDetail = components['schemas']['ErrorDetail'];
+type ErrorResponse = components["schemas"]["ErrorResponse"];
+type ErrorDetail = components["schemas"]["ErrorDetail"];
 
 /**
  * Base error class for Harken API errors.
@@ -9,7 +9,7 @@ type ErrorDetail = components['schemas']['ErrorDetail'];
 export class HarkenError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = 'HarkenError';
+    this.name = "HarkenError";
   }
 }
 
@@ -26,13 +26,9 @@ export class HarkenApiError extends HarkenError {
   /** Retry-After value in seconds (from 429 responses) */
   readonly retryAfter?: number;
 
-  constructor(
-    status: number,
-    response: ErrorResponse,
-    options?: { retryAfter?: number }
-  ) {
+  constructor(status: number, response: ErrorResponse, options?: { retryAfter?: number }) {
     super(response.error.message);
-    this.name = 'HarkenApiError';
+    this.name = "HarkenApiError";
     this.status = status;
     this.code = response.error.code;
     this.details = response.error.details;
@@ -73,7 +69,7 @@ export class HarkenNetworkError extends HarkenError {
 
   constructor(message: string, cause?: Error) {
     super(message);
-    this.name = 'HarkenNetworkError';
+    this.name = "HarkenNetworkError";
     this.cause = cause;
   }
 

package/src/api/index.ts

@@ -1,15 +1,11 @@
 // Client
-export { HarkenClient, createHarkenClient } from './client';
-export type { HarkenClientConfig } from './client';
+export { HarkenClient, createHarkenClient } from "./client";
+export type { HarkenClientConfig } from "./client";
 
 // Errors
-export {
-  HarkenError,
-  HarkenApiError,
-  HarkenNetworkError,
-} from './errors';
+export { HarkenError, HarkenApiError, HarkenNetworkError } from "./errors";
 
 // Retry utilities
-export { withRetry, calculateRetryDelay, isRetryableError } from './retry';
-export type { RetryConfig } from './retry';
-export { DEFAULT_RETRY_CONFIG } from './retry';
+export { withRetry, calculateRetryDelay, isRetryableError } from "./retry";
+export type { RetryConfig } from "./retry";
+export { DEFAULT_RETRY_CONFIG } from "./retry";