litestar-vite-plugin 0.15.0-rc.1 → 0.15.0-rc.3

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

@@ -0,0 +1,122 @@
+import { exec } 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 { emitPagePropsTypes } from "./emit-page-props-types.js";
+const execAsync = promisify(exec);
+const nodeRequire = createRequire(import.meta.url);
+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")];
+  return candidates.find((p) => fs.existsSync(p)) || null;
+}
+function buildHeyApiPlugins(config) {
+  const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
+  if (config.generateSdk) {
+    plugins.push("@hey-api/sdk", config.sdkClientPlugin);
+  }
+  if (config.generateZod) {
+    plugins.push("zod");
+  }
+  return plugins;
+}
+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];
+  } else {
+    const relativeOpenapiPath = path.relative(projectRoot, path.resolve(projectRoot, openapiPath));
+    args = ["@hey-api/openapi-ts", "-i", relativeOpenapiPath, "-o", sdkOutput];
+    if (plugins.length) {
+      args.push("--plugins", ...plugins);
+    }
+  }
+  if (generateZod) {
+    try {
+      nodeRequire.resolve("zod", { paths: [projectRoot] });
+    } catch {
+      logger?.warn(`zod not installed - run: ${resolveInstallHint()} zod`);
+    }
+  }
+  const cmd = resolvePackageExecutor(args.join(" "), executor);
+  await execAsync(cmd, { cwd: projectRoot });
+  return sdkOutput;
+}
+async function runTypeGeneration(config, options = {}) {
+  const { logger } = options;
+  const startTime = Date.now();
+  const result = {
+    generated: false,
+    generatedFiles: [],
+    skippedFiles: [],
+    durationMs: 0,
+    warnings: [],
+    errors: []
+  };
+  try {
+    const { projectRoot, openapiPath, pagePropsPath, output, generateSdk, generatePageProps } = config;
+    const absoluteOpenapiPath = path.resolve(projectRoot, openapiPath);
+    const absolutePagePropsPath = path.resolve(projectRoot, pagePropsPath);
+    const configPath = findOpenApiTsConfig(projectRoot);
+    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);
+        if (message.includes("not found") || message.includes("ENOENT") || message.includes("not installed")) {
+          const zodHint = config.generateZod ? " zod" : "";
+          const warning = `@hey-api/openapi-ts not installed - run: ${resolveInstallHint()} -D @hey-api/openapi-ts${zodHint}`;
+          result.warnings.push(warning);
+          logger?.warn(warning);
+        } else {
+          result.errors.push(message);
+          logger?.error(`Type generation failed: ${message}`);
+        }
+      }
+    }
+    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;
+        } else {
+          result.skippedFiles.push(pagePropsOutput);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.errors.push(`Page props generation failed: ${message}`);
+        logger?.error(`Page props generation failed: ${message}`);
+      }
+    }
+  } finally {
+    result.durationMs = Date.now() - startTime;
+  }
+  return result;
+}
+export {
+  buildHeyApiPlugins,
+  findOpenApiTsConfig,
+  runHeyApiGeneration,
+  runTypeGeneration
+};

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

@@ -1,15 +1,11 @@
-import { exec } 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 colors from "picocolors";
-import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
 import { debounce } from "./debounce.js";
 import { emitPagePropsTypes } from "./emit-page-props-types.js";
 import { formatPath } from "./format-path.js";
