@explorins/pers-sdk 1.1.2 → 1.1.3

package/src/core/auth/create-auth-provider.ts

@@ -1,136 +0,0 @@
-import { PersAuthProvider } from './auth-provider.interface';
-import { SimpleAuthConfig } from './simple-auth-config.interface';
-
-/**
- * Creates a platform-agnostic AuthProvider from simple configuration
- * 
- * This factory function is completely platform-agnostic and can be used
- * across Angular, React, Vue, Node.js, or any other JavaScript environment.
- * 
- * Features:
- * - Token caching with refresh support
- * - Automatic token refresh on expiration
- * - Configurable token providers
- * - Platform-independent (no localStorage assumptions)
- * 
- * @param config - Simple auth configuration
- * @returns AuthProvider implementation
- */
-export function createAuthProvider(config: SimpleAuthConfig): PersAuthProvider {
-  // Store current token for refresh scenarios and caching
-  let currentToken: string | null = config.token || null;
-  let isRefreshing = false; // Prevent concurrent refresh attempts
-  let refreshPromise: Promise<void> | null = null;
-
-  return {
-    authType: config.authType || 'user',
-    
-    async getToken(): Promise<string | null> {
-      // If currently refreshing, wait for it to complete
-      if (isRefreshing && refreshPromise) {
-        await refreshPromise;
-        return currentToken;
-      }
-
-      // Use cached current token (updated after refresh)
-      if (currentToken) {
-        return currentToken;
-      }
-      
-      // Custom token provider function (always fresh)
-      if (config.tokenProvider) {
-        const token = await config.tokenProvider();
-        currentToken = token; // Cache for future calls
-        return token;
-      }
-      
-      // No token available
-      return null;
-    },
-    
-    async getProjectKey(): Promise<string | null> {
-      return config.projectKey || null;
-    },
-    
-    async onTokenExpired(): Promise<void> {
-      // Prevent concurrent refresh attempts
-      if (isRefreshing) {
-        if (refreshPromise) {
-          await refreshPromise;
-        }
-        return;
-      }
-
-      // No refresh logic provided
-      if (!config.onTokenExpired) {
-        console.warn('Token expired but no refresh logic provided');
-        currentToken = null; // Clear expired token
-        return;
-      }
-
-      // Start refresh process
-      isRefreshing = true;
-      refreshPromise = (async () => {
-        try {
-          // Execute refresh logic (should update token source)
-          await config.onTokenExpired!();
-          
-          // After refresh, get the new token
-          if (config.tokenProvider) {
-            const newToken = await config.tokenProvider();
-            if (newToken && newToken !== currentToken) {
-              currentToken = newToken;
-              
-              // Notify about successful token refresh
-              if (config.onTokenRefreshed) {
-                config.onTokenRefreshed(newToken);
-              }
-            } else {
-              console.warn('Token refresh completed but no new token received');
-              currentToken = null;
-            }
-          } else {
-            // For static token configs, clear the token since we can't refresh
-            console.warn('Token expired for static token config - clearing token');
-            currentToken = null;
-          }
-        } catch (error) {
-          console.error('Token refresh failed:', error);
-          currentToken = null; // Clear token on refresh failure
-          throw error; // Re-throw to let SDK handle the error
-        } finally {
-          isRefreshing = false;
-          refreshPromise = null;
-        }
-      })();
-
-      await refreshPromise;
-    }
-  };
-}
-
-/**
- * Platform-specific localStorage token provider for browsers
- * This is a convenience function for browser environments
- */
-/* export function createBrowserTokenProvider(tokenKey: string = 'userJwt'): () => Promise<string | null> {
-  return async () => {
-    if (typeof localStorage !== 'undefined') {
-      return localStorage.getItem(tokenKey);
-    }
-    return null;
-  };
-} */
-
-/**
- * Platform-specific environment variable token provider for Node.js
- * This is a convenience function for Node.js environments
- */
-/* export function createNodeTokenProvider(envVar: string = 'JWT_TOKEN'): () => Promise<string | null> {
-  return async () => {
-    if (typeof process !== 'undefined' && process.env) {
-      return process.env[envVar] || null;
-    }
-    return null;
-  };
-} */

package/src/core/auth/simple-auth-config.interface.ts

