@crosspost/sdk 0.1.7 → 0.1.9

package/src/api/auth.ts

@@ -1,9 +1,16 @@
 import type {
-  ApiResponse,
+  AuthCallbackResponse,
+  AuthInitRequest,
   AuthRevokeResponse,
+  AuthStatusParams,
   AuthStatusResponse,
+  AuthTokenRequest,
+  AuthUrlResponse,
+  ConnectedAccount,
   ConnectedAccountsResponse,
+  NearAuthorizationRequest,
   NearAuthorizationResponse,
+  NearUnauthorizationResponse,
   Platform,
 } from '@crosspost/types';
 import { makeRequest, type RequestOptions } from '../core/request.ts';
@@ -27,7 +34,7 @@ export class AuthApi {
    * @returns A promise resolving with the authorization response.
    */
   async authorizeNearAccount(): Promise<NearAuthorizationResponse> {
-    return makeRequest<NearAuthorizationResponse>(
+    return makeRequest<NearAuthorizationResponse, NearAuthorizationRequest>(
       'POST',
       '/auth/authorize/near',
       this.options,
@@ -40,7 +47,7 @@ export class AuthApi {
    * @returns A promise resolving with the authorization status response.
    */
   async getNearAuthorizationStatus(): Promise<NearAuthorizationResponse> {
-    return makeRequest<NearAuthorizationResponse>(
+    return makeRequest<NearAuthorizationResponse, never>(
       'GET',
       '/auth/authorize/near/status',
       this.options,
@@ -56,9 +63,9 @@ export class AuthApi {
    */
   async loginToPlatform(
     platform: Platform,
-    options?: { successUrl?: string; errorUrl?: string },
-  ): Promise<ApiResponse<any>> { // TODO: Refine response type based on actual API
-    return makeRequest<ApiResponse<any>>(
+    options?: AuthInitRequest,
+  ): Promise<AuthUrlResponse> {
+    return makeRequest<AuthUrlResponse, AuthInitRequest>(
       'POST',
       `/auth/${platform}/login`,
       this.options,
@@ -69,26 +76,29 @@ export class AuthApi {
   /**
    * Refreshes the authentication token for the specified platform.
    * @param platform The target platform.
-   * @returns A promise resolving with the refresh response.
+   * @returns A promise resolving with the refresh response containing updated auth details.
    */
-  async refreshToken(platform: Platform): Promise<ApiResponse<any>> { // TODO: Refine response type
-    return makeRequest<ApiResponse<any>>(
+  async refreshToken(platform: Platform, userId: string): Promise<AuthCallbackResponse> {
+    return makeRequest<AuthCallbackResponse, AuthTokenRequest>(
       'POST',
       `/auth/${platform}/refresh`,
       this.options,
+      { userId },
     );
   }
 
   /**
    * Refreshes the user's profile information from the specified platform.
    * @param platform The target platform.
-   * @returns A promise resolving with the profile refresh response.
+   * @param userId The user ID on the platform
+   * @returns A promise resolving with the updated account profile information.
    */
-  async refreshProfile(platform: Platform): Promise<ApiResponse<any>> { // TODO: Refine response type
-    return makeRequest<ApiResponse<any>>(
+  async refreshProfile(platform: Platform, userId: string): Promise<ConnectedAccount> {
+    return makeRequest<ConnectedAccount, AuthTokenRequest>(
       'POST',
       `/auth/${platform}/refresh-profile`,
       this.options,
+      { userId },
     );
   }
 
@@ -97,11 +107,26 @@ export class AuthApi {
    * @param platform The target platform.
    * @returns A promise resolving with the authentication status response.
    */
-  async getAuthStatus(platform: Platform): Promise<AuthStatusResponse> {
-    return makeRequest<AuthStatusResponse>(
+  async getAuthStatus(platform: Platform, userId: string): Promise<AuthStatusResponse> {
+    return makeRequest<AuthStatusResponse, never, AuthStatusParams>(
       'GET',
-      `/auth/${platform}/status`,
+      `/auth/${platform}/status/${userId}`,
       this.options,
+      undefined,
+      { platform, userId },
+    );
+  }
+
+  /**
+   * Unauthorizes a NEAR account from using the service
+   * @returns A promise resolving with the unauthorized response
+   */
+  async unauthorizeNear(): Promise<NearUnauthorizationResponse> {
+    return makeRequest<NearUnauthorizationResponse, NearAuthorizationRequest>(
+      'DELETE',
+      '/auth/unauthorize/near',
+      this.options,
+      {},
     );
   }
 
@@ -110,11 +135,12 @@ export class AuthApi {
    * @param platform The target platform.
    * @returns A promise resolving with the revocation response.
    */
-  async revokeAuth(platform: Platform): Promise<AuthRevokeResponse> {
-    return makeRequest<AuthRevokeResponse>(
+  async revokeAuth(platform: Platform, userId: string): Promise<AuthRevokeResponse> {
+    return makeRequest<AuthRevokeResponse, AuthTokenRequest>(
       'DELETE',
       `/auth/${platform}/revoke`,
       this.options,
+      { userId },
     );
   }
 
@@ -123,7 +149,7 @@ export class AuthApi {
    * @returns A promise resolving with the list of connected accounts.
    */
   async getConnectedAccounts(): Promise<ConnectedAccountsResponse> {
-    return makeRequest<ConnectedAccountsResponse>(
+    return makeRequest<ConnectedAccountsResponse, never>(
       'GET',
       '/auth/accounts',
       this.options,

package/src/api/post.ts

@@ -36,7 +36,7 @@ export class PostApi {
    * @returns A promise resolving with the post creation response.
    */
   async createPost(request: CreatePostRequest): Promise<CreatePostResponse> {
-    return makeRequest<CreatePostResponse>(
+    return makeRequest<CreatePostResponse, CreatePostRequest>(
       'POST',
       '/api/post',
       this.options,
@@ -50,7 +50,7 @@ export class PostApi {
    * @returns A promise resolving with the repost response.
    */
   async repost(request: RepostRequest): Promise<RepostResponse> {
-    return makeRequest<RepostResponse>(
+    return makeRequest<RepostResponse, RepostRequest>(
       'POST',
       '/api/post/repost',
       this.options,
@@ -64,7 +64,7 @@ export class PostApi {
    * @returns A promise resolving with the quote post response.
    */
   async quotePost(request: QuotePostRequest): Promise<QuotePostResponse> {
-    return makeRequest<QuotePostResponse>(
+    return makeRequest<QuotePostResponse, QuotePostRequest>(
       'POST',
       '/api/post/quote',
       this.options,
@@ -78,7 +78,7 @@ export class PostApi {
    * @returns A promise resolving with the reply response.
    */
   async replyToPost(request: ReplyToPostRequest): Promise<ReplyToPostResponse> {
-    return makeRequest<ReplyToPostResponse>(
+    return makeRequest<ReplyToPostResponse, ReplyToPostRequest>(
       'POST',
       '/api/post/reply',
       this.options,
@@ -92,7 +92,7 @@ export class PostApi {
    * @returns A promise resolving with the like response.
    */
   async likePost(request: LikePostRequest): Promise<LikePostResponse> {
-    return makeRequest<LikePostResponse>(
+    return makeRequest<LikePostResponse, LikePostRequest>(
       'POST',
       `/api/post/like`,
       this.options,
@@ -106,7 +106,7 @@ export class PostApi {
    * @returns A promise resolving with the unlike response.
    */
   async unlikePost(request: UnlikePostRequest): Promise<UnlikePostResponse> {
-    return makeRequest<UnlikePostResponse>(
+    return makeRequest<UnlikePostResponse, UnlikePostRequest>(
       'DELETE',
       `/api/post/like`,
       this.options,
@@ -120,7 +120,7 @@ export class PostApi {
    * @returns A promise resolving with the delete response.
    */
   async deletePost(request: DeletePostRequest): Promise<DeletePostResponse> {
-    return makeRequest<DeletePostResponse>(
+    return makeRequest<DeletePostResponse, DeletePostRequest>(
       'DELETE',
       `/api/post`,
       this.options,

package/src/api/system.ts

@@ -1,4 +1,9 @@
-import type { ApiResponse, EndpointRateLimitResponse, RateLimitResponse } from '@crosspost/types';
+import type {
+  EndpointRateLimitResponse,
+  HealthStatus,
+  RateLimitEndpointParam,
+  RateLimitResponse,
+} from '@crosspost/types';
 import { makeRequest, type RequestOptions } from '../core/request.ts';
 
 /**
@@ -21,7 +26,7 @@ export class SystemApi {
    * @returns A promise resolving with the rate limit response
    */
   async getRateLimits(): Promise<RateLimitResponse> {
-    return makeRequest<RateLimitResponse>(
+    return makeRequest<RateLimitResponse, never>(
       'GET',
       '/api/rate-limit',
       this.options,
@@ -34,10 +39,12 @@ export class SystemApi {
    * @returns A promise resolving with the endpoint rate limit response
    */
   async getEndpointRateLimit(endpoint: string): Promise<EndpointRateLimitResponse> {
-    return makeRequest<EndpointRateLimitResponse>(
+    return makeRequest<EndpointRateLimitResponse, never, RateLimitEndpointParam>(
       'GET',
       `/api/rate-limit/${endpoint}`,
       this.options,
+      undefined,
+      { endpoint },
     );
   }
 
@@ -45,8 +52,8 @@ export class SystemApi {
    * Gets the health status of the API
    * @returns A promise resolving with the health status
    */
-  async getHealthStatus(): Promise<ApiResponse<{ status: string }>> {
-    return makeRequest<ApiResponse<{ status: string }>>(
+  async getHealthStatus(): Promise<HealthStatus> {
+    return makeRequest<HealthStatus, never>(
       'GET',
       '/health',
       this.options,

package/src/core/client.ts

@@ -24,14 +24,12 @@ export class CrosspostClient {
   constructor(config: CrosspostClientConfig = {}) {
     const baseUrl = config.baseUrl || DEFAULT_CONFIG.baseUrl; // you can deploy your own
     const timeout = config.timeout || DEFAULT_CONFIG.timeout;
-    const retries = config.retries ?? DEFAULT_CONFIG.retries;
 
     const nearAuthData = config.nearAuthData;
 
     this.options = {
       baseUrl,
       timeout,
-      retries,
       nearAuthData,
     };
 
@@ -43,17 +41,56 @@ export class CrosspostClient {
 
   /**
    * Sets the authentication data (signature) for the client
+   * Required for non-GET requests
    * @param nearAuthData The NEAR authentication data
    */
   public setAuthentication(nearAuthData: NearAuthData): void {
     this.options.nearAuthData = nearAuthData;
+    // Also set nearAccount from nearAuthData if not already set
+    if (!this.options.nearAccount) {
+      this.options.nearAccount = nearAuthData.account_id;
+    }
+  }
+
+  /**
+   * Sets the NEAR account ID for simplified GET request authentication
+   * If not set, will use account_id from nearAuthData
+   * @param nearAccount The NEAR account ID
+   */
+  public setNearAccount(nearAccount: string): void {
+    this.options.nearAccount = nearAccount;
+  }
+
+  /**
+   * Gets the current NEAR account ID being used for authentication
+   * @returns The NEAR account ID from nearAccount or nearAuthData
+   */
+  public getNearAccount(): string | undefined {
+    return this.options.nearAccount || this.options.nearAuthData?.account_id;
   }
 
   /**
    * Checks if authentication data (signature) exists on client
-   * @param signature The NEAR authentication data
+   * @returns true if nearAuthData is set (required for non-GET requests)
    */
   public isAuthenticated(): boolean {
     return !!this.options.nearAuthData;
   }
+
+  /**
+   * Checks if a NEAR account is set for GET request authentication
+   * @returns true if either nearAccount or nearAuthData.account_id is set
+   */
+  public hasNearAccount(): boolean {
+    return !!(this.options.nearAccount || this.options.nearAuthData?.account_id);
+  }
+
+  /**
+   * Clears all authentication data from the client
+   * This will prevent all requests from working until new authentication is set
+   */
+  public clear(): void {
+    this.options.nearAuthData = undefined;
+    this.options.nearAccount = undefined;
+  }
 }

package/src/core/config.ts

@@ -18,11 +18,6 @@ export interface CrosspostClientConfig {
    * @default 30000
    */
   timeout?: number;
-  /**
-   * Number of retries for failed requests (specifically for network errors or 5xx status codes)
-   * @default 2
-   */
-  retries?: number;
 }
 
 /**
@@ -31,5 +26,4 @@ export interface CrosspostClientConfig {
 export const DEFAULT_CONFIG: Required<Omit<CrosspostClientConfig, 'nearAuthData'>> = {
   baseUrl: 'https://open-crosspost-proxy.deno.dev/',
   timeout: 30000,
-  retries: 2,
 };

package/src/core/request.ts

@@ -1,9 +1,9 @@
 import { ApiErrorCode, type StatusCode } from '@crosspost/types';
 import { createAuthToken, type NearAuthData } from 'near-sign-verify';
 import {
-  apiWrapper,
   createNetworkError,
   CrosspostError,
+  enrichErrorWithContext,
   handleErrorResponse,
 } from '../utils/error.ts';
 
@@ -17,21 +17,22 @@ export interface RequestOptions {
   baseUrl: string;
   /**
    * NEAR authentication data for generating auth tokens
-   * Can be undefined if not authorize yet
+   * Required for non-GET requests, optional for GET requests
    */
   nearAuthData?: NearAuthData;
   /**
-   * Request timeout in milliseconds
+   * NEAR account ID for simplified GET request authentication
+   * If not provided, will use account_id from nearAuthData
    */
-  timeout: number;
+  nearAccount?: string;
   /**
-   * Number of retries for failed requests
+   * Request timeout in milliseconds
    */
-  retries: number;
+  timeout: number;
 }
 
 /**
- * Makes a request to the API with retry and error handling
+ * Makes a request to the API with error handling
  *
  * @param method The HTTP method
  * @param path The API path
@@ -39,17 +40,21 @@ export interface RequestOptions {
  * @param data Optional request data
  * @returns A promise resolving with the response data
  */
-export async function makeRequest<T>(
+export async function makeRequest<
+  TResponse,
+  TRequest = unknown,
+  TQuery = unknown,
+>(
   method: string,
   path: string,
   options: RequestOptions,
-  data?: any,
-  query?: Record<string, any>,
-): Promise<T> {
+  data?: TRequest,
+  query?: TQuery,
+): Promise<TResponse> {
   let url = `${options.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
 
   // Add query parameters if provided
-  if (query && Object.keys(query).length > 0) {
+  if (query && typeof query === 'object' && Object.keys(query).length > 0) {
     const queryParams = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
       if (value !== undefined && value !== null) {
@@ -67,109 +72,118 @@ export async function makeRequest<T>(
     method,
     path,
     url,
-    retries: options.retries,
   };
 
-  return apiWrapper(async () => {
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt <= options.retries; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+  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,
+        );
+      }
+      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,
+        );
+      }
+      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: any;
+    try {
+      responseData = await response.json();
+    } catch (jsonError) {
+      // JSON parsing failed - try to get response text for context
+      let responseText: string | undefined;
       try {
-        const headers: Record<string, string> = {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json',
-          '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); // Clear timeout if fetch completes
-
-        let responseData: any;
-        try {
-          responseData = await response.json();
-        } catch (jsonError) {
-          // If JSON parsing fails, did API throw an error?
-          if (!response.ok) {
-            throw new CrosspostError(
-              `API request failed with status ${response.status} and non-JSON response`,
-              ApiErrorCode.NETWORK_ERROR,
-              response.status as StatusCode,
-              { originalStatusText: response.statusText },
-            );
-          }
-          // Otherwise, throw a custom error
-          throw new CrosspostError(
-            `Failed to parse JSON response: ${
-              jsonError instanceof Error ? jsonError.message : String(jsonError)
-            }`,
-            ApiErrorCode.INTERNAL_ERROR,
-            response.status as StatusCode,
-          );
-        }
-
-        if (!response.ok) {
-          lastError = handleErrorResponse(responseData, response.status);
-          // Only retry rate limit errors
-          const shouldRetry = lastError instanceof CrosspostError &&
-            lastError.code === ApiErrorCode.RATE_LIMITED;
-          if (shouldRetry && attempt < options.retries) {
-            await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-            continue; // Retry
-          }
-          throw lastError; // Throw error if not retrying or retries exhausted
-        }
-
-        // Handle response based on success flag
-        if (responseData && typeof responseData === 'object' && 'success' in responseData) {
-          if (responseData.success) {
-            // Success response - return the data
-            return responseData.data as T;
-          } else {
-            // Error response - handle with our error utilities
-            lastError = handleErrorResponse(responseData, response.status);
-            // Only retry rate limit errors
-            const shouldRetry = lastError instanceof CrosspostError &&
-              lastError.code === ApiErrorCode.RATE_LIMITED;
-            if (shouldRetry && attempt < options.retries) {
-              await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-              continue; // Retry
-            }
-            throw lastError;
-          }
-        }
-      } catch (error) {
-        clearTimeout(timeoutId); // Clear timeout on error
-        lastError = error instanceof Error ? error : new Error(String(error)); // Store the error
-
-        // Handle fetch/network errors specifically for retries
-        const isNetworkError = error instanceof TypeError ||
-          (error instanceof DOMException && error.name === 'AbortError');
-        if (isNetworkError && attempt < options.retries) {
-          await new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, attempt))); // Exponential backoff
-          continue; // Retry network error
-        }
-
-        // If it's not a known ApiError/PlatformError, wrap it
-        if (!(error instanceof CrosspostError)) {
-          throw createNetworkError(error, url, options.timeout);
-        }
-
-        throw error; // Re-throw known ApiError or final network error
-      }
+        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);
     }
 
-    // Should not be reachable if retries >= 0, but needed for type safety
-    throw lastError ||
-      new CrosspostError('Request failed after multiple retries', ApiErrorCode.INTERNAL_ERROR, 500);
-  }, context);
+    // Validate success response structure
+    if (!responseData || typeof responseData !== 'object' || !('success' in responseData)) {
+      throw new CrosspostError(
+        'Invalid success response format from API',
+        ApiErrorCode.INVALID_RESPONSE,
+        response.status as StatusCode,
+        { responseData },
+      );
+    }
+
+    if (responseData.success) {
+      return responseData.data as 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, 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,
+    );
+  }
 }