houdini 2.0.0-next.9 → 2.0.1

package/build/vite/hmr.js

@@ -0,0 +1,433 @@
+import { readFileSync, writeFileSync } from "fs";
+import { codegen_setup, get_config, path, run_pipeline } from "../lib/index.js";
+let compiler;
+function document_hmr(ctx) {
+  const debounceHmr = createDebounceHmr(50);
+  let config;
+  const ownWrites = /* @__PURE__ */ new Map();
+  let generatedDir;
+  let rootPrefix;
+  const cleanupFiles = /* @__PURE__ */ new Set();
+  function isManifestFile(filepath) {
+    return (filepath.split("/").pop() ?? "").startsWith("+");
+  }
+  return {
+    name: "houdini",
+    enforce: "pre",
+    // this is called when the dev server starts
+    async configureServer(server) {
+      config = await get_config();
+      compiler = await codegen_setup(config, "dev", ctx.db, ctx.db_file);
+      generatedDir = path.join(
+        server.config.root,
+        ctx.config.config_file.runtimeDir ?? ".houdini"
+      );
+      rootPrefix = server.config.root.endsWith("/") ? server.config.root : `${server.config.root}/`;
+      server.httpServer?.once("close", () => {
+        compiler.close();
+      });
+      try {
+        await compiler.run_pipeline({
+          // the pipeline through schema is run as part of codegen_setup
+          after: "Schema"
+        });
+        const docCount = ctx.db.get(
+          "SELECT COUNT(*) as count FROM documents WHERE visible = 1"
+        );
+        console.log(
+          `\u{1F3A9} Generated ${docCount?.count ?? 0} ${(docCount?.count ?? 0) === 1 ? "document" : "documents"}`
+        );
+      } catch {
+      }
+    },
+    // hotUpdate is called for 'create', 'update', and 'delete' events in Vite 8+.
+    // The legacy handleHotUpdate hook is only called for 'update', so new .gql files
+    // (type === 'create') would be silently ignored without this hook.
+    // Async so we can read file content eagerly to determine ownership before debouncing.
+    async hotUpdate(opts) {
+      if (!generatedDir) return;
+      const now = Date.now();
+      for (const [fp, ts] of ownWrites.entries()) {
+        if (now - ts > 1e3) ownWrites.delete(fp);
+      }
+      const server = opts.server;
+      if (opts.file.startsWith(`${generatedDir}/`) || opts.file === generatedDir) {
+        return [];
+      }
+      if (opts.type === "delete") {
+        const relPath = opts.file.substring(rootPrefix.length);
+        if (!opts.file.endsWith(".gql") && !isManifestFile(opts.file)) {
+          const rowCount = ctx.db.get(
+            "SELECT COUNT(*) as count FROM raw_documents WHERE filepath = ?",
+            [relPath]
+          )?.count ?? 0;
+          if (rowCount === 0) return;
+        }
+        debounceHmr.queueDelete(relPath, batchCallback);
+        return [];
+      }
+      const ownWriteTime = ownWrites.get(opts.file);
+      if (ownWriteTime !== void 0) {
+        if (Date.now() - ownWriteTime < 500) return [];
+        ownWrites.delete(opts.file);
+      }
+      let preReadContent = null;
+      if (!opts.file.endsWith(".gql")) {
+        try {
+          preReadContent = await opts.read();
+        } catch {
+          return;
+        }
+        if (!preReadContent.includes("$houdini")) {
+          if (!isManifestFile(opts.file)) {
+            const relPath = opts.file.substring(rootPrefix.length);
+            const rowCount = ctx.db.get(
+              "SELECT COUNT(*) as count FROM raw_documents WHERE filepath = ?",
+              [relPath]
+            )?.count ?? 0;
+            if (rowCount === 0) return;
+            cleanupFiles.add(opts.file);
+          }
+        }
+      }
+      debounceHmr.queueUpdate(opts, preReadContent, batchCallback);
+      async function batchCallback(files, deletedFiles, task_id) {
+        if (!compiler) return;
+        await compiler.pipeline_lock(async () => {
+          if (deletedFiles.length > 0) {
+            const delClause = deletedFiles.map(() => "filepath = ?").join(" OR ");
+            ctx.db.run(`DELETE FROM raw_documents WHERE ${delClause}`, deletedFiles);
+          }
+          const filepaths = [];
+          const relativePaths = [];
+          const useStdio = config.config_file.pluginTransport === "stdio";
+          for (const [filepath, content] of Object.entries(files)) {
+            if (!filepath.includes(generatedDir) && (filepath.endsWith(".gql") || content.includes("$houdini") || cleanupFiles.delete(filepath) || isManifestFile(filepath))) {
+              const relPath = filepath.substring(rootPrefix.length);
+              relativePaths.push(relPath);
+              filepaths.push(filepath);
+              if (useStdio) {
+                let fileContent;
+                try {
+                  fileContent = readFileSync(filepath, "utf-8");
+                } catch {
+                  fileContent = content;
+                }
+                if (fileContent.trim() !== "") {
+                  ownWrites.set(filepath, Date.now());
+                  try {
+                    writeFileSync(filepath, fileContent, "utf-8");
+                  } catch {
+                    ownWrites.delete(filepath);
+                  }
+                }
+              }
+            }
+          }
+          if (filepaths.length === 0) {
+            if (deletedFiles.length > 0) {
+              console.log(
+                `\u{1F3A9} Detected ${deletedFiles.length} deleted ${deletedFiles.length === 1 ? "file" : "files"}, re-running compiler`
+              );
+              ctx.db.run(`
+								UPDATE selections AS s
+								SET field_name = s.fragment_ref
+								WHERE s.fragment_ref IS NOT NULL
+								  AND s.kind = 'fragment'
+								  AND NOT EXISTS (SELECT 1 FROM documents d WHERE d.name = s.field_name)
+							`);
+              ctx.db.run(`
+								WITH orphan_selections AS (
+								  SELECT s.id FROM selections s
+								  LEFT JOIN selection_refs rp ON rp.parent_id = s.id
+								  LEFT JOIN selection_refs rc ON rc.child_id = s.id
+								  WHERE rp.id IS NULL AND rc.id IS NULL
+								)
+								DELETE FROM selections WHERE id IN (SELECT id FROM orphan_selections)
+							`);
+              try {
+                const results2 = await run_pipeline(compiler.trigger_hook, {
+                  after: "AfterExtract"
+                });
+                const updated_modules2 = [
+                  ...Object.values(results2.GenerateDocuments || {}).flat(),
+                  ...Object.values(results2.GenerateRuntime || {}).flat()
+                ];
+                const seenUrls2 = /* @__PURE__ */ new Set();
+                const updates2 = updated_modules2.flatMap((module_path) => {
+                  const resolvedPath = module_path.startsWith("$houdini/") ? module_path.replace("$houdini", generatedDir) : module_path;
+                  const mods = [
+                    ...server.moduleGraph.getModulesByFile(resolvedPath) ?? []
+                  ];
+                  return mods.flatMap((mod) => {
+                    if (seenUrls2.has(mod.url)) return [];
+                    seenUrls2.add(mod.url);
+                    server.moduleGraph.invalidateModule(mod);
+                    return [
+                      {
+                        type: "js-update",
+                        path: mod.url,
+                        acceptedPath: mod.url,
+                        timestamp: Date.now()
+                      }
+                    ];
+                  });
+                });
+                if (updates2.length > 0) {
+                  server.ws.send({ type: "update", updates: updates2 });
+                }
+              } catch (err) {
+                console.error("[houdini] pipeline error after deletion:", err);
+              }
+            }
+            return;
+          }
+          const fileCount = filepaths.length;
+          console.log(
+            `\u{1F3A9} Detected ${fileCount} file ${fileCount === 1 ? "change" : "changes"}, re-running compiler`
+          );
+          const eqClause = relativePaths.map(() => "filepath = ?").join(" OR ");
+          const savedDocs = ctx.db.all(
+            `SELECT id, offset_line, offset_column, filepath, content, current_task, loaded_with
+						 FROM raw_documents WHERE ${eqClause}`,
+            relativePaths
+          );
+          ctx.db.run(`DELETE from raw_documents WHERE ${eqClause}`, relativePaths);
+          ctx.db.run(`
+			  UPDATE selections AS s
+			  SET field_name = s.fragment_ref
+			  WHERE s.fragment_ref IS NOT NULL
+			    AND s.kind = 'fragment'
+			    AND NOT EXISTS (SELECT 1 FROM documents d WHERE d.name = s.field_name)
+			`);
+          ctx.db.run(`
+			      WITH orphan_selections AS (
+			        SELECT s.id FROM selections s
+			        LEFT JOIN selection_refs rp ON rp.parent_id = s.id
+			        LEFT JOIN selection_refs rc ON rc.child_id = s.id
+			        WHERE rp.id IS NULL AND rc.id IS NULL
+			      )
+			      DELETE FROM selections WHERE id IN (SELECT id FROM orphan_selections)
+			  `);
+          try {
+            await compiler.trigger_hook("ExtractDocuments", {
+              payload: { filepaths }
+            });
+          } catch (err) {
+            for (const doc of savedDocs) {
+              try {
+                ctx.db.run(
+                  `INSERT OR IGNORE INTO raw_documents
+									 (offset_line, offset_column, filepath, content, loaded_with)
+									 VALUES (?, ?, ?, ?, ?)`,
+                  [
+                    doc.offset_line,
+                    doc.offset_column,
+                    doc.filepath,
+                    doc.content,
+                    doc.loaded_with
+                  ]
+                );
+              } catch {
+              }
+            }
+            ctx.db.flush();
+            ctx.db.reload();
+            throw err;
+          }
+          ctx.db.run(`UPDATE raw_documents SET current_task = ? WHERE ${eqClause}`, [
+            task_id,
+            ...relativePaths
+          ]);
+          const changes = ctx.db.rowsModified();
+          if (changes === 0 && savedDocs.length === 0) {
+            if (!filepaths.some(isManifestFile)) return;
+          }
+          await compiler.trigger_hook("AfterExtract", { task_id });
+          ctx.db.run(
+            `
+			      WITH RECURSIVE
+			      seed AS (
+			        SELECT DISTINCT d.name FROM raw_documents rd
+			        JOIN documents d ON d.raw_document = rd.id
+			        WHERE rd.current_task = $task_id
+			      ),
+			      up AS (
+			        SELECT name FROM seed
+			        UNION
+			        SELECT d2.name FROM up u
+			        JOIN document_dependencies dd ON dd.depends_on = u.name
+			        JOIN documents d2 ON d2.id = dd.document
+			      ),
+			      down AS (
+			        SELECT name FROM seed
+			        UNION
+			        SELECT dd.depends_on FROM down v
+			        JOIN documents d ON d.name = v.name
+			        JOIN document_dependencies dd ON dd.document = d.id
+			      ),
+			      targets_up AS (
+			        SELECT DISTINCT d.raw_document AS raw_id FROM documents d
+			        JOIN up u ON u.name = d.name WHERE d.raw_document IS NOT NULL
+			      ),
+			      targets_down AS (
+			        SELECT DISTINCT d.raw_document AS raw_id FROM documents d
+			        JOIN down v ON v.name = d.name
+			        JOIN raw_documents rd ON rd.id = d.raw_document
+			        WHERE d.raw_document IS NOT NULL
+			      ),
+			      targets AS (SELECT raw_id FROM targets_up UNION SELECT raw_id FROM targets_down)
+			      UPDATE raw_documents SET current_task = $task_id
+			      WHERE id IN (SELECT raw_id FROM targets)
+			    `,
+            { $task_id: task_id }
+          );
+          let results;
+          try {
+            results = await run_pipeline(compiler.trigger_hook, {
+              task_id,
+              after: "AfterExtract"
+            });
+          } finally {
+            ctx.db.run(
+              `UPDATE raw_documents SET current_task = NULL WHERE current_task = ?`,
+              [task_id]
+            );
+          }
+          const changedDocCount = Object.values(results.GenerateDocuments || {}).flat().length;
+          console.log(
+            `\u{1F3A9} Updated ${changedDocCount} ${changedDocCount === 1 ? "document" : "documents"}`
+          );
+          const updated_modules = [
+            ...Object.values(results.GenerateDocuments || {}).flat(),
+            ...Object.values(results.GenerateRuntime || {}).flat()
+          ];
+          const seenUrls = /* @__PURE__ */ new Set();
+          const updates = updated_modules.flatMap((module_path) => {
+            const resolvedPath = module_path.startsWith("$houdini/") ? module_path.replace("$houdini", generatedDir) : module_path;
+            const mods = [...server.moduleGraph.getModulesByFile(resolvedPath) ?? []];
+            return mods.flatMap((mod) => {
+              if (seenUrls.has(mod.url)) return [];
+              seenUrls.add(mod.url);
+              server.moduleGraph.invalidateModule(mod);
+              return [
+                {
+                  type: "js-update",
+                  path: mod.url,
+                  acceptedPath: mod.url,
+                  timestamp: Date.now()
+                }
+              ];
+            });
+          });
+          if (updates.length > 0) {
+            server.ws.send({ type: "update", updates });
+          }
+        });
+      }
+    }
+  };
+}
+function createDebounceHmr(debounceMs = 50) {
+  const updateQueue = /* @__PURE__ */ new Map();
+  const deleteQueue = /* @__PURE__ */ new Set();
+  let updateTimer = null;
+  let batchId = 0;
+  let isProcessing = false;
+  let pendingBatch = null;
+  function scheduleFlush(callback) {
+    if (updateTimer) {
+      clearTimeout(updateTimer);
+    }
+    updateTimer = setTimeout(async () => {
+      const filesToProcess = new Map(updateQueue);
+      const filesToDelete = new Set(deleteQueue);
+      const currentBatchId = ++batchId;
+      updateQueue.clear();
+      deleteQueue.clear();
+      updateTimer = null;
+      if (isProcessing) {
+        if (pendingBatch) {
+          for (const [fp, entry] of filesToProcess.entries()) {
+            pendingBatch.files.set(fp, entry);
+          }
+          for (const relPath of filesToDelete) {
+            pendingBatch.deletedFiles.add(relPath);
+          }
+          pendingBatch.batchId = currentBatchId;
+        } else {
+          pendingBatch = {
+            files: filesToProcess,
+            deletedFiles: filesToDelete,
+            batchId: currentBatchId
+          };
+        }
+        return;
+      }
+      isProcessing = true;
+      try {
+        const filesWithContent = {};
+        await Promise.all(
+          Array.from(filesToProcess.entries()).map(async ([filepath, entry]) => {
+            try {
+              filesWithContent[filepath] = typeof entry === "string" ? entry : await entry();
+            } catch {
+            }
+          })
+        );
+        try {
+          await callback(filesWithContent, [...filesToDelete], currentBatchId.toString());
+        } catch (err) {
+          if (!err?.alreadyLogged) {
+            console.error("[houdini] HMR pipeline error:", err);
+          }
+        }
+        while (pendingBatch) {
+          const {
+            files: nextFiles,
+            deletedFiles: nextDeleted,
+            batchId: nextBatchId
+          } = pendingBatch;
+          pendingBatch = null;
+          const nextFilesWithContent = {};
+          await Promise.all(
+            Array.from(nextFiles.entries()).map(async ([filepath, entry]) => {
+              try {
+                nextFilesWithContent[filepath] = typeof entry === "string" ? entry : await entry();
+              } catch {
+              }
+            })
+          );
+          try {
+            await callback(
+              nextFilesWithContent,
+              [...nextDeleted],
+              nextBatchId.toString()
+            );
+          } catch (err) {
+            console.error("[houdini] HMR pipeline error:", err);
+          }
+        }
+      } finally {
+        isProcessing = false;
+      }
+    }, debounceMs);
+  }
+  return {
+    queueUpdate(ctx, preReadContent, callback) {
+      if (!updateQueue.has(ctx.file)) {
+        updateQueue.set(ctx.file, preReadContent !== null ? preReadContent : ctx.read);
+      }
+      scheduleFlush(callback);
+    },
+    queueDelete(relativePath, callback) {
+      deleteQueue.add(relativePath);
+      scheduleFlush(callback);
+    }
+  };
+}
+export {
+  compiler,
+  createDebounceHmr,
+  document_hmr
+};

