@squad-sports/react-native 1.3.1

package/src/SquadSportsSDK.ts

@@ -0,0 +1,286 @@
+import {
+  SquadApiClient,
+  SessionManager,
+  SSOManager,
+  TokenStorage,
+  InMemoryStorage,
+  NexusPartnerRegistry,
+  PartnerAuthManager,
+  AnalyticsTracker,
+  Logger,
+  getApiBaseUrl,
+  isPartnerConfig,
+} from '@squad-sports/core';
+import type {
+  SquadSDKConfig,
+  SquadPartnerConfig,
+  SquadConfig,
+  StorageAdapter,
+} from '@squad-sports/core';
+import { SecureStorageAdapter } from './storage/SecureStorage';
+
+/**
+ * Main entry point for the Squad Sports SDK.
+ *
+ * Two ways to initialize:
+ *
+ * **Simple (recommended):** Just provide your partner ID.
+ * Everything auto-resolves from the Nexus partner registry.
+ * ```ts
+ * await SquadSportsSDK.setup({ partnerId: 'acme-sports' });
+ * ```
+ *
+ * **With SSO:** Pass a Ticketmaster (or other) token and users are auto-authenticated.
+ * ```ts
+ * await SquadSportsSDK.setup({
+ *   partnerId: 'acme-sports',
+ *   ssoToken: ticketmasterAccessToken,
+ *   ssoProvider: 'ticketmaster',
+ * });
+ * ```
+ *
+ * **Full control:** Provide every config value manually.
+ * ```ts
+ * SquadSportsSDK.initialize({ apiKey: '...', environment: 'production', community: { ... } });
+ * ```
+ */
+export class SquadSportsSDK {
+  private static instance: SquadSportsSDK | null = null;
+
+  readonly config: SquadSDKConfig;
+  readonly apiClient: SquadApiClient;
+  readonly sessionManager: SessionManager;
+  readonly ssoManager: SSOManager;
+  readonly partnerAuthManager: PartnerAuthManager;
+  readonly tokenStorage: TokenStorage;
+
+  private constructor(config: SquadSDKConfig) {
+    this.config = config;
+
+    const storage: StorageAdapter = config.storage ?? new SecureStorageAdapter();
+    this.tokenStorage = new TokenStorage(storage);
+
+    const baseUrl = getApiBaseUrl(config.environment, config.apiBaseUrl);
+
+    this.apiClient = new SquadApiClient({
+      baseUrl,
+      apiKey: config.apiKey,
+    });
+
+    this.sessionManager = new SessionManager(this.apiClient, this.tokenStorage);
+    this.ssoManager = new SSOManager(this.apiClient, this.tokenStorage);
+    this.partnerAuthManager = new PartnerAuthManager(this.apiClient, this.tokenStorage);
+  }
+
+  // --- Initialization paths ---
+
+  /**
+   * RECOMMENDED: One-step async setup.
+   * Accepts either a simple partnerId config or a full config.
+   * Resolves partner config from Nexus, restores session, and handles SSO.
+   */
+  static async setup(config: SquadConfig): Promise<SquadSportsSDK> {
+    let resolvedConfig: SquadSDKConfig;
+
+    if (isPartnerConfig(config)) {
+      // Simple path — resolve everything from partner ID
+      resolvedConfig = await NexusPartnerRegistry.resolve(config);
+    } else {
+      resolvedConfig = config;
+    }
+
+    SquadSportsSDK.reset();
+    const sdk = new SquadSportsSDK(resolvedConfig);
+    SquadSportsSDK.instance = sdk;
+
+    // Configure logger
+    Logger.shared.configure({
+      partnerId: resolvedConfig.partnerAuth?.partnerId,
+      environment: resolvedConfig.environment,
+    });
+
+    // Configure analytics
+    AnalyticsTracker.shared.configure({
+      apiClient: sdk.apiClient,
+      partnerId: resolvedConfig.partnerAuth?.partnerId,
+      enabled: true,
+    });
+
+    // Auto-restore previous session
+    const restored = await sdk.restoreSession();
+
+    if (restored) {
+      AnalyticsTracker.shared.track('session_restored');
+      const userId = await sdk.tokenStorage.getUserId();
+      if (userId) {
+        AnalyticsTracker.shared.setUserId(userId);
+        Logger.shared.setUserId(userId);
+      }
+    }
+
+    // If restored, check community scoping — re-auth if community changed
+    if (restored && resolvedConfig.partnerAuth?.communityId) {
+      const storedCommunityId = await sdk.tokenStorage.getCommunityId();
+      if (storedCommunityId && storedCommunityId !== resolvedConfig.partnerAuth.communityId) {
+        await sdk.tokenStorage.clearAll();
+        sdk.apiClient.clearAuthState();
+      }
+    }
+
+    // Auto-authenticate via SSO if configured
+    if (resolvedConfig.sso?.accessToken && !sdk.apiClient.currentToken) {
+      await sdk.ssoManager.authenticate(resolvedConfig.sso);
+      AnalyticsTracker.shared.track('sso_login', { provider: resolvedConfig.sso.provider });
+      // Persist community/partner context after SSO
+      if (resolvedConfig.partnerAuth && sdk.apiClient.currentToken) {
+        await sdk.tokenStorage.setCommunityId(resolvedConfig.partnerAuth.communityId);
+        await sdk.tokenStorage.setPartnerId(resolvedConfig.partnerAuth.partnerId);
+      }
+    }
+
+    // Partner user sync — if userData provided and still no valid token
+    if (resolvedConfig.partnerAuth?.userData && !sdk.apiClient.currentToken) {
+      const syncResult = await sdk.partnerAuthManager.syncUser(
+        resolvedConfig.partnerAuth.partnerId,
+        resolvedConfig.partnerAuth.communityId,
+        resolvedConfig.partnerAuth.userData,
+      );
+      if (syncResult.success) {
+        AnalyticsTracker.shared.track('partner_sync_success', { partnerId: resolvedConfig.partnerAuth.partnerId });
+        if (syncResult.userId) {
+          AnalyticsTracker.shared.setUserId(syncResult.userId);
+          Logger.shared.setUserId(syncResult.userId);
+        }
+      } else {
+        AnalyticsTracker.shared.track('partner_sync_failed', { partnerId: resolvedConfig.partnerAuth.partnerId });
+        Logger.shared.warn('Partner user sync failed. User will be directed to auth screen.');
+      }
+    }
+
+    // Wire silent re-auth on 401 (interceptor-level, can retry original request)
+    // Supports both partner sync and SSO token refresh
+    const ssoConfig = resolvedConfig.sso;
+    const partnerAuth = resolvedConfig.partnerAuth;
+    const hasPartnerUserData = !!partnerAuth?.userData;
+    const hasSSOToken = !!ssoConfig?.accessToken;
+
+    if (hasPartnerUserData || hasSSOToken) {
+      sdk.apiClient.setSilentReAuth(async () => {
+        // Try partner re-auth first (most reliable — server-side user sync)
+        if (hasPartnerUserData && partnerAuth?.userData) {
+          Logger.shared.info('Attempting silent partner re-auth');
+          const reSync = await sdk.partnerAuthManager.syncUser(
+            partnerAuth.partnerId,
+            partnerAuth.communityId,
+            partnerAuth.userData,
+          );
+          if (reSync.success) {
+            Logger.shared.info('Silent partner re-auth succeeded');
+            return true;
+          }
+        }
+
+        // Try SSO token re-exchange (works if the external SSO token is still valid)
+        if (hasSSOToken && ssoConfig) {
+          Logger.shared.info('Attempting silent SSO re-auth');
+          try {
+            const result = await sdk.ssoManager.authenticate(ssoConfig);
+            if (result?.success) {
+              Logger.shared.info('Silent SSO re-auth succeeded');
+              // Persist community/partner context after SSO refresh
+              if (partnerAuth && sdk.apiClient.currentToken) {
+                await sdk.tokenStorage.setCommunityId(partnerAuth.communityId);
+                await sdk.tokenStorage.setPartnerId(partnerAuth.partnerId);
+              }
+              return true;
+            }
+          } catch {
+            Logger.shared.warn('Silent SSO re-auth failed');
+          }
+        }
+
+        Logger.shared.warn('All silent re-auth attempts failed');
+        return false;
+      });
+    }
+
+    AnalyticsTracker.shared.track('sdk_initialized', {
+      partnerId: resolvedConfig.partnerAuth?.partnerId,
+      environment: resolvedConfig.environment,
+    });
+
+    return sdk;
+  }
+
+  /**
+   * Synchronous initialization with full config (no auto-resolution).
+   * Use this when you already have all config values.
+   */
+  static initialize(config: SquadSDKConfig): SquadSportsSDK {
+    if (SquadSportsSDK.instance) {
+      console.warn('[SquadSportsSDK] Already initialized. Call reset() first to reinitialize.');
+      return SquadSportsSDK.instance;
+    }
+
+    SquadSportsSDK.instance = new SquadSportsSDK(config);
+    return SquadSportsSDK.instance;
+  }
+
+  /**
+   * Get the current SDK instance. Throws if not initialized.
+   */
+  static get shared(): SquadSportsSDK {
+    if (!SquadSportsSDK.instance) {
+      throw new Error(
+        '[SquadSportsSDK] Not initialized. Call SquadSportsSDK.setup() or SquadSportsSDK.initialize() first.',
+      );
+    }
+    return SquadSportsSDK.instance;
+  }
+
+  static get isInitialized(): boolean {
+    return SquadSportsSDK.instance !== null;
+  }
+
+  static reset(): void {
+    if (SquadSportsSDK.instance) {
+      SquadSportsSDK.instance.apiClient.cancelAllRequests();
+      SquadSportsSDK.instance.apiClient.clearAllCaches();
+      AnalyticsTracker.shared.destroy();
+    }
+    SquadSportsSDK.instance = null;
+  }
+
+  // --- Session ---
+
+  /**
+   * Restore a previous session from stored tokens.
+   */
+  async restoreSession(): Promise<boolean> {
+    const token = await this.tokenStorage.getAccessToken();
+    if (!token) return false;
+
+    this.apiClient.updateAccessToken(token);
+    const isValid = await this.sessionManager.validateSession();
+
+    if (!isValid) {
+      await this.tokenStorage.clearAll();
+      this.apiClient.clearAuthState();
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Authenticate via SSO with an external token.
+   * Convenience method for post-initialization SSO.
+   */
+  async authenticateWithSSO(
+    provider: 'ticketmaster' | 'oauth2' | 'custom',
+    token: string,
+  ): Promise<boolean> {
+    const result = await this.ssoManager.authenticateWithToken(provider, token);
+    return result.success;
+  }
+}

package/src/__tests__/DeepLinkHandler.test.ts

@@ -0,0 +1,101 @@
+jest.mock('react-native', () => ({
+  Linking: {
+    addEventListener: jest.fn(),
+    getInitialURL: jest.fn(),
+    openURL: jest.fn(),
+  },
+}));
+
+import { DeepLinkHandler } from '../realtime/DeepLinkHandler';
+
+describe('DeepLinkHandler', () => {
+  describe('parseUrl', () => {
+    // Squad scheme
+    test('parses squad://invite/CODE', () => {
+      const route = DeepLinkHandler.parseUrl('squad://invite/ABC123');
+      expect(route).toEqual({ screen: 'Invite', params: { code: 'ABC123' } });
+    });
+
+    test('parses squad://profile/USER_ID', () => {
+      const route = DeepLinkHandler.parseUrl('squad://profile/user-456');
+      expect(route).toEqual({ screen: 'Profile', params: { userId: 'user-456' } });
+    });
+
+    test('parses squad://message/CONNECTION_ID', () => {
+      const route = DeepLinkHandler.parseUrl('squad://message/conn-789');
+      expect(route).toEqual({ screen: 'Messaging', params: { connectionId: 'conn-789' } });
+    });
+
+    test('parses squad://poll/POLL_ID', () => {
+      const route = DeepLinkHandler.parseUrl('squad://poll/poll-101');
+      expect(route).toEqual({ screen: 'PollResponse', params: { pollId: 'poll-101' } });
+    });
+
+    test('parses squad://events', () => {
+      const route = DeepLinkHandler.parseUrl('squad://events');
+      expect(route).toEqual({ screen: 'Events' });
+    });
+
+    test('parses squad://wallet', () => {
+      const route = DeepLinkHandler.parseUrl('squad://wallet');
+      expect(route).toEqual({ screen: 'Wallet' });
+    });
+
+    test('parses squad://freestyle', () => {
+      const route = DeepLinkHandler.parseUrl('squad://freestyle');
+      expect(route).toEqual({ screen: 'FreestyleCreate' });
+    });
+
+    // Universal links
+    test('parses https://app.withyoursquad.com/invite/CODE', () => {
+      const route = DeepLinkHandler.parseUrl('https://app.withyoursquad.com/invite/XYZ789');
+      expect(route).toEqual({ screen: 'Invite', params: { code: 'XYZ789' } });
+    });
+
+    test('parses https://app.withyoursquad.com/profile/USER_ID', () => {
+      const route = DeepLinkHandler.parseUrl('https://app.withyoursquad.com/profile/user-123');
+      expect(route).toEqual({ screen: 'Profile', params: { userId: 'user-123' } });
+    });
+
+    // Edge cases
+    test('returns null for unknown scheme', () => {
+      expect(DeepLinkHandler.parseUrl('https://random.com/path')).toBeNull();
+    });
+
+    test('returns Home for unknown squad path', () => {
+      const route = DeepLinkHandler.parseUrl('squad://unknown');
+      expect(route).toEqual({ screen: 'Home' });
+    });
+
+    test('returns null for empty URL', () => {
+      expect(DeepLinkHandler.parseUrl('')).toBeNull();
+    });
+
+    test('parses invite without code', () => {
+      const route = DeepLinkHandler.parseUrl('squad://invite');
+      expect(route).toEqual({ screen: 'Invite' });
+    });
+
+    test('profile without userId returns null', () => {
+      const route = DeepLinkHandler.parseUrl('squad://profile');
+      expect(route).toBeNull();
+    });
+  });
+
+  describe('linkingConfig', () => {
+    test('has correct prefixes', () => {
+      const config = DeepLinkHandler.linkingConfig;
+      expect(config.prefixes).toContain('squad://');
+      expect(config.prefixes).toContain('https://app.withyoursquad.com');
+    });
+
+    test('has screen mappings', () => {
+      const screens = DeepLinkHandler.linkingConfig.config.screens;
+      expect(screens).toHaveProperty('Home');
+      expect(screens).toHaveProperty('Invite');
+      expect(screens).toHaveProperty('Profile');
+      expect(screens).toHaveProperty('Messaging');
+      expect(screens).toHaveProperty('PollResponse');
+    });
+  });
+});

package/src/__tests__/ErrorBoundary.test.tsx

@@ -0,0 +1,161 @@
+import React from 'react';
+
+// Mock react-native with proper function components
+jest.mock('react-native', () => {
+  const React = require('react');
+  return {
+    View: (props: any) => React.createElement('View', props),
+    Text: (props: any) => React.createElement('Text', props),
+    Pressable: (props: any) => React.createElement('Pressable', props),
+    StyleSheet: {
+      create: (styles: Record<string, any>) => styles,
+    },
+    Platform: { OS: 'ios' },
+  };
+});
+
+// Mock the theme import
+jest.mock('../theme/ThemeContext', () => ({
+  Colors: {
+    gray1: '#111',
+    gray6: '#666',
+    gray9: '#999',
+    white: '#fff',
+    orange1: '#e9785c',
+    purple1: '#7c3aed',
+  },
+}));
+
+import { create, act } from 'react-test-renderer';
+import type { ReactTestRenderer } from 'react-test-renderer';
+import { ScreenErrorBoundary } from '../components/ErrorBoundary';
+
+// Suppress console.error noise from intentional errors
+const originalConsoleError = console.error;
+beforeAll(() => {
+  console.error = jest.fn();
+});
+afterAll(() => {
+  console.error = originalConsoleError;
+});
+
+// A component that throws on render
+function ThrowingChild() {
+  throw new Error('Test render crash');
+}
+
+describe('ScreenErrorBoundary', () => {
+  test('renders children normally when no error', async () => {
+    let tree: ReactTestRenderer;
+    await act(async () => {
+      tree = create(
+        React.createElement(
+          ScreenErrorBoundary,
+          null,
+          React.createElement('Text', null, 'Hello'),
+        ),
+      );
+    });
+    const json = JSON.stringify(tree!.toJSON());
+    expect(json).toContain('Hello');
+  });
+
+  test('catches render error and shows default fallback', async () => {
+    let tree: ReactTestRenderer;
+    await act(async () => {
+      tree = create(
+        React.createElement(
+          ScreenErrorBoundary,
+          null,
+          React.createElement(ThrowingChild),
+        ),
+      );
+    });
+    const json = JSON.stringify(tree!.toJSON());
+    expect(json).toContain('Something went wrong');
+    expect(json).toContain('Try Again');
+  });
+
+  test('screenName appears in error message', async () => {
+    let tree: ReactTestRenderer;
+    await act(async () => {
+      tree = create(
+        React.createElement(
+          ScreenErrorBoundary,
+          { screenName: 'Home' },
+          React.createElement(ThrowingChild),
+        ),
+      );
+    });
+    const json = JSON.stringify(tree!.toJSON());
+    expect(json).toContain('Home');
+  });
+
+  test('onError callback fires', async () => {
+    const onError = jest.fn();
+    await act(async () => {
+      create(
+        React.createElement(
+          ScreenErrorBoundary,
+          { onError },
+          React.createElement(ThrowingChild),
+        ),
+      );
+    });
+    expect(onError).toHaveBeenCalledWith(
+      expect.any(Error),
+      expect.objectContaining({ componentStack: expect.any(String) }),
+    );
+  });
+
+  test('custom fallback prop is rendered', async () => {
+    let tree: ReactTestRenderer;
+    await act(async () => {
+      tree = create(
+        React.createElement(
+          ScreenErrorBoundary,
+          { fallback: React.createElement('Text', null, 'Custom Fallback') },
+          React.createElement(ThrowingChild),
+        ),
+      );
+    });
+    const json = JSON.stringify(tree!.toJSON());
+    expect(json).toContain('Custom Fallback');
+  });
+
+  test('"Try Again" button resets error state', async () => {
+    let shouldThrow = true;
+    function ConditionalThrower() {
+      if (shouldThrow) throw new Error('boom');
+      return React.createElement('Text', null, 'Recovered');
+    }
+
+    let tree: ReactTestRenderer;
+    await act(async () => {
+      tree = create(
+        React.createElement(
+          ScreenErrorBoundary,
+          null,
+          React.createElement(ConditionalThrower),
+        ),
+      );
+    });
+
+    // Verify we're in error state
+    const instance = tree!.root;
+    const retryButton = instance.findByProps({ accessibilityLabel: 'Try again' });
+    expect(retryButton).toBeTruthy();
+
+    // Fix the child so it won't throw on re-render
+    shouldThrow = false;
+
+    // Press "Try Again"
+    await act(async () => {
+      retryButton.props.onPress();
+    });
+
+    // Should now show recovered content
+    const json = JSON.stringify(tree!.toJSON());
+    expect(json).toContain('Recovered');
+  });
+});