iom-sdk 0.1.8 → 0.1.10

package/dist/client.d.ts

@@ -1,96 +1,45 @@
-import { ClientConfig, UUID, QueryParams, UUObjectDTO, UUPropertyDTO, UUPropertyValueDTO, UUFileDTO, UUStatementDTO, ComplexObjectCreationInput, AggregateFindDTO, AggregateCreateDTO, StatementQueryParams, UUAddressDTO } from './types';
+import { AxiosInstance } from 'axios';
+import { SDKConfig } from './config';
+import { AuthServiceClient } from './services/auth/auth-client';
+import { RegistryServiceClient } from './services/registry/registry-client';
+import { NodeServiceClient } from './services/node/node-client';
+import { AuthResponse } from './types';
+export type AuthChangeListener = (state: {
+    isAuthenticated: boolean;
+    user: AuthResponse | null;
+}) => void;
 /**
- * Initialize the client with the given configuration
- *
- * @param config - Client configuration including baseUrl and optional certificate
+ * Simplified IOM Client
+ * acts as the single source of truth for auth state
  */
-export declare const initializeClient: (config: ClientConfig) => void;
-export declare const createClient: (config: ClientConfig) => {
-    debug: {
-        /**
-         * Enable or disable debug mode at runtime
-         */
-        configure: (options: ClientConfig["debug"]) => void;
-    };
-    auth: {
-        requestBaseAuth: () => Promise<import("./types").ApiResponse<import("./types").AuthResponse | null>>;
-        requestUuidAuth: () => Promise<import("./types").ApiResponse<import("./types").AuthResponse | null>>;
-    };
-    aggregate: {
-        findByUUID: (uuid: UUID) => Promise<import("./types").ApiResponse<import("./types").AggregateEntity[] | null>>;
-        getAggregateEntities: (params?: AggregateFindDTO) => Promise<import("./types").ApiResponse<import("./types").PageAggregateEntity>>;
-        createAggregateObject: (data: AggregateCreateDTO) => Promise<import("./types").ApiResponse<any>>;
-        importAggregateObjects: (data: AggregateCreateDTO) => Promise<import("./types").ApiResponse<any>>;
-    };
-    objects: {
-        create: (object: UUObjectDTO) => Promise<import("./types").ApiResponse<UUObjectDTO>>;
-        createFullObject: (objectData: ComplexObjectCreationInput) => Promise<import("./types").ApiResponse<import("./types").ComplexObjectOutput | null>>;
-        getObjects: (params?: QueryParams) => Promise<import("./types").ApiResponse<UUObjectDTO[]>>;
-        delete: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-    };
-    properties: {
-        addToObject: (objectUuid: UUID, property: Partial<UUPropertyDTO> & {
-            key: string;
-        }) => Promise<import("./types").ApiResponse<UUPropertyDTO>>;
-        create: (property: UUPropertyDTO) => Promise<import("./types").ApiResponse<UUPropertyDTO>>;
-        getProperties: (params?: QueryParams) => Promise<import("./types").ApiResponse<UUPropertyDTO[]>>;
-        getPropertyByKey: (key: string, params?: QueryParams) => Promise<import("./types").ApiResponse<UUPropertyDTO | null>>;
-        delete: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-    };
-    values: {
-        setForProperty: (propertyUuid: UUID, value: Partial<UUPropertyValueDTO>) => Promise<import("./types").ApiResponse<UUPropertyValueDTO>>;
-        create: (value: UUPropertyValueDTO) => Promise<import("./types").ApiResponse<UUPropertyValueDTO>>;
-        getPropertyValues: (params?: QueryParams) => Promise<import("./types").ApiResponse<UUPropertyValueDTO[]>>;
-        delete: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-    };
-    files: {
-        create: (file: UUFileDTO) => Promise<import("./types").ApiResponse<UUFileDTO>>;
-        getFiles: (params?: QueryParams) => Promise<import("./types").ApiResponse<UUFileDTO[]>>;
-        delete: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-        uploadByReference: (input: {
-            fileReference: string;
-            uuidToAttach: UUID;
-            label?: string;
-        }) => Promise<import("./types").ApiResponse<UUFileDTO | null>>;
-        uploadDirect: (input: {
-            file: File | Blob | ArrayBuffer | FormData;
-            uuidToAttach: UUID;
-        }) => Promise<import("./types").ApiResponse<UUFileDTO | null>>;
-        uploadFormData: (input: {
-            formData: FormData;
-            uuidFile: UUID;
-            uuidToAttach: UUID;
-        }) => Promise<import("./types").ApiResponse<any>>;
-        download: (uuid: UUID) => Promise<import("./types").ApiResponse<ArrayBuffer>>;
-    };
-    statements: {
-        getStatements: (params?: StatementQueryParams) => Promise<import("./types").ApiResponse<UUStatementDTO[]>>;
-        create: (statement: UUStatementDTO) => Promise<import("./types").ApiResponse<UUStatementDTO>>;
-        delete: (statement: UUStatementDTO) => Promise<import("./types").ApiResponse<any>>;
-    };
-    uuid: {
-        create: () => Promise<import("./types").ApiResponse<{
-            uuid: UUID;
-        }>>;
-        getOwned: () => Promise<import("./types").ApiResponse<any>>;
-        getRecord: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-        updateRecordMeta: (params: {
-            uuid?: UUID;
-            nodeType: string;
-        }) => Promise<import("./types").ApiResponse<any>>;
-        authorize: (params: {
-            userUUID: UUID;
-            resourceId: UUID;
-        }) => Promise<import("./types").ApiResponse<any>>;
-    };
-    addresses: {
-        create: (address: Omit<UUAddressDTO, "uuid">) => Promise<import("./types").ApiResponse<UUAddressDTO>>;
-        update: (address: UUAddressDTO) => Promise<import("./types").ApiResponse<UUAddressDTO>>;
-        get: (params?: QueryParams) => Promise<import("./types").ApiResponse<UUAddressDTO[]>>;
-        delete: (uuid: UUID) => Promise<import("./types").ApiResponse<any>>;
-        createForObject: (objectUuid: UUID, address: Omit<UUAddressDTO, "uuid">) => Promise<import("./types").ApiResponse<{
-            address: UUAddressDTO;
-            statement: any;
-        }>>;
-    };
-};
+export declare class Client {
+    private config;
+    private axiosInstance;
+    private token;
+    private user;
+    private listeners;
+    auth: AuthServiceClient;
+    registry: RegistryServiceClient;
+    node: NodeServiceClient;
+    private readonly STORAGE_KEY;
+    constructor(config: SDKConfig);
+    private createServiceAxiosInstance;
+    private loadState;
+    private saveState;
+    private notifyListeners;
+    onAuthStateChange(listener: AuthChangeListener): () => void;
+    login(): Promise<{
+        success: boolean;
+        user?: AuthResponse;
+    }>;
+    logout(): void;
+    isAuthenticated(): boolean;
+    getUser(): AuthResponse | null;
+    getToken(): string | null;
+    getAxios(): AxiosInstance;
+}
+/**
+ * Initialize the Client
+ */
+export declare function initClient(config: SDKConfig): Client;
+export declare const createClient: typeof initClient;

