@donkeylabs/adapter-sveltekit 2.0.14 → 2.0.16

package/dist/generator/index.js

@@ -0,0 +1,330 @@
+/**
+ * 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 { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { zodToTypeScript, toPascalCase, toCamelCase, } from "@donkeylabs/server/generator";
+/**
+ * Type guard to check if a route is a full RouteInfo (with prefix and routeName)
+ */
+function isRouteInfo(route) {
+    return (typeof route === "object" &&
+        route !== null &&
+        "prefix" in route &&
+        "routeName" in route &&
+        typeof route.prefix === "string");
+}
+/** SvelteKit-specific generator options */
+export const svelteKitGeneratorOptions = {
+    baseImport: 'import { UnifiedApiClientBase, SSEConnection, type ClientOptions, type RequestOptions, type SSEConnectionOptions } from "@donkeylabs/adapter-sveltekit/client";',
+    baseClass: "UnifiedApiClientBase",
+    constructorSignature: "options?: ClientOptions",
+    constructorBody: "super(options);",
+    factoryFunction: `/**
+ * Create an API client instance
+ *
+ * @param options.locals - Pass SvelteKit locals for SSR direct calls (no HTTP overhead)
+ * @param options.baseUrl - Override the base URL for HTTP calls
+ *
+ * @example SSR usage in +page.server.ts:
+ * \`\`\`ts
+ * export const load = async ({ locals }) => {
+ *   const api = createApi({ locals });
+ *   const data = await api.myRoute.get({}); // Direct call, no HTTP!
+ *   return { data };
+ * };
+ * \`\`\`
+ *
+ * @example Browser usage in +page.svelte:
+ * \`\`\`svelte
+ * <script>
+ *   import { createApi } from '$lib/api';
+ *   const api = createApi(); // HTTP calls
+ *   let data = $state(null);
+ *   async function load() {
+ *     data = await api.myRoute.get({});
+ *   }
+ * </script>
+ * \`\`\`
+ */
+export function createApi(options?: ClientOptions) {
+  return new ApiClient(options);
+}`,
+};
+/**
+ * Build a nested tree structure from routes
+ * e.g., routes "api.counter.get", "api.cache.set" become:
+ * api -> { counter -> { get }, cache -> { set } }
+ */
+function buildRouteTree(routes, commonPrefix) {
+    const tree = new Map();
+    for (const route of routes) {
+        // Get the path parts for nesting (e.g., "api.counter.get" -> ["api", "counter", "get"])
+        const parts = route.name.split(".");
+        const methodName = parts[parts.length - 1]; // Last part is the method
+        const namespaceParts = parts.slice(0, -1); // Everything before is namespace path
+        if (namespaceParts.length === 0) {
+            // Root level method
+            if (!tree.has("_root")) {
+                tree.set("_root", { methods: [], children: new Map() });
+            }
+            tree.get("_root").methods.push(generateMethodAndType(route, methodName, "Root", commonPrefix));
+            continue;
+        }
+        // Navigate/create the tree path
+        let current = tree;
+        for (let i = 0; i < namespaceParts.length; i++) {
+            const part = namespaceParts[i];
+            if (!current.has(part)) {
+                current.set(part, { methods: [], children: new Map() });
+            }
+            if (i === namespaceParts.length - 1) {
+                // At the final namespace level - add the method here
+                const pascalNs = toPascalCase(namespaceParts.join("."));
+                current.get(part).methods.push(generateMethodAndType(route, methodName, pascalNs, commonPrefix));
+            }
+            else {
+                // Continue traversing
+                current = current.get(part).children;
+            }
+        }
+    }
+    return tree;
+}
+/**
+ * Generate method definition and type definition for a route
+ */
+function generateMethodAndType(route, methodName, pascalNs, commonPrefix) {
+    const camelMethod = toCamelCase(methodName);
+    const pascalRoute = toPascalCase(methodName);
+    const fullRouteName = route.name; // Already includes full path
+    // Generate input type
+    const inputType = route.inputSource
+        ? (route.inputSource.trim().startsWith("z.") ? zodToTypeScript(route.inputSource) : route.inputSource)
+        : "Record<string, never>";
+    // Generate type definition
+    let typeDef = "";
+    let methodDef = "";
+    if (route.handler === "stream" || route.handler === "html") {
+        typeDef = `    export namespace ${pascalRoute} {
+      export type Input = Expand<${inputType}>;
+    }
+    export type ${pascalRoute} = { Input: ${pascalRoute}.Input };`;
+        if (route.handler === "stream") {
+            methodDef = `${camelMethod}: {
+      /** POST request with JSON body (programmatic) */
+      fetch: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Response> => this.streamRequest("${fullRouteName}", input, options),
+      /** GET URL for browser src attributes (video, img, download links) */
+      url: (input: Routes.${pascalNs}.${pascalRoute}.Input): string => this.streamUrl("${fullRouteName}", input),
+      /** GET request with query params */
+      get: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Response> => this.streamGet("${fullRouteName}", input, options),
+    }`;
+        }
+        else {
+            const hasInput = route.inputSource;
+            methodDef = `${camelMethod}: (${hasInput ? `input: Routes.${pascalNs}.${pascalRoute}.Input` : ""}): Promise<string> => this.htmlRequest("${fullRouteName}"${hasInput ? ", input" : ""})`;
+        }
+    }
+    else if (route.handler === "sse") {
+        const eventsEntries = route.eventsSource
+            ? Object.entries(route.eventsSource).map(([eventName, eventSchema]) => {
+                const eventType = eventSchema.trim().startsWith("z.")
+                    ? zodToTypeScript(eventSchema)
+                    : eventSchema;
+                return `        "${eventName}": Expand<${eventType}>;`;
+            })
+            : [];
+        const eventsType = eventsEntries.length > 0
+            ? `{\n${eventsEntries.join("\n")}\n      }`
+            : "Record<string, unknown>";
+        typeDef = `    export namespace ${pascalRoute} {
+      export type Input = Expand<${inputType}>;
+      export type Events = ${eventsType};
+    }
+    export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Events: ${pascalRoute}.Events };`;
+        const hasInput = route.inputSource;
+        if (hasInput) {
+            methodDef = `${camelMethod}: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: SSEConnectionOptions): SSEConnection<Routes.${pascalNs}.${pascalRoute}.Events> => this.sseConnect("${fullRouteName}", input, options)`;
+        }
+        else {
+            methodDef = `${camelMethod}: (options?: SSEConnectionOptions): SSEConnection<Routes.${pascalNs}.${pascalRoute}.Events> => this.sseConnect("${fullRouteName}", undefined, options)`;
+        }
+    }
+    else if (route.handler === "raw") {
+        typeDef = ""; // Raw routes don't have types
+        methodDef = `${camelMethod}: (init?: RequestInit): Promise<Response> => this.rawRequest("${fullRouteName}", init)`;
+    }
+    else if (route.handler === "formData") {
+        const outputType = route.outputSource
+            ? (route.outputSource.trim().startsWith("z.") ? zodToTypeScript(route.outputSource) : route.outputSource)
+            : "unknown";
+        typeDef = `    export namespace ${pascalRoute} {
+      export type Input = Expand<${inputType}>;
+      export type Output = Expand<${outputType}>;
+    }
+    export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Output: ${pascalRoute}.Output };`;
+        methodDef = `${camelMethod}: (fields: Routes.${pascalNs}.${pascalRoute}.Input, files: File[]): Promise<Routes.${pascalNs}.${pascalRoute}.Output> => this.formDataRequest("${fullRouteName}", fields, files)`;
+    }
+    else {
+        // typed handler (default)
+        const outputType = route.outputSource
+            ? (route.outputSource.trim().startsWith("z.") ? zodToTypeScript(route.outputSource) : route.outputSource)
+            : "unknown";
+        typeDef = `    export namespace ${pascalRoute} {
+      export type Input = Expand<${inputType}>;
+      export type Output = Expand<${outputType}>;
+    }
+    export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Output: ${pascalRoute}.Output };`;
+        methodDef = `${camelMethod}: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Routes.${pascalNs}.${pascalRoute}.Output> => this.request("${fullRouteName}", input, options)`;
+    }
+    return { methodDef, typeDef };
+}
+/**
+ * Generate nested object code from a tree node
+ */
+function generateNestedMethods(node, indent = "    ") {
+    const parts = [];
+    // Add methods at this level
+    for (const { methodDef } of node.methods) {
+        // Indent each line of the method definition
+        const indented = methodDef.split("\n").map((line, i) => i === 0 ? `${indent}${line}` : `${indent}${line}`).join("\n");
+        parts.push(indented);
+    }
+    // Add nested namespaces
+    for (const [childName, childNode] of node.children) {
+        const childContent = generateNestedMethods(childNode, indent + "  ");
+        parts.push(`${indent}${childName}: {\n${childContent}\n${indent}}`);
+    }
+    return parts.join(",\n");
+}
+/**
+ * Collect all type definitions from a tree
+ */
+function collectTypeDefs(tree, prefix = "") {
+    const result = new Map();
+    for (const [name, node] of tree) {
+        const nsPath = prefix ? `${prefix}.${name}` : name;
+        const pascalNs = name === "_root" ? "Root" : toPascalCase(nsPath);
+        // Collect types from this node's methods
+        const typeDefs = node.methods
+            .map(m => m.typeDef)
+            .filter(t => t.length > 0);
+        if (typeDefs.length > 0) {
+            if (!result.has(pascalNs)) {
+                result.set(pascalNs, []);
+            }
+            result.get(pascalNs).push(...typeDefs);
+        }
+        // Recursively collect from children
+        const childTypes = collectTypeDefs(node.children, nsPath);
+        for (const [childNs, childDefs] of childTypes) {
+            if (!result.has(childNs)) {
+                result.set(childNs, []);
+            }
+            result.get(childNs).push(...childDefs);
+        }
+    }
+    return result;
+}
+/**
+ * Generate a fully-typed SvelteKit-compatible API client
+ */
+function generateTypedSvelteKitClient(routes) {
+    const opts = svelteKitGeneratorOptions;
+    const commonPrefix = ""; // We don't strip prefixes anymore - nested structure handles it
+    // Build nested tree structure from routes
+    const tree = buildRouteTree(routes, commonPrefix);
+    // Collect type definitions from tree
+    const typesByNamespace = collectTypeDefs(tree);
+    const typeBlocks = [];
+    for (const [nsName, typeDefs] of typesByNamespace) {
+        if (typeDefs.length > 0) {
+            typeBlocks.push(`  export namespace ${nsName} {\n${typeDefs.join("\n\n")}\n  }`);
+        }
+    }
+    // Generate method blocks from tree
+    const methodBlocks = [];
+    for (const [topLevel, node] of tree) {
+        if (topLevel === "_root") {
+            // Root level methods become direct class properties
+            for (const { methodDef } of node.methods) {
+                methodBlocks.push(`  ${methodDef};`);
+            }
+            continue;
+        }
+        const content = generateNestedMethods(node, "    ");
+        methodBlocks.push(`  ${topLevel} = {\n${content}\n  };`);
+    }
+    return `// Auto-generated by donkeylabs generate
+// DO NOT EDIT MANUALLY
+
+${opts.baseImport}
+
+// Utility type that forces TypeScript to expand types on hover
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+// ============================================
+// Route Types
+// ============================================
+
+export namespace Routes {
+${typeBlocks.join("\n\n") || "  // No typed routes found"}
+}
+
+// ============================================
+// API Client
+// ============================================
+
+export class ApiClient extends ${opts.baseClass} {
+  constructor(${opts.constructorSignature}) {
+    ${opts.constructorBody}
+  }
+
+${methodBlocks.join("\n\n") || "  // No routes defined"}
+}
+
+${opts.factoryFunction}
+`;
+}
+/**
+ * Generate a SvelteKit-compatible API client
+ *
+ * This is called by the donkeylabs CLI when adapter is set to "@donkeylabs/adapter-sveltekit"
+ */
+export async function generateClient(_config, routes, outputPath) {
+    let code;
+    // Always try typed generation if we have routes
+    if (routes.length > 0 && isRouteInfo(routes[0])) {
+        // Full RouteInfo - generate typed client
+        code = generateTypedSvelteKitClient(routes);
+    }
+    else if (routes.length > 0) {
+        // Convert ExtractedRoute to RouteInfo for typed generation
+        const routeInfos = routes.map((r) => {
+            const parts = r.name.split(".");
+            return {
+                name: r.name,
+                prefix: parts.slice(0, -1).join("."),
+                routeName: parts[parts.length - 1] || r.name,
+                handler: (r.handler || "typed"),
+                inputSource: undefined,
+                outputSource: undefined,
+            };
+        });
+        code = generateTypedSvelteKitClient(routeInfos);
+    }
+    else {
+        // Empty routes - generate minimal client
+        code = generateTypedSvelteKitClient([]);
+    }
+    // Ensure output directory exists
+    const outputDir = dirname(outputPath);
+    await mkdir(outputDir, { recursive: true });
+    // Write the generated client
+    await writeFile(outputPath, code);
+}
+// Re-export building blocks for advanced usage
+export { generateClientCode, zodToTypeScript, toPascalCase, toCamelCase, } from "@donkeylabs/server/generator";

