@cranberry-money/shared-services 1.0.0

package/dist/core/BaseApiClient.js

@@ -0,0 +1,89 @@
+/**
+ * Base API Client abstraction for cross-platform HTTP requests
+ *
+ * This provides a platform-agnostic interface for making HTTP requests
+ * with consistent error handling, authentication, and response processing.
+ */
+/**
+ * Abstract base class for API clients
+ * Platform-specific implementations should extend this class
+ */
+export class BaseApiClient {
+    constructor(config) {
+        this.baseURL = config.baseURL;
+        this.timeout = config.timeout || 30000;
+        this.defaultHeaders = config.defaultHeaders || {};
+        this.withCredentials = config.withCredentials || false;
+    }
+    /**
+     * Set token storage implementation
+     */
+    setTokenStorage(storage) {
+        this.tokenStorage = storage;
+    }
+    /**
+     * Convenience methods for common HTTP operations
+     */
+    async get(url, params) {
+        return this.request({ url, method: 'GET', params });
+    }
+    async post(url, data) {
+        return this.request({ url, method: 'POST', data });
+    }
+    async put(url, data) {
+        return this.request({ url, method: 'PUT', data });
+    }
+    async patch(url, data) {
+        return this.request({ url, method: 'PATCH', data });
+    }
+    async delete(url) {
+        return this.request({ url, method: 'DELETE' });
+    }
+    /**
+     * Build full URL from relative path
+     */
+    buildUrl(url) {
+        if (url.startsWith('http')) {
+            return url;
+        }
+        return `${this.baseURL.replace(/\/$/, '')}/${url.replace(/^\//, '')}`;
+    }
+    /**
+     * Merge headers with defaults and authentication
+     */
+    async buildHeaders(headers = {}) {
+        const mergedHeaders = { ...this.defaultHeaders, ...headers };
+        // Add authentication header if token storage is available and tokens exist
+        if (this.tokenStorage) {
+            const tokens = await this.tokenStorage.retrieveTokens();
+            if (tokens?.access) {
+                mergedHeaders['Authorization'] = `Bearer ${tokens.access}`;
+            }
+        }
+        return mergedHeaders;
+    }
+    /**
+     * Handle API errors consistently
+     */
+    createError(message, status, code, data) {
+        return {
+            message,
+            status,
+            code,
+            data,
+        };
+    }
+    /**
+     * Check if error is authentication related
+     */
+    isAuthError(error) {
+        return error.status === 401 || error.code === 'UNAUTHORIZED';
+    }
+    /**
+     * Handle token refresh logic (to be implemented by platform adapters)
+     */
+    async handleTokenRefresh() {
+        // Default implementation - override in platform-specific clients
+        return false;
+    }
+}

package/dist/core/TokenStorage.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Token storage abstraction for cross-platform authentication
+ *
+ * This interface provides a consistent API for storing authentication tokens
+ * across different platforms (web cookies, mobile secure storage, etc.)
+ */
+export interface TokenPair {
+    access: string;
+    refresh: string;
+}
+export interface TokenStorage {
+    /**
+     * Store authentication tokens securely
+     * @param tokens - The access and refresh tokens to store
+     */
+    storeTokens(tokens: TokenPair): Promise<void>;
+    /**
+     * Retrieve stored authentication tokens
+     * @returns The stored tokens or null if none exist
+     */
+    retrieveTokens(): Promise<TokenPair | null>;
+    /**
+     * Clear all stored authentication tokens
+     */
+    clearTokens(): Promise<void>;
+    /**
+     * Check if tokens are currently stored
+     * @returns True if tokens exist, false otherwise
+     */
+    hasTokens(): Promise<boolean>;
+}
+/**
+ * Base implementation with common utilities
+ */
+export declare abstract class BaseTokenStorage implements TokenStorage {
+    abstract storeTokens(tokens: TokenPair): Promise<void>;
+    abstract retrieveTokens(): Promise<TokenPair | null>;
+    abstract clearTokens(): Promise<void>;
+    hasTokens(): Promise<boolean>;
+    /**
+     * Validate token format (basic validation)
+     */
+    protected validateTokens(tokens: TokenPair): boolean;
+}
+//# sourceMappingURL=TokenStorage.d.ts.map

package/dist/core/TokenStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenStorage.d.ts","sourceRoot":"","sources":["../../src/core/TokenStorage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9C;;;OAGG;IACH,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAE5C;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B;;;OAGG;IACH,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,8BAAsB,gBAAiB,YAAW,YAAY;IAC5D,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IACtD,QAAQ,CAAC,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAE/B,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAKnC;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO;CAKrD"}