package/build/vite/houdini.d.ts

@@ -1,11 +1,5 @@
-import type { SourceMapInput } from 'rollup';
 import type { Plugin as VitePlugin } from 'vite';
-import type { Config, PluginConfig } from '../lib';
-export default function Plugin(opts?: PluginConfig): VitePlugin;
-export interface TransformPage {
-    config: Config;
-    content: string;
-    map?: SourceMapInput;
-    filepath: string;
-    watch_file: (path: string) => void;
-}
+import type { VitePluginContext } from './index.js';
+import type { CompilerProxy } from '../lib/index.js';
+export declare let compiler: CompilerProxy;
+export declare function houdini(ctx: VitePluginContext): VitePlugin;

package/build/vite/houdini.js

@@ -0,0 +1,144 @@
+import path from "node:path";
+import { codegen_setup, init_db } from "../lib/codegen.js";
+import * as fs from "../lib/fs.js";
+let compiler;
+let alreadyBuilt = false;
+function houdini(ctx) {
+  let viteEnv;
+  let viteConfig;
+  let devServer = false;
+  return {
+    name: "houdini",
+    enforce: "pre",
+    async configureServer() {
+      devServer = true;
+    },
+    async configResolved(conf) {
+      viteConfig = conf;
+      if (conf.isWorker) {
+        return;
+      }
+      if (!ctx.db) {
+        const [db] = await init_db(ctx.config, false);
+        ctx.db = db;
+      }
+    },
+    async config(userConfig, env) {
+      viteEnv = env;
+      const runtimeDir = path.join(
+        ctx.config.root_dir,
+        ctx.config.config_file.runtimeDir ?? ".houdini"
+      );
+      const houdiniAliases = {
+        $houdini: runtimeDir,
+        "$houdini/*": path.join(runtimeDir, "*"),
+        "~": path.join(ctx.config.root_dir, "src"),
+        "~/*": path.join(ctx.config.root_dir, "src", "*")
+      };
+      return {
+        resolve: {
+          ...userConfig.resolve,
+          alias: Array.isArray(userConfig.resolve?.alias) ? [
+            ...userConfig.resolve.alias,
+            ...Object.entries(houdiniAliases).map(([find, replacement]) => ({
+              find,
+              replacement
+            }))
+          ] : { ...userConfig.resolve?.alias, ...houdiniAliases }
+        },
+        server: {
+          ...userConfig.server,
+          fs: {
+            ...userConfig.server?.fs,
+            allow: ["."].concat(userConfig.server?.fs?.allow || [])
+          },
+          watch: {
+            ...userConfig.server?.watch,
+            ignored: ["**/*.houdini_tmp"].concat(
+              userConfig.server?.watch?.ignored || []
+            )
+          }
+        }
+      };
+    },
+    async buildStart() {
+      if (viteConfig.isWorker) {
+        return;
+      }
+      if (!compiler && !devServer) {
+        compiler = await codegen_setup(ctx.config, "dev", ctx.db, ctx.db_file);
+      }
+      if (ctx.adapter?.pre && viteEnv.command === "build") {
+        const routerConventions = await import("../router/conventions.js");
+        await ctx.adapter.pre({
+          config: ctx.config,
+          conventions: routerConventions,
+          sourceDir: viteConfig.build.outDir,
+          publicBase: viteConfig.base,
+          outDir: routerConventions.router_build_directory(ctx.config)
+        });
+      }
+      if (!devServer && !process.env.HOUDINI_SKIP_GENERATE && !alreadyBuilt) {
+        const buildResults = await compiler.run_pipeline({
+          // the pipeline through schema is run as part of codegen_setup
+          after: "Schema"
+        });
+        const buildDocCount = Object.values(buildResults.GenerateDocuments ?? {}).flat().length;
+        console.log(
+          `\u{1F3A9} Generated ${buildDocCount} ${buildDocCount === 1 ? "document" : "documents"}`
+        );
+        alreadyBuilt = true;
+        await compiler.close();
+      }
+    },
+    closeBundle: {
+      order: "post",
+      async handler() {
+        if (viteEnv.mode !== "production" || devServer || viteConfig.build.ssr || viteConfig.isWorker) {
+          return;
+        }
+        if (!ctx.adapter) {
+          return;
+        }
+        const routerConventions = await import("../router/conventions.js");
+        const outDir = routerConventions.router_build_directory(ctx.config);
+        const sourceDir = viteConfig.build.outDir;
+        console.log("\u{1F3A9} Generating Deployment Assets...");
+        try {
+          const stat = await fs.stat(outDir);
+          if (stat?.isDirectory()) {
+            await fs.rmdir(outDir);
+          }
+        } catch {
+        }
+        await fs.mkdirp(outDir);
+        const { load_manifest } = await import("../router/manifest.js");
+        const manifest = await load_manifest({
+          config: ctx.config,
+          includeArtifacts: true
+        });
+        if (!ctx.adapter?.disableServer) {
+          await fs.recursiveCopy(path.join(sourceDir, "ssr"), path.join(outDir, "ssr"));
+          await fs.rmdir(path.join(sourceDir, "ssr"));
+        }
+        await fs.recursiveCopy(sourceDir, path.join(outDir, "assets"));
+        await ctx.adapter({
+          config: ctx.config,
+          conventions: routerConventions,
+          sourceDir,
+          publicBase: viteConfig.base,
+          outDir,
+          manifest,
+          adapterPath: "./ssr/entries/adapter"
+        });
+        if (fs.existsSync(path.join(ctx.config.root_dir, "public"))) {
+          await fs.recursiveCopy(path.join(ctx.config.root_dir, "public"), outDir);
+        }
+      }
+    }
+  };
+}
+export {
+  compiler,
+  houdini
+};

package/build/vite/index.d.ts

@@ -1,7 +1,13 @@
-import type { Plugin } from 'vite';
-import type { PluginConfig } from '../lib';
-export * from './ast';
-export * from './imports';
-export * from './schema';
-export * from './houdini';
-export default function (opts?: PluginConfig): (Plugin | null)[];
+import type { Db } from '../lib/db.js';
+import type { PluginOption } from 'vite';
+import { type Adapter, type ConfigFile, type Config } from '../lib/index.js';
+export type PluginConfig = {
+    configPath?: string;
+    adapter?: Adapter;
+} & Partial<ConfigFile>;
+export type VitePluginContext = PluginConfig & {
+    db: Db;
+    db_file: string;
+    config: Config;
+};
+export default function (opts?: PluginConfig): Promise<Array<PluginOption>>;