@crosspost/sdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -4059,19 +4059,22 @@ var z = /* @__PURE__ */ Object.freeze({
 });
 
 // ../types/dist/index.js
-var PlatformSchema = z.enum([
-  "unknown",
-  "twitter"
-  // Add more platforms as they're implemented
-  // 'linkedin',
-  // 'facebook',
-  // 'instagram',
-]).describe("Social media platform");
 var Platform = /* @__PURE__ */ ((Platform2) => {
   Platform2["UNKNOWN"] = "unknown";
   Platform2["TWITTER"] = "twitter";
   return Platform2;
 })(Platform || {});
+var PlatformSchema = z.nativeEnum(Platform).describe("Social media platform");
+var SUPPORTED_PLATFORMS = [
+  "twitter"
+  /* TWITTER */
+  // Add more platforms here as they're implemented
+];
+var SupportedPlatformSchema = SUPPORTED_PLATFORMS.length > 0 ? z.enum(SUPPORTED_PLATFORMS) : z.never();
+SupportedPlatformSchema.describe("Currently supported social media platforms");
+function isPlatformSupported(platform) {
+  return SUPPORTED_PLATFORMS.includes(platform);
+}
 var ApiResponseSchema = z.object({
   data: z.any().describe("Response data"),
   meta: z.object({
@@ -4679,13 +4682,21 @@ var EndpointRateLimitResponseSchema = z.object({
   endpoint: z.string().describe("API endpoint or action"),
   signerId: z.string().describe("NEAR account ID")
 }).describe("Endpoint rate limit response");
-var LeaderboardQuerySchema = z.object({
+var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
+  TimePeriod2["ALL_TIME"] = "all";
+  TimePeriod2["YEARLY"] = "yearly";
+  TimePeriod2["MONTHLY"] = "monthly";
+  TimePeriod2["WEEKLY"] = "weekly";
+  TimePeriod2["DAILY"] = "daily";
+  return TimePeriod2;
+})(TimePeriod || {});
+var ActivityLeaderboardQuerySchema = z.object({
   timeframe: z.enum(["day", "week", "month", "all"]).optional().describe(
     "Timeframe for the leaderboard"
   ),
   limit: z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z.number().min(1).max(100).optional()).describe("Maximum number of results to return (1-100)"),
   offset: z.string().optional().transform((val) => val ? parseInt(val, 10) : void 0).pipe(z.number().min(0).optional()).describe("Offset for pagination")
-}).describe("Leaderboard query");
+}).describe("Activity leaderboard query");
 var AccountActivityEntrySchema = z.object({
   signerId: z.string().describe("NEAR account ID"),
   totalPosts: z.number().describe("Total number of posts"),
@@ -4697,7 +4708,7 @@ var AccountActivityEntrySchema = z.object({
   rank: z.number().describe("Rank on the leaderboard"),
   lastActive: z.string().datetime().describe("Timestamp of last activity")
 }).describe("Account activity entry");
-var LeaderboardResponseSchema = EnhancedResponseSchema(
+var ActivityLeaderboardResponseSchema = EnhancedResponseSchema(
   z.object({
     timeframe: z.enum(["day", "week", "month", "all"]).describe("Timeframe for the leaderboard"),
     entries: z.array(AccountActivityEntrySchema).describe("Leaderboard entries"),
@@ -4706,7 +4717,7 @@ var LeaderboardResponseSchema = EnhancedResponseSchema(
     offset: z.number().describe("Offset for pagination"),
     generatedAt: z.string().datetime().describe("Timestamp when the leaderboard was generated")
   })
-).describe("Leaderboard response");
+).describe("Activity leaderboard response");
 var AccountActivityParamsSchema = z.object({
   signerId: z.string().describe("NEAR account ID")
 }).describe("Account activity params");
@@ -4802,6 +4813,168 @@ var ProfileRefreshResponseSchema = EnhancedResponseSchema(
 import { createAuthToken } from "near-sign-verify";
 
 // src/utils/error.ts
+var 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
+  ]
+};
+function isErrorOfCategory(error, category) {
+  if (error instanceof ApiError) {
+    return category.includes(error.code);
+  }
+  if (error instanceof PlatformError) {
+    return category.includes(error.code);
+  }
+  if (error && typeof error === "object" && "code" in error) {
+    return category.includes(error.code);
+  }
+  return false;
+}
+function isAuthError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.AUTH);
+}
+function isValidationError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.VALIDATION);
+}
+function isNetworkError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.NETWORK);
+}
+function isPlatformError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.PLATFORM) || error instanceof PlatformError;
+}
+function isContentError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.CONTENT);
+}
+function isRateLimitError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.RATE_LIMIT);
+}
+function isPostError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.POST);
+}
+function isMediaError(error) {
+  return isErrorOfCategory(error, ERROR_CATEGORIES.MEDIA);
+}
+function isRecoverableError(error) {
+  if (error instanceof ApiError || error instanceof PlatformError) {
+    return error.recoverable;
+  }
+  return false;
+}
+function getErrorMessage(error, defaultMessage = "An error occurred") {
+  if (error instanceof Error) {
+    return error.message || defaultMessage;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return error.message || defaultMessage;
+  }
+  return defaultMessage;
+}
+function getErrorDetails(error) {
+  if (error instanceof ApiError || error instanceof PlatformError) {
+    return error.details;
+  }
+  if (error && typeof error === "object" && "details" in error) {
+    return error.details;
+  }
+  return void 0;
+}
+function enrichErrorWithContext(error, context) {
+  if (error instanceof ApiError) {
+    return new ApiError(
+      error.message,
+      error.code,
+      error.status,
+      { ...error.details || {}, ...context },
+      error.recoverable
+    );
+  }
+  if (error instanceof PlatformError) {
+    return new PlatformError(
+      error.message,
+      error.platform,
+      error.code,
+      error.recoverable,
+      error.originalError,
+      error.status,
+      error.userId,
+      { ...error.details || {}, ...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
+  );
+}
+async function apiWrapper(apiCall, context) {
+  try {
+    return await apiCall();
+  } catch (error) {
+    if (error instanceof Response) {
+      try {
+        const errorData = await error.json();
+        throw enrichErrorWithContext(
+          handleErrorResponse(errorData, error.status),
+          context || {}
+        );
+      } catch (jsonError) {
+        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,
+              { originalResponse: error.statusText }
+            ),
+            context || {}
+          );
+        }
+        throw jsonError;
+      }
+    }
+    if (error instanceof ApiError || error instanceof PlatformError) {
+      throw enrichErrorWithContext(error, context || {});
+    }
+    throw enrichErrorWithContext(
+      error instanceof Error ? error : new Error(String(error)),
+      context || {}
+    );
+  }
+}
 function handleErrorResponse(data, status) {
   const errorData = data?.error || {};
   const message = errorData?.message || data?.message || "An API error occurred";
@@ -4854,145 +5027,160 @@ function createNetworkError(error, url, timeout) {
   );
 }
 
