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

package/src/web3-chain/services/web3-chain-service.ts

@@ -0,0 +1,131 @@
+import { Web3ChainApi } from '../api/web3-chain-api';
+import { ChainData, CachedChainInstance } from '../models';
+import type { Web3 } from 'web3';
+import { isTokenExpired } from '../../core/utils/jwt.function';
+import { Web3ProviderService } from './provider.service';
+
+export class Web3ChainService {
+
+  private web3InstanceCache = new Map<number, CachedChainInstance>();
+  
+  constructor(
+    private web3ChainApi: Web3ChainApi,
+    private providerService: Web3ProviderService
+  ) {}
+
+  async getWeb3ByChainId(chainId: number): Promise<Web3> {
+    const cached = this.web3InstanceCache.get(chainId);
+
+    // ✅ SMART CACHE: Check if cache is valid based on token expiration
+    if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
+      console.log(`♻️ [Web3ChainService] Using cached Web3 instance for chain ${chainId}`);
+      return cached.web3Instance;
+    }
+
+    // ✅ CREATE WITH ERROR RECOVERY: Handle auth errors gracefully
+    try {
+      console.log(`🔧 [Web3ChainService] Creating new Web3 instance for chain ${chainId}`);
+      const { web3, chainData } = await this.createWeb3Instance(chainId);
+      
+      // ✅ CACHE NEW INSTANCE
+      this.web3InstanceCache.set(chainId, {
+        web3Instance: web3,
+        chainData: chainData,
+        createdAt: Date.now(),
+        chainId
+      });
+      
+      return web3;
+    } catch (error) {
+      // ✅ AUTH ERROR RECOVERY: Clear cache and retry once
+      if (this.isAuthError(error)) {
+        console.warn(`🔄 [Web3ChainService] Auth error detected, clearing cache and retrying...`);
+        this.web3InstanceCache.delete(chainId);
+        
+        // Retry once with fresh instance
+        const { web3, chainData } = await this.createWeb3Instance(chainId);
+        
+        this.web3InstanceCache.set(chainId, {
+          web3Instance: web3,
+          chainData: chainData,
+          createdAt: Date.now(),
+          chainId
+        });
+        
+        return web3;
+      }
+      
+      throw error;
+    }
+  }
+
+  async getChainDataWithCache(chainId: number): Promise<ChainData> {
+    const cached = this.web3InstanceCache.get(chainId);
+    //const now = Date.now();
+
+    if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
+      console.log(`♻️ [Web3ChainService] Using cached ChainData for chain ${chainId}`);
+      return cached.chainData;
+    }
+
+    // If not cached, fetch fresh data
+    const chainData = await this.getChainDataById(chainId);
+    if (!chainData) {
+      throw new Error(`Chain data not found for chainId: ${chainId}`);
+    }
+
+    return chainData;
+  }
+
+  private checkIsTokenExpired(authHeader?: string): boolean {
+    // ✅ NULL CHECK: Handle undefined case
+    if (!authHeader) {
+      return false; // No token means no expiration (public chains)
+    }
+    
+    // ✅ FUNCTION CALL: Use imported function, not method
+    return isTokenExpired(authHeader);
+  }
+
+  private async createWeb3Instance(chainId: number): Promise<{ web3: Web3; chainData: ChainData }> {
+    const chainData = await this.getChainDataById(chainId);
+
+    if (!chainData) {
+      throw new Error(`Chain data not found for chainId: ${chainId}`);
+    }
+
+    // ✅ CRITICAL CHECK: Ensure authHeader is present for private chains
+    if (chainData.chainType === 'PRIVATE' && !chainData.authHeader) {
+      console.error('❌ [Web3ChainService] CRITICAL: Private chain missing authHeader!');
+      throw new Error(`Private chain ${chainId} missing authentication header`);
+    }
+
+    const web3 = await this.providerService.getWeb3(
+      chainId, 
+      chainData.chainType || 'PUBLIC', 
+      chainData
+    );
+
+    return { web3, chainData };
+  }
+
+  // ✅ HELPER: Type-safe error checking
+  private isAuthError(error: unknown): boolean {
+    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+    return (
+      message.includes('unauthorized') ||
+      message.includes('401') ||
+      message.includes('token expired') ||
+      message.includes('invalid token')
+    );
+  }
+
+  async getChainDataById(chainId: number): Promise<ChainData | null> {
+    try {
+      return await this.web3ChainApi.getChainData(chainId);
+    } catch (error) {
+      console.error('❌ [SDK Web3ChainService] Error getting chain data for chainId:', chainId, error);
+      return null;
+    }
+  }
+}