package/dist/config/index.d.ts

@@ -0,0 +1 @@
+export * from './service-config';

package/dist/config/service-config.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Service configuration interfaces for the IOB SDK
+ * Provides type-safe configuration for individual services
+ */
+/**
+ * Configuration for an individual service
+ */
+export interface ServiceConfig {
+    /** Base URL for the service */
+    baseUrl: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Number of retry attempts for failed requests (default: 3) */
+    retries?: number;
+    /** Additional headers to include with requests */
+    headers?: Record<string, string>;
+}
+/**
+ * Error handling configuration
+ */
+export interface ErrorHandlingConfig {
+    /** Global handler for authentication errors */
+    onAuthError?: (error: SDKError) => void;
+    /** Global handler for network errors */
+    onNetworkError?: (error: SDKError) => void;
+    /** Global handler for service-specific errors */
+    onServiceError?: (error: SDKError, service: string) => void;
+    /** Enable debug logging for requests/responses */
+    debug?: boolean;
+    /** Automatically retry authentication failures */
+    autoRetryAuth?: boolean;
+    /** Network retry configuration */
+    autoRetryNetwork?: {
+        maxRetries: number;
+        delay?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+}
+/**
+ * SDK Error interface with service context
+ */
+export interface SDKError extends Error {
+    /** Service that generated the error */
+    service?: string;
+    /** Error type classification */
+    type?: 'authentication' | 'network' | 'validation' | 'service' | 'unknown';
+    /** HTTP status code if applicable */
+    status?: number;
+    /** Additional error details */
+    details?: any;
+    /** Request context */
+    context?: {
+        method: string;
+        url: string;
+        timestamp: Date;
+    };
+}
+/**
+ * Main SDK configuration interface
+ */
+export interface SDKConfig {
+    /** Auth service configuration */
+    auth: ServiceConfig;
+    /** Registry/UUID service configuration */
+    registry: ServiceConfig;
+    /** Node service configuration */
+    node: ServiceConfig;
+    /** Client certificate for mTLS authentication (optional - browser will handle cert selection) */
+    certificate?: {
+        cert: string;
+        key: string;
+    };
+    /** Token storage strategy */
+    tokenStorage?: 'localStorage' | 'sessionStorage' | 'memory';
+    /** Error handling configuration */
+    errorHandling?: ErrorHandlingConfig;
+}
+/**
+ * Validates a service configuration
+ */
+export declare function validateServiceConfig(config: ServiceConfig, serviceName: string): void;
+/**
+ * Validates the complete SDK configuration
+ */
+export declare function validateSDKConfig(config: SDKConfig): void;
+/**
+ * Creates a default service configuration with sensible defaults
+ */
+export declare function createDefaultServiceConfig(baseUrl: string): ServiceConfig;
+/**
+ * Creates default error handling configuration
+ */
+export declare function createDefaultErrorHandling(): ErrorHandlingConfig;

package/dist/core/auth-manager.d.ts

@@ -0,0 +1,110 @@
+import { JWTToken, JWTAuthResponse, TokenRefreshConfig, AuthState } from '../types';
+import { SDKConfig } from '../config';
+import { TokenStorage } from './token-storage';
+/**
+ * Central JWT token management system with persistent storage
+ * Handles token storage, validation, and automatic refresh
+ */
+export declare class AuthManager {
+    private config;
+    private loginFunction;
+    private tokenStorage;
+    private authState;
+    private refreshConfig;
+    private refreshPromise;
+    private refreshTimeoutId;
+    private readyPromise;
+    private stateListeners;
+    constructor(config: SDKConfig, loginFunction: () => Promise<JWTAuthResponse>, tokenStorage: TokenStorage, refreshConfig?: Partial<TokenRefreshConfig>);
+    /**
+     * Wait for AuthManager to be ready (storage initialized)
+     * Prevents race conditions where isAuthenticated() is called before storage is checked
+     */
+    ready(): Promise<void>;
+    /**
+     * Initialize auth state from stored token and user data
+     */
+    private initializeFromStorage;
+    /**
+     * Get the current JWT token, refreshing if necessary
+     * Does NOT perform initial authentication - user must call login() first
+     */
+    getValidToken(): Promise<string | null>;
+    /**
+     * Public method for user-initiated login
+     * Call this when user clicks "Authorize/Login" button
+     */
+    login(): Promise<JWTToken | null>;
+    /**
+     * Public method for user-initiated logout
+     * Call this when user clicks "Logout" button
+     */
+    logout(): Promise<void>;
+    /**
+     * Perform initial authentication to get JWT token
+     * Private method - use login() for user-initiated authentication
+     * Fails fast - no retries, no loops
+     */
+    private authenticate;
+    /**
+     * Refresh the current JWT token
+     */
+    refreshToken(): Promise<JWTToken | null>;
+    /**
+     * Perform the actual token refresh - single attempt, no retries
+     */
+    private performTokenRefresh;
+    /**
+     * Check if the current user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Get the current authentication state
+     */
+    getAuthState(): Readonly<AuthState>;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(listener: (state: Readonly<AuthState>) => void): () => void;
+    /**
+     * Clear the current token and authentication state
+     */
+    clearToken(): Promise<void>;
+    /**
+     * Force token refresh on next request
+     */
+    invalidateToken(): void;
+    /**
+     * Create a JWTToken from the auth response
+     */
+    private createTokenFromResponse;
+    /**
+     * Set the current token and update auth state
+     */
+    private setToken;
+    /**
+     * Check if a token is still valid (not expired)
+     */
+    private isTokenValid;
+    /**
+     * Check if a token is expired
+     */
+    private isTokenExpired;
+    /**
+     * Check if a token should be refreshed (within threshold of expiry)
+     */
+    private shouldRefreshToken;
+    /**
+     * Schedule automatic token refresh
+     */
+    private scheduleTokenRefresh;
+    private notifyAuthStateChange;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+/**
+ * Create a new AuthManager instance
+ */
+export declare const createAuthManager: (config: SDKConfig, loginFunction: () => Promise<JWTAuthResponse>, tokenStorage: TokenStorage, refreshConfig?: Partial<TokenRefreshConfig>) => AuthManager;

package/dist/core/base-service-client.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Base service client with common functionality
+ * Provides HTTP operations, error handling, and retry logic
+ */
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { ServiceConfig, SDKError, ErrorHandlingConfig } from '../config';
+import { ApiResponse } from '../types';
+/**
+ * Base service client class
+ */
+export declare abstract class BaseServiceClient {
+    protected client: AxiosInstance;
+    protected config: ServiceConfig;
+    protected errorHandling: ErrorHandlingConfig;
+    protected serviceName: string;
+    constructor(config: ServiceConfig, errorHandling: ErrorHandlingConfig, serviceName: string, certificate?: {
+        cert: string;
+        key: string;
+    });
+    /**
+     * Setup request and response interceptors
+     */
+    protected setupInterceptors(): void;
+    /**
+     * Create standardized SDK error from axios error
+     */
+    protected createSDKError(error: any): SDKError;
+    /**
+     * Handle error with global handlers
+     */
+    protected handleError(error: SDKError): Promise<void>;
+    /**
+     * Determine if request should be retried
+     */
+    protected shouldRetry(error: SDKError): boolean;
+    /**
+     * Retry failed request with backoff
+     */
+    protected retryRequest(config: AxiosRequestConfig, error: SDKError): Promise<AxiosResponse>;
+    /**
+     * Make GET request
+     */
+    protected get<T>(url: string, params?: Record<string, any>): Promise<ApiResponse<T>>;
+    /**
+     * Make POST request
+     */
+    protected post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Make PUT request
+     */
+    protected put<T>(url: string, data?: any): Promise<ApiResponse<T>>;
+    /**
+     * Make DELETE request
+     */
+    protected delete<T>(url: string, data?: any): Promise<ApiResponse<T>>;
+    /**
+     * Make GET request for binary data
+     */
+    protected getBinary<T = ArrayBuffer>(url: string): Promise<ApiResponse<T>>;
+    /**
+     * Make POST request with form data
+     */
+    protected postForm<T>(url: string, formData: any): Promise<ApiResponse<T>>;
+    /**
+     * Create standardized API response
+     */
+    protected createApiResponse<T>(response: AxiosResponse): ApiResponse<T>;
+    /**
+     * Add authorization header
+     */
+    protected setAuthorizationHeader(token: string): void;
+    /**
+     * Remove authorization header
+     */
+    protected removeAuthorizationHeader(): void;
+}
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        _retryCount?: number;
+    }
+}

