litestar-vite-plugin 0.24.1 → 0.26.0

package/dist/js/shared/typegen-core.js

@@ -1,19 +1,23 @@
-import { exec } from "node:child_process";
+import { execFile } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { promisify } from "node:util";
-import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
+import { resolveInstallHint, resolvePackageExecutorArgv } from "../install-hint.js";
+import { HEY_API_PINNED_SPEC } from "./constants.js";
 import { emitPagePropsTypes } from "./emit-page-props-types.js";
 import { emitSchemasTypes } from "./emit-schemas-types.js";
-const execAsync = promisify(exec);
+import { emitStaticPropsTypes } from "./emit-static-props-types.js";
+const execFileAsync = promisify(execFile);
 const nodeRequire = createRequire(import.meta.url);
 function resolveDefaultSdkClientPlugin(options) {
   void options;
   return "@hey-api/client-fetch";
 }
 function findOpenApiTsConfig(projectRoot) {
-  const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
+  const bases = ["openapi-ts.config", "hey-api.config", ".hey-api.config"];
+  const extensions = [".ts", ".mjs", ".cjs", ".js"];
+  const candidates = bases.flatMap((base) => extensions.map((extension) => path.resolve(projectRoot, `${base}${extension}`)));
   return candidates.find((p) => fs.existsSync(p)) || null;
 }
 function buildHeyApiPlugins(config) {
@@ -26,22 +30,28 @@ function buildHeyApiPlugins(config) {
   }
   return plugins;
 }