@@ -1,15 +0,0 @@
-/**
- * Simple Auth Configuration Interface - Dev-Friendly Alternative
- * 
- * Instead of implementing AuthProvider, developers can use this simple config
- * which will be automatically converted to a full AuthProvider implementation.
- */
-export interface SimpleAuthConfig {
-  authType?: 'admin' | 'user' | 'firebase';
-  token?: string;
-  tokenProvider?: () => Promise<string | null>;
-  projectKey?: string;
-  onTokenExpired?: () => Promise<void>;
-  // Advanced: for reactive token updates after refresh
-  onTokenRefreshed?: (newToken: string) => void;
-}

package/src/core/index.ts

@@ -1,33 +0,0 @@
-/**
- * @explorins/pers-sdk/core - Core SDK Entry Point
- * 
- * Platform-agnostic PERS API client and core functionality
- */
-
-// Core PERS API client
-export * from './pers-api-client';
-
-// Configuration interfaces and types
-export * from './pers-config';
-export type { PersEnvironment, PersApiVersion } from './pers-config';
-
-// Authentication interfaces  
-export { 
-  PersAuthProvider, 
-  SimpleAuthConfig,
-  createAuthProvider,
-  /* createBrowserTokenProvider,
-  createNodeTokenProvider */
-} from './auth/auth-provider.interface';
-
-// Add compatibility alias for Angular package
-// export { PersAuthProvider as AuthProvider } from './auth/auth-provider.interface';
-
-export type { PersRequestOptions as AuthRequestOptions } from './auth/auth-provider.interface';
-
-// Platform abstractions
-export * from './abstractions/http-client';
-
-// Main SDK class
-export { PersSDK, createPersSDK } from '../pers-sdk';
-

package/src/core/pers-api-client.ts