package/dist/core/index.d.ts

@@ -1,2 +1,4 @@
-export * from './http-client';
+/**
+ * Core functionality exports
+ */
 export * from './logger';

package/dist/core/logger.d.ts

@@ -1,8 +1,13 @@
-import { ClientConfig } from '@/types';
+interface DebugConfig {
+    enabled: boolean;
+    logLevel?: 'error' | 'info';
+    logToConsole?: boolean;
+    logCallback?: (message: string, data?: any) => void;
+}
 /**
  * Configure the logger with the provided debug options
  */
-export declare const configureLogger: (config?: ClientConfig["debug"]) => void;
+export declare const configureLogger: (config?: DebugConfig) => void;
 /**
  * Log a message if debug is enabled
  */
@@ -15,3 +20,4 @@ export declare const logHttp: (method: string, url: string, status?: number, dat
  * Log error information
  */
 export declare const logError: (operation: string, error: any) => void;
+export {};

package/dist/core/service-factory.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Service factory for creating individual service clients
+ * Implements factory pattern with dependency injection
+ */
+import { SDKConfig, ErrorHandlingConfig } from '../config';
+import { AuthManager } from './auth-manager';
+import { TokenStorage } from './token-storage';
+import { AuthServiceClient } from '../services/auth/auth-client';
+import { RegistryServiceClient } from '../services/registry/registry-client';
+import { NodeServiceClient } from '../services/node/node-client';
+/**
+ * Service factory class that manages service client creation and lifecycle
+ */
+export declare class ServiceFactory {
+    private config;
+    private errorHandling;
+    private tokenStorage;
+    private authManager;
+    private authClient?;
+    private registryClient?;
+    private nodeClient?;
+    constructor(config: SDKConfig);
+    /**
+     * Get or create auth service client
+     */
+    getAuthClient(): AuthServiceClient;
+    /**
+     * Get or create registry service client
+     */
+    getRegistryClient(): RegistryServiceClient;
+    /**
+     * Get or create node service client
+     */
+    getNodeClient(): NodeServiceClient;
+    /**
+     * Get auth manager instance
+     */
+    getAuthManager(): AuthManager;
+    /**
+     * Get token storage instance
+     */
+    getTokenStorage(): TokenStorage;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SDKConfig;
+    /**
+     * Update error handling configuration
+     */
+    updateErrorHandling(newConfig: Partial<ErrorHandlingConfig>): void;
+    /**
+     * Destroy all service clients and cleanup resources
+     */
+    destroy(): void;
+}
+/**
+ * Create service factory with configuration validation
+ */
+export declare function createServiceFactory(config: SDKConfig): ServiceFactory;

package/dist/core/token-storage.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Token storage abstraction for persistent JWT token management
+ * Supports localStorage, sessionStorage, and memory storage with graceful fallbacks
+ */
+import { JWTToken, AuthResponse } from '../types';
+/**
+ * Stored auth data including token and user info
+ */
+export interface StoredAuthData {
+    token: JWTToken;
+    user?: AuthResponse;
+}
+/**
+ * Storage interface for token persistence
+ */
+export interface TokenStorage {
+    /** Get stored token */
+    getToken(): Promise<JWTToken | null>;
+    /** Store token */
+    setToken(token: JWTToken): Promise<void>;
+    /** Remove stored token */
+    removeToken(): Promise<void>;
+    /** Check if storage is available */
+    isAvailable(): boolean;
+    /** Get stored auth data (token + user) */
+    getAuthData(): Promise<StoredAuthData | null>;
+    /** Store auth data (token + user) */
+    setAuthData(data: StoredAuthData): Promise<void>;
+}
+/**
+ * Storage type options
+ */
+export type StorageType = 'localStorage' | 'sessionStorage' | 'memory';
+/**
+ * Creates appropriate token storage based on environment and preferences
+ */
+export declare function createTokenStorage(storageType?: StorageType, enableCrossTabSync?: boolean): TokenStorage;
+/**
+ * Token storage with automatic cleanup
+ */
+export declare class ManagedTokenStorage implements TokenStorage {
+    private storage;
+    private cleanupInterval;
+    constructor(storage: TokenStorage, cleanupIntervalMs?: number);
+    isAvailable(): boolean;
+    getToken(): Promise<JWTToken | null>;
+    setToken(token: JWTToken): Promise<void>;
+    removeToken(): Promise<void>;
+    getAuthData(): Promise<StoredAuthData | null>;
+    setAuthData(data: StoredAuthData): Promise<void>;
+    /**
+     * Cleanup expired tokens
+     */
+    private cleanup;
+    /**
+     * Destroy the storage and cleanup resources
+     */
+    destroy(): void;
+    /**
+     * Add cross-tab synchronization listener if supported
+     */
+    onTokenChange(listener: (token: JWTToken | null) => void): (() => void) | null;
+}