@lgriffin/esi.ts 2.0.0 → 5.0.0

package/src/core/ApiClient.ts

@@ -1,18 +0,0 @@
-export class ApiClient {
-    constructor(
-        private clientId: string,
-        private link: string,
-        private accessToken?: string
-    ) {
-        // Remove trailing slash from the link if present
-        this.link = this.link.replace(/\/$/, '');
-    }
-
-    getAuthorizationHeader(): string | undefined {
-        return this.accessToken ? `Bearer ${this.accessToken}` : undefined;
-    }
-
-    getLink(): string {
-        return this.link;
-    }
-}

package/src/core/ApiClientBuilder.ts

@@ -1,26 +0,0 @@
-import { ApiClient } from './ApiClient';
-
-export class ApiClientBuilder {
-    private clientId!: string;
-    private link!: string;
-    private accessToken?: string; // Make accessToken optional
-
-    setClientId(clientId: string): ApiClientBuilder {
-        this.clientId = clientId;
-        return this;
-    }
-
-    setLink(link: string): ApiClientBuilder {
-        this.link = link;
-        return this;
-    }
-
-    setAccessToken(accessToken?: string): ApiClientBuilder { // Update method to accept optional token
-        this.accessToken = accessToken;
-        return this;
-    }
-
-    build(): ApiClient {
-        return new ApiClient(this.clientId, this.link, this.accessToken);
-    }
-}

package/src/core/ApiError.ts

@@ -1,6 +0,0 @@
-export class ApiError extends Error {
-    constructor(public statusCode: number, message: string) {
-        super(message);
-        this.name = 'ApiError';
-    }
-}

package/src/core/ApiRequestHandler.ts

