@crosspost/sdk 0.1.3 → 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,91 +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';
-
-/**
- * Checks if the code is running in a Deno environment
- */
-export const isDeno = (): boolean => { // monorepo builds primarily for Deno
-  // we could expect that frontends in Deno environment will use this package,
-  // and then we can determine auth solution there (ValTown, Smallweb, etc)
-  return typeof (globalThis as any).Deno !== 'undefined';
-};
-
-/**
- * Checks if the code is running in a browser environment
- */
-export const isBrowser = (): boolean => {
-  return !isDeno() && typeof globalThis.window !== 'undefined';
-};
-
-export const AUTH_COOKIE_OPTIONS: Cookies.CookieAttributes = {
-  secure: true,
-  sameSite: 'lax', // Restrict to same-site and top-level navigation
-  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 (!isBrowser()) {
-      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 (!isBrowser()) {
-      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 (!isBrowser()) {
-    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 (!isBrowser()) {
-    return undefined;
-  }
-
-  return Cookies.get(CSRF_COOKIE_NAME);
-}

package/src/utils/error-utils.ts

@@ -1,310 +0,0 @@
-import { ApiError, ApiErrorCode, Platform, PlatformError } from '@crosspost/types';
-import { handleErrorResponse as baseHandleErrorResponse } from './error.ts';
-
-/**
- * Error categories grouped by type for better organization and usage
- */
-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,
-  );
-}
-
-/**
- * Re-export the handleErrorResponse function from error.ts
- * for backward compatibility
- */
-export function handleErrorResponse(data: any, status: number): ApiError | PlatformError {
-  return baseHandleErrorResponse(data, status);
-}
-
-/**
- * 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 || {},
-    );
-  }
-}