@crosspost/sdk 0.2.12 → 0.3.1

package/src/core/request.ts

@@ -1,5 +1,5 @@
+import retry from 'async-retry';
 import { ApiErrorCode, type ApiResponse, type StatusCode } from '@crosspost/types';
-import { createAuthToken, type NearAuthData } from 'near-sign-verify';
 import {
   createNetworkError,
   CrosspostError,
@@ -16,15 +16,13 @@ export interface RequestOptions {
    */
   baseUrl: URL;
   /**
-   * NEAR authentication data for generating auth tokens
-   * Required for non-GET requests, optional for GET requests
+   * Auth token from near-sign-verify
    */
-  nearAuthData?: NearAuthData;
+  authToken?: string;
   /**
-   * NEAR account ID for simplified GET request authentication
-   * If not provided, will use account_id from nearAuthData
+   * NEAR account ID for simple GET request authentication
    */
-  nearAccount?: string;
+  accountId?: string;
   /**
    * Request timeout in milliseconds
    */
@@ -76,122 +74,153 @@ export async function makeRequest<
     url,
   };
 
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), options.timeout);
-
-  try {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json',
-    };
-
-    // For GET requests, use X-Near-Account header if available
-    if (method === 'GET') {
-      const nearAccount = options.nearAccount || options.nearAuthData?.account_id;
-      if (!nearAccount) {
-        throw new CrosspostError(
-          'No NEAR account provided for GET request',
-          ApiErrorCode.UNAUTHORIZED,
-          401,
+  return retry(
+    async (bail, _attemptNumber) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+
+      try {
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        };
+
+        // For GET requests, use X-Near-Account header if available
+        if (method === 'GET') {
+          const accountId = options.accountId;
+          if (!accountId) {
+            throw new CrosspostError(
+              'No NEAR account provided for GET request',
+              ApiErrorCode.UNAUTHORIZED,
+              401,
+            );
+          }
+          headers['X-Near-Account'] = accountId;
+        } else {
+          // For non-GET requests, require authToken
+          if (!options.authToken) {
+            throw new CrosspostError(
+              'Auth token required for non-GET request',
+              ApiErrorCode.UNAUTHORIZED,
+              401,
+            );
+          }
+          headers['Authorization'] = `Bearer ${options.authToken}`;
+        }
+
+        const requestOptions: RequestInit = {
+          method,
+          headers,
+          body: method !== 'GET' && data ? JSON.stringify(data) : undefined,
+          signal: controller.signal,
+        };
+
+        const response = await fetch(url, requestOptions);
+        clearTimeout(timeoutId);
+
+        let responseData: ApiResponse<TResponse>;
+        try {
+          responseData = await response.json();
+        } catch (jsonError) {
+          // JSON parsing failed - try to get response text for context
+          let responseText: string | undefined;
+          try {
+            responseText = await response.text();
+          } catch (_) { /* ignore */ }
+
+          throw new CrosspostError(
+            `API request failed with status ${response.status} and non-JSON response`,
+            ApiErrorCode.INVALID_RESPONSE,
+            response.status as StatusCode,
+            {
+              originalStatusText: response.statusText,
+              originalError: jsonError instanceof Error ? jsonError.message : String(jsonError),
+              responseText,
+            },
+          );
+        }
+
+        // Handle non-ok responses (4xx/5xx)
+        if (!response.ok) {
+          throw handleErrorResponse(responseData, response.status);
+        }
+
+        // Validate success response structure
+        if (
+          !responseData || typeof responseData !== 'object' || !('success' in responseData) ||
+          !('meta' in responseData)
+        ) {
+          throw new CrosspostError(
+            'Invalid response format from API',
+            ApiErrorCode.INVALID_RESPONSE,
+            response.status as StatusCode,
+            { responseData },
+          );
+        }
+
+        if (responseData.success) {
+          return responseData as ApiResponse<TResponse>;
+        }
+
+        // If we get here, we have response.ok but success: false
+        // This is unexpected - treat as an error
+        throw handleErrorResponse(responseData, response.status);
+      } catch (error) {
+        clearTimeout(timeoutId);
+
+        // Check if the error is one we want to retry on
+        if (
+          error instanceof TypeError ||
+          (error instanceof DOMException && error.name === 'AbortError')
+        ) {
+          // If it's a retryable error, async-retry will handle the retry.
+          // Re-throw it here so async-retry knows the attempt failed.
+          throw error;
+        }
+
+        // If it's not a retryable error, or if retries are exhausted,
+        // enrich and bail out of retries.
+        if (error instanceof CrosspostError) {
+          // Enrich CrosspostError with request context and bail
+          const enrichedError = enrichErrorWithContext(error, context);
+          bail(enrichedError); // bail will throw this error
+          throw enrichedError; // Redundant but satisfies some linters/type checkers
+        }
+
+        if (
+          error instanceof TypeError ||
+          (error instanceof DOMException && error.name === 'AbortError')
+        ) {
+          const networkError = createNetworkError(error, url.toString(), options.timeout);
+          const enrichedNetworkError = enrichErrorWithContext(networkError, context);
+          bail(enrichedNetworkError);
+          throw enrichedNetworkError;
+        }
+
+        // For any other non-retryable errors, wrap them, enrich, and bail
+        const wrappedError = new CrosspostError(
+          error instanceof Error ? error.message : String(error),
+          ApiErrorCode.INTERNAL_ERROR,
+          500,
+          { originalError: String(error) },
         );
+        const enrichedWrappedError = enrichErrorWithContext(wrappedError, context);
+        bail(enrichedWrappedError); // bail will throw this error
+        throw enrichedWrappedError; // Redundant
       }
-      headers['X-Near-Account'] = nearAccount;
-    } else {
-      // For non-GET requests, require nearAuthData
-      if (!options.nearAuthData) {
-        throw new CrosspostError(
-          'NEAR authentication data required for non-GET request',
-          ApiErrorCode.UNAUTHORIZED,
-          401,
+    },
+    {
+      retries: 3,
+      factor: 1,
+      minTimeout: 1000,
+      maxTimeout: 1000,
+      onRetry: (error, attempt) => {
+        console.warn(
+          `Attempt ${attempt} failed for ${context.method} ${context.path}: ${
+            (error instanceof Error) ? error.message : 'Unknown error'
+          }. Retrying...`,
         );
-      }
-      headers['Authorization'] = `Bearer ${createAuthToken(options.nearAuthData)}`;
-    }
-
-    const requestOptions: RequestInit = {
-      method,
-      headers,
-      body: method !== 'GET' && data ? JSON.stringify(data) : undefined,
-      signal: controller.signal,
-    };
-
-    const response = await fetch(url, requestOptions);
-    clearTimeout(timeoutId);
-
-    let responseData: ApiResponse<TResponse>;
-    try {
-      responseData = await response.json();
-    } catch (jsonError) {
-      // JSON parsing failed - try to get response text for context
-      let responseText: string | undefined;
-      try {
-        responseText = await response.text();
-      } catch (_) { /* ignore */ }
-
-      throw new CrosspostError(
-        `API request failed with status ${response.status} and non-JSON response`,
-        ApiErrorCode.INVALID_RESPONSE,
-        response.status as StatusCode,
-        {
-          originalStatusText: response.statusText,
-          originalError: jsonError instanceof Error ? jsonError.message : String(jsonError),
-          responseText,
-        },
-      );
-    }
-
-    // Handle non-ok responses (4xx/5xx)
-    if (!response.ok) {
-      throw handleErrorResponse(responseData, response.status);
-    }
-
-    // Validate success response structure
-    if (
-      !responseData || typeof responseData !== 'object' || !('success' in responseData) ||
-      !('meta' in responseData)
-    ) {
-      throw new CrosspostError(
-        'Invalid response format from API',
-        ApiErrorCode.INVALID_RESPONSE,
-        response.status as StatusCode,
-        { responseData },
-      );
-    }
-
-    if (responseData.success) {
-      return responseData as ApiResponse<TResponse>;
-    }
-
-    // If we get here, we have response.ok but success: false
-    // This is unexpected - treat as an error
-    throw handleErrorResponse(responseData, response.status);
-  } catch (error) {
-    clearTimeout(timeoutId);
-
-    if (error instanceof CrosspostError) {
-      // Enrich CrosspostError with request context
-      throw enrichErrorWithContext(error, context);
-    }
-
-    // Handle network errors (including timeouts)
-    if (
-      error instanceof TypeError || (error instanceof DOMException && error.name === 'AbortError')
-    ) {
-      throw enrichErrorWithContext(
-        createNetworkError(error, url.toString(), options.timeout),
-        context,
-      );
-    }
-
-    // For any other errors, wrap them with context
-    throw enrichErrorWithContext(
-      new CrosspostError(
-        error instanceof Error ? error.message : String(error),
-        ApiErrorCode.INTERNAL_ERROR,
-        500,
-        { originalError: String(error) },
-      ),
-      context,
-    );
-  }
+      },
+    },
+  );
 }