@@ -1,212 +0,0 @@
-import { ApiClient } from './ApiClient';
-import { buildError } from '../core/util/error';
-import { logInfo, logWarn, logError, logDebug } from '../core/logger/loggerUtil';
-import HeadersUtil from '../core/util/headersUtil';
-import { ETagCacheManager } from './cache/ETagCacheManager';
-
-const statusHandlers: Record<number, string> = {
-    201: 'Created',
-    204: 'No Content',
-    304: 'Not Modified',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Resource not found',
-    420: 'Error Limited',
-    422: 'Unprocessable Entity',
-    429: 'Too many requests',
-    500: 'Internal server error',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    520: 'Internal server error, did the request terminate too soon?',
-};
-
-// Global ETag cache instance
-let etagCache: ETagCacheManager | null = null;
-
-export const initializeETagCache = (config?: any): ETagCacheManager => {
-    if (!etagCache) {
-        etagCache = new ETagCacheManager(config);
-    }
-    return etagCache;
-};
-
-export const getETagCache = (): ETagCacheManager | null => {
-    return etagCache;
-};
-
-export const resetETagCache = (): void => {
-    if (etagCache) {
-        etagCache.shutdown();
-    }
-    etagCache = null;
-};
-
-// Helper function for backward compatibility - returns just the body
-export const handleRequestBody = async (
-    client: ApiClient,
-    endpoint: string,
-    method: string,
-    body?: any,
-    requiresAuth: boolean = false,
-    useETag: boolean = true
-): Promise<any> => {
-    const response = await handleRequest(client, endpoint, method, body, requiresAuth, useETag);
-    return response.body || response; // Handle both new and old response formats
-};
-
-const fetchPageData = async (
-    client: ApiClient,
-    baseEndpoint: string,
-    method: string,
-    page: number,
-    requiresAuth: boolean,
-    body?: any
-): Promise<any> => {
-    // Build the correct paginated endpoint for the specific page
-    const paginatedEndpoint = `${baseEndpoint}?page=${page}`;
-
-    // Log the correct endpoint with incremented page number
-    logInfo(`Fetching page ${page}: ${client.getLink()}/${paginatedEndpoint}`);
-
-    // Fetch the specific page data
-    const response = await fetch(`${client.getLink()}/${paginatedEndpoint}`, {
-        method,
-        headers: {
-            accept: 'gzip, deflate, br',
-            'User-Agent': 'esiJS/1.0.0',
-            ...(requiresAuth ? { Authorization: client.getAuthorizationHeader() } : {})
-        },
-        body: body ? JSON.stringify(body) : undefined
-    });
-
-    if (!response.ok) {
-        throw buildError(`Error: ${response.statusText}`, 'API_ERROR');
-    }
-
-    const responseData = await response.json();
-    return responseData;  // Return only the data (body)
-};
-
-export const handleRequest = async (
-    client: ApiClient,
-    endpoint: string,
-    method: string,
-    body?: any,
-    requiresAuth: boolean = false,
-    useETag: boolean = true
-): Promise<any> => {
-    // Extract the base URL (without any pagination or extra query params)
-    const [baseEndpoint] = endpoint.split('?');  // Get only the part before `?`
-
-    const url = `${client.getLink()}/${endpoint}`;
-    const headers: HeadersInit = {
-        accept: 'gzip, deflate, br',
-        'User-Agent': `esiJS/1.0.0`  // Use the version from package.json ideally
-    };
-
-    if (requiresAuth) {
-        const authHeader = client.getAuthorizationHeader();
-        if (!authHeader) {
-            throw buildError('Authorization header is required but not provided', 'NO_AUTH_TOKEN');
-        }
-        headers['Authorization'] = authHeader;
-    }
-
-    // Add ETag support for GET requests
-    if (useETag && method === 'GET' && etagCache) {
-        const cachedETag = etagCache.getETag(url);
-        if (cachedETag) {
-            headers['If-None-Match'] = cachedETag;
-            logDebug(`Adding If-None-Match header: ${cachedETag}`);
-        }
-    }
-
-    const options: RequestInit = {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : undefined
-    };
-
-    logInfo(`Hitting endpoint: ${url}`);
-
-    try {
-        // Fetch the first page (page 1)
-        const response = await fetch(url, options);
-        const responseHeaders = HeadersUtil.extractHeaders(response.headers);
-
-        if (statusHandlers[response.status]) {
-            const errorMessage = statusHandlers[response.status];
-            if (response.status === 204) {
-                logInfo(`${errorMessage} for endpoint: ${url}`);
-                return { headers: responseHeaders, body: { error: 'no content' } };
-            } else if (response.status === 304) {
-                // Not Modified - return cached data
-                if (useETag && etagCache) {
-                    const cachedEntry = etagCache.get(url);
-                    if (cachedEntry) {
-                        logInfo(`Cache hit (304) for endpoint: ${url}`);
-                        return { 
-                            headers: { ...cachedEntry.headers, ...responseHeaders }, 
-                            body: cachedEntry.data,
-                            fromCache: true 
-                        };
-                    }
-                }
-                logWarn(`${errorMessage} for endpoint: ${url} - no cached data available`);
-                return { headers: responseHeaders, body: { error: errorMessage.toLowerCase() } };
-            } else {
-                logWarn(`${errorMessage} for endpoint: ${url}`);
-                return { headers: responseHeaders, body: { error: errorMessage.toLowerCase() } };
-            }
-        }
-
-        if (!response.ok) {
-            throw buildError(`Error: ${response.statusText}`, 'API_ERROR');
-        }
-
-        // Get the data and number of pages from the first response
-        const data = await response.json();
-        const totalPages = HeadersUtil.xPages;
-
-        // Cache the response if ETag is present and this is a GET request
-        if (useETag && method === 'GET' && etagCache && HeadersUtil.etag) {
-            etagCache.set(url, HeadersUtil.etag, data, responseHeaders);
-            logDebug(`Cached response for ${url} with ETag ${HeadersUtil.etag}`);
-        }
-
-        // If there's only one page, return the data immediately
-        if (totalPages <= 1) {
-            return { headers: responseHeaders, body: data };
-        }
-
-        // Now fetch the additional pages (starting from page 2)
-        logInfo(`Found ${totalPages} pages, fetching additional pages...`);
-        const allData = [data];  // Store data from page 1
-
-        for (let page = 2; page <= totalPages; page++) {
-            logInfo(`Fetching page ${page}...`);
-            const paginatedData = await fetchPageData(client, baseEndpoint, method, page, requiresAuth, body);
-            allData.push(...paginatedData);  // Append the paginated data
-        }
-
-        // Merge all pages' data into one response
-        const finalData = allData.flat();
-        
-        // Cache the complete paginated response if ETag is present
-        if (useETag && method === 'GET' && etagCache && HeadersUtil.etag) {
-            etagCache.set(url, HeadersUtil.etag, finalData, responseHeaders);
-            logDebug(`Cached paginated response for ${url} with ETag ${HeadersUtil.etag}`);
-        }
-        
-        return { headers: responseHeaders, body: finalData };  // Flatten the array if needed
-    } catch (error) {
-        if (error instanceof Error) {
-            logError(`Unexpected error: ${error.message}`);
-            throw buildError(error.message, 'ESIJS_ERROR');
-        } else {
-            logError(`Unexpected error: ${error}`);
-            throw buildError(String(error), 'ESIJS_ERROR');
-        }
-    }
-};