package/src/business/business/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["ES2022", "DOM"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.spec.ts", "**/*.test.ts"]
-}

package/src/core/abstractions/core-interfaces.ts

@@ -1,56 +0,0 @@
-/**
- * Core SDK interfaces based on actual PERS Tourism Loyalty App patterns
- * These interfaces reflect the real DDD architecture with Lazy Facade pattern
- */
-
-// Core HTTP abstractions matching the app's ApiService patterns
-export interface CoreHttpClient {
-  get<T>(url: string, options?: any): Observable<T>;
-  post<T>(url: string, body: any, options?: any): Observable<T>;
-  put<T>(url: string, body: any, options?: any): Observable<T>;
-  delete<T>(url: string, options?: any): Observable<T>;
-}
-
-// Base facade interface reflecting the app's LazyClass pattern
-export interface CoreFacade {
-  [key: string]: any;
-}
-
-// Environment configuration interface based on LoyaltyEnvironment
-export interface CoreEnvironment {
-  production: boolean;
-  version: string;
-  apiVersion: string
-  apiRoot: string;
-  apiProjectKey?: string;
-}
-
-// State management interface reflecting the app's Signal-based patterns
-export interface CoreStateManager<T> {
-  state$: Observable<T>;
-  updateState(partialState: Partial<T>): void;
-  resetState(): void;
-}
-
-// Event system interface for cross-platform communication
-export interface CoreEventEmitter<T = any> {
-  emit(eventName: string, data?: T): void;
-  on(eventName: string, callback: (data?: T) => void): void;
-  off(eventName: string, callback?: (data?: T) => void): void;
-}
-
-// Service factory interface for platform-specific implementations
-export interface CoreServiceFactory {
-  createHttpClient(): CoreHttpClient;
-  createStateManager<T>(initialState: T): CoreStateManager<T>;
-  createEventEmitter<T>(): CoreEventEmitter<T>;
-}
-
-// Observable type for platform-agnostic reactive programming
-export interface Observable<T> {
-  subscribe(observer: {
-    next?: (value: T) => void;
-    error?: (error: any) => void;
-    complete?: () => void;
-  }): { unsubscribe(): void };
-}

package/src/core/core.ts

@@ -1,30 +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
-export * from './pers-config';
-
-// Authentication interfaces  
-export { 
-  AuthProvider, 
-  SimpleAuthConfig,
-  createAuthProvider,
-  createBrowserTokenProvider,
-  createNodeTokenProvider
-} from './auth/auth-provider.interface';
-export type { RequestOptions as AuthRequestOptions } from './auth/auth-provider.interface';
-
-// Platform abstractions
-export * from './abstractions/http-client';
-
-// Main SDK class
-export * from '../pers-sdk';
-
-// Version
-export const PERS_SDK_VERSION = '1.0.0-alpha.1';

package/src/core.ts

@@ -1,30 +0,0 @@
-/**
- * @explorins/pers-sdk/core - Core SDK Entry Point
- * 
- * Platform-agnostic PERS API client and core functionality
- */
-
-// Core PERS API client
-export * from './core/pers-api-client';
-
-// Configuration interfaces
-export * from './core/pers-config';
-
-// Authentication interfaces  
-export { 
-  AuthProvider, 
-  SimpleAuthConfig,
-  createAuthProvider,
-  createBrowserTokenProvider,
-  createNodeTokenProvider
-} from './core/auth/auth-provider.interface';
-export type { RequestOptions as AuthRequestOptions } from './core/auth/auth-provider.interface';
-
-// Platform abstractions
-export * from './core/abstractions/http-client';
-
-// Main SDK class
-export * from './pers-sdk';
-
-// Version
-export const PERS_SDK_VERSION = '1.0.0-alpha.1';