-const execAsync = promisify(exec);
-const nodeRequire = createRequire(import.meta.url);
+import { shouldRunOpenApiTs, updateOpenApiTsCache } from "./typegen-cache.js";
+import { buildHeyApiPlugins, findOpenApiTsConfig, runHeyApiGeneration } from "./typegen-core.js";
 async function getFileMtime(filePath) {
   const stat = await fs.promises.stat(filePath);
   return stat.mtimeMs.toString();
@@ -21,8 +17,14 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
   let server = null;
   let isGenerating = false;
   let resolvedConfig = null;
-  let _chosenConfigPath = null;
-  async function runTypeGeneration() {
+  function createViteLogger() {
+    return {
+      info: (message) => resolvedConfig?.logger.info(`${colors.cyan("\u2022")} ${message}`),
+      warn: (message) => resolvedConfig?.logger.warn(`${colors.yellow("!")} ${message}`),
+      error: (message) => resolvedConfig?.logger.error(`${colors.red("\u2717")} ${message}`)
+    };
+  }
+  async function runTypeGenerationWithCache() {
     if (isGenerating) {
       return false;
     }
@@ -30,49 +32,70 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
     const startTime = Date.now();
     try {
       const projectRoot = resolvedConfig?.root ?? process.cwd();
-      const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
-      const pagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
+      const absoluteOpenapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
+      const absolutePagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
       let generated = false;
-      const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
-      const configPath = candidates.find((p) => fs.existsSync(p)) || null;
-      _chosenConfigPath = configPath;
-      const shouldRunOpenApiTs = configPath || typesConfig.generateSdk;
-      if (fs.existsSync(openapiPath) && shouldRunOpenApiTs) {
-        resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Generating TypeScript types...`);
-        if (resolvedConfig && configPath) {
-          const relConfigPath = formatPath(configPath, resolvedConfig.root);
-          resolvedConfig.logger.info(`${colors.cyan("\u2022")} openapi-ts config: ${colors.yellow(relConfigPath)}`);
-        }
-        const sdkOutput = path.join(typesConfig.output, "api");
-        let args;
-        if (configPath) {
-          args = ["@hey-api/openapi-ts", "--file", configPath];
-        } else {
-          args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", sdkOutput];
-          const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
-          if (typesConfig.generateSdk) {
-            plugins.push("@hey-api/sdk", sdkClientPlugin);
-          }
-          if (typesConfig.generateZod) {
-            plugins.push("zod");
-          }
-          if (plugins.length) {
-            args.push("--plugins", ...plugins);
+      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)}`);
           }
-        }
-        if (typesConfig.generateZod) {
+          const coreConfig = {
+            projectRoot,
+            openapiPath: typesConfig.openapiPath,
+            output: typesConfig.output,
+            pagePropsPath: typesConfig.pagePropsPath,
+            generateSdk: typesConfig.generateSdk,
+            generateZod: typesConfig.generateZod,
+            generatePageProps: false,
+            // Handle separately below
+            sdkClientPlugin,
+            executor
+          };
           try {
-            nodeRequire.resolve("zod", { paths: [projectRoot] });
-          } catch {
-            resolvedConfig?.logger.warn(`${colors.yellow("!")} zod not installed - run: ${resolveInstallHint()} zod`);
+            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}`);
+            }
           }
+        } else {
+          resolvedConfig?.logger.info(`${colors.cyan("\u2022")} TypeScript types ${colors.dim("(unchanged)")}`);
         }
-        await execAsync(resolvePackageExecutor(args.join(" "), executor), { cwd: projectRoot });
-        generated = true;
       }
-      if (typesConfig.generatePageProps && fs.existsSync(pagePropsPath)) {
-        await emitPagePropsTypes(pagePropsPath, typesConfig.output);
-        generated = true;
+      if (typesConfig.generatePageProps && fs.existsSync(absolutePagePropsPath)) {
+        try {
+          const changed = await emitPagePropsTypes(absolutePagePropsPath, typesConfig.output);
+          if (changed) {
+            generated = true;
+          } 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}`);
+        }
       }
       if (generated && resolvedConfig) {
         const duration = Date.now() - startTime;
@@ -91,22 +114,13 @@ function createLitestarTypeGenPlugin(typesConfig, options) {
       return true;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (resolvedConfig) {
-        if (message.includes("not found") || message.includes("ENOENT")) {
-          const zodHint = typesConfig.generateZod ? " zod" : "";
-          resolvedConfig.logger.warn(
-            `${colors.cyan("litestar-vite")} ${colors.yellow("@hey-api/openapi-ts not installed")} - run: ${resolveInstallHint()} -D @hey-api/openapi-ts${zodHint}`
-          );
-        } else {
-          resolvedConfig.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
-        }
-      }
+      resolvedConfig?.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
       return false;
     } finally {
       isGenerating = false;
     }
   }
