@crosspost/sdk 0.1.2 → 0.1.4

package/src/utils/error.ts

@@ -1,5 +1,305 @@
 import { ApiError, ApiErrorCode, Platform, PlatformError } from '@crosspost/types';
 
+/**
+ * Error categories grouped by type
+ */
+export const ERROR_CATEGORIES = {
+  AUTH: [
+    ApiErrorCode.UNAUTHORIZED,
+    ApiErrorCode.FORBIDDEN,
+  ],
+  VALIDATION: [
+    ApiErrorCode.VALIDATION_ERROR,
+    ApiErrorCode.INVALID_REQUEST,
+  ],
+  NETWORK: [
+    ApiErrorCode.NETWORK_ERROR,
+  ],
+  PLATFORM: [
+    ApiErrorCode.PLATFORM_ERROR,
+    ApiErrorCode.PLATFORM_UNAVAILABLE,
+  ],
+  CONTENT: [
+    ApiErrorCode.CONTENT_POLICY_VIOLATION,
+    ApiErrorCode.DUPLICATE_CONTENT,
+  ],
+  RATE_LIMIT: [
+    ApiErrorCode.RATE_LIMITED,
+  ],
+  POST: [
+    ApiErrorCode.POST_CREATION_FAILED,
+    ApiErrorCode.THREAD_CREATION_FAILED,
+    ApiErrorCode.POST_DELETION_FAILED,
+    ApiErrorCode.POST_INTERACTION_FAILED,
+  ],
+  MEDIA: [
+    ApiErrorCode.MEDIA_UPLOAD_FAILED,
+  ],
+};
+
+/**
+ * Check if an error belongs to a specific category
+ *
+ * @param error The error to check
+ * @param category The category to check against
+ * @returns True if the error belongs to the category, false otherwise
+ */
+export function isErrorOfCategory(error: unknown, category: ApiErrorCode[]): boolean {
+  if (error instanceof ApiError) {
+    return category.includes(error.code);
+  }
+
+  if (error instanceof PlatformError) {
+    return category.includes(error.code);
+  }
+
+  // Fallback for error-like objects with code property
+  if (error && typeof error === 'object' && 'code' in error) {
+    return category.includes((error as any).code);
+  }
+
+  return false;
+}
+
+/**
+ * Check if an error is an authentication error
+ *
+ * @param error The error to check
+ * @returns True if the error is an authentication error, false otherwise
+ */
+export function isAuthError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.AUTH);
+}
+
+/**
+ * Check if an error is a validation error
+ *
+ * @param error The error to check
+ * @returns True if the error is a validation error, false otherwise
+ */
+export function isValidationError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.VALIDATION);
+}
+
+/**
+ * Check if an error is a network error
+ *
+ * @param error The error to check
+ * @returns True if the error is a network error, false otherwise
+ */
+export function isNetworkError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.NETWORK);
+}
+
+/**
+ * Check if an error is a platform error
+ *
+ * @param error The error to check
+ * @returns True if the error is a platform error, false otherwise
+ */
+export function isPlatformError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.PLATFORM) || error instanceof PlatformError;
+}
+
+/**
+ * Check if an error is a content policy error
+ *
+ * @param error The error to check
+ * @returns True if the error is a content policy error, false otherwise
+ */
+export function isContentError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.CONTENT);
+}
+
+/**
+ * Check if an error is a rate limit error
+ *
+ * @param error The error to check
+ * @returns True if the error is a rate limit error, false otherwise
+ */
+export function isRateLimitError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.RATE_LIMIT);
+}
+
+/**
+ * Check if an error is a post-related error
+ *
+ * @param error The error to check
+ * @returns True if the error is a post-related error, false otherwise
+ */
+export function isPostError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.POST);
+}
+
+/**
+ * Check if an error is a media-related error
+ *
+ * @param error The error to check
+ * @returns True if the error is a media-related error, false otherwise
+ */
+export function isMediaError(error: unknown): boolean {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.MEDIA);
+}
+
+/**
+ * Check if an error is recoverable
+ *
+ * @param error The error to check
+ * @returns True if the error is recoverable, false otherwise
+ */
+export function isRecoverableError(error: unknown): boolean {
+  if (error instanceof ApiError || error instanceof PlatformError) {
+    return error.recoverable;
+  }
+
+  return false;
+}
+
+/**
+ * Get a user-friendly error message
+ *
+ * @param error The error to get the message from
+ * @param defaultMessage The default message to return if no message is found
+ * @returns The error message
+ */
+export function getErrorMessage(
+  error: unknown,
+  defaultMessage: string = 'An error occurred',
+): string {
+  if (error instanceof Error) {
+    return error.message || defaultMessage;
+  }
+
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  if (error && typeof error === 'object' && 'message' in error) {
+    return (error as any).message || defaultMessage;
+  }
+
+  return defaultMessage;
+}
+
+/**
+ * Extract error details if available
+ *
+ * @param error The error to extract details from
+ * @returns The error details or undefined if none are found
+ */
+export function getErrorDetails(error: unknown): Record<string, any> | undefined {
+  if (error instanceof ApiError || error instanceof PlatformError) {
+    return error.details;
+  }
+
+  if (error && typeof error === 'object' && 'details' in error) {
+    return (error as any).details;
+  }
+
+  return undefined;
+}
+
+/**
+ * Enrich an error with additional context
+ *
+ * @param error The error to enrich
+ * @param context The context to add to the error
+ * @returns The enriched error
+ */
+export function enrichErrorWithContext(
+  error: unknown,
+  context: Record<string, any>,
+): Error {
+  if (error instanceof ApiError) {
+    // Create a new ApiError with the merged details since details is read-only
+    return new ApiError(
+      error.message,
+      error.code,
+      error.status,
+      { ...(error.details || {}), ...context },
+      error.recoverable,
+    );
+  }
+
+  if (error instanceof PlatformError) {
+    // Create a new PlatformError with the merged details since details is read-only
+    return new PlatformError(
+      error.message,
+      error.platform,
+      error.code,
+      error.recoverable,
+      error.originalError,
+      error.status,
+      error.userId,
+      { ...(error.details || {}), ...context },
+    );
+  }
+
+  // For regular errors or non-Error objects, create a new ApiError with the context
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  return new ApiError(
+    errorMessage || 'An error occurred',
+    ApiErrorCode.INTERNAL_ERROR,
+    500,
+    { originalError: error, ...context },
+    false,
+  );
+}
+
+/**
+ * Wrapper for API calls with consistent error handling
+ *
+ * @param apiCall The API call to wrap
+ * @param context Optional context to add to any errors
+ * @returns The result of the API call
+ * @throws An enriched error if the API call fails
+ */
+export async function apiWrapper<T>(
+  apiCall: () => Promise<T>,
+  context?: Record<string, any>,
+): 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(
+            new ApiError(
+              `API request failed with status ${error.status} and non-JSON response`,
+              ApiErrorCode.NETWORK_ERROR,
+              error.status as any,
+              { originalResponse: error.statusText },
+            ),
+            context || {},
+          );
+        }
+        // If it's already an enriched error from handleErrorResponse, just throw it
+        throw jsonError;
+      }
+    }
+
+    // If it's already an ApiError or PlatformError, just add context
+    if (error instanceof ApiError || error instanceof PlatformError) {
+      throw enrichErrorWithContext(error, context || {});
+    }
+
+    // Otherwise wrap it in an ApiError
+    throw enrichErrorWithContext(
+      error instanceof Error ? error : new Error(String(error)),
+      context || {},
+    );
+  }
+}
+
 /**
  * Handles error responses from the API and converts them to appropriate error objects.
  *

package/src/utils/cookie.ts

@@ -1,75 +0,0 @@
-import Cookies from 'js-cookie';
-import type { NearAuthData } from 'near-sign-verify';
-
-export const AUTH_COOKIE_NAME = '__crosspost_auth';
-export const CSRF_COOKIE_NAME = 'XSRF-TOKEN';
-export const CSRF_HEADER_NAME = 'X-CSRF-Token';
-
-export const AUTH_COOKIE_OPTIONS: Cookies.CookieAttributes = {
-  secure: true,
-  sameSite: 'lax', // how could we make this none?
-  path: '/',
-  expires: 30, // 30 days
-};
-
-/**
- * Gets authentication data from the cookie
- * @returns The NearAuthData object or undefined if not found
- */
-export function getAuthFromCookie(): NearAuthData | undefined {
-  try {
-    if (typeof document === 'undefined') {
-      return undefined;
-    }
-
-    const cookieValue = Cookies.get(AUTH_COOKIE_NAME);
-    if (!cookieValue) {
-      return undefined;
-    }
-
-    return JSON.parse(cookieValue) as NearAuthData;
-  } catch (error) {
-    console.error('Failed to parse auth cookie:', error);
-    return undefined;
-  }
-}
-
-/**
- * Stores authentication data in a secure cookie
- * @param authData The NearAuthData object to store
- */
-export function storeAuthInCookie(authData: NearAuthData): void {
-  try {
-    if (typeof document === 'undefined') {
-      return;
-    }
-
-    const cookieValue = JSON.stringify(authData);
-    Cookies.set(AUTH_COOKIE_NAME, cookieValue, AUTH_COOKIE_OPTIONS);
-  } catch (error) {
-    console.error('Failed to store auth cookie:', error);
-  }
-}
-
-/**
- * Clears the authentication cookie
- */
-export function clearAuthCookie(): void {
-  if (typeof document === 'undefined') {
-    return;
-  }
-
-  Cookies.remove(AUTH_COOKIE_NAME, { path: AUTH_COOKIE_OPTIONS.path });
-}
-
-/**
- * Gets the CSRF token from the cookie
- * @returns The CSRF token or undefined if not found
- */
-export function getCsrfToken(): string | undefined {
-  if (typeof document === 'undefined') {
-    return undefined;
-  }
-
-  return Cookies.get(CSRF_COOKIE_NAME);
-}