+function resolveHeyApiBin(projectRoot) {
+  try {
+    const packageJsonPath = nodeRequire.resolve("@hey-api/openapi-ts/package.json", { paths: [projectRoot] });
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const bin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.["openapi-ts"];
+    if (!bin) {
+      return null;
+    }
+    return { binPath: path.resolve(path.dirname(packageJsonPath), bin) };
+  } catch {
+    return null;
+  }
+}
 async function runHeyApiGeneration(config, configPath, plugins, logger) {
   const { projectRoot, openapiPath, output, executor, generateZod } = config;
   const sdkOutput = path.join(output, "api");
-  if (process.env.VITEST || process.env.VITE_TEST || process.env.NODE_ENV === "test" || process.env.CI) {
-    try {
-      nodeRequire.resolve("@hey-api/openapi-ts/package.json", { paths: [projectRoot] });
-    } catch {
-      throw new Error("@hey-api/openapi-ts not installed");
-    }
-  }
   let args;
   if (configPath) {
-    args = ["@hey-api/openapi-ts", "--file", configPath];
+    args = ["--file", configPath];
   } else {
     const relativeOpenapiPath = path.relative(projectRoot, path.resolve(projectRoot, openapiPath));
-    args = ["@hey-api/openapi-ts", "-i", relativeOpenapiPath, "-o", sdkOutput];
+    args = ["-i", relativeOpenapiPath, "-o", sdkOutput];
     if (plugins.length) {
       args.push("--plugins", ...plugins);
     }
@@ -53,12 +63,23 @@ async function runHeyApiGeneration(config, configPath, plugins, logger) {
       logger?.warn(`zod not installed - run: ${resolveInstallHint("zod")}`);
     }
   }
-  const cmd = resolvePackageExecutor(args.join(" "), executor);
-  await execAsync(cmd, { cwd: projectRoot });
+  const local = resolveHeyApiBin(projectRoot);
+  if (local) {
+    await execFileAsync(process.execPath, [local.binPath, ...args], { cwd: projectRoot });
+    return sdkOutput;
+  }
+  const fallback = resolvePackageExecutorArgv(args, executor, {
+    packageSpec: HEY_API_PINNED_SPEC,
+    binName: "openapi-ts"
+  });
+  if (!fallback.length) {
+    throw new Error("@hey-api/openapi-ts not installed");
+  }
+  await execFileAsync(fallback[0], fallback.slice(1), { cwd: projectRoot });
   return sdkOutput;
 }
 async function runTypeGeneration(config, options = {}) {
-  const { logger } = options;
+  const { cache, logger } = options;
   const startTime = Date.now();
   const result = {
     generated: false,
@@ -76,40 +97,60 @@ async function runTypeGeneration(config, options = {}) {
     const shouldGenerateSdk = configPath || generateSdk;
     if (fs.existsSync(absoluteOpenapiPath) && shouldGenerateSdk) {
       const plugins = buildHeyApiPlugins(config);
-      logger?.info("Generating TypeScript types...");
-      if (configPath) {
-        const relConfigPath = path.relative(projectRoot, configPath);
-        logger?.info(`openapi-ts config: ${relConfigPath}`);
-      }
-      try {
-        const outputPath = await runHeyApiGeneration(config, configPath, plugins, logger);
-        result.generatedFiles.push(outputPath);
-        result.generated = true;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const isPackageNotInstalled = message.includes("not installed");
-        const isRuntimeEnoent = !isPackageNotInstalled && (message.includes("ENOENT") || error instanceof Error && "code" in error && error.code === "ENOENT");
-        if (isPackageNotInstalled) {
-          const zodHint = config.generateZod ? " zod" : "";
-          const warning = `@hey-api/openapi-ts not installed - run: ${resolveInstallHint(`@hey-api/openapi-ts${zodHint}`)}`;
-          result.warnings.push(warning);
-          logger?.warn(warning);
-        } else if (isRuntimeEnoent) {
-          result.errors.push(`File not found during type generation: ${message}`);
-          logger?.error(`Type generation failed (file not found): ${message}`);
-        } else {
-          result.errors.push(message);
-          logger?.error(`Type generation failed: ${message}`);
+      const sdkOutput = path.join(output, "api");
+      const cacheOptions = {
+        generateSdk: config.generateSdk,
+        generateZod: config.generateZod,
+        plugins,
+        outputPaths: [path.join(projectRoot, sdkOutput, "types.gen.ts")]
+      };
+      const shouldRun = cache ? await cache.shouldRunOpenApiTs(absoluteOpenapiPath, configPath, cacheOptions) : true;
+      if (shouldRun) {
+        logger?.info("Generating TypeScript types...");
+        if (configPath) {
+          const relConfigPath = path.relative(projectRoot, configPath);
+          logger?.info(`openapi-ts config: ${relConfigPath}`);
         }
+        try {
+          const outputPath = await runHeyApiGeneration(config, configPath, plugins, logger);
+          await cache?.updateOpenApiTsCache(absoluteOpenapiPath, configPath, cacheOptions);
+          result.generatedFiles.push(outputPath);
+          result.generated = true;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const isPackageNotInstalled = message.includes("not installed");
+          const isRuntimeEnoent = !isPackageNotInstalled && (message.includes("ENOENT") || error instanceof Error && "code" in error && error.code === "ENOENT");
+          if (isPackageNotInstalled) {
+            const zodHint = config.generateZod ? " zod" : "";
+            const errorMessage = `@hey-api/openapi-ts not installed - run: ${resolveInstallHint(`@hey-api/openapi-ts${zodHint}`)}`;
+            result.errors.push(errorMessage);
+            logger?.error(errorMessage);
+          } else if (isRuntimeEnoent) {
+            result.errors.push(`File not found during type generation: ${message}`);
+            logger?.error(`Type generation failed (file not found): ${message}`);
+          } else {
+            result.errors.push(message);
+            logger?.error(`Type generation failed: ${message}`);
+          }
+        }
+      } else {
+        result.skippedFiles.push(sdkOutput);
       }
     }
     if (generatePageProps && fs.existsSync(absolutePagePropsPath)) {
       try {
-        const changed = await emitPagePropsTypes(absolutePagePropsPath, output);
         const pagePropsOutput = path.join(output, "page-props.ts");
-        if (changed) {
-          result.generatedFiles.push(pagePropsOutput);
-          result.generated = true;
+        const absolutePagePropsOutput = path.resolve(projectRoot, pagePropsOutput);
+        const shouldRun = cache ? await cache.shouldRegeneratePageProps(absolutePagePropsPath, absolutePagePropsOutput) : true;
+        if (shouldRun) {
+          const changed = await emitPagePropsTypes(absolutePagePropsPath, output, projectRoot);
+          await cache?.updatePagePropsCache(absolutePagePropsPath);
+          if (changed) {
+            result.generatedFiles.push(pagePropsOutput);
+            result.generated = true;
+          } else {
+            result.skippedFiles.push(pagePropsOutput);
+          }
         } else {
           result.skippedFiles.push(pagePropsOutput);
         }
@@ -124,7 +165,7 @@ async function runTypeGeneration(config, options = {}) {
       const absoluteRoutesPath = path.resolve(projectRoot, routesPath);
       if (fs.existsSync(absoluteRoutesPath)) {
         try {
-          const changed = await emitSchemasTypes(absoluteRoutesPath, output, schemasTsPath);
+          const changed = await emitSchemasTypes(absoluteRoutesPath, output, schemasTsPath, projectRoot);
           const schemasOutput = schemasTsPath ?? path.join(output, "schemas.ts");
           if (changed) {
             result.generatedFiles.push(schemasOutput);
@@ -139,6 +180,20 @@ async function runTypeGeneration(config, options = {}) {
         }
       }
     }
+    try {
+      const changed = await emitStaticPropsTypes(output, projectRoot);
+      const staticPropsOutput = path.join(output, "static-props.ts");
+      if (changed) {
+        result.generatedFiles.push(staticPropsOutput);
+        result.generated = true;
+      } else {
+        result.skippedFiles.push(staticPropsOutput);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(`Static props generation failed: ${message}`);
+      logger?.error(`Static props generation failed: ${message}`);
+    }
   } finally {
     result.durationMs = Date.now() - startTime;
   }
@@ -148,6 +203,7 @@ export {
   buildHeyApiPlugins,
   findOpenApiTsConfig,
   resolveDefaultSdkClientPlugin,
+  resolveHeyApiBin,
   runHeyApiGeneration,
   runTypeGeneration
 };

package/dist/js/shared/typegen-plugin.d.ts

@@ -1,4 +1,5 @@
 import type { Plugin } from "vite";
+import type { BridgeTypesConfig } from "./bridge-schema.js";
 export interface RequiredTypeGenConfig {
     enabled: boolean;
     output: string;
@@ -12,6 +13,7 @@ export interface RequiredTypeGenConfig {
     generatePageProps: boolean;
     generateSchemas: boolean;
     globalRoute: boolean;
+    failOnError?: boolean;
     debounce: number;
 }
 export interface TypeGenPluginOptions {
@@ -26,6 +28,30 @@ export interface TypeGenPluginOptions {
     /** Whether .litestar.json was present (used for buildStart warnings) */
     hasPythonConfig?: boolean;
 }
+export interface TypesConfigShape {
+    enabled?: boolean;
+    output?: string;
+    openapiPath?: string;
+    routesPath?: string;
+    pagePropsPath?: string;
+    schemasTsPath?: string;
+    generateZod?: boolean;
+    generateSdk?: boolean;
+    generateRoutes?: boolean;
+    generatePageProps?: boolean;
+    generateSchemas?: boolean;
+    globalRoute?: boolean;
+    failOnError?: boolean;
+    debounce?: number;
+}
+export interface ResolveTypesConfigOptions {
+    requested: boolean | "auto" | TypesConfigShape | undefined;
+    pythonConfig?: BridgeTypesConfig;
+    defaultOutput: string;
+    mergePythonWhenTrue?: boolean;
+    mergePythonForObject?: boolean;
+}
+export declare function resolveTypesConfig(options: ResolveTypesConfigOptions): RequiredTypeGenConfig | false;
 /**
  * Unified Litestar type generation Vite plugin.
  *

package/dist/js/shared/typegen-plugin.js

@@ -1,13 +1,97 @@
 import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
+import { DEBOUNCE_MS } from "./constants.js";
 import { debounce } from "./debounce.js";
-import { emitPagePropsTypes } from "./emit-page-props-types.js";
-import { emitSchemasTypes } from "./emit-schemas-types.js";
-import { emitStaticPropsTypes } from "./emit-static-props-types.js";
-import { formatPath } from "./format-path.js";
 import { shouldRegeneratePageProps, shouldRunOpenApiTs, updateOpenApiTsCache, updatePagePropsCache } from "./typegen-cache.js";
-import { buildHeyApiPlugins, findOpenApiTsConfig, runHeyApiGeneration } from "./typegen-core.js";
+import { runTypeGeneration } from "./typegen-core.js";
+function buildTypeDefaults(output) {
+  return {
+    openapiPath: path.join(output, "openapi.json"),
+    routesPath: path.join(output, "routes.json"),
+    pagePropsPath: path.join(output, "inertia-pages.json"),
+    schemasTsPath: path.join(output, "schemas.ts")
+  };
+}
+function resolveFromPython(pythonConfig, defaultOutput) {
+  const output = pythonConfig.output ?? defaultOutput;
+  const defaults = buildTypeDefaults(output);
+  return {
+    enabled: true,
+    output,
+    openapiPath: pythonConfig.openapiPath ?? defaults.openapiPath,
+    routesPath: pythonConfig.routesPath ?? defaults.routesPath,
+    pagePropsPath: pythonConfig.pagePropsPath ?? defaults.pagePropsPath,
+    schemasTsPath: pythonConfig.schemasTsPath ?? defaults.schemasTsPath,
+    generateZod: pythonConfig.generateZod ?? false,
+    generateSdk: pythonConfig.generateSdk ?? true,
+    generateRoutes: pythonConfig.generateRoutes ?? true,
+    generatePageProps: pythonConfig.generatePageProps ?? true,
+    generateSchemas: pythonConfig.generateSchemas ?? true,
+    globalRoute: pythonConfig.globalRoute ?? false,
+    failOnError: pythonConfig.failOnError,
+    debounce: DEBOUNCE_MS
+  };
+}
+function resolveDefaultTypesConfig(defaultOutput) {
+  const defaults = buildTypeDefaults(defaultOutput);
+  return {
+    enabled: true,
+    output: defaultOutput,
+    openapiPath: defaults.openapiPath,
+    routesPath: defaults.routesPath,
+    pagePropsPath: defaults.pagePropsPath,
+    schemasTsPath: defaults.schemasTsPath,
+    generateZod: false,
+    generateSdk: true,
+    generateRoutes: true,
+    generatePageProps: true,
+    generateSchemas: true,
+    globalRoute: false,
+    failOnError: void 0,
+    debounce: DEBOUNCE_MS
+  };
+}
+function resolveTypesConfig(options) {
+  const { requested, pythonConfig, defaultOutput, mergePythonWhenTrue = false, mergePythonForObject = false } = options;
+  if (requested === false) {
+    return false;
+  }
+  if (requested === true) {
+    if (mergePythonWhenTrue && pythonConfig) {
+      return resolveFromPython(pythonConfig, defaultOutput);
+    }
+    return resolveDefaultTypesConfig(defaultOutput);
+  }
+  if (requested === "auto" || typeof requested === "undefined") {
+    return pythonConfig?.enabled ? resolveFromPython(pythonConfig, defaultOutput) : false;
+  }
+  const userProvidedOutput = Object.hasOwn(requested, "output");
+  const output = requested.output ?? (mergePythonForObject ? pythonConfig?.output : void 0) ?? defaultOutput;
+  const defaults = buildTypeDefaults(output);
+  const pathFallback = (key) => {
+    if (!mergePythonForObject || userProvidedOutput) {
+      return defaults[key];
+    }
+    return pythonConfig?.[key] ?? defaults[key];
+  };
+  return {
+    enabled: requested.enabled ?? true,
+    output,
+    openapiPath: requested.openapiPath ?? pathFallback("openapiPath"),
+    routesPath: requested.routesPath ?? pathFallback("routesPath"),
+    pagePropsPath: requested.pagePropsPath ?? pathFallback("pagePropsPath"),
+    schemasTsPath: requested.schemasTsPath ?? pathFallback("schemasTsPath"),
+    generateZod: requested.generateZod ?? (mergePythonForObject ? pythonConfig?.generateZod : void 0) ?? false,
+    generateSdk: requested.generateSdk ?? (mergePythonForObject ? pythonConfig?.generateSdk : void 0) ?? true,
+    generateRoutes: requested.generateRoutes ?? (mergePythonForObject ? pythonConfig?.generateRoutes : void 0) ?? true,
+    generatePageProps: requested.generatePageProps ?? (mergePythonForObject ? pythonConfig?.generatePageProps : void 0) ?? true,
+    generateSchemas: requested.generateSchemas ?? (mergePythonForObject ? pythonConfig?.generateSchemas : void 0) ?? true,
+    globalRoute: requested.globalRoute ?? (mergePythonForObject ? pythonConfig?.globalRoute : void 0) ?? false,
+    failOnError: requested.failOnError ?? pythonConfig?.failOnError,
+    debounce: requested.debounce ?? DEBOUNCE_MS
+  };
+}
 async function getFileMtime(filePath) {
   const stat = await fs.promises.stat(filePath);
   return stat.mtimeMs.toString();
@@ -16,8 +100,10 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
   const { pluginName, frameworkName, sdkClientPlugin, executor, hasPythonConfig } = options;
   let lastTypesHash = null;
   let lastPagePropsHash = null;
+  let lastRoutesHash = null;
   let server = null;
-  let isGenerating = false;
+  let generationPromise = null;
+  let rerunRequested = false;
   let resolvedConfig = null;
   function createViteLogger() {
     return {
@@ -27,37 +113,31 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
     };
   }
   async function runTypeGenerationWithCache() {
-    if (isGenerating) {
-      return false;
+    if (generationPromise) {
+      rerunRequested = true;
+      return generationPromise;
     }
-    isGenerating = true;
-    const startTime = Date.now();
-    try {
+    generationPromise = (async () => {
+      const combined = {
+        generated: false,
+        generatedFiles: [],
+        skippedFiles: [],
+        durationMs: 0,
+        warnings: [],
+        errors: []
+      };
       const projectRoot = resolvedConfig?.root ?? process.cwd();
-      const absoluteOpenapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
-      const absolutePagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
-      let generated = false;
       const logger = createViteLogger();
-      const configPath = findOpenApiTsConfig(projectRoot);
-      const shouldGenerateSdk = configPath || typesConfig.generateSdk;
-      if (fs.existsSync(absoluteOpenapiPath) && shouldGenerateSdk) {
-        const plugins = buildHeyApiPlugins({
-          generateSdk: typesConfig.generateSdk,
-          generateZod: typesConfig.generateZod,
-          sdkClientPlugin
-        });
-        const cacheOptions = {
-          generateSdk: typesConfig.generateSdk,
-          generateZod: typesConfig.generateZod,
-          plugins
-        };
-        const shouldRun = await shouldRunOpenApiTs(absoluteOpenapiPath, configPath, cacheOptions);
-        if (shouldRun) {
-          logger.info("Generating TypeScript types...");
-          if (configPath && resolvedConfig) {
-            const relConfigPath = formatPath(configPath, resolvedConfig.root);
-            logger.info(`openapi-ts config: ${colors.yellow(relConfigPath)}`);
-          }
+      const cache = {
+        shouldRunOpenApiTs,
+        updateOpenApiTsCache,
+        shouldRegeneratePageProps,
+        updatePagePropsCache
+      };
+      try {
+        do {
+          rerunRequested = false;
+          const startTime = Date.now();
           const coreConfig = {
             projectRoot,
             openapiPath: typesConfig.openapiPath,
@@ -66,96 +146,76 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
             pagePropsPath: typesConfig.pagePropsPath,
             generateSdk: typesConfig.generateSdk,
             generateZod: typesConfig.generateZod,
-            generatePageProps: false,
-            // Handle separately below
+            generatePageProps: typesConfig.generatePageProps,
             generateSchemas: typesConfig.generateSchemas,
+            schemasTsPath: typesConfig.schemasTsPath,
             sdkClientPlugin,
             executor
           };
-          try {
-            await runHeyApiGeneration(coreConfig, configPath, plugins, logger);
-            await updateOpenApiTsCache(absoluteOpenapiPath, configPath, cacheOptions);
-            generated = true;
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (message.includes("not found") || message.includes("ENOENT")) {
-              logger.warn("@hey-api/openapi-ts not installed");
-            } else {
-              logger.error(`Type generation failed: ${message}`);
-            }
+          const result = await runTypeGeneration(coreConfig, { logger, cache });
+          combined.generated ||= result.generated;
+          combined.generatedFiles.push(...result.generatedFiles);
+          combined.skippedFiles.push(...result.skippedFiles);
+          combined.warnings.push(...result.warnings);
+          combined.errors.push(...result.errors);
+          combined.durationMs += result.durationMs || Date.now() - startTime;
+          for (const file of result.skippedFiles) {
+            const label = file.endsWith("page-props.ts") ? "Page props types" : file.endsWith("schemas.ts") ? "Schema types" : file.includes("api") ? "TypeScript types" : file;
+            resolvedConfig?.logger.info(`${colors.cyan("\u2022")} ${label} ${colors.dim("(unchanged)")}`);
           }
-        } else {
-          resolvedConfig?.logger.info(`${colors.cyan("\u2022")} TypeScript types ${colors.dim("(unchanged)")}`);
+        } while (rerunRequested);
+        if (combined.generated && resolvedConfig) {
+          resolvedConfig.logger.info(`${colors.green("\u2713")} TypeScript artifacts updated ${colors.dim(`(${combined.durationMs}ms)`)}`);
         }
-      }
-      if (typesConfig.generatePageProps && fs.existsSync(absolutePagePropsPath)) {
-        try {
-          const shouldRun = await shouldRegeneratePageProps(absolutePagePropsPath);
-          if (shouldRun) {
-            const changed = await emitPagePropsTypes(absolutePagePropsPath, typesConfig.output);
-            await updatePagePropsCache(absolutePagePropsPath);
-            if (changed) {
-              generated = true;
-            } else {
-              resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Page props types ${colors.dim("(unchanged)")}`);
+        if (combined.generated && server) {
+          server.ws.send({
+            type: "custom",
+            event: "litestar:types-updated",
+            data: {
+              output: typesConfig.output,
+              timestamp: Date.now()
             }
-          } else {
-            resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Page props types ${colors.dim("(unchanged)")}`);
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          logger.error(`Page props generation failed: ${message}`);
-        }
-      }
-      const absoluteRoutesPath = path.resolve(projectRoot, typesConfig.routesPath);
-      if (typesConfig.generateSchemas && fs.existsSync(absoluteRoutesPath)) {
-        try {
-          const changed = await emitSchemasTypes(absoluteRoutesPath, typesConfig.output, typesConfig.schemasTsPath);
-          if (changed) {
-            generated = true;
-          } else {
-            resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Schema types ${colors.dim("(unchanged)")}`);
-          }
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          logger.error(`Schema types generation failed: ${message}`);
-        }
-      }
-      try {
-        const changed = await emitStaticPropsTypes(typesConfig.output);
-        if (changed) {
-          generated = true;
-        } else {
-          resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Static props types ${colors.dim("(unchanged)")}`);
+          });
         }
+        return combined;
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Static props generation failed: ${message}`);
-      }
-      if (generated && resolvedConfig) {
-        const duration = Date.now() - startTime;
-        resolvedConfig.logger.info(`${colors.green("\u2713")} TypeScript artifacts updated ${colors.dim(`(${duration}ms)`)}`);
+        resolvedConfig?.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
+        combined.errors.push(message);
+        return combined;
+      } finally {
+        generationPromise = null;
       }
-      if (generated && 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);
-      resolvedConfig?.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
-      return false;
-    } finally {
-      isGenerating = false;
+    })();
+    return generationPromise;
+  }
+  const debouncedRunTypeGeneration = debounce(async (file, cacheKey) => {
+    const newHash = await getFileMtime(file);
+    if (cacheKey === "openapi" && lastTypesHash === newHash) return;
+    if (cacheKey === "pageProps" && lastPagePropsHash === newHash) return;
+    if (cacheKey === "routes" && lastRoutesHash === newHash) return;
+    const result = await runTypeGenerationWithCache();
+    if (result.errors.length === 0) {
+      if (cacheKey === "openapi") lastTypesHash = newHash;
+      if (cacheKey === "pageProps") lastPagePropsHash = newHash;
+      if (cacheKey === "routes") lastRoutesHash = newHash;
+    }
+  }, typesConfig.debounce);
+  function shouldFailOnTypegenError() {
+    return typesConfig.failOnError ?? resolvedConfig?.command === "build";
+  }
+  function reportTypegenErrors(result, context) {
+    if (!result.errors.length) {
+      return;
+    }
+    const message = `Litestar type generation failed:
+${result.errors.join("\n")}`;
+    if (shouldFailOnTypegenError()) {
+      context.error(message);
+    } else {
+      context.warn(message);
     }
   }
-  const debouncedRunTypeGeneration = debounce(runTypeGenerationWithCache, typesConfig.debounce);
   return {
     name: pluginName,
     enforce: "pre",
@@ -170,6 +230,9 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
       }
     },
     async buildStart() {
+      if (resolvedConfig?.command === "build" && process.env.LITESTAR_VITE_SKIP_BUILD_TYPEGEN === "1") {
+        return;
+      }
       if (typesConfig.enabled && hasPythonConfig === false) {
         const projectRoot = resolvedConfig?.root ?? process.cwd();
         const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
@@ -190,10 +253,13 @@ Solutions:
         const projectRoot = resolvedConfig?.root ?? process.cwd();
         const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
         const pagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
+        const routesPath = path.resolve(projectRoot, typesConfig.routesPath);
         const hasOpenapi = fs.existsSync(openapiPath);
         const hasPageProps = typesConfig.generatePageProps && fs.existsSync(pagePropsPath);
-        if (hasOpenapi || hasPageProps) {
-          await runTypeGenerationWithCache();
+        const hasRoutes = typesConfig.generateSchemas && fs.existsSync(routesPath);
+        if (hasOpenapi || hasPageProps || hasRoutes) {
+          const result = await runTypeGenerationWithCache();
+          reportTypegenErrors(result, this);
         }
       }
     },
@@ -202,26 +268,22 @@ Solutions:
         return;
       }
       const root = resolvedConfig?.root ?? process.cwd();
-      const relativePath = path.relative(root, file);
-      const openapiPath = typesConfig.openapiPath.replace(/^\.\//, "");
-      const pagePropsPath = typesConfig.pagePropsPath.replace(/^\.\//, "");
-      const isOpenapi = relativePath === openapiPath || file.endsWith(openapiPath);
-      const isPageProps = typesConfig.generatePageProps && (relativePath === pagePropsPath || file.endsWith(pagePropsPath));
-      if (isOpenapi || isPageProps) {
+      const absoluteFile = path.resolve(file);
+      const relativePath = path.relative(root, absoluteFile);
+      const openapiPath = path.resolve(root, typesConfig.openapiPath);
+      const pagePropsPath = path.resolve(root, typesConfig.pagePropsPath);
+      const routesPath = path.resolve(root, typesConfig.routesPath);
+      const isOpenapi = absoluteFile === openapiPath;
+      const isPageProps = typesConfig.generatePageProps && absoluteFile === pagePropsPath;
+      const isRoutes = typesConfig.generateSchemas && absoluteFile === routesPath;
+      if (isOpenapi || isPageProps || isRoutes) {
         resolvedConfig?.logger.info(`${colors.cyan(frameworkName)} ${colors.dim("schema changed:")} ${colors.yellow(relativePath)}`);
-        const newHash = await getFileMtime(file);
-        if (isOpenapi) {
-          if (lastTypesHash === newHash) return;
-          lastTypesHash = newHash;
-        } else if (isPageProps) {
-          if (lastPagePropsHash === newHash) return;
-          lastPagePropsHash = newHash;
-        }
-        debouncedRunTypeGeneration();
+        debouncedRunTypeGeneration(absoluteFile, isOpenapi ? "openapi" : isPageProps ? "pageProps" : "routes");
       }
     }
   };
 }
 export {
-  createLitestarTypeGenPlugin
+  createLitestarTypeGenPlugin,
+  resolveTypesConfig
 };