@lgriffin/esi.ts 4.0.0 → 5.1.0

package/dist/core/errors/ApiError.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorHandler = exports.ApiError = exports.ApiErrorType = void 0;
-var ApiErrorType;
-(function (ApiErrorType) {
-    ApiErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
-    ApiErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
-    ApiErrorType["AUTHORIZATION_ERROR"] = "AUTHORIZATION_ERROR";
-    ApiErrorType["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
-    ApiErrorType["SERVER_ERROR"] = "SERVER_ERROR";
-    ApiErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
-    ApiErrorType["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    ApiErrorType["NOT_FOUND_ERROR"] = "NOT_FOUND_ERROR";
-    ApiErrorType["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
-    ApiErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-})(ApiErrorType || (exports.ApiErrorType = ApiErrorType = {}));
-class ApiError extends Error {
-    constructor(message, type = ApiErrorType.UNKNOWN_ERROR, statusCode, details, requestId) {
-        super(message);
-        this.name = 'ApiError';
-        this.type = type;
-        this.statusCode = statusCode;
-        this.details = details;
-        this.timestamp = new Date();
-        this.requestId = requestId;
-        // Maintains proper stack trace for where our error was thrown (only available on V8)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, ApiError);
-        }
-    }
-    static fromHttpStatus(statusCode, message, details, requestId) {
-        let type;
-        switch (Math.floor(statusCode / 100)) {
-            case 4:
-                if (statusCode === 401) {
-                    type = ApiErrorType.AUTHENTICATION_ERROR;
-                }
-                else if (statusCode === 403) {
-                    type = ApiErrorType.AUTHORIZATION_ERROR;
-                }
-                else if (statusCode === 404) {
-                    type = ApiErrorType.NOT_FOUND_ERROR;
-                }
-                else if (statusCode === 429) {
-                    type = ApiErrorType.RATE_LIMIT_ERROR;
-                }
-                else {
-                    type = ApiErrorType.CLIENT_ERROR;
-                }
-                break;
-            case 5:
-                type = ApiErrorType.SERVER_ERROR;
-                break;
-            default:
-                type = ApiErrorType.UNKNOWN_ERROR;
-        }
-        return new ApiError(message, type, statusCode, details, requestId);
-    }
-    static networkError(message = 'Network connection failed', details) {
-        return new ApiError(message, ApiErrorType.NETWORK_ERROR, undefined, details);
-    }
-    static timeoutError(message = 'Request timeout', details) {
-        return new ApiError(message, ApiErrorType.TIMEOUT_ERROR, undefined, details);
-    }
-    static validationError(message, details) {
-        return new ApiError(message, ApiErrorType.VALIDATION_ERROR, 400, details);
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            type: this.type,
-            statusCode: this.statusCode,
-            details: this.details,
-            timestamp: this.timestamp.toISOString(),
-            requestId: this.requestId,
-            stack: this.stack
-        };
-    }
-}
-exports.ApiError = ApiError;
-class ErrorHandler {
-    static handle(error, requestId) {
-        var _a, _b, _c;
-        if (error instanceof ApiError) {
-            throw error;
-        }
-        // Handle Axios/HTTP errors
-        if (error.response) {
-            const statusCode = error.response.status;
-            const message = ((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.error) ||
-                ((_b = error.response.data) === null || _b === void 0 ? void 0 : _b.message) ||
-                error.message ||
-                `HTTP ${statusCode} Error`;
-            throw ApiError.fromHttpStatus(statusCode, message, error.response.data, requestId);
-        }
-        // Handle network errors
-        if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || error.code === 'ECONNRESET') {
-            throw ApiError.networkError(`Network error: ${error.message}`, { code: error.code });
-        }
-        // Handle timeout errors
-        if (error.code === 'ECONNABORTED' || ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('timeout'))) {
-            throw ApiError.timeoutError(`Request timeout: ${error.message}`);
-        }
-        // Default to unknown error
-        throw new ApiError(error.message || 'An unknown error occurred', ApiErrorType.UNKNOWN_ERROR, undefined, error, requestId);
-    }
-    static isRetryable(error) {
-        return [
-            ApiErrorType.NETWORK_ERROR,
-            ApiErrorType.TIMEOUT_ERROR,
-            ApiErrorType.SERVER_ERROR,
-            ApiErrorType.RATE_LIMIT_ERROR
-        ].includes(error.type);
-    }
-    static getRetryDelay(error, attempt) {
-        var _a, _b;
-        if (error.type === ApiErrorType.RATE_LIMIT_ERROR) {
-            // Check for Retry-After header in details
-            const retryAfter = (_b = (_a = error.details) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b['retry-after'];
-            if (retryAfter) {
-                return parseInt(retryAfter) * 1000; // Convert to milliseconds
-            }
-        }
-        // Exponential backoff: 1s, 2s, 4s, 8s, etc.
-        return Math.min(1000 * Math.pow(2, attempt - 1), 30000); // Max 30 seconds
-    }
-}
-exports.ErrorHandler = ErrorHandler;

package/dist/core/factory/ApiFactory.js

@@ -1,170 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiFactory = exports.ApiFactory = exports.ApiModule = void 0;
-const ApiClient_1 = require("../ApiClient");
-const Container_1 = require("../container/Container");
-const ApiError_1 = require("../errors/ApiError");
-const logger_1 = __importDefault(require("../logger/logger"));
-class ApiModule {
-    constructor(client, container) {
-        this.client = client;
-        this.container = container;
-    }
-}
-exports.ApiModule = ApiModule;
-class ApiFactory {
-    constructor() {
-        this.clients = new Map();
-        this.modules = new Map();
-        this.container = new Container_1.Container({
-            enableLogging: process.env.NODE_ENV === 'development',
-            enableCircularDependencyDetection: true
-        });
-        this.registerCoreServices();
-    }
-    static getInstance() {
-        if (!this.instance) {
-            this.instance = new ApiFactory();
-        }
-        return this.instance;
-    }
-    /**
-     * Register core services in the container
-     */
-    registerCoreServices() {
-        this.container.registerInstance('logger', logger_1.default);
-        this.container.registerInstance('errorHandler', ApiError_1.ErrorHandler);
-    }
-    /**
-     * Create and register an API client
-     */
-    createClient(name, config) {
-        try {
-            const client = new ApiClient_1.ApiClient(config.clientId, config.baseUrl, config.accessToken);
-            this.clients.set(name, client);
-            this.container.registerInstance(`client:${name}`, client);
-            logger_1.default.info(`API client '${name}' created and registered`);
-            return client;
-        }
-        catch (error) {
-            logger_1.default.error(`Failed to create API client '${name}':`, error);
-            throw ApiError_1.ErrorHandler.handle(error);
-        }
-    }
-    /**
-     * Get an existing API client
-     */
-    getClient(name) {
-        const client = this.clients.get(name);
-        if (!client) {
-            throw new ApiError_1.ApiError(`API client '${name}' not found. Available clients: ${Array.from(this.clients.keys()).join(', ')}`, ApiError_1.ApiErrorType.CLIENT_ERROR);
-        }
-        return client;
-    }
-    /**
-     * Register an API module
-     */
-    registerModule(module) {
-        try {
-            // Check dependencies
-            if (module.config.dependencies) {
-                for (const dependency of module.config.dependencies) {
-                    if (!this.container.has(dependency)) {
-                        throw new ApiError_1.ApiError(`Module '${module.config.name}' requires dependency '${dependency}' which is not registered`, ApiError_1.ApiErrorType.VALIDATION_ERROR);
-                    }
-                }
-            }
-            // Register the module
-            module.register();
-            this.modules.set(module.config.name, module);
-            this.container.registerInstance(`module:${module.config.name}`, module);
-            logger_1.default.info(`API module '${module.config.name}' v${module.config.version} registered`);
-        }
-        catch (error) {
-            logger_1.default.error(`Failed to register module '${module.config.name}':`, error);
-            throw ApiError_1.ErrorHandler.handle(error);
-        }
-    }
-    /**
-     * Get a service from the container
-     */
-    getService(token) {
-        try {
-            return this.container.resolve(token);
-        }
-        catch (error) {
-            logger_1.default.error(`Failed to resolve service '${token}':`, error);
-            throw ApiError_1.ErrorHandler.handle(error);
-        }
-    }
-    /**
-     * Register a service in the container
-     */
-    registerService(token, factory, singleton = false) {
-        try {
-            this.container.register(token, factory, singleton);
-            logger_1.default.debug(`Service '${token}' registered (singleton: ${singleton})`);
-        }
-        catch (error) {
-            logger_1.default.error(`Failed to register service '${token}':`, error);
-            throw ApiError_1.ErrorHandler.handle(error);
-        }
-    }
-    /**
-     * Get all registered clients
-     */
-    getRegisteredClients() {
-        return Array.from(this.clients.keys());
-    }
-    /**
-     * Get all registered modules
-     */
-    getRegisteredModules() {
-        return Array.from(this.modules.keys());
-    }
-    /**
-     * Health check for all registered clients
-     */
-    async healthCheck() {
-        const results = {};
-        for (const [name, client] of this.clients) {
-            try {
-                // Perform a simple health check (this would need to be implemented in ApiClient)
-                // For now, just check if client exists and has required properties
-                results[name] = !!(client && client.getLink());
-            }
-            catch (error) {
-                logger_1.default.warn(`Health check failed for client '${name}':`, error);
-                results[name] = false;
-            }
-        }
-        return results;
-    }
-    /**
-     * Shutdown factory and cleanup resources
-     */
-    async shutdown() {
-        try {
-            // Cleanup modules
-            for (const [name, module] of this.modules) {
-                logger_1.default.debug(`Shutting down module: ${name}`);
-                // If modules have cleanup methods, call them here
-            }
-            // Clear containers
-            this.container.clear();
-            this.clients.clear();
-            this.modules.clear();
-            logger_1.default.info('ApiFactory shutdown completed');
-        }
-        catch (error) {
-            logger_1.default.error('Error during ApiFactory shutdown:', error);
-            throw ApiError_1.ErrorHandler.handle(error);
-        }
-    }
-}
-exports.ApiFactory = ApiFactory;
-// Export singleton instance
-exports.apiFactory = ApiFactory.getInstance();

package/dist/core/logger/index.d.ts

@@ -1,2 +0,0 @@
-export { default } from './logger';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/logger/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/logger/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/core/logger/index.js

@@ -1,8 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(logger_1).default; } });

