litestar-vite-plugin 0.25.0 → 0.26.1

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

@@ -1,3 +1,9 @@
+interface OpenApiTsCacheOptions {
+    generateSdk: boolean;
+    generateZod: boolean;
+    plugins: string[];
+    outputPaths?: string[];
+}
 /**
  * Check if openapi-ts should run based on input cache.
  *
@@ -6,11 +12,7 @@
  * @param options - Generator options
  * @returns true if generation should run, false if cached
  */
-export declare function shouldRunOpenApiTs(openapiPath: string, configPath: string | null, options: {
-    generateSdk: boolean;
-    generateZod: boolean;
-    plugins: string[];
-}): Promise<boolean>;
+export declare function shouldRunOpenApiTs(openapiPath: string, configPath: string | null, options: OpenApiTsCacheOptions): Promise<boolean>;
 /**
  * Update cache after successful openapi-ts run.
  *
@@ -18,11 +20,7 @@ export declare function shouldRunOpenApiTs(openapiPath: string, configPath: stri
  * @param configPath - Path to config file (or null)
  * @param options - Generator options
  */
-export declare function updateOpenApiTsCache(openapiPath: string, configPath: string | null, options: {
-    generateSdk: boolean;
-    generateZod: boolean;
-    plugins: string[];
-}): Promise<void>;
+export declare function updateOpenApiTsCache(openapiPath: string, configPath: string | null, options: OpenApiTsCacheOptions): Promise<void>;
 /**
  * Compute input hash for page props generation.
  *
@@ -36,10 +34,11 @@ export declare function computePagePropsHash(pagePropsPath: string): Promise<str
  * @param pagePropsPath - Path to inertia-pages.json
  * @returns true if generation should run, false if cached
  */
-export declare function shouldRegeneratePageProps(pagePropsPath: string): Promise<boolean>;
+export declare function shouldRegeneratePageProps(pagePropsPath: string, outputPath?: string): Promise<boolean>;
 /**
  * Update cache after successful page props generation.
  *
  * @param pagePropsPath - Path to inertia-pages.json
  */
 export declare function updatePagePropsCache(pagePropsPath: string): Promise<void>;
+export {};

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

@@ -45,11 +45,17 @@ function isOptionalMetadataMatch(a, b) {
   }
   return isMetadataMatch(a, b);
 }
+function areExpectedOutputsPresent(outputPaths) {
+  return !outputPaths?.some((outputPath) => !fs.existsSync(outputPath));
+}
 function hashObject(obj) {
   const sorted = JSON.stringify(obj, Object.keys(obj).toSorted());
   return crypto.createHash("sha256").update(sorted).digest("hex");
 }
 async function shouldRunOpenApiTs(openapiPath, configPath, options) {
+  if (!areExpectedOutputsPresent(options.outputPaths)) {
+    return true;
+  }
   const cache = await loadCache();
   const optionsHash = hashObject(options);
   const cacheKey = "openapi-ts";
@@ -81,7 +87,10 @@ async function updateOpenApiTsCache(openapiPath, configPath, options) {
 async function computePagePropsHash(pagePropsPath) {
   return hashFile(pagePropsPath);
 }
-async function shouldRegeneratePageProps(pagePropsPath) {
+async function shouldRegeneratePageProps(pagePropsPath, outputPath) {
+  if (outputPath && !fs.existsSync(outputPath)) {
+    return true;
+  }
   const cache = await loadCache();
   const currentMetadata = await readFileMetadata(pagePropsPath);
   const cacheKey = "page-props";

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

@@ -53,12 +53,30 @@ export interface TypeGenLogger {
     warn(message: string): void;
     error(message: string): void;
 }
+export interface TypeGenCacheHooks {
+    shouldRunOpenApiTs(openapiPath: string, configPath: string | null, options: {
+        generateSdk: boolean;
+        generateZod: boolean;
+        plugins: string[];
+        outputPaths?: string[];
+    }): Promise<boolean>;
+    updateOpenApiTsCache(openapiPath: string, configPath: string | null, options: {
+        generateSdk: boolean;
+        generateZod: boolean;
+        plugins: string[];
+        outputPaths?: string[];
+    }): Promise<void>;
+    shouldRegeneratePageProps(pagePropsPath: string, outputPath?: string): Promise<boolean>;
+    updatePagePropsCache(pagePropsPath: string): Promise<void>;
+}
 /**
  * Options for running type generation.
  */
 export interface RunTypeGenOptions {
     /** Logger for output (optional - silent if not provided) */
     logger?: TypeGenLogger;
+    /** Optional cache hooks for Vite dev/build contexts */
+    cache?: TypeGenCacheHooks;
 }
 /**
  * Resolve the default hey-api client plugin for the current project mode.
@@ -79,6 +97,12 @@ export declare function buildHeyApiPlugins(config: {
     generateZod: boolean;
     sdkClientPlugin: string;
 }): string[];
+/**
+ * Resolve the locally installed @hey-api/openapi-ts executable.
+ */
+export declare function resolveHeyApiBin(projectRoot: string): {
+    binPath: string;
+} | null;
 /**
  * Run @hey-api/openapi-ts to generate TypeScript types from OpenAPI spec.
  *

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.
  *