-  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
+  const debouncedRunTypeGeneration = debounce(runTypeGenerationWithCache, typesConfig.debounce);
   return {
     name: pluginName,
     enforce: "pre",
@@ -144,7 +158,7 @@ Solutions:
         const hasOpenapi = fs.existsSync(openapiPath);
         const hasPageProps = typesConfig.generatePageProps && fs.existsSync(pagePropsPath);
         if (hasOpenapi || hasPageProps) {
-          await runTypeGeneration();
+          await runTypeGenerationWithCache();
         }
       }
     },

package/dist/js/shared/write-if-changed.d.ts

@@ -0,0 +1,16 @@
+export interface WriteResult {
+    changed: boolean;
+    path: string;
+}
+/**
+ * Write file only if content differs from existing.
+ * Uses direct Buffer comparison (more efficient than hashing for small files).
+ *
+ * @param filePath - Absolute path to file
+ * @param content - Content to write
+ * @param options - Write options
+ * @returns WriteResult indicating whether file was changed
+ */
+export declare function writeIfChanged(filePath: string, content: string, options?: {
+    encoding?: BufferEncoding;
+}): Promise<WriteResult>;

package/dist/js/shared/write-if-changed.js

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+async function writeIfChanged(filePath, content, options) {
+  const encoding = options?.encoding ?? "utf-8";
+  const newBuffer = Buffer.from(content, encoding);
+  try {
+    const existing = await fs.promises.readFile(filePath);
+    if (existing.equals(newBuffer)) {
+      return { changed: false, path: filePath };
+    }
+  } catch {
+  }
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, newBuffer);
+  return { changed: true, path: filePath };
+}
+export {
+  writeIfChanged
+};