package/dist/core/util/file.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.log = exports.getSettings = exports.checkForConfig = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const checkForConfig = () => {
-    const configPath = path_1.default.join(__dirname, '../../config/esi.json');
-    return fs_1.default.existsSync(configPath);
-};
-exports.checkForConfig = checkForConfig;
-const getSettings = () => {
-    const configPath = path_1.default.join(__dirname, '../../config/esi.json');
-    if (fs_1.default.existsSync(configPath)) {
-        const config = fs_1.default.readFileSync(configPath, 'utf8');
-        return JSON.parse(config);
-    }
-    return null;
-};
-exports.getSettings = getSettings;
-const log = (message, level = 'INFO') => {
-    console.log(`[${level}] ${message}`);
-};
-exports.log = log;

package/dist/core/util/inputValidation.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputValidation = void 0;
-const inputValidation = ({ input, type, message }) => {
-    if (typeof input !== type) {
-        throw new Error(message);
-    }
-};
-exports.inputValidation = inputValidation;

package/dist/core/util/network.js

@@ -1,15 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.request = void 0;
-const axios_1 = __importDefault(require("axios"));
-const request = async ({ subUrl, needsAuth = false }) => {
-    const baseUrl = 'https://esi.evetech.net/latest/';
-    const url = `${baseUrl}${subUrl}`;
-    const headers = needsAuth ? { Authorization: `Bearer ${process.env.AUTH_TOKEN}` } : {};
-    const response = await axios_1.default.get(url, { headers });
-    return response.data;
-};
-exports.request = request;

