imagenai/dist/client.js

Core client library for Imagenai image generation API

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ImagenaiClient = void 0;
exports.createImagenaiClient = createImagenaiClient;
class ImagenaiClient {
    constructor(config) {
        this.config = Object.assign({ timeout: 30000, retries: 3 }, config);
        this.baseUrl = config.baseUrl || 'https://your-domain.com';
    }
    /**
     * Generate a single image
     */
    generateImage(options) {
        return __awaiter(this, void 0, void 0, function* () {
            const response = yield this.makeRequest('/api/imagenai', {
                method: 'POST',
                body: JSON.stringify(Object.assign(Object.assign({}, options), { apiKey: this.config.apiKey }))
            });
            if (!response.ok) {
                const error = yield response.json();
                throw new Error(error.error || 'Failed to generate image');
            }
            return yield response.json();
        });
    }
    /**
     * Make HTTP request with retry logic
     */
    makeRequest(url, options) {
        return __awaiter(this, void 0, void 0, function* () {
            let lastError;
            for (let attempt = 1; attempt <= this.config.retries; attempt++) {
                try {
                    const controller = new AbortController();
                    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
                    const response = yield fetch(`${this.baseUrl}${url}`, Object.assign(Object.assign({}, options), { signal: controller.signal, headers: Object.assign({ 'Content-Type': 'application/json' }, options.headers) }));
                    clearTimeout(timeoutId);
                    return response;
                }
                catch (error) {
                    lastError = error instanceof Error ? error : new Error('Request failed');
                    if (attempt === this.config.retries) {
                        break;
                    }
                    // Wait before retry (exponential backoff, reduced for tests)
                    const baseDelay = process.env.NODE_ENV === 'test' ? 10 : 1000;
                    yield new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * baseDelay));
                }
            }
            throw lastError;
        });
    }
    /**
     * Handle and format errors
     */
    handleError(error) {
        if (error instanceof Error) {
            return error;
        }
        if (typeof error === 'string') {
            return new Error(error);
        }
        return new Error('An unknown error occurred');
    }
}
exports.ImagenaiClient = ImagenaiClient;
// Export a factory function for easier usage
function createImagenaiClient(config) {
    return new ImagenaiClient(config);
}