package/dist/core/TokenStorage.js

@@ -0,0 +1,23 @@
+/**
+ * Token storage abstraction for cross-platform authentication
+ *
+ * This interface provides a consistent API for storing authentication tokens
+ * across different platforms (web cookies, mobile secure storage, etc.)
+ */
+/**
+ * Base implementation with common utilities
+ */
+export class BaseTokenStorage {
+    async hasTokens() {
+        const tokens = await this.retrieveTokens();
+        return tokens !== null && tokens.access !== '' && tokens.refresh !== '';
+    }
+    /**
+     * Validate token format (basic validation)
+     */
+    validateTokens(tokens) {
+        return !!(tokens.access && tokens.refresh &&
+            typeof tokens.access === 'string' &&
+            typeof tokens.refresh === 'string');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Centralized export of all shared services
+ */
+export * from './core/TokenStorage';
+export * from './core/BaseApiClient';
+export * from './adapters/WebTokenStorage';
+export * from './adapters/WebApiClient';
+export * from './adapters/MobileTokenStorage';
+export * from './adapters/MobileApiClient';
+export * from './services/BaseService';
+export * from './services/AuthService';
+export * from './services/PortfolioService';
+export * from './query/QueryClient';
+export * from './query/useAuth';
+export * from './query/usePortfolios';
+export * from './auth/AuthManager';
+export * from './auth/createAuthManager';
+export * from './auth/useAuthManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAG3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAG5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * Centralized export of all shared services
+ */
+// Core abstractions
+export * from './core/TokenStorage';
+export * from './core/BaseApiClient';
+// Platform adapters
+export * from './adapters/WebTokenStorage';
+export * from './adapters/WebApiClient';
+export * from './adapters/MobileTokenStorage';
+export * from './adapters/MobileApiClient';
+// Services
+export * from './services/BaseService';
+export * from './services/AuthService';
+export * from './services/PortfolioService';
+// React Query integration
+export * from './query/QueryClient';
+export * from './query/useAuth';
+export * from './query/usePortfolios';
+// Authentication Manager
+export * from './auth/AuthManager';
+export * from './auth/createAuthManager';
+export * from './auth/useAuthManager';

package/dist/query/QueryClient.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared React Query client configuration
+ *
+ * Provides platform-optimized React Query configurations for web and mobile
+ * with appropriate caching, retry, and offline behavior settings.
+ */
+import { QueryClient } from '@tanstack/react-query';
+export type Platform = 'web' | 'mobile';
+export interface CreateQueryClientOptions {
+    platform: Platform;
+    defaultStaleTime?: number;
+    defaultRetryCount?: number;
+    enableOfflineSupport?: boolean;
+}
+/**
+ * Create a QueryClient with platform-optimized defaults
+ */
+export declare const createQueryClient: (options: CreateQueryClientOptions) => QueryClient;
+/**
+ * Default query keys factory
+ * Provides consistent query key structure across the application
+ */
+export declare const queryKeys: {
+    readonly auth: {
+        readonly profile: () => readonly ["auth", "profile"];
+        readonly status: () => readonly ["auth", "status"];
+    };
+    readonly portfolios: {
+        readonly all: () => readonly ["portfolios"];
+        readonly detail: (id: string) => readonly ["portfolios", string];
+        readonly holdings: (id: string) => readonly ["portfolios", string, "holdings"];
+        readonly allocations: (id: string) => readonly ["portfolios", string, "allocations"];
+    };
+    readonly instruments: {
+        readonly all: (filters?: Record<string, unknown>) => readonly ["instruments", Record<string, unknown> | undefined];
+        readonly detail: (id: string) => readonly ["instruments", string];
+        readonly search: (query: string) => readonly ["instruments", "search", string];
+    };
+    readonly trades: {
+        readonly all: (filters?: Record<string, unknown>) => readonly ["trades", Record<string, unknown> | undefined];
+        readonly target: (filters?: Record<string, unknown>) => readonly ["trades", "target", Record<string, unknown> | undefined];
+        readonly detail: (id: string) => readonly ["trades", string];
+    };
+    readonly reference: {
+        readonly countries: () => readonly ["reference", "countries"];
+        readonly sectors: () => readonly ["reference", "sectors"];
+        readonly industries: () => readonly ["reference", "industries"];
+        readonly exchanges: () => readonly ["reference", "exchanges"];
+    };
+    readonly users: {
+        readonly profile: () => readonly ["users", "profile"];
+        readonly preferences: () => readonly ["users", "preferences"];
+    };
+};
+/**
+ * Common query options factory
+ */
+export declare const createQueryOptions: {
+    /**
+     * Create options for frequently updated data
+     */
+    realtime: (platform: Platform) => {
+        staleTime: number;
+        refetchInterval: number;
+    };
+    /**
+     * Create options for static reference data
+     */
+    reference: () => {
+        staleTime: number;
+        gcTime: number;
+        refetchOnWindowFocus: boolean;
+        refetchOnReconnect: boolean;
+    };
+    /**
+     * Create options for user-specific data
+     */
+    user: (platform: Platform) => {
+        staleTime: number;
+    };
+};
+//# sourceMappingURL=QueryClient.d.ts.map

package/dist/query/QueryClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryClient.d.ts","sourceRoot":"","sources":["../../src/query/QueryClient.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAA0B,MAAM,uBAAuB,CAAC;AAE5E,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC;AAExC,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,QAAQ,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,wBAAwB,KAAG,WA4CrE,CAAC;AA2BF;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;8BAUL,MAAM;gCACJ,MAAM;mCACH,MAAM;;;iCAKR,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;8BAC1B,MAAM;iCACH,MAAM;;;iCAKN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;oCACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;8BAC7B,MAAM;;;;;;;;;;;;CAgBb,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;OAEG;yBACkB,QAAQ;;;;IAK7B;;OAEG;;;;;;;IAQH;;OAEG;qBACc,QAAQ;;;CAG1B,CAAC"}

package/dist/query/QueryClient.js

@@ -0,0 +1,136 @@
+/**
+ * Shared React Query client configuration
+ *
+ * Provides platform-optimized React Query configurations for web and mobile
+ * with appropriate caching, retry, and offline behavior settings.
+ */
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Create a QueryClient with platform-optimized defaults
+ */
+export const createQueryClient = (options) => {
+    const { platform, defaultStaleTime, defaultRetryCount, enableOfflineSupport = platform === 'mobile', } = options;
+    // Platform-specific defaults
+    const platformDefaults = getPlatformDefaults(platform);
+    const config = {
+        defaultOptions: {
+            queries: {
+                // Stale time - how long data stays fresh
+                staleTime: defaultStaleTime ?? platformDefaults.staleTime,
+                // Cache time - how long data stays in cache after becoming stale
+                gcTime: platformDefaults.gcTime,
+                // Retry configuration
+                retry: defaultRetryCount ?? platformDefaults.retry,
+                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+                // Refetch behavior
+                refetchOnWindowFocus: platformDefaults.refetchOnWindowFocus,
+                refetchOnReconnect: platformDefaults.refetchOnReconnect,
+                refetchOnMount: true,
+                // Network mode for offline support
+                networkMode: enableOfflineSupport ? 'offlineFirst' : 'online',
+            },
+            mutations: {
+                // Retry mutations on network errors
+                retry: platform === 'mobile' ? 2 : 1,
+                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 10000),
+                // Network mode for offline support
+                networkMode: enableOfflineSupport ? 'offlineFirst' : 'online',
+            },
+        },
+    };
+    return new QueryClient(config);
+};
+/**
+ * Get platform-specific default configurations
+ */
+function getPlatformDefaults(platform) {
+    if (platform === 'mobile') {
+        return {
+            // Mobile: Longer stale times for better offline experience
+            staleTime: 5 * 60 * 1000, // 5 minutes
+            gcTime: 10 * 60 * 1000, // 10 minutes
+            retry: 3, // More retries for unstable connections
+            refetchOnWindowFocus: false, // No window focus on mobile
+            refetchOnReconnect: true, // Refetch when network reconnects
+        };
+    }
+    else {
+        return {
+            // Web: Shorter stale times for more responsive experience
+            staleTime: 30 * 1000, // 30 seconds
+            gcTime: 5 * 60 * 1000, // 5 minutes
+            retry: 1, // Single retry for stable connections
+            refetchOnWindowFocus: true, // Refetch when user returns to tab
+            refetchOnReconnect: true, // Refetch when network reconnects
+        };
+    }
+}
+/**
+ * Default query keys factory
+ * Provides consistent query key structure across the application
+ */
+export const queryKeys = {
+    // Authentication
+    auth: {
+        profile: () => ['auth', 'profile'],
+        status: () => ['auth', 'status'],
+    },
+    // Portfolios
+    portfolios: {
+        all: () => ['portfolios'],
+        detail: (id) => ['portfolios', id],
+        holdings: (id) => ['portfolios', id, 'holdings'],
+        allocations: (id) => ['portfolios', id, 'allocations'],
+    },
+    // Instruments
+    instruments: {
+        all: (filters) => ['instruments', filters],
+        detail: (id) => ['instruments', id],
+        search: (query) => ['instruments', 'search', query],
+    },
+    // Trades
+    trades: {
+        all: (filters) => ['trades', filters],
+        target: (filters) => ['trades', 'target', filters],
+        detail: (id) => ['trades', id],
+    },
+    // Reference data
+    reference: {
+        countries: () => ['reference', 'countries'],
+        sectors: () => ['reference', 'sectors'],
+        industries: () => ['reference', 'industries'],
+        exchanges: () => ['reference', 'exchanges'],
+    },
+    // Users
+    users: {
+        profile: () => ['users', 'profile'],
+        preferences: () => ['users', 'preferences'],
+    },
+};
+/**
+ * Common query options factory
+ */
+export const createQueryOptions = {
+    /**
+     * Create options for frequently updated data
+     */
+    realtime: (platform) => ({
+        staleTime: platform === 'mobile' ? 1 * 60 * 1000 : 10 * 1000, // 1min mobile, 10s web
+        refetchInterval: platform === 'mobile' ? 2 * 60 * 1000 : 30 * 1000, // 2min mobile, 30s web
+    }),
+    /**
+     * Create options for static reference data
+     */
+    reference: () => ({
+        staleTime: 24 * 60 * 60 * 1000, // 24 hours
+        gcTime: 48 * 60 * 60 * 1000, // 48 hours
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
+    }),
+    /**
+     * Create options for user-specific data
+     */
+    user: (platform) => ({
+        staleTime: platform === 'mobile' ? 10 * 60 * 1000 : 2 * 60 * 1000, // 10min mobile, 2min web
+    }),
+};

package/dist/query/useAuth.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Shared authentication React Query hooks
+ *
+ * Provides consistent authentication state management and operations
+ * across web and mobile platforms with proper query invalidation.
+ */
+import { type UseMutationOptions } from '@tanstack/react-query';
+import type { AuthService, SigninPayload, SignupPayload, EmailVerificationPayload } from '../services/AuthService';
+export interface UseAuthOptions {
+    authService: AuthService;
+    enabled?: boolean;
+}
+export interface AuthMutationOptions<TData, TVariables> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationFn'> {
+    authService: AuthService;
+}
+/**
+ * Get current user profile with authentication status
+ */
+export declare function useProfile({ authService, enabled }: UseAuthOptions): import("@tanstack/react-query").UseQueryResult<import("..").UserProfile, Error>;
+/**
+ * Check authentication status
+ */
+export declare function useAuthStatus({ authService, enabled }: UseAuthOptions): import("@tanstack/react-query").UseQueryResult<{
+    authenticated: boolean;
+}, Error>;
+/**
+ * Sign in mutation
+ */
+export declare function useSignin(options: AuthMutationOptions<unknown, SigninPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, SigninPayload, unknown>;
+/**
+ * Sign out mutation
+ */
+export declare function useSignout(options: AuthMutationOptions<unknown, void>): import("@tanstack/react-query").UseMutationResult<unknown, Error, void, unknown>;
+/**
+ * Sign up mutation
+ */
+export declare function useSignup(options: AuthMutationOptions<unknown, SignupPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, SignupPayload, unknown>;
+/**
+ * Email verification mutation
+ */
+export declare function useVerifyEmail(options: AuthMutationOptions<unknown, EmailVerificationPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, EmailVerificationPayload, unknown>;
+/**
+ * Resend verification code mutation
+ */
+export declare function useResendVerification(options: AuthMutationOptions<unknown, void>): import("@tanstack/react-query").UseMutationResult<unknown, Error, void, unknown>;
+/**
+ * Composite auth hook that provides complete authentication state
+ */
+export declare function useAuth(options: UseAuthOptions): {
+    user: import("..").UserProfile | undefined;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isLoadingProfile: boolean;
+    isLoadingStatus: boolean;
+    error: Error | null;
+    profileError: Error | null;
+    statusError: Error | null;
+    refetchProfile: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").UserProfile, Error>>;
+    refetchStatus: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        authenticated: boolean;
+    }, Error>>;
+    refetch: () => void;
+};
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/query/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/query/useAuth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAyC,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACvG,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGnH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB,CAAC,KAAK,EAAE,UAAU,CAAE,SACtD,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC;IAChE,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,WAAW,EAAE,OAAc,EAAE,EAAE,cAAc,mFAczE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,OAAc,EAAE,EAAE,cAAc;;UAQ5E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,6FAgB7E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,oFAerE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,6FAe7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,CAAC,wGAe7F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,oFAOhF;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc;;;;;;;;;;;;;;EA2B9C"}

package/dist/query/useAuth.js

@@ -0,0 +1,144 @@
+/**
+ * Shared authentication React Query hooks
+ *
+ * Provides consistent authentication state management and operations
+ * across web and mobile platforms with proper query invalidation.
+ */
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { queryKeys } from './QueryClient';
+/**
+ * Get current user profile with authentication status
+ */
+export function useProfile({ authService, enabled = true }) {
+    return useQuery({
+        queryKey: queryKeys.auth.profile(),
+        queryFn: () => authService.getProfile(),
+        enabled,
+        retry: (failureCount, error) => {
+            // Don't retry on authentication errors
+            if (error && 'status' in error && error.status === 401) {
+                return false;
+            }
+            return failureCount < 3;
+        },
+        staleTime: 2 * 60 * 1000, // 2 minutes
+    });
+}
+/**
+ * Check authentication status
+ */
+export function useAuthStatus({ authService, enabled = true }) {
+    return useQuery({
+        queryKey: queryKeys.auth.status(),
+        queryFn: () => authService.checkStatus(),
+        enabled,
+        retry: false, // Don't retry auth status checks
+        staleTime: 1 * 60 * 1000, // 1 minute
+    });
+}
+/**
+ * Sign in mutation
+ */
+export function useSignin(options) {
+    const queryClient = useQueryClient();
+    const { authService, ...mutationOptions } = options;
+    return useMutation({
+        mutationFn: (data) => authService.signin(data),
+        onSuccess: (...args) => {
+            // Invalidate auth-related queries
+            queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
+            queryClient.invalidateQueries({ queryKey: queryKeys.auth.status() });
+            // Call user's onSuccess if provided
+            mutationOptions.onSuccess?.(...args);
+        },
+        ...mutationOptions,
+    });
+}
+/**
+ * Sign out mutation
+ */
+export function useSignout(options) {
+    const queryClient = useQueryClient();
+    const { authService, ...mutationOptions } = options;
+    return useMutation({
+        mutationFn: () => authService.signout(),
+        onSuccess: (...args) => {
+            // Clear all cached data on signout
+            queryClient.clear();
+            // Call user's onSuccess if provided
+            mutationOptions.onSuccess?.(...args);
+        },
+        ...mutationOptions,
+    });
+}
+/**
+ * Sign up mutation
+ */
+export function useSignup(options) {
+    const { authService, ...mutationOptions } = options;
+    return useMutation({
+        mutationFn: (data) => authService.signup(data),
+        onSuccess: (...args) => {
+            // Optionally invalidate auth queries if signup auto-signs in
+            // const queryClient = useQueryClient();
+            // queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
+            // Call user's onSuccess if provided
+            mutationOptions.onSuccess?.(...args);
+        },
+        ...mutationOptions,
+    });
+}
+/**
+ * Email verification mutation
+ */
+export function useVerifyEmail(options) {
+    const queryClient = useQueryClient();
+    const { authService, ...mutationOptions } = options;
+    return useMutation({
+        mutationFn: (data) => authService.verifyEmail(data),
+        onSuccess: (...args) => {
+            // Invalidate profile to get updated verification status
+            queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
+            // Call user's onSuccess if provided
+            mutationOptions.onSuccess?.(...args);
+        },
+        ...mutationOptions,
+    });
+}
+/**
+ * Resend verification code mutation
+ */
+export function useResendVerification(options) {
+    const { authService, ...mutationOptions } = options;
+    return useMutation({
+        mutationFn: () => authService.resendVerificationCode(),
+        ...mutationOptions,
+    });
+}
+/**
+ * Composite auth hook that provides complete authentication state
+ */
+export function useAuth(options) {
+    const profileQuery = useProfile(options);
+    const statusQuery = useAuthStatus(options);
+    return {
+        // Data
+        user: profileQuery.data,
+        isAuthenticated: !!(statusQuery.data && profileQuery.data),
+        // Loading states
+        isLoading: profileQuery.isLoading || statusQuery.isLoading,
+        isLoadingProfile: profileQuery.isLoading,
+        isLoadingStatus: statusQuery.isLoading,
+        // Error states
+        error: profileQuery.error || statusQuery.error,
+        profileError: profileQuery.error,
+        statusError: statusQuery.error,
+        // Refetch functions
+        refetchProfile: profileQuery.refetch,
+        refetchStatus: statusQuery.refetch,
+        refetch: () => {
+            profileQuery.refetch();
+            statusQuery.refetch();
+        },
+    };
+}