@@ -1,343 +0,0 @@
-// packages/pers-sdk/src/core/pers-api-client.ts
-/**
- * PERS API Client - Core platform-agnostic client for PERS backend
- */
-
-import { HttpClient, RequestOptions } from './abstractions/http-client';
-import { PersConfig, buildApiRoot, mergeWithDefaults } from './pers-config';
-
-export class PersApiClient {
-  private readonly apiRoot: string;
-  private readonly mergedConfig: ReturnType<typeof mergeWithDefaults>;
-
-  constructor(
-    private httpClient: HttpClient,
-    private config: PersConfig
-  ) {
-    // Merge user config with defaults (production + v2)
-    this.mergedConfig = mergeWithDefaults(config);
-    
-    // Build API root from merged environment and version
-    this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion);
-  }
-
-  /**
-   * Get request headers including auth token and project key
-   */
-  private async getHeaders(): Promise<Record<string, string>> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    };
-
-    // Add authentication token
-    if (this.mergedConfig.authProvider) {
-      const token = await this.mergedConfig.authProvider.getToken();
-      if (token) {
-        headers['Authorization'] = `Bearer ${token}`;
-      }
-    }
-
-    // Add project key
-    if (this.mergedConfig.authProvider) {
-      const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-      if (projectKey) {
-        headers['x-project-key'] = projectKey;
-      }
-    } else if(this.mergedConfig.apiProjectKey) {
-      // Fallback to config project key if no auth provider
-      headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-    }
-
-    return headers;
-  }
-
-  /**
-   * Make a request with proper headers, auth, and error handling
-   */
-  private async request<T>(
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-    endpoint: string,
-    body?: unknown,
-    options?: { retryCount?: number; responseType?: 'json' | 'blob' | 'text' | 'arraybuffer' }
-  ): Promise<T> {
-    const { retryCount = 0, responseType = 'json' } = options || {};
-    const url = `${this.apiRoot}${endpoint}`;
-    
-    // ✅ DEBUGGING: Add extensive logging for CSV endpoint
-    const isCSVEndpoint = endpoint.includes('/export/csv');
-    
-    const requestOptions: RequestOptions = {
-      headers: await this.getHeaders(),
-      timeout: this.mergedConfig.timeout,
-      responseType
-    };
-
-    try {
-      let result: T;
-      
-      switch (method) {
-        case 'GET':
-          result = await this.httpClient.get<T>(url, requestOptions);
-          break;
-        case 'POST':
-          result = await this.httpClient.post<T>(url, body, requestOptions);
-          break;
-        case 'PUT':
-          result = await this.httpClient.put<T>(url, body, requestOptions);
-          break;
-        case 'DELETE':
-          result = await this.httpClient.delete<T>(url, requestOptions);
-          break;
-        default:
-          throw new Error(`Unsupported HTTP method: ${method}`);
-      }
-
-      return result;
-    } catch (error: unknown) {
-      if (isCSVEndpoint) {
-        console.error('❌ [PERS API CLIENT] CSV Request failed:', error);
-      }
-
-      // Handle 401 errors with automatic token refresh
-      const apiError = error as { status?: number; message?: string };
-      
-      if (apiError.status === 401 && retryCount === 0 && this.mergedConfig.authProvider?.onTokenExpired) {
-        try {
-          await this.mergedConfig.authProvider.onTokenExpired();
-          // Retry once with refreshed token
-          return this.request<T>(method, endpoint, body, { ...options, retryCount: 1 });
-        } catch (refreshError) {
-          throw new PersApiError(
-            `Authentication refresh failed: ${refreshError}`, 
-            endpoint, 
-            method, 
-            401
-          );
-        }
-      }
-
-      throw new PersApiError(
-        `PERS API request failed: ${apiError.message || error}`, 
-        endpoint, 
-        method, 
-        apiError.status
-      );
-    }
-  }
-
-  /**
-   * Generic GET request
-   */
-  async get<T>(endpoint: string, responseType?: 'json' | 'blob' | 'text' | 'arraybuffer'): Promise<T> {
-    return this.request<T>('GET', endpoint, undefined, { responseType });
-  }
-
-  /**
-   * Generic POST request
-   */
-  async post<T>(endpoint: string, body?: unknown): Promise<T> {
-    return this.request<T>('POST', endpoint, body);
-  }
-
-  /**
-   * Generic PUT request
-   */
-  async put<T>(endpoint: string, body?: unknown): Promise<T> {
-    return this.request<T>('PUT', endpoint, body);
-  }
-
-  /**
-   * Generic DELETE request
-   */
-  async delete<T>(endpoint: string): Promise<T> {
-    return this.request<T>('DELETE', endpoint);
-  }
-
-  /**
-   * Get current configuration (returns merged config)
-   */
-  getConfig(): ReturnType<typeof mergeWithDefaults> {
-    return this.mergedConfig;
-  }
-
-  /**
-   * Get original user configuration
-   */
-  getOriginalConfig(): PersConfig {
-    return this.config;
-  }
-}
-
-export class PersApiError extends Error {
-  constructor(
-    message: string,
-    public endpoint: string,
-    public method: string,
-    public statusCode?: number
-  ) {
-    super(message);
-    this.name = 'PersApiError';
-  }
-}
-/**
- * PERS API Client - Core platform-agnostic client for PERS backend
- */
-
-/*import { HttpClient, RequestOptions } from './abstractions/http-client';
-import { PersConfig, buildApiRoot, mergeWithDefaults } from './pers-config';
-
-export class PersApiClient {
-  private readonly apiRoot: string;
-  private readonly mergedConfig: ReturnType<typeof mergeWithDefaults>;
-
-  constructor(
-    private httpClient: HttpClient,
-    private config: PersConfig
-  ) {
-    // Merge user config with defaults (production + v2)
-    this.mergedConfig = mergeWithDefaults(config);
-    
-    // Build API root from merged environment and version
-    this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion);
-  }
-
-  /**
-   * Get request headers including auth token and project key
-   */
-  /*private async getHeaders(): Promise<Record<string, string>> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    };
-
-    // Add authentication token
-    if (this.mergedConfig.authProvider) {
-      const token = await this.mergedConfig.authProvider.getToken();
-      if (token) {
-        headers['Authorization'] = `Bearer ${token}`;
-      }
-    }
-
-    // Add project key
-    if (this.mergedConfig.authProvider) {
-      const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-      if (projectKey) {
-        headers['x-project-key'] = projectKey;
-      }
-    } else if(this.mergedConfig.apiProjectKey) {
-      // Fallback to config project key if no auth provider
-      headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-    }
-
-    return headers;
-  }
-
-  /**
-   * Make a request with proper headers, auth, and error handling
-   */
-  /*private async request<T>(
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
-    endpoint: string,
-    body?: any,
-    options?: { retryCount?: number }
-  ): Promise<T> {
-    const { retryCount = 0 } = options || {};
-    const url = `${this.apiRoot}${endpoint}`;
-    
-    const requestOptions: RequestOptions = {
-      headers: await this.getHeaders(),
-      timeout: this.mergedConfig.timeout,
-    };
-
-    try {
-      switch (method) {
-        case 'GET':
-          return await this.httpClient.get<T>(url, requestOptions);
-        case 'POST':
-          return await this.httpClient.post<T>(url, body, requestOptions);
-        case 'PUT':
-          return await this.httpClient.put<T>(url, body, requestOptions);
-        case 'DELETE':
-          return await this.httpClient.delete<T>(url, requestOptions);
-        default:
-          throw new Error(`Unsupported HTTP method: ${method}`);
-      }
-    } catch (error: any) {
-      // Handle 401 errors with automatic token refresh
-      if (error.status === 401 && retryCount === 0 && this.mergedConfig.authProvider?.onTokenExpired) {
-        try {
-          await this.mergedConfig.authProvider.onTokenExpired();
-          // Retry once with refreshed token
-          return this.request<T>(method, endpoint, body, { ...options, retryCount: 1 });
-        } catch (refreshError) {
-          throw new PersApiError(
-            `Authentication refresh failed: ${refreshError}`, 
-            endpoint, 
-            method, 
-            401
-          );
-        }
-      }
-
-      throw new PersApiError(
-        `PERS API request failed: ${error.message || error}`, 
-        endpoint, 
-        method, 
-        error.status
-      );
-    }
-  }
-
-  /**
-   * Generic GET request
-   */
-  /*async get<T>(endpoint: string): Promise<T> {
-    return this.request<T>('GET', endpoint);
-  }
-
-  /**
-   * Generic POST request
-   */
-  /*async post<T>(endpoint: string, body?: any): Promise<T> {
-    return this.request<T>('POST', endpoint, body);
-  }
-
-  /**
-   * Generic PUT request
-   */
-  /*async put<T>(endpoint: string, body?: any): Promise<T> {
-    return this.request<T>('PUT', endpoint, body);
-  }
-
-  /**
-   * Generic DELETE request
-   */
-  /*async delete<T>(endpoint: string): Promise<T> {
-    return this.request<T>('DELETE', endpoint);
-  }
-
-  /**
-   * Get current configuration (returns merged config)
-   */
-  /*getConfig(): ReturnType<typeof mergeWithDefaults> {
-    return this.mergedConfig;
-  }
-
-  /**
-   * Get original user configuration
-   */
-  /*getOriginalConfig(): PersConfig {
-    return this.config;
-  }
-}
-
-export class PersApiError extends Error {
-  constructor(
-    message: string,
-    public endpoint: string,
-    public method: string,
-    public statusCode?: number
-  ) {
-    super(message);
-    this.name = 'PersApiError';
-  }
-}*/

