@yetter/client 0.0.12 → 0.0.13

package/src/client.ts

@@ -1,697 +0,0 @@
-import { YetterImageClient } from "./api.js";
-import { EventSourcePolyfill } from 'event-source-polyfill';
-import {
-    ClientOptions,
-    GetStatusResponse,
-    GetResponseResponse,
-    SubscribeOptions,
-    GenerateResponse,
-    SubmitQueueOptions,
-    GetResultOptions,
-    GetResultResponse,
-    StatusOptions,
-    StatusResponse,
-    StreamOptions,
-    StreamEvent,
-    YetterStream,
-    UploadOptions,
-    UploadCompleteResponse,
-} from "./types.js";
-
-export class yetter {
-    private static apiKey: string = 'Key ' + (process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "");
-    private static endpoint: string = "https://api.yetter.ai";
-
-    public static configure(options: ClientOptions) {
-        if (options.apiKey) {
-            if (options.is_bearer) {
-                yetter.apiKey = 'Bearer ' + options.apiKey;
-            } else {
-                yetter.apiKey = 'Key ' + options.apiKey;
-            }
-        }
-        if (options.endpoint) {
-            yetter.endpoint = options.endpoint;
-        }
-    }
-
-    public static async subscribe(
-        model: string,
-        options: SubscribeOptions
-    ): Promise<GetResponseResponse> {
-        if (!yetter.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: yetter.apiKey,
-            endpoint: yetter.endpoint
-        });
-
-        const generateResponse = await client.generate({
-            model: model,
-            ...options.input,
-        });
-
-        let status = generateResponse.status;
-        let lastStatusResponse: GetStatusResponse | undefined;
-
-        const startTime = Date.now();
-        const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
-
-        while (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
-            if (Date.now() - startTime > timeoutMilliseconds) {
-                console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
-                try {
-                    await client.cancel({ url: generateResponse.cancel_url });
-                    console.log(`Cancellation request sent for request ID: ${generateResponse.request_id}.`);
-                } catch (cancelError: any) {
-                    console.error(`Failed to cancel request ID: ${generateResponse.request_id} after timeout:`, cancelError.message || cancelError);
-                }
-                throw new Error(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}.`);
-            }
-
-            try {
-                lastStatusResponse = await client.getStatus({
-                    url: generateResponse.status_url,
-                    logs: options.logs,
-                });
-                status = lastStatusResponse.status;
-
-                if (options.onQueueUpdate) {
-                    options.onQueueUpdate(lastStatusResponse);
-                }
-            } catch (error) {
-                console.error("Error during status polling:", error);
-                throw error; 
-            }
-        }
-
-        if (status === "ERROR") {
-            const errorMessage = lastStatusResponse?.logs?.map(log => log.message).join("\n") || "Image generation failed.";
-            throw new Error(errorMessage);
-        } else if (status === "CANCELLED") {
-            throw new Error("Image generation was cancelled by user.");
-        }
-
-        const finalResponse = await client.getResponse({
-            url: generateResponse.response_url,
-        });
-
-        return finalResponse;
-    }
-
-    public static queue = {
-        submit: async (
-            model: string,
-            options: SubmitQueueOptions
-        ): Promise<GenerateResponse> => {
-            if (!yetter.apiKey) {
-                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-            }
-            const client = new YetterImageClient({
-                apiKey: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            const generateResponse = await client.generate({
-                model: model,
-                ...options.input,
-            });
-
-            return generateResponse;
-        },
-
-        status: async (
-            model: string,
-            options: StatusOptions
-        ): Promise<StatusResponse> => {
-            if (!yetter.apiKey) {
-                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-            }
-            const client = new YetterImageClient({
-                apiKey: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            const endpoint = client.getApiEndpoint();
-
-            const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
-
-            const statusData = await client.getStatus({ url: statusUrl });
-
-            return {
-                data: statusData,
-                requestId: options.requestId,
-            };
-        },
-
-        result: async (
-            model: string,
-            options: GetResultOptions
-        ): Promise<GetResultResponse> => {
-            if (!yetter.apiKey) {
-                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-            }
-            const client = new YetterImageClient({
-                apiKey: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            const endpoint = client.getApiEndpoint();
-
-            const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
-
-            const responseData = await client.getResponse({ url: responseUrl });
-
-            return {
-                data: responseData,
-                requestId: options.requestId,
-            };
-        }
-    };
-
-    public static async stream(
-        model: string,
-        options: StreamOptions
-    ): Promise<YetterStream> {
-        if (!yetter.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
-        }
-        const client = new YetterImageClient({
-            apiKey: yetter.apiKey,
-            endpoint: yetter.endpoint
-        });
-
-        const initialApiResponse = await client.generate({
-            model: model,
-            ...options.input,
-        });
-        const requestId = initialApiResponse.request_id;
-        const responseUrl = initialApiResponse.response_url;
-        const cancelUrl = initialApiResponse.cancel_url;
-        const sseStreamUrl = `${client.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
-
-        let eventSource: EventSource;
-
-        // Setup the promise for the done() method
-        let resolveDonePromise: (value: GetResponseResponse) => void;
-        let rejectDonePromise: (reason?: any) => void;
-        const donePromise = new Promise<GetResponseResponse>((resolve, reject) => {
-            resolveDonePromise = resolve;
-            rejectDonePromise = reject;
-        });
-
-        const controller = {
-            // This will be used by the async iterator to pull events
-            // It needs a way to buffer events or signal availability
-            events: [] as StreamEvent[],
-            resolvers: [] as Array<(value: IteratorResult<StreamEvent, any>) => void>,
-            isClosed: false,
-            isSettled: false,
-            currentStatus: "" as "COMPLETED" | "ERROR" | "CANCELLED" | "IN_PROGRESS" | "IN_QUEUE",
-            callResolver(value: GetResponseResponse) {
-                if (this.isSettled) return;
-                this.isSettled = true;
-                resolveDonePromise(value);
-            },
-            callRejecter(reason?: any) {
-                if (this.isSettled) return;
-                this.isSettled = true;
-                rejectDonePromise(reason);
-            },
-            push(event: StreamEvent) {
-                if (this.isClosed) return;
-                if (this.resolvers.length > 0) {
-                    this.resolvers.shift()!({ value: event, done: false });
-                } else {
-                    this.events.push(event);
-                }
-                // Check for terminal events to resolve/reject the donePromise
-                this.currentStatus = event.status as "COMPLETED" | "ERROR" | "CANCELLED" | "IN_PROGRESS" | "IN_QUEUE";
-            },
-            error(err: any) {
-                if (this.isClosed) return;
-                if (this.resolvers.length > 0) {
-                    this.resolvers.shift()!({ value: undefined, done: true });
-                }
-                this._close();
-                const errorToReport = err instanceof Error ? err : new Error("Stream closed prematurely or unexpectedly.");
-                this.callRejecter(errorToReport);
-            },
-            done(value: GetResponseResponse) {
-                if (this.isClosed) return;
-                if (this.resolvers.length > 0) {
-                    this.resolvers.shift()!({ value: undefined, done: true });
-                }
-                this._close();
-                this.callResolver(value);
-            },
-            cancel() {
-                if (this.isClosed) return;
-                if (this.resolvers.length > 0) {
-                    this.resolvers.shift()!({ value: undefined, done: true });
-                }
-                this._close();
-                this.callRejecter(new Error("Stream was cancelled by user."));
-            },
-            _close() {
-                if (this.isClosed) return;
-                this.isClosed = true;
-                this.resolvers.forEach(resolve => resolve({ value: undefined, done: true }));
-                this.resolvers = [];
-                eventSource?.close();
-            },
-            next(): Promise<IteratorResult<StreamEvent, any>> {
-                if (this.events.length > 0) {
-                    return Promise.resolve({ value: this.events.shift()!, done: false });
-                }
-                if (this.isClosed) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise(resolve => this.resolvers.push(resolve));
-            }
-        };
-
-        eventSource = new EventSourcePolyfill(sseStreamUrl, {
-            headers: { 'Authorization': `${yetter.apiKey}` },
-        } as any);
-
-        eventSource.onopen = (event: Event) => {
-            console.log("SSE Connection Opened:", event);
-        };
-
-        eventSource.addEventListener('data', (event: MessageEvent) => {
-            // console.log("SSE 'data' event received, raw data:", event.data);
-            try {
-                const statusData: GetStatusResponse = JSON.parse(event.data as string);
-                controller.push(statusData as StreamEvent);
-            } catch (e: any) {
-                console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
-                controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
-            }
-        });
-        // when 'done' event is received, currentStatus can only be COMPLETED or CANCELLED
-        // TODO: remove currentStatus and branch two cases(COMPLETED and CANCELLED) by response status by responseUrl
-        // TODO: Determine whether raise error or not when response status is CANCELLED
-        //  => current code raise error when response status is CANCELLED because resolveDonePromise only get completed response
-        // => this mean that user expect only completed response from .done() method
-        eventSource.addEventListener('done', async (event: MessageEvent) => {
-            // console.log("SSE 'done' event received, raw data:", event.data);
-            try {
-                if (controller.currentStatus === "COMPLETED") {
-                    // Close SSE immediately to avoid any late 'error' events during await
-                    try { eventSource?.close(); } catch {}
-                    const response = await client.getResponse({ url: responseUrl });
-                    controller.done(response);
-                } else if (controller.currentStatus === "CANCELLED") {
-                    controller.cancel();
-                }
-            } catch (e: any) {
-                console.error("Error parsing SSE 'done' event:", e, "Raw data:", event.data);
-                controller.error(new Error(`Error parsing SSE 'done' event: ${e.message}`));
-            }
-        });
-        eventSource.addEventListener('error', (event: MessageEvent) => {
-            // console.log("SSE 'done' event received, raw data:", event.data);
-            console.log("SSE 'error' event received, raw data:", event.data);
-            controller.error(new Error("Stream reported ERROR for ${requestId}"));
-        });
-
-        eventSource.onerror = (err: Event | MessageEvent) => { 
-            const message = (err as any)?.error?.message || (err as any)?.message || '';
-            const isIdleTimeout = typeof message === 'string' && message.includes('No activity within') && message.includes('Reconnecting');
-            if (isIdleTimeout) {
-                console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
-                return;
-            }
-            console.warn("SSE Connection Error (onerror) - will allow auto-reconnect:", err);
-        };
-
-        // Handle if API immediately returns a terminal status in initialApiResponse (e.g. already completed/failed)
-        if (initialApiResponse.status === "COMPLETED"){
-            controller.push(initialApiResponse as any as StreamEvent);
-        } else if (initialApiResponse.status === "ERROR"){
-            controller.push(initialApiResponse as any as StreamEvent);
-        }
-
-        return {
-            async *[Symbol.asyncIterator]() {
-                while (!controller.isClosed || controller.events.length > 0) {
-                    const event = await controller.next();
-                    if (event.done) break;
-                    yield event.value;
-                }
-            },
-            done: () => donePromise,
-            cancel: async () => {
-                try {
-                    await client.cancel({ url: cancelUrl });
-                    console.log(`Stream for ${requestId} - underlying request cancelled.`);
-                } catch (e: any) {
-                    console.error(`Error cancelling underlying request for stream ${requestId}:`, e.message);
-                }
-            },
-            getRequestId: () => requestId,
-        };
-    }
-
-    /**
-     * Upload a file from the filesystem (Node.js) or File/Blob object (browser)
-     *
-     * @param fileOrPath File path (Node.js) or File/Blob object (browser)
-     * @param options Upload configuration options
-     * @returns Promise resolving to upload result with public URL
-     *
-     * @example
-     * ```typescript
-     * // Node.js
-     * const result = await yetter.uploadFile("/path/to/image.jpg", {
-     *   onProgress: (pct) => console.log(`Upload: ${pct}%`)
-     * });
-     *
-     * // Browser
-     * const fileInput = document.querySelector('input[type="file"]');
-     * const file = fileInput.files[0];
-     * const result = await yetter.uploadFile(file, {
-     *   onProgress: (pct) => updateProgressBar(pct)
-     * });
-     * ```
-     */
-    public static async uploadFile(
-        fileOrPath: string | File | Blob,
-        options: UploadOptions = {}
-    ): Promise<UploadCompleteResponse> {
-        if (!yetter.apiKey) {
-            throw new Error("API key is not configured. Call yetter.configure()");
-        }
-
-        if (typeof fileOrPath === 'string') {
-            // Node.js path
-            return yetter._uploadFromPath(fileOrPath, options);
-        } else {
-            // Browser File/Blob
-            return yetter._uploadFromBlob(fileOrPath, options);
-        }
-    }
-
-    /**
-     * Upload a file from browser (File or Blob object)
-     * This is an alias for uploadFile for better clarity in browser contexts
-     */
-    public static async uploadBlob(
-        file: File | Blob,
-        options: UploadOptions = {}
-    ): Promise<UploadCompleteResponse> {
-        return yetter.uploadFile(file, options);
-    }
-
-    /**
-     * Upload file from filesystem path (Node.js only)
-     */
-    private static async _uploadFromPath(
-        filePath: string,
-        options: UploadOptions
-    ): Promise<UploadCompleteResponse> {
-        // Dynamic import for Node.js modules
-        const fs = await import('fs');
-        const mime = await import('mime-types');
-
-        // Validate file exists
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-
-        const stats = fs.statSync(filePath);
-        const fileSize = stats.size;
-        const fileName = filePath.split(/[\\/]/).pop() || "upload";
-        const mimeType = mime.default.lookup(filePath) || "application/octet-stream";
-
-        const client = new YetterImageClient({
-            apiKey: yetter.apiKey,
-            endpoint: yetter.endpoint,
-        });
-
-        // Step 1: Request presigned URL(s)
-        const uploadUrlResponse = await client.getUploadUrl({
-            file_name: fileName,
-            content_type: mimeType,
-            size: fileSize,
-        });
-
-        // Step 2: Upload file content
-        if (uploadUrlResponse.mode === "single") {
-            await yetter._uploadFileSingle(
-                filePath,
-                uploadUrlResponse.put_url!,
-                mimeType,
-                fileSize,
-                options,
-                fs
-            );
-        } else {
-            await yetter._uploadFileMultipart(
-                filePath,
-                uploadUrlResponse.part_urls!,
-                uploadUrlResponse.part_size!,
-                fileSize,
-                options,
-                fs
-            );
-        }
-
-        // Step 3: Notify completion
-        const result = await client.uploadComplete({
-            key: uploadUrlResponse.key,
-        });
-
-        if (options.onProgress) {
-            options.onProgress(100);
-        }
-
-        return result;
-    }
-
-    /**
-     * Upload file from Blob/File object (browser)
-     */
-    private static async _uploadFromBlob(
-        file: File | Blob,
-        options: UploadOptions
-    ): Promise<UploadCompleteResponse> {
-        const fileSize = file.size;
-        const fileName = options.filename ||
-                        (file instanceof File ? file.name : "blob-upload");
-        const mimeType = file.type || "application/octet-stream";
-
-        const client = new YetterImageClient({
-            apiKey: yetter.apiKey,
-            endpoint: yetter.endpoint,
-        });
-
-        // Step 1: Request presigned URL(s)
-        const uploadUrlResponse = await client.getUploadUrl({
-            file_name: fileName,
-            content_type: mimeType,
-            size: fileSize,
-        });
-
-        // Step 2: Upload file content
-        if (uploadUrlResponse.mode === "single") {
-            await yetter._uploadBlobSingle(
-                file,
-                uploadUrlResponse.put_url!,
-                mimeType,
-                fileSize,
-                options
-            );
-        } else {
-            await yetter._uploadBlobMultipart(
-                file,
-                uploadUrlResponse.part_urls!,
-                uploadUrlResponse.part_size!,
-                fileSize,
-                options
-            );
-        }
-
-        // Step 3: Notify completion
-        const result = await client.uploadComplete({
-            key: uploadUrlResponse.key,
-        });
-
-        if (options.onProgress) {
-            options.onProgress(100);
-        }
-
-        return result;
-    }
-
-    /**
-     * Upload file using single PUT request (Node.js, private helper)
-     */
-    private static async _uploadFileSingle(
-        filePath: string,
-        presignedUrl: string,
-        contentType: string,
-        totalSize: number,
-        options: UploadOptions,
-        fs: any
-    ): Promise<void> {
-        const fileBuffer = fs.readFileSync(filePath);
-
-        const response = await fetch(presignedUrl, {
-            method: "PUT",
-            headers: {
-                "Content-Type": contentType,
-                "Content-Length": String(totalSize),
-            },
-            body: fileBuffer,
-        });
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(
-                `Single-part upload failed (${response.status}): ${errorText}`
-            );
-        }
-
-        if (options.onProgress) {
-            options.onProgress(90);
-        }
-    }
-
-    /**
-     * Upload file using multipart upload (Node.js, private helper)
-     */
-    private static async _uploadFileMultipart(
-        filePath: string,
-        partUrls: Array<{ part_number: number; url: string }>,
-        partSize: number,
-        totalSize: number,
-        options: UploadOptions,
-        fs: any
-    ): Promise<void> {
-        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
-
-        const fileHandle = fs.openSync(filePath, "r");
-        try {
-            for (let i = 0; i < sortedParts.length; i++) {
-                const part = sortedParts[i];
-                const buffer = Buffer.alloc(partSize);
-                const offset = (part.part_number - 1) * partSize;
-
-                const bytesRead = fs.readSync(fileHandle, buffer, 0, partSize, offset);
-                const chunk = buffer.slice(0, bytesRead);
-
-                if (chunk.length === 0) {
-                    break;
-                }
-
-                const response = await fetch(part.url, {
-                    method: "PUT",
-                    headers: {
-                        "Content-Length": String(chunk.length),
-                    },
-                    body: chunk,
-                });
-
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new Error(
-                        `Multipart upload failed at part ${part.part_number} ` +
-                        `(${response.status}): ${errorText}`
-                    );
-                }
-
-                if (options.onProgress) {
-                    const progress = Math.min(
-                        90,
-                        Math.floor(((i + 1) / sortedParts.length) * 90)
-                    );
-                    options.onProgress(progress);
-                }
-            }
-        } finally {
-            fs.closeSync(fileHandle);
-        }
-    }
-
-    /**
-     * Upload blob using single PUT request (browser, private helper)
-     */
-    private static async _uploadBlobSingle(
-        blob: Blob,
-        presignedUrl: string,
-        contentType: string,
-        totalSize: number,
-        options: UploadOptions
-    ): Promise<void> {
-        const response = await fetch(presignedUrl, {
-            method: "PUT",
-            headers: {
-                "Content-Type": contentType,
-                "Content-Length": String(totalSize),
-            },
-            body: blob,
-        });
-
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(
-                `Single-part upload failed (${response.status}): ${errorText}`
-            );
-        }
-
-        if (options.onProgress) {
-            options.onProgress(90);
-        }
-    }
-
-    /**
-     * Upload blob using multipart upload (browser, private helper)
-     */
-    private static async _uploadBlobMultipart(
-        blob: Blob,
-        partUrls: Array<{ part_number: number; url: string }>,
-        partSize: number,
-        totalSize: number,
-        options: UploadOptions
-    ): Promise<void> {
-        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
-
-        for (let i = 0; i < sortedParts.length; i++) {
-            const part = sortedParts[i];
-            const start = (part.part_number - 1) * partSize;
-            const end = Math.min(start + partSize, totalSize);
-            const chunk = blob.slice(start, end);
-
-            if (chunk.size === 0) {
-                break;
-            }
-
-            const response = await fetch(part.url, {
-                method: "PUT",
-                headers: {
-                    "Content-Length": String(chunk.size),
-                },
-                body: chunk,
-            });
-
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(
-                    `Multipart upload failed at part ${part.part_number} ` +
-                    `(${response.status}): ${errorText}`
-                );
-            }
-
-            if (options.onProgress) {
-                const progress = Math.min(
-                    90,
-                    Math.floor(((i + 1) / sortedParts.length) * 90)
-                );
-                options.onProgress(progress);
-            }
-        }
-    }
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-export { YetterImageClient } from "./api.js";
-export * from "./types.js";
-export { yetter } from "./client.js";
-
-// Explicitly export upload-related types for better discoverability
-export type {
-    UploadOptions,
-    GetUploadUrlRequest,
-    GetUploadUrlResponse,
-    UploadCompleteRequest,
-    UploadCompleteResponse,
-} from "./types.js";