package/src/core/IAPIBuilder.ts

@@ -1,13 +0,0 @@
-export interface IAPIBuilder<T = any> {
-    build(): T;
-}
-
-export interface IApiClient {
-    getAuthorizationHeader(): string | undefined;
-    getLink(): string;
-}
-
-export interface IApiService {
-    readonly name: string;
-    readonly version: string;
-}

package/src/core/cache/ETagCacheManager.ts

@@ -1,248 +0,0 @@
-import { logInfo, logDebug, logWarn } from '../logger/loggerUtil';
-
-export interface CacheEntry {
-    etag: string;
-    data: any;
-    headers: Record<string, string>;
-    timestamp: number;
-    ttl?: number; // Time to live in milliseconds
-}
-
-export interface ETagCacheConfig {
-    maxEntries?: number;
-    defaultTtl?: number; // Default TTL in milliseconds
-    cleanupInterval?: number; // Cleanup interval in milliseconds
-    persistToStorage?: boolean;
-    storageKey?: string;
-}
-
-export class ETagCacheManager {
-    private cache: Map<string, CacheEntry> = new Map();
-    private config: Required<ETagCacheConfig>;
-    private cleanupTimer?: NodeJS.Timeout;
-
-    constructor(config: ETagCacheConfig = {}) {
-        this.config = {
-            maxEntries: config.maxEntries ?? 1000,
-            defaultTtl: config.defaultTtl ?? 5 * 60 * 1000, // 5 minutes default
-            cleanupInterval: config.cleanupInterval ?? 60 * 1000, // 1 minute cleanup
-            persistToStorage: config.persistToStorage ?? false,
-            storageKey: config.storageKey ?? 'esi-etag-cache'
-        };
-
-        if (this.config.persistToStorage) {
-            this.loadFromStorage();
-        }
-
-        this.startCleanupTimer();
-        logInfo(`ETag cache manager initialized with ${this.config.maxEntries} max entries`);
-    }
-
-    /**
-     * Get cached data if ETag matches
-     */
-    get(url: string): CacheEntry | null {
-        const entry = this.cache.get(url);
-        
-        if (!entry) {
-            return null;
-        }
-
-        // Check if entry has expired
-        if (this.isExpired(entry)) {
-            this.cache.delete(url);
-            logDebug(`Cache entry expired for ${url}`);
-            return null;
-        }
-
-        logDebug(`Cache hit for ${url} with ETag ${entry.etag}`);
-        return entry;
-    }
-
-    /**
-     * Get ETag for a URL (for If-None-Match header)
-     */
-    getETag(url: string): string | null {
-        const entry = this.get(url);
-        return entry ? entry.etag : null;
-    }
-
-    /**
-     * Set cache entry
-     */
-    set(url: string, etag: string, data: any, headers: Record<string, string>, customTtl?: number): void {
-        // Remove oldest entries if cache is full
-        if (this.cache.size >= this.config.maxEntries) {
-            this.evictOldest();
-        }
-
-        const entry: CacheEntry = {
-            etag,
-            data,
-            headers,
-            timestamp: Date.now(),
-            ttl: customTtl ?? this.config.defaultTtl
-        };
-
-        this.cache.set(url, entry);
-        logDebug(`Cached response for ${url} with ETag ${etag}`);
-
-        if (this.config.persistToStorage) {
-            this.saveToStorage();
-        }
-    }
-
-    /**
-     * Check if cached data exists and is valid
-     */
-    has(url: string): boolean {
-        const entry = this.cache.get(url);
-        return entry !== undefined && !this.isExpired(entry);
-    }
-
-    /**
-     * Clear specific cache entry
-     */
-    delete(url: string): boolean {
-        const deleted = this.cache.delete(url);
-        if (deleted && this.config.persistToStorage) {
-            this.saveToStorage();
-        }
-        return deleted;
-    }
-
-    /**
-     * Clear all cache entries
-     */
-    clear(): void {
-        this.cache.clear();
-        if (this.config.persistToStorage) {
-            this.saveToStorage();
-        }
-        logInfo('ETag cache cleared');
-    }
-
-    /**
-     * Get cache statistics
-     */
-    getStats(): {
-        totalEntries: number;
-        maxEntries: number;
-        hitRate: number;
-        oldestEntry: number | null;
-        newestEntry: number | null;
-    } {
-        const entries = Array.from(this.cache.values());
-        const timestamps = entries.map(e => e.timestamp);
-        
-        return {
-            totalEntries: this.cache.size,
-            maxEntries: this.config.maxEntries,
-            hitRate: 0, // Would need to track hits/misses for this
-            oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : null,
-            newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : null
-        };
-    }
-
-    /**
-     * Update cache configuration
-     */
-    updateConfig(newConfig: Partial<ETagCacheConfig>): void {
-        this.config = { ...this.config, ...newConfig };
-        logInfo('ETag cache configuration updated');
-    }
-
-    /**
-     * Cleanup expired entries
-     */
-    cleanup(): number {
-        const beforeSize = this.cache.size;
-        const now = Date.now();
-        const expiredKeys: string[] = [];
-
-        for (const [url, entry] of this.cache.entries()) {
-            if (this.isExpired(entry)) {
-                expiredKeys.push(url);
-            }
-        }
-
-        expiredKeys.forEach(key => this.cache.delete(key));
-
-        const cleanedCount = beforeSize - this.cache.size;
-        if (cleanedCount > 0) {
-            logDebug(`Cleaned up ${cleanedCount} expired cache entries`);
-            if (this.config.persistToStorage) {
-                this.saveToStorage();
-            }
-        }
-
-        return cleanedCount;
-    }
-
-    /**
-     * Shutdown cache manager
-     */
-    shutdown(): void {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-        }
-        if (this.config.persistToStorage) {
-            this.saveToStorage();
-        }
-        logInfo('ETag cache manager shut down');
-    }
-
-    private isExpired(entry: CacheEntry): boolean {
-        if (!entry.ttl) return false;
-        return Date.now() - entry.timestamp > entry.ttl;
-    }
-
-    private evictOldest(): void {
-        let oldestKey: string | null = null;
-        let oldestTime = Infinity;
-
-        for (const [key, entry] of this.cache.entries()) {
-            if (entry.timestamp < oldestTime) {
-                oldestTime = entry.timestamp;
-                oldestKey = key;
-            }
-        }
-
-        if (oldestKey) {
-            this.cache.delete(oldestKey);
-            logDebug(`Evicted oldest cache entry: ${oldestKey}`);
-        }
-    }
-
-    private startCleanupTimer(): void {
-        this.cleanupTimer = setInterval(() => {
-            this.cleanup();
-        }, this.config.cleanupInterval);
-    }
-
-    private loadFromStorage(): void {
-        try {
-            if (typeof localStorage !== 'undefined') {
-                const stored = localStorage.getItem(this.config.storageKey);
-                if (stored) {
-                    const data = JSON.parse(stored);
-                    this.cache = new Map(data);
-                    logInfo(`Loaded ${this.cache.size} entries from storage`);
-                }
-            }
-        } catch (error) {
-            logWarn(`Failed to load cache from storage: ${error}`);
-        }
-    }
-
-    private saveToStorage(): void {
-        try {
-            if (typeof localStorage !== 'undefined') {
-                const data = Array.from(this.cache.entries());
-                localStorage.setItem(this.config.storageKey, JSON.stringify(data));
-            }
-        } catch (error) {
-            logWarn(`Failed to save cache to storage: ${error}`);
-        }
-    }
-}

