@explorins/pers-sdk 1.0.0-alpha.1 → 1.1.2

package/src/core/index.ts

@@ -0,0 +1,33 @@
+/**
+ * @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,19 +1,24 @@
+// 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 } from './pers-config';
+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
   ) {
-    // Build API root from environment and version
-    this.apiRoot = buildApiRoot(config.environment, config.apiVersion);
+    // 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);
   }
 
   /**
@@ -25,22 +30,22 @@ export class PersApiClient {
     };
 
     // Add authentication token
-    if (this.config.authProvider) {
-      const token = await this.config.authProvider.getToken();
+    if (this.mergedConfig.authProvider) {
+      const token = await this.mergedConfig.authProvider.getToken();
       if (token) {
         headers['Authorization'] = `Bearer ${token}`;
       }
     }
 
     // Add project key
-    if (this.config.authProvider) {
-      const projectKey = await this.config.authProvider.getProjectKey();
+    if (this.mergedConfig.authProvider) {
+      const projectKey = await this.mergedConfig.authProvider.getProjectKey();
       if (projectKey) {
         headers['x-project-key'] = projectKey;
       }
-    } else {
+    } else if(this.mergedConfig.apiProjectKey) {
       // Fallback to config project key if no auth provider
-      headers['x-project-key'] = this.config.apiProjectKey;
+      headers['x-project-key'] = this.mergedConfig.apiProjectKey;
     }
 
     return headers;
@@ -50,6 +55,186 @@ export class PersApiClient {
    * 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,
@@ -60,7 +245,7 @@ export class PersApiClient {
     
     const requestOptions: RequestOptions = {
       headers: await this.getHeaders(),
-      timeout: this.config.timeout || 30000,
+      timeout: this.mergedConfig.timeout,
     };
 
     try {
@@ -78,9 +263,9 @@ export class PersApiClient {
       }
     } catch (error: any) {
       // Handle 401 errors with automatic token refresh
-      if (error.status === 401 && retryCount === 0 && this.config.authProvider?.onTokenExpired) {
+      if (error.status === 401 && retryCount === 0 && this.mergedConfig.authProvider?.onTokenExpired) {
         try {
-          await this.config.authProvider.onTokenExpired();
+          await this.mergedConfig.authProvider.onTokenExpired();
           // Retry once with refreshed token
           return this.request<T>(method, endpoint, body, { ...options, retryCount: 1 });
         } catch (refreshError) {
@@ -105,35 +290,42 @@ export class PersApiClient {
   /**
    * Generic GET request
    */
-  async get<T>(endpoint: string): Promise<T> {
+  /*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> {
+  /*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> {
+  /*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> {
+  /*async delete<T>(endpoint: string): Promise<T> {
     return this.request<T>('DELETE', endpoint);
   }
 
   /**
-   * Get current configuration
+   * Get current configuration (returns merged config)
+   */
+  /*getConfig(): ReturnType<typeof mergeWithDefaults> {
+    return this.mergedConfig;
+  }
+
+  /**
+   * Get original user configuration
    */
-  getConfig(): PersConfig {
+  /*getOriginalConfig(): PersConfig {
     return this.config;
   }
 }
@@ -148,4 +340,4 @@ export class PersApiError extends Error {
     super(message);
     this.name = 'PersApiError';
   }
-}
+}*/

package/src/core/pers-config.ts

@@ -2,18 +2,18 @@
  * PERS SDK Configuration interfaces
  */
 
-import { AuthProvider } from './auth/auth-provider.interface';
+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;
+  environment?: PersEnvironment;
+  apiProjectKey?: string;
   apiVersion?: PersApiVersion;
   timeout?: number;
   retries?: number;
-  authProvider?: AuthProvider;
+  authProvider?: PersAuthProvider;
   // Internal - constructed automatically
   readonly apiRoot?: string;
 }
@@ -24,15 +24,42 @@ export interface PersAuthConfig {
 }
 
 /**
- * Internal function to construct API root from environment
+ * Default configuration values
  */
+export const DEFAULT_PERS_CONFIG = {
+  environment: 'production' as PersEnvironment,
+  apiVersion: 'v2' as PersApiVersion,
+  timeout: 30000,
+  retries: 3
+} as const;
 
-export function buildApiRoot(environment: PersEnvironment, version: PersApiVersion = 'v2'): string {
+/**
+ * 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://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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,47 @@
+/**
+ * @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>;

package/src/donation/models/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Donation Domain Models
+ * 
+ * Re-exports from centralized pers-shared interfaces for consistency with backend
+ * and to provide a single import source for donation-related types.
+ */
+
+// Core donation entities from centralized pers-shared interfaces
+export type {
+  DonationTypeDTO
+} from '../../shared/interfaces/pers-shared-lib.interfaces';

package/src/donation/services/donation-service.ts

@@ -0,0 +1,25 @@
+import { DonationApi } from '../api/donation-api';
+import { DonationTypeDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
+
+/**
+ * Platform-Agnostic Donation Service
+ * 
+ * Contains donation business logic and operations that work across platforms.
+ * No framework dependencies - pure TypeScript business logic.
+ * Matches framework DonationApiService capabilities exactly.
+ */
+export class DonationService {
+  constructor(private donationApi: DonationApi) {}
+
+  // ==========================================
+  // PUBLIC OPERATIONS
+  // ==========================================
+
+  /**
+   * PUBLIC: Get all donation types
+   * ✅ ONLY method actually used by framework
+   */
+  async getAllDonationTypes(): Promise<DonationTypeDTO[]> {
+    return this.donationApi.getAllDonationTypes();
+  }
+}

package/src/index.ts

@@ -5,11 +5,50 @@
  */
 
 // Re-export everything from core
-export * from './core/core';
+export * from './core'
 
 // Re-export everything from business domain
 export * from './business';
 
+// Re-export everything from transaction domain
+export * from './transaction';
+
+// Re-export everything from analytics domain
+export * from './analytics';
+
+// Re-export everything from auth-admin domain
+export * from './auth-admin';
+
+// Re-export everything from campaign domain
+export * from './campaign';
+
+// Re-export everything from donation domain
+export * from './donation';
+
+// Re-export everything from analytics domain
+export * from './payment';
+
+// Re-export everything from analytics domain
+export * from './redemption';
+
+// Re-export everything from analytics domain
+export * from './tenant';
+
+// Re-export everything from analytics domain
+export * from './token';
+
+// Re-export everything from user domain
+export * from './user';
+
+// Re-export everything from user-status domain
+export * from './user-status';
+
+// Re-export everything from web3-chain domain
+export * from './web3-chain';
+
+// Re-export everything from web3 domain
+export * from './web3';
+
 // NOTE: Angular integration available in separate package '@explorins/pers-sdk-angular'
 // Future domains will be added here
 // export * from './campaign';