package/dist/hooks/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SvelteKit hooks helper for @donkeylabs/adapter-sveltekit
+ */
+import type { Handle } from "@sveltejs/kit";
+export interface DonkeylabsPlatform {
+    donkeylabs?: {
+        services: Record<string, any>;
+        core: {
+            logger: any;
+            cache: any;
+            events: any;
+            cron: any;
+            jobs: any;
+            sse: any;
+            rateLimiter: any;
+            db: any;
+        };
+        /** Direct route handler for SSR (no HTTP!) */
+        handleRoute: (routeName: string, input: any) => Promise<any>;
+    };
+}
+export interface DonkeylabsLocals {
+    plugins: Record<string, any>;
+    core: {
+        logger: any;
+        cache: any;
+        events: any;
+        sse: any;
+    };
+    db: any;
+    ip: string;
+    /** Direct route handler for SSR API calls */
+    handleRoute?: (routeName: string, input: any) => Promise<any>;
+}
+/**
+ * Create a SvelteKit handle function that populates event.locals
+ * with @donkeylabs/server context.
+ *
+ * @example
+ * // src/hooks.server.ts
+ * import { createHandle } from "@donkeylabs/adapter-sveltekit/hooks";
+ * export const handle = createHandle();
+ */
+export declare function createHandle(): Handle;
+/**
+ * Sequence multiple handle functions together.
+ *
+ * @example
+ * import { sequence, createHandle } from "@donkeylabs/adapter-sveltekit/hooks";
+ * export const handle = sequence(createHandle(), myOtherHandle);
+ */
+export declare function sequence(...handlers: Handle[]): Handle;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,eAAe,CAAC;AAyB1D,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE;QACX,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9B,IAAI,EAAE;YACJ,MAAM,EAAE,GAAG,CAAC;YACZ,KAAK,EAAE,GAAG,CAAC;YACX,MAAM,EAAE,GAAG,CAAC;YACZ,IAAI,EAAE,GAAG,CAAC;YACV,IAAI,EAAE,GAAG,CAAC;YACV,GAAG,EAAE,GAAG,CAAC;YACT,WAAW,EAAE,GAAG,CAAC;YACjB,EAAE,EAAE,GAAG,CAAC;SACT,CAAC;QACF,8CAA8C;QAC9C,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;KAC9D,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,IAAI,EAAE;QACJ,MAAM,EAAE,GAAG,CAAC;QACZ,KAAK,EAAE,GAAG,CAAC;QACX,MAAM,EAAE,GAAG,CAAC;QACZ,GAAG,EAAE,GAAG,CAAC;KACV,CAAC;IACF,EAAE,EAAE,GAAG,CAAC;IACR,EAAE,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CAC/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,MAAM,CA6CrC;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAYtD"}