package/src/core/container/Container.ts

@@ -1,176 +0,0 @@
-export type Factory<T = any> = () => T;
-export type AsyncFactory<T = any> = () => Promise<T>;
-
-export interface ContainerConfig {
-    enableLogging?: boolean;
-    enableCircularDependencyDetection?: boolean;
-}
-
-export class CircularDependencyError extends Error {
-    constructor(dependencyChain: string[]) {
-        super(`Circular dependency detected: ${dependencyChain.join(' -> ')}`);
-        this.name = 'CircularDependencyError';
-    }
-}
-
-export class Container {
-    private dependencies = new Map<string, Factory>();
-    private singletons = new Map<string, any>();
-    private resolutionStack: string[] = [];
-    private config: ContainerConfig;
-
-    constructor(config: ContainerConfig = {}) {
-        this.config = {
-            enableLogging: false,
-            enableCircularDependencyDetection: true,
-            ...config
-        };
-    }
-
-    /**
-     * Register a factory function for a dependency
-     */
-    register<T>(token: string, factory: Factory<T>, singleton: boolean = false): this {
-        if (this.config.enableLogging) {
-            console.log(`Registering dependency: ${token} (singleton: ${singleton})`);
-        }
-
-        this.dependencies.set(token, factory);
-        
-        if (singleton) {
-            // Pre-resolve singleton to catch errors early
-            this.resolve<T>(token);
-        }
-
-        return this;
-    }
-
-    /**
-     * Register a singleton dependency
-     */
-    registerSingleton<T>(token: string, factory: Factory<T>): this {
-        return this.register(token, factory, true);
-    }
-
-    /**
-     * Register an instance directly as a singleton
-     */
-    registerInstance<T>(token: string, instance: T): this {
-        this.singletons.set(token, instance);
-        return this;
-    }
-
-    /**
-     * Resolve a dependency by token
-     */
-    resolve<T>(token: string): T {
-        // Check if it's already a singleton instance
-        if (this.singletons.has(token)) {
-            return this.singletons.get(token) as T;
-        }
-
-        // Get the factory
-        const factory = this.dependencies.get(token);
-        if (!factory) {
-            throw new Error(`Dependency '${token}' not found. Available dependencies: ${Array.from(this.dependencies.keys()).join(', ')}`);
-        }
-
-        // Check for circular dependencies
-        if (this.config.enableCircularDependencyDetection && this.resolutionStack.includes(token)) {
-            throw new CircularDependencyError([...this.resolutionStack, token]);
-        }
-
-        // Add to resolution stack
-        this.resolutionStack.push(token);
-
-        try {
-            const instance = factory();
-
-            // Store as singleton if it was registered as one
-            if (this.isSingleton(token)) {
-                this.singletons.set(token, instance);
-            }
-
-            return instance as T;
-        } finally {
-            // Remove from resolution stack
-            this.resolutionStack.pop();
-        }
-    }
-
-    /**
-     * Check if a dependency is registered
-     */
-    has(token: string): boolean {
-        return this.dependencies.has(token) || this.singletons.has(token);
-    }
-
-    /**
-     * Remove a dependency
-     */
-    remove(token: string): boolean {
-        const hadDependency = this.dependencies.delete(token);
-        const hadSingleton = this.singletons.delete(token);
-        return hadDependency || hadSingleton;
-    }
-
-    /**
-     * Clear all dependencies
-     */
-    clear(): void {
-        this.dependencies.clear();
-        this.singletons.clear();
-        this.resolutionStack = [];
-    }
-
-    /**
-     * Get all registered dependency tokens
-     */
-    getRegisteredTokens(): string[] {
-        const dependencyTokens = Array.from(this.dependencies.keys());
-        const singletonTokens = Array.from(this.singletons.keys());
-        return [...new Set([...dependencyTokens, ...singletonTokens])];
-    }
-
-    /**
-     * Create a child container that inherits from this one
-     */
-    createChild(): Container {
-        const child = new Container(this.config);
-        
-        // Copy dependencies (not instances)
-        for (const [token, factory] of this.dependencies) {
-            child.dependencies.set(token, factory);
-        }
-
-        return child;
-    }
-
-    private isSingleton(token: string): boolean {
-        // Check if the token was registered with singleton behavior
-        // This is determined by checking if resolve was called during registration
-        return false; // For now, we'll manage this manually
-    }
-}
-
-// Global container instance
-export const container = new Container({
-    enableLogging: process.env.NODE_ENV === 'development',
-    enableCircularDependencyDetection: true
-});
-
-// Dependency injection decorators (if using experimental decorators)
-export function Injectable(token?: string) {
-    return function <T extends new (...args: any[]) => {}>(constructor: T) {
-        const dependencyToken = token || constructor.name;
-        container.register(dependencyToken, () => new constructor());
-        return constructor;
-    };
-}
-
-export function Inject(token: string) {
-    return function (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) {
-        // This would require reflect-metadata for full implementation
-        // For now, it's a placeholder for future enhancement
-    };
-}