@crosspost/sdk 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crosspost/sdk",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "SDK for interacting with the Crosspost API",
   "type": "module",
   "main": "dist/index.cjs",
@@ -36,6 +36,7 @@
   "author": "crosspost.near",
   "license": "MIT",
   "dependencies": {
+    "@crosspost/types": "^0.1.9",
     "near-sign-verify": "^0.1.3"
   },
   "devDependencies": {

package/src/api/auth.ts

@@ -5,7 +5,6 @@ import type {
   AuthStatusParams,
   AuthStatusResponse,
   AuthTokenRequest,
-  AuthUrlResponse,
   ConnectedAccount,
   ConnectedAccountsResponse,
   NearAuthorizationRequest,
@@ -14,6 +13,7 @@ import type {
   Platform,
 } from '@crosspost/types';
 import { makeRequest, type RequestOptions } from '../core/request.ts';
+import { openAuthPopup } from '../utils/popup.ts';
 
 /**
  * Authentication-related API operations
@@ -55,22 +55,40 @@ export class AuthApi {
   }
 
   /**
-   * Initiates the login process for a specific platform.
-   * The service handles the OAuth flow; this method triggers it.
+   * Initiates the login process for a specific platform using a popup window.
    * @param platform The target platform.
    * @param options Optional success and error redirect URLs.
-   * @returns A promise resolving with the response from the service (might indicate success/failure or redirect info).
+   * @returns Promise that resolves with the authentication result when the popup completes.
+   * @throws Error if popups are blocked or if running in a non-browser environment.
    */
   async loginToPlatform(
     platform: Platform,
     options?: AuthInitRequest,
-  ): Promise<AuthUrlResponse> {
-    return makeRequest<AuthUrlResponse, AuthInitRequest>(
-      'POST',
-      `/auth/${platform}/login`,
-      this.options,
-      options || {},
-    );
+  ): Promise<AuthCallbackResponse> {
+    // Construct the login URL
+    const baseUrl = this.options.baseUrl || '';
+    const loginUrl = new URL(`/auth/${platform}/login`, baseUrl);
+
+    // Add successUrl and errorUrl if provided
+    if (options?.successUrl) {
+      loginUrl.searchParams.set('successUrl', options.successUrl);
+    }
+    if (options?.errorUrl) {
+      loginUrl.searchParams.set('errorUrl', options.errorUrl);
+    }
+
+    // Open the popup and wait for the result
+    const result = await openAuthPopup(loginUrl.toString());
+
+    if (!result.success || !result.userId) {
+      throw new Error(result.error || 'Authentication failed');
+    }
+
+    // Return the result in the expected format
+    return {
+      platform,
+      userId: result.userId,
+    };
   }
 
   /**
@@ -146,7 +164,8 @@ export class AuthApi {
 
   /**
    * Lists all accounts connected to the NEAR account.
-   * @returns A promise resolving with the list of connected accounts.
+   * @returns A promise resolving with the connected accounts response containing an array of accounts.
+   * @throws {CrosspostError} If the request fails or returns invalid data.
    */
   async getConnectedAccounts(): Promise<ConnectedAccountsResponse> {
     return makeRequest<ConnectedAccountsResponse, never>(

package/src/core/request.ts

@@ -32,13 +32,20 @@ export interface RequestOptions {
 }
 
 /**
- * Makes a request to the API with error handling
+ * Makes a request to the API with error handling and data extraction
  *
  * @param method The HTTP method
  * @param path The API path
  * @param options The request options
  * @param data Optional request data
- * @returns A promise resolving with the response data
+ * @param query Optional query parameters
+ * @returns A promise resolving with the data field from the API response
+ * @throws {CrosspostError}
+ *  - If the request fails (network error, timeout)
+ *  - If the response is not valid JSON
+ *  - If the response does not follow the expected ApiResponse format
+ *  - If the response indicates success but contains no data
+ *  - If the response indicates failure (includes error details and metadata)
  */
 export async function makeRequest<
   TResponse,
@@ -154,6 +161,14 @@ export async function makeRequest<
     }
 
     if (responseData.success) {
+      if (!responseData.data) {
+        throw new CrosspostError(
+          'API returned success but no data',
+          ApiErrorCode.INVALID_RESPONSE,
+          response.status as StatusCode,
+          { responseData },
+        );
+      }
       return responseData.data as TResponse;
     }
 

package/src/utils/popup.ts

@@ -0,0 +1,129 @@
+import type { PlatformName } from '@crosspost/types';
+
+// Augment the Window interface
+declare global {
+  interface Window {
+    innerWidth: number;
+    innerHeight: number;
+    open(url: string, target: string, features: string): Window | null;
+  }
+
+  interface WindowEventMap {
+    message: MessageEvent<AuthCallbackMessage>;
+  }
+}
+
+interface PopupOptions {
+  width?: number;
+  height?: number;
+  left?: number;
+  top?: number;
+}
+
+interface AuthCallbackData {
+  success: boolean;
+  platform: PlatformName;
+  userId?: string;
+  error?: string;
+  error_description?: string;
+}
+
+interface AuthCallbackMessage {
+  type: 'AUTH_CALLBACK';
+  data: AuthCallbackData;
+}
+
+/**
+ * Opens a popup window and returns a promise that resolves when the authentication is complete
+ * @param url The URL to open in the popup
+ * @param options Optional popup window dimensions and position
+ * @returns Promise that resolves with the authentication result
+ * @throws Error if popups are blocked or if running in a non-browser environment
+ */
+export function openAuthPopup(url: string, options: PopupOptions = {}): Promise<AuthCallbackData> {
+  // Check for browser environment
+  if (typeof window === 'undefined') {
+    throw new Error('openAuthPopup can only be used in a browser environment');
+  }
+
+  return new Promise((resolve, reject) => {
+    // Calculate popup dimensions and position
+    const {
+      width = 600,
+      height = 700,
+      left = Math.max(0, (window.innerWidth - 600) / 2),
+      top = Math.max(0, (window.innerHeight - 700) / 2),
+    } = options;
+
+    // Open the popup
+    const popup = window.open(
+      url,
+      'authPopup',
+      `width=${width},height=${height},left=${left},top=${top},scrollbars=yes`,
+    );
+
+    if (!popup) {
+      reject(new Error('Popup blocked. Please allow popups for this site.'));
+      return;
+    }
+
+    let messageReceived = false;
+
+    // Function to handle messages from the popup with proper typing
+    const handleMessage = (event: MessageEvent<AuthCallbackMessage>) => {
+      // Verify the message is from our popup and popup exists
+      if (!popup || event.source !== popup) {
+        return;
+      }
+
+      const message = event.data;
+      if (message?.type === 'AUTH_CALLBACK') {
+        messageReceived = true;
+        window.removeEventListener('message', handleMessage);
+        clearInterval(checkClosedInterval);
+
+        if (message.data.success) {
+          resolve(message.data);
+        } else {
+          reject(message.data);
+        }
+
+        // Give a moment for any final operations before closing
+        setTimeout(() => {
+          try {
+            if (popup && !popup.closed) {
+              popup.close();
+            }
+          } catch (e) {
+            console.warn('Failed to close popup window:', e);
+          }
+        }, 100);
+      }
+    };
+
+    // Listen for messages from the popup
+    window.addEventListener('message', handleMessage as EventListener);
+
+    // Check if popup was closed manually
+    const checkClosedInterval = setInterval(() => {
+      try {
+        if (!popup || popup.closed) {
+          cleanup();
+        }
+      } catch (e) {
+        console.warn('Error checking popup state:', e);
+        cleanup();
+      }
+    }, 500);
+
+    // Cleanup function to handle popup closure
+    function cleanup() {
+      clearInterval(checkClosedInterval);
+      window.removeEventListener('message', handleMessage as EventListener);
+
+      if (!messageReceived) {
+        reject(new Error('Authentication cancelled by user.'));
+      }
+    }
+  });
+}