package/src/index.ts

@@ -7,7 +7,6 @@ export { PostApi } from './api/post.ts';
 export { SystemApi } from './api/system.ts';
 
 export {
-  apiWrapper,
   CrosspostError,
   getErrorDetails,
   getErrorMessage,

package/src/utils/error.ts

@@ -195,54 +195,6 @@ export function enrichErrorWithContext(
   );
 }
 
-/**
- * Wrapper for API calls with consistent error handling
- */
-export async function apiWrapper<T>(
-  apiCall: () => Promise<T>,
-  context?: Record<string, unknown>,
-): Promise<T> {
-  try {
-    return await apiCall();
-  } catch (error) {
-    // If it's a Response object, use handleErrorResponse
-    if (error instanceof Response) {
-      try {
-        const errorData = await error.json();
-        throw enrichErrorWithContext(
-          handleErrorResponse(errorData, error.status),
-          context || {},
-        );
-      } catch (jsonError) {
-        // If JSON parsing fails, create a generic error
-        if (jsonError instanceof Error && jsonError.name === 'SyntaxError') {
-          throw enrichErrorWithContext(
-            createError(
-              `API request failed with status ${error.status} and non-JSON response`,
-              ApiErrorCode.NETWORK_ERROR,
-              error.status as StatusCode,
-              { originalResponse: error.statusText },
-            ),
-            context || {},
-          );
-        }
-        throw jsonError;
-      }
-    }
-
-    // If it's already a CrosspostError, just add context
-    if (error instanceof CrosspostError) {
-      throw enrichErrorWithContext(error, context || {});
-    }
-
-    // Otherwise wrap it in a CrosspostError
-    throw enrichErrorWithContext(
-      error instanceof Error ? error : new Error(String(error)),
-      context || {},
-    );
-  }
-}
-
 /**
  * Handles error responses from the API and converts them to appropriate error objects.
  */