litestar-vite-plugin 0.14.0 → 0.15.0-alpha.1

package/dist/js/sveltekit.d.ts

@@ -0,0 +1,158 @@
+/**
+ * SvelteKit integration for Litestar-Vite.
+ *
+ * This module provides a Vite plugin specifically designed to work alongside
+ * SvelteKit's own Vite plugin. It enables:
+ * - API proxy configuration for dev server
+ * - Type generation integration (shares @hey-api/openapi-ts output)
+ * - Seamless integration with SvelteKit's load functions
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { sveltekit } from '@sveltejs/kit/vite';
+ * import { litestarSvelteKit } from 'litestar-vite-plugin/sveltekit';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     litestarSvelteKit({
+ *       apiProxy: 'http://localhost:8000',
+ *       types: {
+ *         enabled: true,
+ *         output: 'src/lib/api',
+ *       },
+ *     }),
+ *     sveltekit(),  // SvelteKit plugin comes after
+ *   ],
+ * });
+ * ```
+ *
+ * @module
+ */
+import type { Plugin } from "vite";
+/**
+ * Configuration for TypeScript type generation in SvelteKit.
+ */
+export interface SvelteKitTypesConfig {
+    /**
+     * Enable type generation.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Path to output generated TypeScript types.
+     * Recommended to use SvelteKit's $lib alias path.
+     *
+     * @default 'src/lib/api'
+     */
+    output?: string;
+    /**
+     * Path where the OpenAPI schema is exported by Litestar.
+     *
+     * @default 'openapi.json'
+     */
+    openapiPath?: string;
+    /**
+     * Path where route metadata is exported by Litestar.
+     *
+     * @default 'routes.json'
+     */
+    routesPath?: string;
+    /**
+     * Generate Zod schemas in addition to TypeScript types.
+     *
+     * @default false
+     */
+    generateZod?: boolean;
+    /**
+     * Debounce time in milliseconds for type regeneration.
+     *
+     * @default 300
+     */
+    debounce?: number;
+}
+/**
+ * Configuration options for the Litestar SvelteKit integration.
+ */
+export interface LitestarSvelteKitConfig {
+    /**
+     * URL of the Litestar API backend for proxying requests during development.
+     *
+     * @example 'http://localhost:8000'
+     * @default 'http://localhost:8000'
+     */
+    apiProxy?: string;
+    /**
+     * API route prefix to proxy to the Litestar backend.
+     * Requests matching this prefix will be forwarded to the apiProxy URL.
+     *
+     * @example '/api'
+     * @default '/api'
+     */
+    apiPrefix?: string;
+    /**
+     * Enable and configure TypeScript type generation.
+     *
+     * When set to `true`, enables type generation with default settings.
+     * When set to a SvelteKitTypesConfig object, enables type generation with custom settings.
+     *
+     * @default false
+     */
+    types?: boolean | SvelteKitTypesConfig;
+    /**
+     * Enable verbose logging for debugging.
+     *
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Litestar integration plugin for SvelteKit.
+ *
+ * This plugin should be added BEFORE the sveltekit() plugin in your vite.config.ts.
+ * It provides API proxying during development and integrates type generation.
+ *
+ * @param userConfig - Configuration options for the integration
+ * @returns A Vite plugin array
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { sveltekit } from '@sveltejs/kit/vite';
+ * import { litestarSvelteKit } from 'litestar-vite-plugin/sveltekit';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     litestarSvelteKit({
+ *       apiProxy: 'http://localhost:8000',
+ *       apiPrefix: '/api',
+ *       types: {
+ *         enabled: true,
+ *         output: 'src/lib/api',
+ *         generateZod: true,
+ *       },
+ *     }),
+ *     sveltekit(),
+ *   ],
+ * });
+ * ```
+ *
+ * @example Using with SvelteKit load functions
+ * ```typescript
+ * // src/routes/users/[id]/+page.ts
+ * import type { PageLoad } from './$types';
+ * import type { User } from '$lib/api/types.gen';
+ * import { route } from '$lib/api/routes';
+ *
+ * export const load: PageLoad = async ({ params, fetch }) => {
+ *   const response = await fetch(route('users.show', { id: params.id }));
+ *   const user: User = await response.json();
+ *   return { user };
+ * };
+ * ```
+ */
+export declare function litestarSvelteKit(userConfig?: LitestarSvelteKitConfig): Plugin[];
+export default litestarSvelteKit;

package/dist/js/sveltekit.js

@@ -0,0 +1,168 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import colors from "picocolors";
+import { resolveInstallHint } from "./install-hint.js";
+const execAsync = promisify(exec);
+function resolveConfig(config = {}) {
+  let typesConfig = false;
+  if (config.types === true) {
+    typesConfig = {
+      enabled: true,
+      output: "src/lib/api",
+      openapiPath: "openapi.json",
+      routesPath: "routes.json",
+      generateZod: false,
+      debounce: 300
+    };
+  } else if (typeof config.types === "object" && config.types !== null) {
+    typesConfig = {
+      enabled: config.types.enabled ?? true,
+      output: config.types.output ?? "src/lib/api",
+      openapiPath: config.types.openapiPath ?? "openapi.json",
+      routesPath: config.types.routesPath ?? "routes.json",
+      generateZod: config.types.generateZod ?? false,
+      debounce: config.types.debounce ?? 300
+    };
+  }
+  return {
+    apiProxy: config.apiProxy ?? "http://localhost:8000",
+    apiPrefix: config.apiPrefix ?? "/api",
+    types: typesConfig,
+    verbose: config.verbose ?? false
+  };
+}
+function debounce(func, wait) {
+  let timeout = null;
+  return (...args) => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+function litestarSvelteKit(userConfig = {}) {
+  const config = resolveConfig(userConfig);
+  const plugins = [];
+  plugins.push({
+    name: "litestar-sveltekit",
+    enforce: "pre",
+    config() {
+      return {
+        server: {
+          proxy: {
+            [config.apiPrefix]: {
+              target: config.apiProxy,
+              changeOrigin: true,
+              secure: false
+            }
+          }
+        }
+      };
+    },
+    configureServer(server) {
+      if (config.verbose) {
+        server.middlewares.use((req, _res, next) => {
+          if (req.url?.startsWith(config.apiPrefix)) {
+            console.log(colors.cyan("[litestar-sveltekit]"), `Proxying: ${req.method} ${req.url}`);
+          }
+          next();
+        });
+      }
+      server.httpServer?.once("listening", () => {
+        setTimeout(() => {
+          console.log("");
+          console.log(`  ${colors.cyan("[litestar-sveltekit]")} ${colors.green("Integration active")}`);
+          console.log(`  ${colors.dim("\u251C\u2500")} API Proxy: ${colors.yellow(config.apiProxy)}`);
+          console.log(`  ${colors.dim("\u251C\u2500")} API Prefix: ${colors.yellow(config.apiPrefix)}`);
+          if (config.types !== false && config.types.enabled) {
+            console.log(`  ${colors.dim("\u2514\u2500")} Types Output: ${colors.yellow(config.types.output)}`);
+          } else {
+            console.log(`  ${colors.dim("\u2514\u2500")} Types: ${colors.dim("disabled")}`);
+          }
+          console.log("");
+        }, 100);
+      });
+    }
+  });
+  if (config.types !== false && config.types.enabled) {
+    plugins.push(createTypeGenerationPlugin(config.types));
+  }
+  return plugins;
+}
+function createTypeGenerationPlugin(typesConfig) {
+  let server = null;
+  let isGenerating = false;
+  async function runTypeGeneration() {
+    if (isGenerating) {
+      return false;
+    }
+    isGenerating = true;
+    const startTime = Date.now();
+    try {
+      const openapiPath = path.resolve(process.cwd(), typesConfig.openapiPath);
+      if (!fs.existsSync(openapiPath)) {
+        console.log(colors.cyan("[litestar-sveltekit]"), colors.yellow("OpenAPI schema not found:"), typesConfig.openapiPath);
+        return false;
+      }
+      console.log(colors.cyan("[litestar-sveltekit]"), colors.dim("Generating TypeScript types..."));
+      const args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", typesConfig.output];
+      if (typesConfig.generateZod) {
+        args.push("--plugins", "@hey-api/schemas", "@hey-api/types");
+      }
+      await execAsync(`npx ${args.join(" ")}`, {
+        cwd: process.cwd()
+      });
+      const duration = Date.now() - startTime;
+      console.log(colors.cyan("[litestar-sveltekit]"), colors.green("Types generated"), colors.dim(`in ${duration}ms`));
+      if (server) {
+        server.ws.send({
+          type: "custom",
+          event: "litestar:types-updated",
+          data: {
+            output: typesConfig.output,
+            timestamp: Date.now()
+          }
+        });
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not found") || message.includes("ENOENT")) {
+        console.log(colors.cyan("[litestar-sveltekit]"), colors.yellow("@hey-api/openapi-ts not installed"), "- run:", resolveInstallHint());
+      } else {
+        console.error(colors.cyan("[litestar-sveltekit]"), colors.red("Type generation failed:"), message);
+      }
+      return false;
+    } finally {
+      isGenerating = false;
+    }
+  }
+  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
+  return {
+    name: "litestar-sveltekit-types",
+    enforce: "pre",
+    configureServer(devServer) {
+      server = devServer;
+      console.log(colors.cyan("[litestar-sveltekit]"), colors.dim("Watching for schema changes:"), colors.yellow(typesConfig.openapiPath));
+    },
+    handleHotUpdate({ file }) {
+      if (!typesConfig.enabled) {
+        return;
+      }
+      const relativePath = path.relative(process.cwd(), file);
+      const openapiPath = typesConfig.openapiPath.replace(/^\.\//, "");
+      const routesPath = typesConfig.routesPath.replace(/^\.\//, "");
+      if (relativePath === openapiPath || relativePath === routesPath || file.endsWith(openapiPath) || file.endsWith(routesPath)) {
+        console.log(colors.cyan("[litestar-sveltekit]"), colors.dim("Schema changed:"), colors.yellow(relativePath));
+        debouncedRunTypeGeneration();
+      }
+    }
+  };
+}
+var sveltekit_default = litestarSvelteKit;
+export {
+  sveltekit_default as default,
+  litestarSvelteKit
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litestar-vite-plugin",
-  "version": "0.14.0",
+  "version": "0.15.0-alpha.1",
   "type": "module",
   "description": "Litestar plugin for Vite.",
   "keywords": ["litestar", "vite", "vite-plugin"],
@@ -16,9 +16,27 @@
       "types": "./dist/js/index.d.ts",
       "default": "./dist/js/index.js"
     },
+    "./helpers": {
+      "types": "./dist/js/helpers/index.d.ts",
+      "default": "./dist/js/helpers/index.js"
+    },
+    "./install-hint": "./dist/js/install-hint.js",
+    "./litestar-meta": "./dist/js/litestar-meta.js",
     "./inertia-helpers": {
       "types": "./dist/js/inertia-helpers/index.d.ts",
       "default": "./dist/js/inertia-helpers/index.js"
+    },
+    "./astro": {
+      "types": "./dist/js/astro.d.ts",
+      "default": "./dist/js/astro.js"
+    },
+    "./sveltekit": {
+      "types": "./dist/js/sveltekit.d.ts",
+      "default": "./dist/js/sveltekit.js"
+    },
+    "./nuxt": {
+      "types": "./dist/js/nuxt.d.ts",
+      "default": "./dist/js/nuxt.js"
     }
   },
   "types": "./dist/js/index.d.ts",
@@ -27,11 +45,13 @@
     "clean-orphaned-assets": "tools/clean.js"
   },
   "scripts": {
-    "build": "npm run build-plugin && npm run build-inertia-helpers",
+    "build": "npm run build-plugin && npm run build-helpers && npm run build-inertia-helpers && npm run build-integrations",
     "build-plugin": "rm -rf dist/js && npm run build-plugin-types && npm run build-plugin-esm && cp src/js/src/dev-server-index.html dist/js/",
     "build-plugin-types": "tsc --project src/js/tsconfig.json --emitDeclarationOnly",
-    "build-plugin-esm": "esbuild src/js/src/index.ts --platform=node --format=esm --outfile=dist/js/index.js",
-    "build-inertia-helpers": "rm -rf dist/inertia-helpers && tsc --project src/js/tsconfig.inertia-helpers.json",
+    "build-plugin-esm": "esbuild src/js/src/index.ts --platform=node --format=esm --outfile=dist/js/index.js && esbuild src/js/src/install-hint.ts --platform=node --format=esm --outfile=dist/js/install-hint.js && esbuild src/js/src/litestar-meta.ts --platform=node --format=esm --outfile=dist/js/litestar-meta.js",
+    "build-helpers": "rm -rf dist/js/helpers && tsc --project src/js/tsconfig.helpers.json",
+    "build-inertia-helpers": "rm -rf dist/js/inertia-helpers && tsc --project src/js/tsconfig.inertia-helpers.json",
+    "build-integrations": "esbuild src/js/src/astro.ts src/js/src/sveltekit.ts src/js/src/nuxt.ts --platform=node --format=esm --outdir=dist/js",
     "lint": "eslint --ext .ts ./src/js/src ./src/js/tests",
     "test": "vitest --config ./src/js/vitest.config.ts run"
   },
@@ -39,7 +59,7 @@
     "@biomejs/biome": "1.9.4",
     "@types/node": "^22.15.3",
     "esbuild": "0.25.3",
-    "happy-dom": "^17.4.6",
+    "happy-dom": "^20.0.2",
     "typescript": "^5.8.3",
     "vite": "^7.1.2",
     "vitest": "^3.1.2"

package/dist/js/inertia-helpers/index.d.ts

@@ -1,20 +0,0 @@
-export declare function resolvePageComponent<T>(path: string | string[], pages: Record<string, Promise<T> | (() => Promise<T>)>): Promise<T>;
-type RouteArg = string | number | boolean;
-type RouteArgs = Record<string, RouteArg> | RouteArg[];
-export declare function route(routeName: string, ...args: [RouteArgs?]): string;
-export declare function getRelativeUrlPath(url: string): string;
-export declare function toRoute(url: string): string | null;
-export declare function currentRoute(): string | null;
-export declare function isRoute(url: string, routeName: string): boolean;
-export declare function isCurrentRoute(routeName: string): boolean;
-declare global {
-    var routes: {
-        [key: string]: string;
-    };
-    function route(routeName: string, ...args: [RouteArgs?]): string;
-    function toRoute(url: string): string | null;
-    function currentRoute(): string | null;
-    function isRoute(url: string, routeName: string): boolean;
-    function isCurrentRoute(routeName: string): boolean;
-}
-export {};

package/dist/js/inertia-helpers/index.js

@@ -1,138 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export async function resolvePageComponent(path, pages) {
-    for (const p of Array.isArray(path) ? path : [path]) {
-        const page = pages[p];
-        if (typeof page === "undefined") {
-            continue;
-        }
-        return typeof page === "function" ? page() : page;
-    }
-    throw new Error(`Page not found: ${path}`);
-}
-export function route(routeName, ...args) {
-    let url = globalThis.routes[routeName];
-    if (!url) {
-        console.error(`URL '${routeName}' not found in routes.`);
-        return "#"; // Return "#" to indicate failure
-    }
-    const argTokens = url.match(/\{([^}]+):([^}]+)\}/g);
-    if (!argTokens && args.length > 0) {
-        console.error(`Invalid URL lookup: URL '${routeName}' does not expect arguments.`);
-        return "#";
-    }
-    try {
-        if (typeof args[0] === "object" && !Array.isArray(args[0])) {
-            for (const token of argTokens ?? []) {
-                let argName = token.slice(1, -1);
-                if (argName.includes(":")) {
-                    argName = argName.split(":")[0];
-                }
-                const argValue = args[0][argName];
-                if (argValue === undefined) {
-                    throw new Error(`Invalid URL lookup: Argument '${argName}' was not provided.`);
-                }
-                url = url.replace(token, String(argValue));
-            }
-        }
-        else {
-            const argsArray = Array.isArray(args[0]) ? args[0] : Array.from(args);
-            if (argTokens && argTokens.length !== argsArray.length) {
-                throw new Error(`Invalid URL lookup: Wrong number of arguments; expected ${argTokens.length.toString()} arguments.`);
-            }
-            argTokens?.forEach((token, i) => {
-                const argValue = argsArray[i];
-                if (argValue === undefined) {
-                    throw new Error(`Missing argument at position ${i}`);
-                }
-                url = url.replace(token, argValue.toString());
-            });
-        }
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        return "#";
-    }
-    const fullUrl = new URL(url, window.location.origin);
-    return fullUrl.href;
-}
-export function getRelativeUrlPath(url) {
-    try {
-        const urlObject = new URL(url);
-        return urlObject.pathname + urlObject.search + urlObject.hash;
-    }
-    catch (e) {
-        // If the URL is invalid or already a relative path, just return it as is
-        return url;
-    }
-}
-function routePatternToRegex(pattern) {
-    return new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
-}
-export function toRoute(url) {
-    const processedUrl = getRelativeUrlPath(url);
-    const normalizedUrl = processedUrl === "/" ? processedUrl : processedUrl.replace(/\/$/, "");
-    for (const [routeName, routePattern] of Object.entries(routes)) {
-        const regexPattern = routePattern.replace(/\//g, "\\/").replace(/\{([^}]+):([^}]+)\}/g, (_, __, paramType) => {
-            switch (paramType) {
-                case "uuid":
-                    return "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-                case "path":
-                    return ".*"; // Matches any characters including forward slashes
-                default:
-                    return "[^/]+"; // Matches any characters except forward slashes
-            }
-        });
-        const regex = new RegExp(`^${regexPattern}$`);
-        if (regex.test(normalizedUrl)) {
-            return routeName;
-        }
-    }
-    return null;
-}
-export function currentRoute() {
-    const currentUrl = window.location.pathname;
-    return toRoute(currentUrl);
-}
-export function isRoute(url, routeName) {
-    const processedUrl = getRelativeUrlPath(url);
-    const normalizedUrl = processedUrl === "/" ? processedUrl : processedUrl.replace(/\/$/, "");
-    const routeNameRegex = routePatternToRegex(routeName);
-    // Find all matching route names based on the pattern
-    const matchingRouteNames = Object.keys(routes).filter((name) => routeNameRegex.test(name));
-    // For each matching route name, check if the URL matches its pattern
-    for (const name of matchingRouteNames) {
-        const routePattern = routes[name];
-        const regexPattern = routePattern.replace(/\//g, "\\/").replace(/\{([^}]+):([^}]+)\}/g, (match, paramName, paramType) => {
-            switch (paramType) {
-                case "str":
-                    return "([^/]+)";
-                case "path":
-                    return "(.*)";
-                case "uuid":
-                    return "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-                default:
-                    return "([^/]+)";
-            }
-        });
-        const regex = new RegExp(`^${regexPattern}$`);
-        if (regex.test(normalizedUrl)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function isCurrentRoute(routeName) {
-    const currentRouteName = currentRoute();
-    if (!currentRouteName) {
-        console.error("Could not match current window location to a named route.");
-        return false;
-    }
-    const routeNameRegex = routePatternToRegex(routeName);
-    return routeNameRegex.test(currentRouteName);
-}
-globalThis.routes = globalThis.routes || {};
-globalThis.route = route;
-globalThis.toRoute = toRoute;
-globalThis.currentRoute = currentRoute;
-globalThis.isRoute = isRoute;
-globalThis.isCurrentRoute = isCurrentRoute;