-// src/utils/cookie.ts
-import Cookies from "js-cookie";
-var AUTH_COOKIE_NAME = "__crosspost_auth";
-var CSRF_COOKIE_NAME = "XSRF-TOKEN";
-var CSRF_HEADER_NAME = "X-CSRF-Token";
-var AUTH_COOKIE_OPTIONS = {
-  secure: true,
-  sameSite: "lax",
-  // how could we make this none?
-  path: "/",
-  expires: 30
-  // 30 days
-};
-function getAuthFromCookie() {
-  try {
-    if (typeof document === "undefined") {
-      return void 0;
-    }
-    const cookieValue = Cookies.get(AUTH_COOKIE_NAME);
-    if (!cookieValue) {
-      return void 0;
+// src/core/request.ts
+async function makeRequest(method, path, options, data, query) {
+  let url = `${options.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  if (query && Object.keys(query).length > 0) {
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0 && value !== null) {
+        queryParams.append(key, String(value));
+      }
     }
-    return JSON.parse(cookieValue);
-  } catch (error) {
-    console.error("Failed to parse auth cookie:", error);
-    return void 0;
-  }
-}
-function storeAuthInCookie(authData) {
-  try {
-    if (typeof document === "undefined") {
-      return;
+    const queryString = queryParams.toString();
+    if (queryString) {
+      url += `?${queryString}`;
     }
-    const cookieValue = JSON.stringify(authData);
-    Cookies.set(AUTH_COOKIE_NAME, cookieValue, AUTH_COOKIE_OPTIONS);
-  } catch (error) {
-    console.error("Failed to store auth cookie:", error);
-  }
-}
-function clearAuthCookie() {
-  if (typeof document === "undefined") {
-    return;
   }
-  Cookies.remove(AUTH_COOKIE_NAME, { path: AUTH_COOKIE_OPTIONS.path });
-}
-function getCsrfToken() {
-  if (typeof document === "undefined") {
-    return void 0;
-  }
-  return Cookies.get(CSRF_COOKIE_NAME);
-}
-
-// src/core/request.ts
-async function makeRequest(method, path, options, data) {
-  const url = `${options.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
-  let lastError = null;
-  if (!options.signature) {
+  if (!options.nearAuthData) {
     throw ApiError.unauthorized("Authentication required. Please provide NEAR signature.");
   }
-  for (let attempt = 0; attempt <= options.retries; attempt++) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), options.timeout);
-    try {
-      const headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-        "Authorization": `Bearer ${createAuthToken(options.signature)}`
-      };
-      if (method !== "GET") {
-        const csrfToken = getCsrfToken();
-        if (csrfToken) {
-          headers[CSRF_HEADER_NAME] = csrfToken;
-        }
-      }
-      const requestOptions = {
-        method,
-        headers,
-        body: method !== "GET" && data ? JSON.stringify(data) : void 0,
-        signal: controller.signal
-      };
-      const response = await fetch(url, requestOptions);
-      clearTimeout(timeoutId);
-      let responseData;
+  const context = {
+    method,
+    path,
+    url,
+    retries: options.retries
+  };
+  return apiWrapper(async () => {
+    let lastError = null;
+    for (let attempt = 0; attempt <= options.retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), options.timeout);
       try {
-        responseData = await response.json();
-      } catch (jsonError) {
-        if (!response.ok) {
+        const headers = {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": `Bearer ${createAuthToken(options.nearAuthData)}`
+        };
+        const requestOptions = {
+          method,
+          headers,
+          body: method !== "GET" && data ? JSON.stringify(data) : void 0,
+          signal: controller.signal
+        };
+        const response = await fetch(url, requestOptions);
+        clearTimeout(timeoutId);
+        let responseData;
+        try {
+          responseData = await response.json();
+        } catch (jsonError) {
+          if (!response.ok) {
+            throw new ApiError(
+              `API request failed with status ${response.status} and non-JSON response`,
+              ApiErrorCode.NETWORK_ERROR,
+              response.status,
+              { originalStatusText: response.statusText }
+            );
+          }
+          if (response.status === 204) return {};
           throw new ApiError(
-            `API request failed with status ${response.status} and non-JSON response`,
-            ApiErrorCode.NETWORK_ERROR,
-            // Or a more specific code
-            response.status,
-            { originalStatusText: response.statusText }
+            `Failed to parse JSON response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
+            ApiErrorCode.INTERNAL_ERROR,
+            response.status
           );
         }
-        if (response.status === 204) return {};
-        throw new ApiError(
-          `Failed to parse JSON response: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}`,
-          ApiErrorCode.INTERNAL_ERROR,
-          // Or NETWORK_ERROR?
-          response.status
-        );
-      }
-      if (!response.ok) {
-        lastError = handleErrorResponse(responseData, response.status);
-        const shouldRetry = response.status >= 500 || lastError instanceof ApiError && lastError.recoverable;
-        if (shouldRetry && attempt < options.retries) {
-          await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-          continue;
+        if (!response.ok) {
+          lastError = handleErrorResponse(responseData, response.status);
+          const shouldRetry = response.status >= 500 || lastError instanceof ApiError && lastError.recoverable;
+          if (shouldRetry && attempt < options.retries) {
+            await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
+            continue;
+          }
+          throw lastError;
         }
-        throw lastError;
-      }
-      if (responseData && typeof responseData === "object" && "success" in responseData && !responseData.success && responseData.error) {
-        lastError = handleErrorResponse(responseData, response.status);
-        const shouldRetry = lastError instanceof ApiError && lastError.recoverable;
-        if (shouldRetry && attempt < options.retries) {
+        if (responseData && typeof responseData === "object" && "success" in responseData && !responseData.success && responseData.error) {
+          lastError = handleErrorResponse(responseData, response.status);
+          const shouldRetry = lastError instanceof ApiError && lastError.recoverable;
+          if (shouldRetry && attempt < options.retries) {
+            await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
+            continue;
+          }
+          throw lastError;
+        }
+        return responseData;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const isNetworkError2 = error instanceof TypeError || error instanceof DOMException && error.name === "AbortError";
+        if (isNetworkError2 && attempt < options.retries) {
           await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
           continue;
         }
-        throw lastError;
-      }
-      return responseData;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      lastError = error;
-      const isNetworkError = error instanceof TypeError || error instanceof DOMException && error.name === "AbortError";
-      if (isNetworkError && attempt < options.retries) {
-        await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt)));
-        continue;
-      }
-      if (!(error instanceof ApiError)) {
-        throw createNetworkError(error, url, options.timeout);
+        if (!(error instanceof ApiError)) {
+          throw createNetworkError(error, url, options.timeout);
+        }
+        throw error;
       }
-      throw error;
     }
-  }
-  throw lastError || new ApiError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
+    throw lastError || new ApiError("Request failed after multiple retries", ApiErrorCode.INTERNAL_ERROR, 500);
+  }, context);
 }
 
+// src/api/activity.ts
+var ActivityApi = class {
+  /**
+   * Creates an instance of ActivityApi
+   * @param options Request options
+   */
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Gets the global activity leaderboard
+   * @param query Optional query parameters
+   * @returns A promise resolving with the leaderboard response
+   */
+  async getLeaderboard(query) {
+    return makeRequest(
+      "GET",
+      "/api/activity",
+      this.options,
+      void 0,
+      query
+    );
+  }
+  /**
+   * Gets activity for a specific account
+   * @param signerId The NEAR account ID
+   * @param query Optional query parameters
+   * @returns A promise resolving with the account activity response
+   */
+  async getAccountActivity(signerId, query) {
+    return makeRequest(
+      "GET",
+      `/api/activity/${signerId}`,
+      this.options,
+      void 0,
+      query
+    );
+  }
+  /**
+   * Gets posts for a specific account
+   * @param signerId The NEAR account ID
+   * @param query Optional query parameters
+   * @returns A promise resolving with the account posts response
+   */
+  async getAccountPosts(signerId, query) {
+    return makeRequest(
+      "GET",
+      `/api/activity/${signerId}/posts`,
+      this.options,
+      void 0,
+      query
+    );
+  }
+};
+
 // src/api/auth.ts
 var AuthApi = class {
   /**
@@ -5211,6 +5399,51 @@ var PostApi = class {
   }
 };
 
+// src/api/system.ts
+var SystemApi = class {
+  /**
+   * Creates an instance of SystemApi
+   * @param options Request options
+   */
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Gets the current rate limit status
+   * @returns A promise resolving with the rate limit response
+   */
+  async getRateLimits() {
+    return makeRequest(
+      "GET",
+      "/api/rate-limit",
+      this.options
+    );
+  }
+  /**
+   * Gets the rate limit status for a specific endpoint
+   * @param endpoint The endpoint to get rate limit for
+   * @returns A promise resolving with the endpoint rate limit response
+   */
+  async getEndpointRateLimit(endpoint) {
+    return makeRequest(
+      "GET",
+      `/api/rate-limit/${endpoint}`,
+      this.options
+    );
+  }
+  /**
+   * Gets the health status of the API
+   * @returns A promise resolving with the health status
+   */
+  async getHealthStatus() {
+    return makeRequest(
+      "GET",
+      "/health",
+      this.options
+    );
+  }
+};
+
 // src/core/config.ts
 var DEFAULT_CONFIG = {
   baseUrl: "https://open-crosspost-proxy.deno.dev/",
@@ -5228,28 +5461,34 @@ var CrosspostClient = class {
     const baseUrl = config.baseUrl || DEFAULT_CONFIG.baseUrl;
     const timeout = config.timeout || DEFAULT_CONFIG.timeout;
     const retries = config.retries ?? DEFAULT_CONFIG.retries;
-    const signature = config.signature || getAuthFromCookie();
+    const nearAuthData = config.nearAuthData;
     this.options = {
       baseUrl,
       timeout,
       retries,
-      signature
+      nearAuthData
     };
     this.auth = new AuthApi(this.options);
     this.post = new PostApi(this.options);
+    this.activity = new ActivityApi(this.options);
+    this.system = new SystemApi(this.options);
+  }
+  /**
+   * Sets the authentication data (signature) for the client
+   * @param nearAuthData The NEAR authentication data
+   */
+  setAuthentication(nearAuthData) {
+    this.options.nearAuthData = nearAuthData;
   }
   /**
-   * Sets the authentication data (signature) for the client and stores it in a cookie
+   * Checks if authentication data (signature) exists on client
    * @param signature The NEAR authentication data
    */
-  async setAuthentication(signature) {
-    this.options.signature = signature;
-    storeAuthInCookie(signature);
+  isAuthenticated() {
+    return !!this.options.nearAuthData;
   }
 };
 export {
-  AUTH_COOKIE_NAME,
-  AUTH_COOKIE_OPTIONS,
   AccountActivityEntrySchema,
   AccountActivityParamsSchema,
   AccountActivityQuerySchema,
@@ -5258,6 +5497,9 @@ export {
   AccountPostsParamsSchema,
   AccountPostsQuerySchema,
   AccountPostsResponseSchema,
+  ActivityApi,
+  ActivityLeaderboardQuerySchema,
+  ActivityLeaderboardResponseSchema,
   AllRateLimitsResponseSchema,
   ApiError,
   ApiErrorCode,
@@ -5270,8 +5512,6 @@ export {
   AuthStatusResponseSchema,
   AuthUrlResponseSchema,
   BaseError,
-  CSRF_COOKIE_NAME,
-  CSRF_HEADER_NAME,
   ConnectedAccountSchema,
   ConnectedAccountsResponseSchema,
   CreatePostRequestSchema,
@@ -5283,14 +5523,13 @@ export {
   DeletePostRequestSchema,
   DeletePostResponseSchema,
   DeleteResultSchema,
+  ERROR_CATEGORIES,
   EndpointRateLimitResponseSchema,
   EnhancedErrorResponseSchema,
   EnhancedResponseMetaSchema,
   EnhancedResponseSchema,
   ErrorDetailSchema,
   ErrorResponseSchema,
-  LeaderboardQuerySchema,
-  LeaderboardResponseSchema,
   LikePostRequestSchema,
   LikePostResponseSchema,
   LikeResultSchema,
@@ -5328,13 +5567,17 @@ export {
   ReplyToPostResponseSchema,
   RepostRequestSchema,
   RepostResponseSchema,
+  SUPPORTED_PLATFORMS,
   SuccessDetailSchema,
+  SupportedPlatformSchema,
+  SystemApi,
   TargetSchema,
+  TimePeriod,
   UnlikePostRequestSchema,
   UnlikePostResponseSchema,
   UsageRateLimitSchema,
   UserProfileSchema,
-  clearAuthCookie,
+  apiWrapper,
   createApiResponse,
   createEnhancedApiResponse,
   createEnhancedErrorResponse,
@@ -5343,8 +5586,19 @@ export {
   createMultiStatusResponse,
   createNetworkError,
   createSuccessDetail,
-  getAuthFromCookie,
-  getCsrfToken,
+  enrichErrorWithContext,
+  getErrorDetails,
+  getErrorMessage,
   handleErrorResponse,
-  storeAuthInCookie
+  isAuthError,
+  isContentError,
+  isErrorOfCategory,
+  isMediaError,
+  isNetworkError,
+  isPlatformError,
+  isPlatformSupported,
+  isPostError,
+  isRateLimitError,
+  isRecoverableError,
+  isValidationError
 };