package/dist/hooks/index.js

@@ -0,0 +1,96 @@
+/**
+ * SvelteKit hooks helper for @donkeylabs/adapter-sveltekit
+ */
+// Try to import dev server reference (only available in dev mode)
+let getDevServer;
+try {
+    // Dynamic import to avoid bundling vite.ts in production
+    const viteModule = await import("../vite.js");
+    getDevServer = viteModule.getDevServer;
+}
+catch {
+    // Not in dev mode or vite not available
+}
+/**
+ * Safely get client IP address with fallback.
+ * SvelteKit's getClientAddress() throws when running with Bun or without proper proxy headers.
+ */
+function safeGetClientAddress(event) {
+    try {
+        return safeGetClientAddress(event);
+    }
+    catch {
+        // Fallback when address cannot be determined (e.g., Bun runtime, SSR without client)
+        return "127.0.0.1";
+    }
+}
+/**
+ * Create a SvelteKit handle function that populates event.locals
+ * with @donkeylabs/server context.
+ *
+ * @example
+ * // src/hooks.server.ts
+ * import { createHandle } from "@donkeylabs/adapter-sveltekit/hooks";
+ * export const handle = createHandle();
+ */
+export function createHandle() {
+    return async ({ event, resolve }) => {
+        const platform = event.platform;
+        if (platform?.donkeylabs) {
+            // Production mode: use platform.donkeylabs from adapter
+            const { services, core, handleRoute } = platform.donkeylabs;
+            // Populate locals with server context
+            event.locals.plugins = services;
+            event.locals.core = {
+                logger: core.logger,
+                cache: core.cache,
+                events: core.events,
+                sse: core.sse,
+            };
+            event.locals.db = core.db;
+            event.locals.ip = safeGetClientAddress(event);
+            // Expose the direct route handler for SSR API calls
+            event.locals.handleRoute = handleRoute;
+        }
+        else if (getDevServer) {
+            // Dev mode: use global dev server from vite plugin
+            const devServer = getDevServer();
+            if (devServer) {
+                const core = devServer.getCore();
+                const plugins = devServer.getServices();
+                event.locals.plugins = plugins;
+                event.locals.core = {
+                    logger: core.logger,
+                    cache: core.cache,
+                    events: core.events,
+                    sse: core.sse,
+                };
+                event.locals.db = core.db;
+                event.locals.ip = safeGetClientAddress(event);
+                // Direct route handler for SSR
+                event.locals.handleRoute = async (routeName, input) => {
+                    return devServer.callRoute(routeName, input, safeGetClientAddress(event));
+                };
+            }
+        }
+        return resolve(event);
+    };
+}
+/**
+ * Sequence multiple handle functions together.
+ *
+ * @example
+ * import { sequence, createHandle } from "@donkeylabs/adapter-sveltekit/hooks";
+ * export const handle = sequence(createHandle(), myOtherHandle);
+ */
+export function sequence(...handlers) {
+    return async ({ event, resolve }) => {
+        let resolveChain = resolve;
+        for (let i = handlers.length - 1; i >= 0; i--) {
+            const handler = handlers[i];
+            const next = resolveChain;
+            resolveChain = (event) => handler({ event, resolve: next });
+        }
+        return resolveChain(event);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @donkeylabs/adapter-sveltekit
+ *
+ * SvelteKit adapter that integrates with @donkeylabs/server.
+ * - Single Bun process serves both SvelteKit pages and API routes
+ * - Direct service calls during SSR (no HTTP overhead)
+ * - Unified API client works in both SSR and browser
+ */
+import type { Adapter } from "@sveltejs/kit";
+export interface AdapterOptions {
+    /**
+     * Output directory for the built app.
+     * @default "build"
+     */
+    out?: string;
+    /**
+     * Path to your @donkeylabs/server entry file.
+     * This file should export a configured AppServer instance.
+     *
+     * @default "./src/server/index.ts"
+     */
+    serverEntry?: string;
+    /**
+     * Whether to precompress static assets with gzip/brotli.
+     * @default true
+     */
+    precompress?: boolean;
+    /**
+     * Environment variable prefix for PORT and HOST.
+     * @default ""
+     */
+    envPrefix?: string;
+    /**
+     * Enable development mode features.
+     * @default false
+     */
+    development?: boolean;
+}
+export default function adapter(options?: AdapterOptions): Adapter;
+export type { AdapterOptions as Options };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,eAAe,CAAC;AAQtD,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAgErE;AAmRD,YAAY,EAAE,cAAc,IAAI,OAAO,EAAE,CAAC"}