package/src/core/pers-config.ts

@@ -1,65 +0,0 @@
-/**
- * PERS SDK Configuration interfaces
- */
-
-import { PersAuthProvider } from './auth/auth-provider.interface';
-
-export type PersEnvironment = 'development' | 'staging' | 'production';
-export type PersApiVersion = 'v1' | 'v1.8' | 'v1.9' | 'v2';
-
-export interface PersConfig {
-  environment?: PersEnvironment;
-  apiProjectKey?: string;
-  apiVersion?: PersApiVersion;
-  timeout?: number;
-  retries?: number;
-  authProvider?: PersAuthProvider;
-  // Internal - constructed automatically
-  readonly apiRoot?: string;
-}
-
-export interface PersAuthConfig {
-  type: 'firebase' | 'jwt' | 'none';
-  tokenProvider?: () => Promise<string | null>;
-}
-
-/**
- * Default configuration values
- */
-export const DEFAULT_PERS_CONFIG = {
-  environment: 'production' as PersEnvironment,
-  apiVersion: 'v2' as PersApiVersion,
-  timeout: 30000,
-  retries: 3
-} as const;
-
-/**
- * Internal function to construct API root from environment
- * Now defaults to production and v2
- */
-export function buildApiRoot(
-  environment: PersEnvironment = 'production', 
-  version: PersApiVersion = 'v2'
-): string {
-  const baseUrls = {
-    development: 'https://explorins-loyalty.ngrok.io',
-    staging: `https://dev.api.pers.ninja/${version}`, 
-    production: `https://api.pers.ninja/${version}`
-  };
-  
-  return `${baseUrls[environment]}`;
-}
-
-/**
- * Merge user config with defaults
- */
-export function mergeWithDefaults(config: PersConfig): PersConfig & Required<Pick<PersConfig, 'environment' | 'apiVersion' | 'timeout' | 'retries'>> {
-  return {
-    ...DEFAULT_PERS_CONFIG,
-    ...config,
-    environment: config.environment ?? DEFAULT_PERS_CONFIG.environment,
-    apiVersion: config.apiVersion ?? DEFAULT_PERS_CONFIG.apiVersion,
-    timeout: config.timeout ?? DEFAULT_PERS_CONFIG.timeout,
-    retries: config.retries ?? DEFAULT_PERS_CONFIG.retries
-  };
-}

