@cranberry-money/shared-services 1.12.1 → 3.0.0

package/dist/adapters/MobileApiClient.js

@@ -1,240 +0,0 @@
-/**
- * Mobile-specific API client implementation
- *
- * This implementation is designed for React Native environments
- * and includes mobile-specific features like network state awareness,
- * offline capability, and retry logic.
- */
-import { HTTP_HEADER_CONTENT_TYPE, CONTENT_TYPE_APPLICATION_JSON } from '@cranberry-money/shared-constants';
-import { BaseApiClient } from '../core/BaseApiClient';
-export class MobileApiClient extends BaseApiClient {
-    constructor(config) {
-        super({
-            ...config,
-            defaultHeaders: {
-                [HTTP_HEADER_CONTENT_TYPE]: CONTENT_TYPE_APPLICATION_JSON,
-                ...config.defaultHeaders,
-            },
-        });
-        this.offlineQueue = [];
-        this.isOnline = true;
-        this.retryAttempts = config.retryAttempts || 3;
-        this.retryDelay = config.retryDelay || 1000;
-        this.offlineQueueEnabled = config.offlineQueueEnabled || false;
-    }
-    async request(config) {
-        // Check if we're offline and should queue the request
-        if (!this.isOnline && this.offlineQueueEnabled) {
-            return this.queueRequest(config);
-        }
-        return this.executeRequest(config);
-    }
-    async executeRequest(config, attempt = 1) {
-        const url = this.buildUrl(config.url);
-        const headers = await this.buildHeaders(config.headers);
-        // Build fetch options
-        const fetchOptions = {
-            method: config.method || 'GET',
-            headers,
-            signal: config.timeout ? AbortSignal.timeout(config.timeout) : undefined,
-        };
-        // Add body for non-GET requests
-        if (config.data && config.method !== 'GET') {
-            if (headers[HTTP_HEADER_CONTENT_TYPE] === CONTENT_TYPE_APPLICATION_JSON) {
-                fetchOptions.body = JSON.stringify(config.data);
-            }
-            else {
-                fetchOptions.body = config.data;
-            }
-        }
-        // Add query parameters for GET requests
-        const requestUrl = config.params && config.method === 'GET'
-            ? `${url}?${new URLSearchParams(config.params).toString()}`
-            : url;
-        try {
-            const response = await fetch(requestUrl, fetchOptions);
-            // Handle non-2xx responses
-            if (!response.ok) {
-                const errorData = await this.parseResponseData(response);
-                // Handle authentication errors
-                if (response.status === 401) {
-                    const refreshed = await this.handleTokenRefresh();
-                    if (refreshed && attempt === 1) {
-                        // Retry once with new token
-                        return this.executeRequest(config, attempt + 1);
-                    }
-                }
-                throw this.createError(response.statusText || 'Request failed', response.status, 'HTTP_ERROR', errorData);
-            }
-            const data = await this.parseResponseData(response);
-            return {
-                data,
-                status: response.status,
-                statusText: response.statusText,
-                headers: this.parseResponseHeaders(response.headers),
-            };
-        }
-        catch (error) {
-            // Handle network errors with retry logic
-            if (this.shouldRetry(error, attempt)) {
-                await this.delay(this.retryDelay * attempt); // Exponential backoff
-                return this.executeRequest(config, attempt + 1);
-            }
-            // Handle different error types
-            if (error instanceof TypeError && error.message.includes('fetch')) {
-                throw this.createError('Network error', 0, 'NETWORK_ERROR');
-            }
-            if (error instanceof DOMException && error.name === 'AbortError') {
-                throw this.createError('Request timeout', 0, 'TIMEOUT_ERROR');
-            }
-            // Re-throw API errors
-            if (this.isApiError(error)) {
-                throw error;
-            }
-            // Handle unexpected errors
-            throw this.createError(error instanceof Error ? error.message : 'Unknown error', 0, 'UNEXPECTED_ERROR');
-        }
-    }
-    /**
-     * Queue request for when back online
-     */
-    async queueRequest(config) {
-        return new Promise((resolve, reject) => {
-            this.offlineQueue.push({
-                ...config,
-                resolve: resolve,
-                reject,
-            });
-        });
-    }
-    /**
-     * Process offline queue when back online
-     */
-    async syncWhenOnline() {
-        if (!this.isOnline || this.offlineQueue.length === 0)
-            return;
-        const queue = [...this.offlineQueue];
-        this.offlineQueue = [];
-        for (const request of queue) {
-            try {
-                const response = await this.executeRequest(request);
-                request.resolve(response);
-            }
-            catch (error) {
-                request.reject(error);
-            }
-        }
-    }
-    /**
-     * Enable offline mode
-     */
-    enableOfflineMode() {
-        this.isOnline = false;
-    }
-    /**
-     * Enable online mode and sync queue
-     */
-    async enableOnlineMode() {
-        this.isOnline = true;
-        if (this.offlineQueueEnabled) {
-            await this.syncWhenOnline();
-        }
-    }
-    /**
-     * Set network state
-     */
-    setNetworkState(isOnline) {
-        const wasOffline = !this.isOnline;
-        this.isOnline = isOnline;
-        if (wasOffline && isOnline && this.offlineQueueEnabled) {
-            // Process queue when coming back online
-            this.syncWhenOnline().catch(console.error);
-        }
-    }
-    /**
-     * Parse response data based on content type
-     */
-    async parseResponseData(response) {
-        const contentType = response.headers.get('content-type') || '';
-        if (contentType.includes('application/json')) {
-            return response.json();
-        }
-        if (contentType.includes('text/')) {
-            return response.text();
-        }
-        // For other content types, return as blob
-        return response.blob();
-    }
-    /**
-     * Convert Headers to plain object
-     */
-    parseResponseHeaders(headers) {
-        const headerObj = {};
-        headers.forEach((value, key) => {
-            headerObj[key] = value;
-        });
-        return headerObj;
-    }
-    /**
-     * Check if error is an API error
-     */
-    isApiError(error) {
-        return typeof error === 'object' &&
-            error !== null &&
-            'message' in error &&
-            'status' in error;
-    }
-    /**
-     * Determine if request should be retried
-     */
-    shouldRetry(error, attempt) {
-        if (attempt >= this.retryAttempts)
-            return false;
-        // Retry on network errors
-        if (error instanceof TypeError && error.message.includes('fetch')) {
-            return true;
-        }
-        // Retry on timeout errors
-        if (error instanceof DOMException && error.name === 'AbortError') {
-            return true;
-        }
-        // Retry on certain HTTP status codes
-        if (this.isApiError(error)) {
-            const status = error.status;
-            return status === 429 || (status !== undefined && status >= 500); // Rate limit or server errors
-        }
-        return false;
-    }
-    /**
-     * Handle token refresh for mobile (secure storage based)
-     */
-    async handleTokenRefresh() {
-        if (!this.tokenStorage)
-            return false;
-        try {
-            const tokens = await this.tokenStorage.retrieveTokens();
-            if (!tokens?.refresh)
-                return false;
-            const response = await this.request({
-                url: '/auth/refresh',
-                method: 'POST',
-                data: { refresh: tokens.refresh },
-            });
-            if (response.status === 200 && response.data) {
-                const newTokens = response.data;
-                await this.tokenStorage.storeTokens(newTokens);
-                return true;
-            }
-            return false;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Utility delay function
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-}

package/dist/adapters/MobileTokenStorage.d.ts

@@ -1,43 +0,0 @@
-/**
- * Mobile-specific token storage using secure storage
- *
- * This implementation uses platform-secure storage mechanisms
- * like iOS Keychain and Android Keystore via React Native libraries.
- *
- * For Expo: Uses Expo SecureStore
- * For bare React Native: Would use @react-native-async-storage/async-storage
- * with encryption or react-native-keychain
- */
-import { BaseTokenStorage, type TokenPair } from '../core/TokenStorage';
-export declare class MobileTokenStorage extends BaseTokenStorage {
-    private secureStore;
-    constructor(secureStore: SecureStoreInterface);
-    storeTokens(tokens: TokenPair): Promise<void>;
-    retrieveTokens(): Promise<TokenPair | null>;
-    clearTokens(): Promise<void>;
-    hasTokens(): Promise<boolean>;
-    /**
-     * Check if secure storage is available
-     */
-    isAvailable(): Promise<boolean>;
-}
-/**
- * Interface for secure storage implementations
- * This abstracts the specific secure storage library being used
- */
-export interface SecureStoreInterface {
-    setItemAsync(key: string, value: string): Promise<void>;
-    getItemAsync(key: string): Promise<string | null>;
-    deleteItemAsync(key: string): Promise<void>;
-    isAvailableAsync?(): Promise<boolean>;
-}
-/**
- * Factory function to create MobileTokenStorage with different backends
- */
-export declare const createMobileTokenStorage: (secureStore: SecureStoreInterface) => MobileTokenStorage;
-/**
- * Expo SecureStore adapter
- * Usage: createMobileTokenStorage(createExpoSecureStoreAdapter())
- */
-export declare const createExpoSecureStoreAdapter: () => SecureStoreInterface;
-//# sourceMappingURL=MobileTokenStorage.d.ts.map

package/dist/adapters/MobileTokenStorage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MobileTokenStorage.d.ts","sourceRoot":"","sources":["../../src/adapters/MobileTokenStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAQxE,qBAAa,kBAAmB,SAAQ,gBAAgB;IACtD,OAAO,CAAC,WAAW,CAAuB;gBAE9B,WAAW,EAAE,oBAAoB;IAKvC,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAe7C,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA0B3C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAanC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;CAStC;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAClD,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,gBAAgB,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,oBAAoB,KAAG,kBAE5E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAAO,oBAsB/C,CAAC"}

package/dist/adapters/MobileTokenStorage.js

@@ -1,128 +0,0 @@
-/**
- * Mobile-specific token storage using secure storage
- *
- * This implementation uses platform-secure storage mechanisms
- * like iOS Keychain and Android Keystore via React Native libraries.
- *
- * For Expo: Uses Expo SecureStore
- * For bare React Native: Would use @react-native-async-storage/async-storage
- * with encryption or react-native-keychain
- */
-import { BaseTokenStorage } from '../core/TokenStorage';
-// Keys for secure storage
-const STORAGE_KEYS = {
-    ACCESS_TOKEN: 'myportfolio_access_token',
-    REFRESH_TOKEN: 'myportfolio_refresh_token',
-};
-export class MobileTokenStorage extends BaseTokenStorage {
-    constructor(secureStore) {
-        super();
-        this.secureStore = secureStore;
-    }
-    async storeTokens(tokens) {
-        if (!this.validateTokens(tokens)) {
-            throw new Error('Invalid token format');
-        }
-        try {
-            await Promise.all([
-                this.secureStore.setItemAsync(STORAGE_KEYS.ACCESS_TOKEN, tokens.access),
-                this.secureStore.setItemAsync(STORAGE_KEYS.REFRESH_TOKEN, tokens.refresh),
-            ]);
-        }
-        catch (error) {
-            throw new Error(`Failed to store tokens: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async retrieveTokens() {
-        try {
-            const [access, refresh] = await Promise.all([
-                this.secureStore.getItemAsync(STORAGE_KEYS.ACCESS_TOKEN),
-                this.secureStore.getItemAsync(STORAGE_KEYS.REFRESH_TOKEN),
-            ]);
-            if (!access || !refresh) {
-                return null;
-            }
-            const tokens = { access, refresh };
-            if (!this.validateTokens(tokens)) {
-                // Clear invalid tokens
-                await this.clearTokens();
-                return null;
-            }
-            return tokens;
-        }
-        catch (error) {
-            console.error('Failed to retrieve tokens:', error);
-            return null;
-        }
-    }
-    async clearTokens() {
-        try {
-            await Promise.all([
-                this.secureStore.deleteItemAsync(STORAGE_KEYS.ACCESS_TOKEN),
-                this.secureStore.deleteItemAsync(STORAGE_KEYS.REFRESH_TOKEN),
-            ]);
-        }
-        catch (error) {
-            console.error('Failed to clear tokens:', error);
-            // Don't throw - clearing should be idempotent
-        }
-    }
-    async hasTokens() {
-        try {
-            const [access, refresh] = await Promise.all([
-                this.secureStore.getItemAsync(STORAGE_KEYS.ACCESS_TOKEN),
-                this.secureStore.getItemAsync(STORAGE_KEYS.REFRESH_TOKEN),
-            ]);
-            return !!(access && refresh);
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Check if secure storage is available
-     */
-    async isAvailable() {
-        try {
-            // Try to perform a simple operation to check availability
-            await this.secureStore.isAvailableAsync?.();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-/**
- * Factory function to create MobileTokenStorage with different backends
- */
-export const createMobileTokenStorage = (secureStore) => {
-    return new MobileTokenStorage(secureStore);
-};
-/**
- * Expo SecureStore adapter
- * Usage: createMobileTokenStorage(createExpoSecureStoreAdapter())
- */
-export const createExpoSecureStoreAdapter = () => {
-    // This would be implemented when actually using Expo
-    // For now, return a mock implementation for type checking
-    return {
-        async setItemAsync(key, value) {
-            // In real implementation: await ExpoSecureStore.setItemAsync(key, value);
-            console.log(`Mock: Storing ${key} = ${value}`);
-        },
-        async getItemAsync(key) {
-            // In real implementation: return await ExpoSecureStore.getItemAsync(key);
-            console.log(`Mock: Retrieving ${key}`);
-            return null;
-        },
-        async deleteItemAsync(key) {
-            // In real implementation: await ExpoSecureStore.deleteItemAsync(key);
-            console.log(`Mock: Deleting ${key}`);
-        },
-        async isAvailableAsync() {
-            // In real implementation: return await ExpoSecureStore.isAvailableAsync();
-            return true;
-        },
-    };
-};

package/dist/adapters/WebApiClient.d.ts

@@ -1,28 +0,0 @@
-/**
- * Web-specific API client implementation using fetch or axios
- *
- * This implementation is designed for web browsers and supports
- * cookie-based authentication with proper CORS handling.
- */
-import { BaseApiClient, type RequestConfig, type ApiResponse, type ApiClientConfig } from '../core/BaseApiClient';
-export declare class WebApiClient extends BaseApiClient {
-    constructor(config: ApiClientConfig);
-    request<T = unknown>(config: RequestConfig): Promise<ApiResponse<T>>;
-    /**
-     * Parse response data based on content type
-     */
-    private parseResponseData;
-    /**
-     * Convert Headers to plain object
-     */
-    private parseResponseHeaders;
-    /**
-     * Check if error is an API error
-     */
-    private isApiError;
-    /**
-     * Handle token refresh for web (cookie-based)
-     */
-    protected handleTokenRefresh(): Promise<boolean>;
-}
-//# sourceMappingURL=WebApiClient.d.ts.map

package/dist/adapters/WebApiClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebApiClient.d.ts","sourceRoot":"","sources":["../../src/adapters/WebApiClient.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAElH,qBAAa,YAAa,SAAQ,aAAa;gBACjC,MAAM,EAAE,eAAe;IAU7B,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAoE1E;;OAEG;YACW,iBAAiB;IAe/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;cACa,kBAAkB,IAAI,OAAO,CAAC,OAAO,CAAC;CAcvD"}

package/dist/adapters/WebApiClient.js

@@ -1,119 +0,0 @@
-/**
- * Web-specific API client implementation using fetch or axios
- *
- * This implementation is designed for web browsers and supports
- * cookie-based authentication with proper CORS handling.
- */
-import { HTTP_HEADER_CONTENT_TYPE, CONTENT_TYPE_APPLICATION_JSON } from '@cranberry-money/shared-constants';
-import { BaseApiClient } from '../core/BaseApiClient';
-export class WebApiClient extends BaseApiClient {
-    constructor(config) {
-        super({
-            ...config,
-            defaultHeaders: {
-                [HTTP_HEADER_CONTENT_TYPE]: CONTENT_TYPE_APPLICATION_JSON,
-                ...config.defaultHeaders,
-            },
-        });
-    }
-    async request(config) {
-        const url = this.buildUrl(config.url);
-        const headers = await this.buildHeaders(config.headers);
-        // Build fetch options
-        const fetchOptions = {
-            method: config.method || 'GET',
-            headers,
-            credentials: this.withCredentials ? 'include' : 'omit',
-        };
-        // Add body for non-GET requests
-        if (config.data && config.method !== 'GET') {
-            if (headers[HTTP_HEADER_CONTENT_TYPE] === CONTENT_TYPE_APPLICATION_JSON) {
-                fetchOptions.body = JSON.stringify(config.data);
-            }
-            else {
-                fetchOptions.body = config.data;
-            }
-        }
-        // Add query parameters for GET requests
-        const requestUrl = config.params && config.method === 'GET'
-            ? `${url}?${new URLSearchParams(config.params).toString()}`
-            : url;
-        try {
-            const response = await fetch(requestUrl, fetchOptions);
-            // Handle non-2xx responses
-            if (!response.ok) {
-                const errorData = await this.parseResponseData(response);
-                throw this.createError(response.statusText || 'Request failed', response.status, 'HTTP_ERROR', errorData);
-            }
-            const data = await this.parseResponseData(response);
-            return {
-                data,
-                status: response.status,
-                statusText: response.statusText,
-                headers: this.parseResponseHeaders(response.headers),
-            };
-        }
-        catch (error) {
-            // Handle network errors
-            if (error instanceof TypeError && error.message.includes('fetch')) {
-                throw this.createError('Network error', 0, 'NETWORK_ERROR');
-            }
-            // Re-throw API errors
-            if (this.isApiError(error)) {
-                throw error;
-            }
-            // Handle unexpected errors
-            throw this.createError(error instanceof Error ? error.message : 'Unknown error', 0, 'UNEXPECTED_ERROR');
-        }
-    }
-    /**
-     * Parse response data based on content type
-     */
-    async parseResponseData(response) {
-        const contentType = response.headers.get('content-type') || '';
-        if (contentType.includes('application/json')) {
-            return response.json();
-        }
-        if (contentType.includes('text/')) {
-            return response.text();
-        }
-        // For other content types, return as blob
-        return response.blob();
-    }
-    /**
-     * Convert Headers to plain object
-     */
-    parseResponseHeaders(headers) {
-        const headerObj = {};
-        headers.forEach((value, key) => {
-            headerObj[key] = value;
-        });
-        return headerObj;
-    }
-    /**
-     * Check if error is an API error
-     */
-    isApiError(error) {
-        return typeof error === 'object' &&
-            error !== null &&
-            'message' in error &&
-            'status' in error;
-    }
-    /**
-     * Handle token refresh for web (cookie-based)
-     */
-    async handleTokenRefresh() {
-        try {
-            // For cookie-based auth, make a request to refresh endpoint
-            // The server will set new cookies automatically
-            const response = await this.request({
-                url: '/auth/refresh',
-                method: 'POST',
-            });
-            return response.status === 200;
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/adapters/WebTokenStorage.d.ts

@@ -1,38 +0,0 @@
-/**
- * Web-specific token storage using HTTP-only cookies
- *
- * This implementation relies on the backend to set HTTP-only cookies
- * and doesn't directly manage tokens on the client side for security.
- *
- * For web applications using cookie-based authentication, the tokens
- * are automatically included in requests via browser cookie handling.
- */
-import { BaseTokenStorage, type TokenPair } from '../core/TokenStorage';
-export declare class WebTokenStorage extends BaseTokenStorage {
-    /**
-     * For cookie-based auth, tokens are managed by the browser/server
-     * This method would typically not store anything client-side
-     */
-    storeTokens(tokens: TokenPair): Promise<void>;
-    /**
-     * For cookie-based auth, we can't directly access HTTP-only cookies
-     * This method checks if authentication cookies likely exist
-     */
-    retrieveTokens(): Promise<TokenPair | null>;
-    /**
-     * Clear authentication state
-     * In cookie systems, this would typically call a logout endpoint
-     */
-    clearTokens(): Promise<void>;
-    /**
-     * Check authentication status
-     * In cookie systems, this would check if auth cookies exist
-     */
-    hasTokens(): Promise<boolean>;
-    /**
-     * Check if authentication cookies exist
-     * This is a web-specific method for cookie-based auth
-     */
-    hasCookies(): boolean;
-}
-//# sourceMappingURL=WebTokenStorage.d.ts.map

package/dist/adapters/WebTokenStorage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebTokenStorage.d.ts","sourceRoot":"","sources":["../../src/adapters/WebTokenStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAExE,qBAAa,eAAgB,SAAQ,gBAAgB;IACnD;;;OAGG;IACG,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAWnD;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAuBjD;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlC;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAYnC;;;OAGG;IACH,UAAU,IAAI,OAAO;CAOtB"}