@donkeylabs/adapter-sveltekit 2.0.14 → 2.0.16

package/dist/client/index.js

@@ -0,0 +1,501 @@
+/**
+ * Unified API client for @donkeylabs/adapter-sveltekit
+ *
+ * Auto-detects environment:
+ * - SSR: Direct service calls through locals (no HTTP)
+ * - Browser: HTTP calls to API routes
+ */
+/**
+ * Type-safe SSE connection wrapper.
+ * Provides typed event handlers with automatic JSON parsing.
+ *
+ * @example
+ * ```ts
+ * // With auto-reconnect (default)
+ * const connection = api.notifications.subscribe({ userId: "123" });
+ *
+ * // Disable auto-reconnect for manual control
+ * const connection = api.notifications.subscribe({ userId: "123" }, {
+ *   autoReconnect: false
+ * });
+ *
+ * // Custom reconnect delay
+ * const connection = api.notifications.subscribe({ userId: "123" }, {
+ *   reconnectDelay: 5000 // 5 seconds
+ * });
+ *
+ * // Typed event handler - returns unsubscribe function
+ * const unsubscribe = connection.on("notification", (data) => {
+ *   console.log(data.message); // Fully typed!
+ * });
+ *
+ * // Later: unsubscribe from this specific handler
+ * unsubscribe();
+ *
+ * // Close entire connection
+ * connection.close();
+ * ```
+ */
+export class SSEConnection {
+    eventSource;
+    handlers = new Map();
+    url;
+    options;
+    reconnectTimeout = null;
+    closed = false;
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = {
+            autoReconnect: true,
+            reconnectDelay: 3000,
+            ...options,
+        };
+        this.eventSource = this.createEventSource();
+    }
+    createEventSource() {
+        const es = new EventSource(this.url);
+        es.onopen = () => {
+            this.options.onConnect?.();
+        };
+        es.onerror = () => {
+            // Native EventSource auto-reconnects, but we want control
+            // Close it and handle reconnection ourselves
+            if (this.options.autoReconnect && !this.closed) {
+                this.options.onDisconnect?.();
+                es.close();
+                this.scheduleReconnect();
+            }
+        };
+        // Re-attach existing handlers to new EventSource
+        for (const [event] of this.handlers) {
+            es.addEventListener(event, (e) => {
+                this.dispatchEvent(event, e.data);
+            });
+        }
+        return es;
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimeout || this.closed)
+            return;
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            if (!this.closed) {
+                this.eventSource = this.createEventSource();
+            }
+        }, this.options.reconnectDelay);
+    }
+    dispatchEvent(event, rawData) {
+        const handlers = this.handlers.get(event);
+        if (!handlers)
+            return;
+        let data;
+        try {
+            data = JSON.parse(rawData);
+        }
+        catch {
+            data = rawData;
+        }
+        for (const h of handlers) {
+            h(data);
+        }
+    }
+    /**
+     * Register a typed event handler.
+     * @returns Unsubscribe function to remove this specific handler
+     */
+    on(event, handler) {
+        const isNewEvent = !this.handlers.has(event);
+        if (isNewEvent) {
+            this.handlers.set(event, new Set());
+            // Add EventSource listener for this event type
+            this.eventSource?.addEventListener(event, (e) => {
+                this.dispatchEvent(event, e.data);
+            });
+        }
+        this.handlers.get(event).add(handler);
+        // Return unsubscribe function
+        return () => {
+            const handlers = this.handlers.get(event);
+            if (handlers) {
+                handlers.delete(handler);
+            }
+        };
+    }
+    /**
+     * Register a typed event handler that fires only once.
+     * @returns Unsubscribe function to remove this specific handler
+     */
+    once(event, handler) {
+        const wrappedHandler = (data) => {
+            unsubscribe();
+            handler(data);
+        };
+        const unsubscribe = this.on(event, wrappedHandler);
+        return unsubscribe;
+    }
+    /**
+     * Remove all handlers for an event.
+     */
+    off(event) {
+        this.handlers.delete(event);
+    }
+    /**
+     * Register error handler.
+     * Note: With autoReconnect enabled, errors trigger automatic reconnection.
+     */
+    onError(handler) {
+        const wrappedHandler = (e) => {
+            handler(e);
+        };
+        if (this.eventSource) {
+            const existingHandler = this.eventSource.onerror;
+            this.eventSource.onerror = (e) => {
+                // Call existing handler (for reconnection logic)
+                if (existingHandler)
+                    existingHandler(e);
+                wrappedHandler(e);
+            };
+        }
+        return () => {
+            // Can't easily remove, but handler will be replaced on reconnect
+        };
+    }
+    /**
+     * Register open handler (connection established)
+     */
+    onOpen(handler) {
+        if (this.eventSource) {
+            const existingHandler = this.eventSource.onopen;
+            this.eventSource.onopen = (e) => {
+                if (existingHandler)
+                    existingHandler(e);
+                handler(e);
+            };
+        }
+        return () => {
+            if (this.eventSource)
+                this.eventSource.onopen = null;
+        };
+    }
+    /**
+     * Get connection state
+     */
+    get readyState() {
+        return this.eventSource?.readyState ?? EventSource.CLOSED;
+    }
+    /**
+     * Check if connected
+     */
+    get connected() {
+        return this.eventSource?.readyState === EventSource.OPEN;
+    }
+    /**
+     * Check if reconnecting
+     */
+    get reconnecting() {
+        return this.reconnectTimeout !== null;
+    }
+    /**
+     * Close the SSE connection and stop reconnection attempts
+     */
+    close() {
+        this.closed = true;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        this.eventSource?.close();
+        this.eventSource = null;
+        this.handlers.clear();
+    }
+}
+/**
+ * Base class for unified API clients.
+ * Extend this class with your generated route methods.
+ */
+export class UnifiedApiClientBase {
+    baseUrl;
+    locals;
+    isSSR;
+    customFetch;
+    constructor(options) {
+        this.baseUrl = options?.baseUrl ?? "";
+        this.locals = options?.locals;
+        this.isSSR = typeof window === "undefined";
+        this.customFetch = options?.fetch;
+    }
+    /**
+     * Make a request to an API route.
+     * Automatically uses direct calls in SSR (when locals.handleRoute is available), HTTP otherwise.
+     */
+    async request(route, input, options) {
+        // Use direct route handler if available (SSR with locals)
+        if (this.locals?.handleRoute) {
+            return this.locals.handleRoute(route, input);
+        }
+        // Fall back to HTTP (browser or SSR without locals)
+        return this.httpCall(route, input, options);
+    }
+    /**
+     * HTTP call to API endpoint (browser or SSR with event.fetch).
+     */
+    async httpCall(route, input, options) {
+        const url = `${this.baseUrl}/${route}`;
+        const fetchFn = this.customFetch ?? fetch;
+        const response = await fetchFn(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+            body: JSON.stringify(input),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: "Unknown error" }));
+            throw new Error(error.message || error.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Make a raw request (for non-JSON endpoints like streaming).
+     * Returns the raw Response object without processing.
+     */
+    async rawRequest(route, init) {
+        const url = `${this.baseUrl}/${route}`;
+        const fetchFn = this.customFetch ?? fetch;
+        return fetchFn(url, {
+            method: "POST",
+            ...init,
+        });
+    }
+    /**
+     * Make a stream request (validated input, Response output).
+     * For streaming, binary data, or custom content-type responses.
+     *
+     * By default uses POST with JSON body. For browser compatibility
+     * (video src, image src, download links), use streamUrl() instead.
+     */
+    async streamRequest(route, input, options) {
+        const url = `${this.baseUrl}/${route}`;
+        const fetchFn = this.customFetch ?? fetch;
+        const response = await fetchFn(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...options?.headers,
+            },
+            body: JSON.stringify(input),
+            signal: options?.signal,
+        });
+        // Unlike typed requests, we return the raw Response
+        // Error handling is left to the caller
+        return response;
+    }
+    /**
+     * Get the URL for a stream endpoint (for browser src attributes).
+     * Returns a URL with query params that can be used in:
+     * - <video src={url}>
+     * - <img src={url}>
+     * - <a href={url} download>
+     * - window.open(url)
+     */
+    streamUrl(route, input) {
+        let url = `${this.baseUrl}/${route}`;
+        if (input && typeof input === "object") {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(input)) {
+                params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+            }
+            url += `?${params.toString()}`;
+        }
+        return url;
+    }
+    /**
+     * Fetch a stream via GET with query params.
+     * Alternative to streamRequest() for cases where GET is preferred.
+     */
+    async streamGet(route, input, options) {
+        const url = this.streamUrl(route, input);
+        const fetchFn = this.customFetch ?? fetch;
+        return fetchFn(url, {
+            method: "GET",
+            headers: options?.headers,
+            signal: options?.signal,
+        });
+    }
+    /**
+     * Connect to an SSE endpoint.
+     * Returns a typed SSEConnection for handling server-sent events.
+     */
+    sseConnect(route, input, options) {
+        let url = `${this.baseUrl}/${route}`;
+        // Add input as query params for GET request
+        if (input && typeof input === "object") {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(input)) {
+                params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+            }
+            url += `?${params.toString()}`;
+        }
+        return new SSEConnection(url, options);
+    }
+    /**
+     * Connect to a specific SSE route endpoint.
+     * Alias for sseConnect() - provides compatibility with @donkeylabs/server generated clients.
+     * @returns SSE connection with typed event handlers
+     */
+    connectToSSERoute(route, input = {}, options) {
+        // Map SSEOptions to SSEConnectionOptions
+        const connectionOptions = options ? {
+            autoReconnect: options.autoReconnect,
+            reconnectDelay: options.reconnectDelay,
+            onConnect: options.onConnect,
+            onDisconnect: options.onDisconnect,
+        } : undefined;
+        return this.sseConnect(route, input, connectionOptions);
+    }
+    /**
+     * Make a formData request (file uploads with validated fields).
+     */
+    async formDataRequest(route, fields, files, options) {
+        const url = `${this.baseUrl}/${route}`;
+        const fetchFn = this.customFetch ?? fetch;
+        const formData = new FormData();
+        // Add fields
+        if (fields && typeof fields === "object") {
+            for (const [key, value] of Object.entries(fields)) {
+                formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+            }
+        }
+        // Add files
+        for (const file of files) {
+            formData.append("file", file);
+        }
+        const response = await fetchFn(url, {
+            method: "POST",
+            headers: options?.headers,
+            body: formData,
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: "Unknown error" }));
+            throw new Error(error.message || error.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    /**
+     * Make an HTML request (returns HTML string).
+     */
+    async htmlRequest(route, input, options) {
+        let url = `${this.baseUrl}/${route}`;
+        const fetchFn = this.customFetch ?? fetch;
+        // Add input as query params for GET request
+        if (input && typeof input === "object") {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(input)) {
+                params.set(key, typeof value === "string" ? value : JSON.stringify(value));
+            }
+            url += `?${params.toString()}`;
+        }
+        const response = await fetchFn(url, {
+            method: "GET",
+            headers: {
+                Accept: "text/html",
+                ...options?.headers,
+            },
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return response.text();
+    }
+    /**
+     * SSE (Server-Sent Events) subscription.
+     * Only works in the browser.
+     */
+    sse = {
+        /**
+         * Subscribe to SSE channels.
+         * Returns a function to unsubscribe.
+         *
+         * @example
+         * const unsub = api.sse.subscribe(["notifications"], (event, data) => {
+         *   console.log(event, data);
+         * });
+         * // Later: unsub();
+         */
+        subscribe: (channels, callback, options) => {
+            if (typeof window === "undefined") {
+                // SSR - return no-op
+                return () => { };
+            }
+            const url = `${this.baseUrl}/sse?channels=${channels.join(",")}`;
+            let eventSource = new EventSource(url);
+            let reconnectTimeout = null;
+            // Known event types from the server
+            const eventTypes = [
+                'cron-event', 'job-completed', 'internal-event', 'manual', 'message',
+                // Workflow events
+                'workflow.started', 'workflow.progress', 'workflow.completed',
+                'workflow.failed', 'workflow.cancelled',
+                'workflow.step.started', 'workflow.step.completed', 'workflow.step.failed',
+            ];
+            const handleMessage = (e) => {
+                try {
+                    const data = JSON.parse(e.data);
+                    callback(e.type || "message", data);
+                }
+                catch {
+                    callback(e.type || "message", e.data);
+                }
+            };
+            const handleError = () => {
+                if (options?.reconnect !== false && eventSource) {
+                    eventSource.close();
+                    reconnectTimeout = setTimeout(() => {
+                        eventSource = new EventSource(url);
+                        // Re-attach all listeners on reconnect
+                        eventSource.onmessage = handleMessage;
+                        eventSource.onerror = handleError;
+                        for (const type of eventTypes) {
+                            eventSource.addEventListener(type, handleMessage);
+                        }
+                    }, 1000);
+                }
+            };
+            // Listen for unnamed messages
+            eventSource.onmessage = handleMessage;
+            eventSource.onerror = handleError;
+            // Listen for named event types (SSE sends "event: type-name")
+            for (const type of eventTypes) {
+                eventSource.addEventListener(type, handleMessage);
+            }
+            // Return unsubscribe function
+            return () => {
+                if (reconnectTimeout) {
+                    clearTimeout(reconnectTimeout);
+                }
+                if (eventSource) {
+                    eventSource.close();
+                    eventSource = null;
+                }
+            };
+        },
+    };
+}
+/**
+ * Create an API client instance.
+ * Call with locals and fetch in SSR, without in browser.
+ *
+ * @example
+ * // +page.server.ts (SSR)
+ * const api = createApiClient({ locals, fetch });
+ *
+ * // +page.svelte (browser)
+ * const api = createApiClient();
+ */
+export function createApiClient(ClientClass, options) {
+    return new ClientClass(options);
+}

package/dist/generator/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * SvelteKit-specific client generator
+ *
+ * This generator extends the core @donkeylabs/server generator
+ * to produce clients that work with both SSR (direct calls) and browser (HTTP).
+ */
+import { type RouteInfo, type ExtractedRoute, type ClientGeneratorOptions } from "@donkeylabs/server/generator";
+/** SvelteKit-specific generator options */
+export declare const svelteKitGeneratorOptions: ClientGeneratorOptions;
+/**
+ * Generate a SvelteKit-compatible API client
+ *
+ * This is called by the donkeylabs CLI when adapter is set to "@donkeylabs/adapter-sveltekit"
+ */
+export declare function generateClient(_config: Record<string, unknown>, routes: RouteInfo[] | ExtractedRoute[], outputPath: string): Promise<void>;
+export { generateClientCode, zodToTypeScript, toPascalCase, toCamelCase, type RouteInfo, type ExtractedRoute, type ClientGeneratorOptions, } from "@donkeylabs/server/generator";
+//# sourceMappingURL=index.d.ts.map

package/dist/generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC5B,MAAM,8BAA8B,CAAC;AAetC,2CAA2C;AAC3C,eAAO,MAAM,yBAAyB,EAAE,sBAoCvC,CAAC;AAuRF;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,MAAM,EAAE,SAAS,EAAE,GAAG,cAAc,EAAE,EACtC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAGD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,WAAW,EACX,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,sBAAsB,GAC5B,MAAM,8BAA8B,CAAC"}