package/src/core/utils/jwt.function.ts

@@ -1,24 +0,0 @@
-import { jwtDecode } from "jwt-decode";
-
-
-export const isTokenExpired = (token: string, margin: number = 60): boolean => {
-    // ✅ SANITIZE: Remove any words (Bearer etc) if exists and get the token
-    const cleanToken = token.split(' ')[1] || token;
-
-    // ✅ VALIDATION: Check if token is jwt
-    if (!cleanToken || cleanToken.split('.').length !== 3) {
-      return true; // Consider invalid tokens as expired
-    }
-    
-    try {
-      // ✅ TYPE-SAFE: Decode with proper typing
-      const decoded: any = jwtDecode(cleanToken);
-      const currentTime = Math.floor(Date.now() / 1000);
-
-      // ✅ CONFIGURABLE: Use provided margin (default 60 seconds)
-      return decoded.exp < (currentTime + margin);
-    } catch (error) {
-      console.error('[SDK JWT Utils] Error decoding JWT token:', error);
-      return true; // Consider unparseable tokens as expired
-    }
-};

package/src/donation/api/donation-api.ts

@@ -1,24 +0,0 @@
-import { PersApiClient } from '../../core/pers-api-client';
-import { DonationTypeDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
-
-/**
- * Platform-Agnostic Donation API Client
- * 
- * Handles donation operations using the PERS backend.
- * Matches framework DonationApiService methods exactly.
- */
-export class DonationApi {
-  constructor(private apiClient: PersApiClient) {}
-
-  // ==========================================
-  // PUBLIC OPERATIONS
-  // ==========================================
-
-  /**
-   * PUBLIC: Get all donation types
-   * ✅ ONLY method actually used by framework
-   */
-  async getAllDonationTypes(): Promise<DonationTypeDTO[]> {
-    return this.apiClient.get<DonationTypeDTO[]>('/purchase/donation/type');
-  }
-}

package/src/donation/index.ts

@@ -1,47 +0,0 @@
-/**
- * @explorins/pers-sdk-donation
- * 
- * Platform-agnostic Donation Domain SDK for PERS ecosystem
- * Handles donation type retrieval for purchase flow integration
- */
-
-// API Layer
-export { DonationApi } from './api/donation-api';
-
-// Service Layer  
-export { DonationService } from './services/donation-service';
-
-// Models & Types - re-export all centralized interfaces
-export * from '../shared/interfaces/pers-shared-lib.interfaces';
-
-// Models & Types - imported from centralized interfaces
-
-// Factory function for creating donation SDK instance
-import { PersApiClient } from '../core/pers-api-client';
-import { DonationApi } from './api/donation-api';
-import { DonationService } from './services/donation-service';
-
-/**
- * Create a complete Donation SDK instance
- * 
- * @param apiClient - Configured PERS API client
- * @returns Donation SDK with flattened structure for better DX
- */
-export function createDonationSDK(apiClient: PersApiClient) {
-  const donationApi = new DonationApi(apiClient);
-  const donationService = new DonationService(donationApi);
-  
-  return {
-    // Direct access to service methods (primary interface)
-    // ✅ FRAMEWORK ALIGNED: Only method actually used by framework
-    
-    // Public methods
-    getAllDonationTypes: () => donationService.getAllDonationTypes(),
-    
-    // Advanced access for edge cases
-    api: donationApi,
-    service: donationService
-  };
-}
-
-export type DonationSDK = ReturnType<typeof createDonationSDK>;