package/dist/core/util/request.js

@@ -1,21 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputValidation = exports.request = void 0;
-const axios_1 = __importDefault(require("axios"));
-const request = async ({ subUrl, needsAuth = false }) => {
-    const baseUrl = 'https://esi.evetech.net/latest/';
-    const url = `${baseUrl}${subUrl}`;
-    const headers = needsAuth ? { Authorization: `Bearer ${process.env.AUTH_TOKEN}` } : {};
-    const response = await axios_1.default.get(url, { headers });
-    return response.data;
-};
-exports.request = request;
-const inputValidation = ({ input, type, message }) => {
-    if (typeof input !== type) {
-        throw new Error(message);
-    }
-};
-exports.inputValidation = inputValidation;

package/dist/testing/TestHelpers.js

@@ -1,205 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHeaders = exports.getBody = exports.TestAssertions = exports.TestScenarios = exports.MockApiClient = exports.TestDataFactory = void 0;
-exports.createMockApiClient = createMockApiClient;
-const ApiClient_1 = require("../core/ApiClient");
-const ApiError_1 = require("../core/errors/ApiError");
-class TestDataFactory {
-    static createAllianceInfo(overrides = {}) {
-        return Object.assign({ alliance_id: 99005338, name: 'Goonswarm Federation', ticker: 'CONDI', creator_id: 1689391488, creator_corporation_id: 1344654522, executor_corporation_id: 1344654522, date_founded: '2010-06-01T00:00:00Z', faction_id: 500001 }, overrides);
-    }
-    static createAllianceContact(overrides = {}) {
-        return Object.assign({ contact_id: 1689391488, contact_type: 'character', standing: 10.0, label_ids: [1, 2] }, overrides);
-    }
-    static createAllianceContactLabel(overrides = {}) {
-        return Object.assign({ label_id: 1, label_name: 'Test Label' }, overrides);
-    }
-    static createError(type, statusCode) {
-        const messages = {
-            [ApiError_1.ApiErrorType.NETWORK_ERROR]: 'Network connection failed',
-            [ApiError_1.ApiErrorType.AUTHENTICATION_ERROR]: 'Authentication failed',
-            [ApiError_1.ApiErrorType.AUTHORIZATION_ERROR]: 'Access denied',
-            [ApiError_1.ApiErrorType.RATE_LIMIT_ERROR]: 'Rate limit exceeded',
-            [ApiError_1.ApiErrorType.SERVER_ERROR]: 'Internal server error',
-            [ApiError_1.ApiErrorType.CLIENT_ERROR]: 'Bad request',
-            [ApiError_1.ApiErrorType.VALIDATION_ERROR]: 'Validation failed',
-            [ApiError_1.ApiErrorType.NOT_FOUND_ERROR]: 'Resource not found',
-            [ApiError_1.ApiErrorType.TIMEOUT_ERROR]: 'Request timeout',
-            [ApiError_1.ApiErrorType.UNKNOWN_ERROR]: 'Unknown error occurred'
-        };
-        return new ApiError_1.ApiError(messages[type], type, statusCode);
-    }
-}
-exports.TestDataFactory = TestDataFactory;
-class MockApiClient {
-    constructor(config = {}) {
-        this.config = Object.assign({ delay: 0, failureRate: 0, networkErrors: false, timeoutErrors: false, serverErrors: false }, config);
-    }
-    async mockRequest(data) {
-        // Simulate network delay
-        if (this.config.delay && this.config.delay > 0) {
-            await this.delay(this.config.delay);
-        }
-        // Simulate random failures
-        if (this.config.failureRate && Math.random() < this.config.failureRate) {
-            throw this.generateRandomError();
-        }
-        return data;
-    }
-    async delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    generateRandomError() {
-        const errorTypes = [];
-        if (this.config.networkErrors)
-            errorTypes.push(ApiError_1.ApiErrorType.NETWORK_ERROR);
-        if (this.config.timeoutErrors)
-            errorTypes.push(ApiError_1.ApiErrorType.TIMEOUT_ERROR);
-        if (this.config.serverErrors)
-            errorTypes.push(ApiError_1.ApiErrorType.SERVER_ERROR);
-        if (errorTypes.length === 0) {
-            errorTypes.push(ApiError_1.ApiErrorType.CLIENT_ERROR);
-        }
-        const randomType = errorTypes[Math.floor(Math.random() * errorTypes.length)];
-        return TestDataFactory.createError(randomType, this.getStatusCodeForError(randomType));
-    }
-    getStatusCodeForError(type) {
-        switch (type) {
-            case ApiError_1.ApiErrorType.AUTHENTICATION_ERROR: return 401;
-            case ApiError_1.ApiErrorType.AUTHORIZATION_ERROR: return 403;
-            case ApiError_1.ApiErrorType.NOT_FOUND_ERROR: return 404;
-            case ApiError_1.ApiErrorType.RATE_LIMIT_ERROR: return 429;
-            case ApiError_1.ApiErrorType.SERVER_ERROR: return 500;
-            case ApiError_1.ApiErrorType.CLIENT_ERROR: return 400;
-            default: return 500;
-        }
-    }
-}
-exports.MockApiClient = MockApiClient;
-class TestScenarios {
-    static async testRetryLogic(operation, maxRetries = 3, expectedFailures = 2) {
-        let attempts = 0;
-        let lastError;
-        while (attempts < maxRetries) {
-            try {
-                attempts++;
-                const result = await operation();
-                if (attempts <= expectedFailures) {
-                    throw new Error(`Expected failure on attempt ${attempts}`);
-                }
-                return result;
-            }
-            catch (error) {
-                lastError = error;
-                if (attempts >= maxRetries) {
-                    throw lastError;
-                }
-                // Wait before retry (exponential backoff)
-                await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempts - 1) * 100));
-            }
-        }
-        throw lastError;
-    }
-    static async testConcurrency(operation, concurrentRequests = 10) {
-        const promises = Array(concurrentRequests)
-            .fill(null)
-            .map(() => operation());
-        return Promise.all(promises);
-    }
-    static async testErrorRecovery(operation, fallbackOperation) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            console.warn('Primary operation failed, trying fallback:', error);
-            return await fallbackOperation();
-        }
-    }
-}
-exports.TestScenarios = TestScenarios;
-class TestAssertions {
-    static assertValidAllianceInfo(data) {
-        if (!data || typeof data !== 'object') {
-            throw new Error('Alliance info must be an object');
-        }
-        const required = ['alliance_id', 'name', 'ticker', 'creator_id', 'creator_corporation_id', 'date_founded'];
-        for (const field of required) {
-            if (!(field in data)) {
-                throw new Error(`Alliance info missing required field: ${field}`);
-            }
-        }
-        if (typeof data.alliance_id !== 'number' || data.alliance_id <= 0) {
-            throw new Error('Alliance ID must be a positive number');
-        }
-        if (typeof data.name !== 'string' || data.name.length === 0) {
-            throw new Error('Alliance name must be a non-empty string');
-        }
-        if (typeof data.ticker !== 'string' || data.ticker.length === 0) {
-            throw new Error('Alliance ticker must be a non-empty string');
-        }
-    }
-    static assertValidError(error) {
-        if (!(error instanceof ApiError_1.ApiError)) {
-            throw new Error('Expected ApiError instance');
-        }
-        if (!error.type || !Object.values(ApiError_1.ApiErrorType).includes(error.type)) {
-            throw new Error(`Invalid error type: ${error.type}`);
-        }
-        if (!error.message || error.message.length === 0) {
-            throw new Error('Error must have a non-empty message');
-        }
-        if (!error.timestamp || !(error.timestamp instanceof Date)) {
-            throw new Error('Error must have a valid timestamp');
-        }
-    }
-    static assertResponseTime(startTime, maxMs) {
-        const elapsed = Date.now() - startTime;
-        if (elapsed > maxMs) {
-            throw new Error(`Response time ${elapsed}ms exceeded maximum ${maxMs}ms`);
-        }
-    }
-    static assertArrayNotEmpty(array, message) {
-        if (!Array.isArray(array) || array.length === 0) {
-            throw new Error(message || 'Array must not be empty');
-        }
-    }
-}
-exports.TestAssertions = TestAssertions;
-function createMockApiClient(config = {}) {
-    // This would be a more sophisticated mock in a real implementation
-    const mockClient = new ApiClient_1.ApiClient('test-client', 'https://esi.evetech.net', 'mock-token');
-    // Override methods for testing
-    const originalGetLink = mockClient.getLink;
-    mockClient.getLink = function () {
-        if (config.networkErrors && Math.random() < 0.1) {
-            throw TestDataFactory.createError(ApiError_1.ApiErrorType.NETWORK_ERROR);
-        }
-        return originalGetLink.call(this);
-    };
-    return mockClient;
-}
-// Export utility functions that were in the original testHelpers
-const getBody = async (operation) => {
-    try {
-        return await operation();
-    }
-    catch (error) {
-        if (error instanceof ApiError_1.ApiError) {
-            throw error;
-        }
-        throw new ApiError_1.ApiError('Operation failed', ApiError_1.ApiErrorType.UNKNOWN_ERROR, undefined, error);
-    }
-};
-exports.getBody = getBody;
-const getHeaders = (client) => {
-    const headers = {
-        'Content-Type': 'application/json',
-        'User-Agent': 'ESI.ts/2.0.0'
-    };
-    const authHeader = client.getAuthorizationHeader();
-    if (authHeader) {
-        headers['Authorization'] = authHeader;
-    }
-    return headers;
-};
-exports.getHeaders = getHeaders;