package/dist/js/typegen-cli.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import colors from "picocolors";
+import { readBridgeConfig } from "./shared/bridge-schema.js";
+import { runTypeGeneration } from "./shared/typegen-core.js";
+function parseArgs() {
+  const args = process.argv.slice(2);
+  return {
+    verbose: args.includes("--verbose")
+  };
+}
+function log(message) {
+  console.log(message);
+}
+function logError(message) {
+  console.error(message);
+}
+function createConsoleLogger() {
+  return {
+    info: (message) => log(`${colors.cyan("\u2022")} ${message}`),
+    warn: (message) => log(`${colors.yellow("!")} ${message}`),
+    error: (message) => logError(`${colors.red("\u2717")} ${message}`)
+  };
+}
+async function main() {
+  parseArgs();
+  const projectRoot = process.cwd();
+  const bridgeConfig = readBridgeConfig();
+  if (!bridgeConfig) {
+    logError(`${colors.red("\u2717")} .litestar.json not found`);
+    logError("  Run 'litestar run' or 'litestar assets generate-types' first to generate it.");
+    process.exit(1);
+  }
+  const typesConfig = bridgeConfig.types;
+  if (!typesConfig || !typesConfig.enabled) {
+    log(`${colors.yellow("!")} Type generation is disabled in configuration`);
+    process.exit(0);
+  }
+  const coreConfig = {
+    projectRoot,
+    openapiPath: typesConfig.openapiPath,
+    output: typesConfig.output,
+    pagePropsPath: typesConfig.pagePropsPath,
+    generateSdk: typesConfig.generateSdk,
+    generateZod: typesConfig.generateZod,
+    generatePageProps: typesConfig.generatePageProps,
+    sdkClientPlugin: "@hey-api/client-fetch",
+    // Default for CLI
+    executor: bridgeConfig.executor
+  };
+  const logger = createConsoleLogger();
+  const result = await runTypeGeneration(coreConfig, { logger });
+  if (result.errors.length > 0) {
+    process.exit(1);
+  }
+  for (const file of result.skippedFiles) {
+    const name = file.includes("page-props") ? "Page props types" : file;
+    log(`${colors.cyan("\u2022")} ${name} ${colors.dim("(unchanged)")}`);
+  }
+  if (result.generated) {
+    log(`${colors.green("\u2713")} TypeScript artifacts updated ${colors.dim(`(${result.durationMs}ms)`)}`);
+  }
+}
+main().catch((error) => {
+  logError(`${colors.red("\u2717")} Unexpected error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litestar-vite-plugin",
-  "version": "0.15.0-rc.1",
+  "version": "0.15.0-rc.3",
   "type": "module",
   "description": "Litestar plugin for Vite.",
   "keywords": [
@@ -15,6 +15,8 @@
   },
   "license": "MIT",
   "author": "Litestar",
+  "main": "./dist/js/index.js",
+  "module": "./dist/js/index.js",
   "exports": {
     ".": {
       "types": "./dist/js/index.d.ts",
@@ -39,24 +41,51 @@
     "./nuxt": {
       "types": "./dist/js/nuxt.d.ts",
       "import": "./dist/js/nuxt.js"
+    },
+    "./inertia": {
+      "types": "./dist/js/inertia-types.d.ts",
+      "import": "./dist/js/inertia-types.js"
     }
   },
   "types": "./dist/js/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "helpers": [
+        "./dist/js/helpers/index.d.ts"
+      ],
+      "inertia-helpers": [
+        "./dist/js/inertia-helpers/index.d.ts"
+      ],
+      "astro": [
+        "./dist/js/astro.d.ts"
+      ],
+      "sveltekit": [
+        "./dist/js/sveltekit.d.ts"
+      ],
+      "nuxt": [
+        "./dist/js/nuxt.d.ts"
+      ],
+      "inertia": [
+        "./dist/js/inertia-types.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist/js/**/*",
     "tools/clean.js"
   ],
   "bin": {
-    "clean-orphaned-assets": "tools/clean.js"
+    "clean-orphaned-assets": "tools/clean.js",
+    "litestar-vite-typegen": "dist/js/typegen-cli.js"
   },
   "scripts": {
     "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 && 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 && mkdir -p dist/js/shared && esbuild src/js/src/shared/bridge-schema.ts src/js/src/shared/debounce.ts src/js/src/shared/format-path.ts src/js/src/shared/logger.ts src/js/src/shared/emit-page-props-types.ts src/js/src/shared/typegen-plugin.ts --platform=node --format=esm --outdir=dist/js/shared",
+    "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 && esbuild src/js/src/typegen-cli.ts --platform=node --format=esm --outfile=dist/js/typegen-cli.js --banner:js='#!/usr/bin/env node' && mkdir -p dist/js/shared && esbuild src/js/src/shared/bridge-schema.ts src/js/src/shared/debounce.ts src/js/src/shared/format-path.ts src/js/src/shared/logger.ts src/js/src/shared/emit-page-props-types.ts src/js/src/shared/typegen-plugin.ts src/js/src/shared/typegen-core.ts src/js/src/shared/write-if-changed.ts src/js/src/shared/typegen-cache.ts --platform=node --format=esm --outdir=dist/js/shared",
     "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",
+    "build-integrations": "esbuild src/js/src/astro.ts src/js/src/sveltekit.ts src/js/src/nuxt.ts src/js/src/inertia-types.ts --platform=node --format=esm --outdir=dist/js",
     "lint": "biome check --vcs-enabled=false src/js/src src/js/tests",
     "test": "vitest --config ./src/js/vitest.config.ts run"
   },