houdini 2.0.7 → 2.0.8

package/build/cmd/init.js

@@ -472,12 +472,12 @@ async function packageJSON(targetPath, frameworkInfo) {
   }
   packageJSON2.devDependencies = {
     ...packageJSON2.devDependencies,
-    houdini: "^2.0.7"
+    houdini: "^2.0.8"
   };
   if (frameworkInfo.framework === "svelte" || frameworkInfo.framework === "kit") {
     packageJSON2.devDependencies = {
       ...packageJSON2.devDependencies,
-      "houdini-svelte": "^3.0.3"
+      "houdini-svelte": "^3.0.4"
     };
   } else {
     throw new Error(`Unmanaged framework: "${JSON.stringify(frameworkInfo)}"`);

package/build/lib/codegen.js

@@ -196,8 +196,16 @@ async function codegen_setup(config, mode, db, db_file) {
           };
           spec_results[name] = spec;
           _db.run(
-            `INSERT OR IGNORE INTO plugins (name, hooks, port, plugin_order, include_runtime, include_static_runtime, config_module, client_plugins)
-							 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+            `INSERT INTO plugins (name, hooks, port, plugin_order, include_runtime, include_static_runtime, config_module, client_plugins)
+							 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+							 ON CONFLICT(name) DO UPDATE SET
+								hooks = excluded.hooks,
+								port = excluded.port,
+								plugin_order = excluded.plugin_order,
+								include_runtime = excluded.include_runtime,
+								include_static_runtime = excluded.include_static_runtime,
+								config_module = excluded.config_module,
+								client_plugins = excluded.client_plugins`,
             [
               spec.name,
               JSON.stringify([...spec.hooks]),

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "houdini",
-    "version": "2.0.7",
+    "version": "2.0.8",
     "description": "The disappearing GraphQL clients",
     "keywords": [
         "typescript",

package/build/runtime/cache/index.d.ts

@@ -45,6 +45,7 @@ export declare class Cache {
         when?: {};
     }): void;
     refresh(id: string | string[]): void;
+    refreshAll(session?: App.Session | null): void;
     markRecordStale(id: string, options: {
         field?: string;
         when?: {};

package/build/runtime/cache/index.js

@@ -153,6 +153,22 @@ class Cache {
       }
     }
   }
+  // ask every active query document to refetch itself.
+  // this is used when global request context changes (for example, the
+  // SvelteKit session) and any query might resolve differently even if its
+  // cached records did not change. non-query artifacts are skipped because
+  // only queries can be refetched through this cache notification path.
+  refreshAll(session) {
+    const message = session === void 0 ? { kind: "refetch" } : { kind: "refetch", session };
+    for (const [spec] of this._internal_unstable.subscriptions.all({
+      includeMaskedParents: true
+    })) {
+      if (spec.kind !== ArtifactKind.Query) {
+        continue;
+      }
+      spec.onMessage(message);
+    }
+  }
   markRecordStale(id, options) {
     if (options.field) {
       const key = computeKey({ field: options.field, args: options.when ?? {} });

package/build/runtime/cache/subscription.d.ts

@@ -49,6 +49,9 @@ export declare class InMemorySubscriptions {
     getAll(id: string, { includeMaskedParents }?: {
         includeMaskedParents?: boolean;
     }): FieldSelection[];
+    all({ includeMaskedParents }?: {
+        includeMaskedParents?: boolean;
+    }): FieldSelection[];
     remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[], masked?: boolean): void;
     reset(): Readonly<{
         rootType: string;

package/build/runtime/cache/subscription.js

@@ -209,6 +209,29 @@ class InMemorySubscriptions {
       (fieldSub) => includeMaskedParents ? fieldSub.selections.concat(fieldSub.maskedParentSelections) : fieldSub.selections
     );
   }
+  all({ includeMaskedParents = false } = {}) {
+    const result = [];
+    const notified = /* @__PURE__ */ new Set();
+    for (const fields of this.subscribers.values()) {
+      for (const fieldSub of fields.values()) {
+        for (const selection of fieldSub.selections) {
+          if (!notified.has(selection[0].onMessage)) {
+            notified.add(selection[0].onMessage);
+            result.push(selection);
+          }
+        }
+        if (includeMaskedParents) {
+          for (const selection of fieldSub.maskedParentSelections) {
+            if (!notified.has(selection[0].onMessage)) {
+              notified.add(selection[0].onMessage);
+              result.push(selection);
+            }
+          }
+        }
+      }
+    }
+    return result;
+  }
   remove(id, selection, targets, variables, visited = [], masked = false) {
     visited.push(id);
     const linkedIDs = [];

package/build/runtime/types.d.ts

@@ -267,6 +267,7 @@ export type CacheMessage<_Data = any> = {
     data: _Data;
 } | {
     kind: 'refetch';
+    session?: App.Session | null;
 };
 export type SubscriptionSpec = Readonly<{
     rootType: string;

package/build/vite/hmr.d.ts

@@ -1,5 +1,4 @@
 import type { HmrContext, Plugin as VitePlugin } from 'vite';
-import { type CompilerProxy } from '../lib/index.js';
 import type { VitePluginContext } from './index.js';
 /**
  * Houdini Vite HMR Plugin
@@ -16,7 +15,6 @@ import type { VitePluginContext } from './index.js';
  * The plugin uses the same dependency resolution logic for both scenarios, walking both up and down
  * the dependency graph to ensure all related documents are properly regenerated.
  */
-export declare let compiler: CompilerProxy;
 export declare function document_hmr(ctx: VitePluginContext): VitePlugin;
 type BatchCallback = (filesWithContent: Record<string, string>, deletedFiles: string[], batchId: string) => void | Promise<void>;
 export declare function createDebounceHmr(debounceMs?: number): {

package/build/vite/hmr.js

@@ -1,8 +1,9 @@
 import { readFileSync, writeFileSync } from "fs";
 import { codegen_setup, get_config, path, run_pipeline } from "../lib/index.js";
-let compiler;
+import { dispose_active_session, register_session } from "./session.js";
 function document_hmr(ctx) {
   const debounceHmr = createDebounceHmr(50);
+  let compiler;
   let config;
   const ownWrites = /* @__PURE__ */ new Map();
   let generatedDir;
@@ -62,17 +63,29 @@ function document_hmr(ctx) {
     // 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);
+      await dispose_active_session(ctx.db_file);
+      const ownedCompiler = await codegen_setup(config, "dev", ctx.db, ctx.db_file);
+      compiler = ownedCompiler;
+      ctx.compiler = ownedCompiler;
       generatedDir = path.join(
         server.config.root,
         ctx.config.config_file.runtimeDir ?? ".houdini"
       );
       rootPrefix = server.config.root.endsWith("/") ? server.config.root : `${server.config.root}/`;
+      const dispose_session = register_session(ctx.db_file, async () => {
+        if (compiler === ownedCompiler) {
+          compiler = void 0;
+        }
+        if (ctx.compiler === ownedCompiler) {
+          ctx.compiler = void 0;
+        }
+        await ownedCompiler.close();
+      });
       server.httpServer?.once("close", () => {
-        compiler.close();
+        dispose_session();
       });
       try {
-        await compiler.run_pipeline({
+        await ownedCompiler.run_pipeline({
           // the pipeline through schema is run as part of codegen_setup
           after: "Schema"
         });
@@ -140,8 +153,9 @@ function document_hmr(ctx) {
         return opts.modules.filter((mod) => mod.type === "js");
       }
       async function batchCallback(files, deletedFiles, task_id) {
-        if (!compiler) return;
-        await compiler.pipeline_lock(async () => {
+        const batchCompiler = compiler;
+        if (!batchCompiler) return;
+        await batchCompiler.pipeline_lock(async () => {
           if (deletedFiles.length > 0) {
             const delClause = deletedFiles.map(() => "filepath = ?").join(" OR ");
             ctx.db.run(`DELETE FROM raw_documents WHERE ${delClause}`, deletedFiles);
@@ -196,7 +210,7 @@ function document_hmr(ctx) {
 								`);
               });
               try {
-                const results2 = await run_pipeline(compiler.trigger_hook, {
+                const results2 = await run_pipeline(batchCompiler.trigger_hook, {
                   after: "AfterExtract"
                 });
                 const updated_modules2 = [
@@ -240,7 +254,7 @@ function document_hmr(ctx) {
 			  `);
           });
           try {
-            await compiler.trigger_hook("ExtractDocuments", {
+            await batchCompiler.trigger_hook("ExtractDocuments", {
               payload: { filepaths }
             });
           } catch (err) {
@@ -273,7 +287,7 @@ function document_hmr(ctx) {
           if (changes === 0 && savedDocs.length === 0) {
             if (!filepaths.some(isManifestFile)) return;
           }
-          await compiler.trigger_hook("AfterExtract", { task_id });
+          await batchCompiler.trigger_hook("AfterExtract", { task_id });
           ctx.db.run(
             `
 			      WITH RECURSIVE
@@ -314,7 +328,7 @@ function document_hmr(ctx) {
           );
           let results;
           try {
-            results = await run_pipeline(compiler.trigger_hook, {
+            results = await run_pipeline(batchCompiler.trigger_hook, {
               task_id,
               after: "AfterExtract"
             });
@@ -437,7 +451,6 @@ function createDebounceHmr(debounceMs = 50) {
   };
 }
 export {
-  compiler,
   createDebounceHmr,
   document_hmr
 };

package/build/vite/houdini.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { codegen_setup, init_db } from "../lib/codegen.js";
 import * as fs from "../lib/fs.js";
+import { dispose_active_session } from "./session.js";
 let compiler;
 let alreadyBuilt = false;
 function houdini(ctx) {
@@ -19,6 +20,7 @@ function houdini(ctx) {
         return;
       }
       if (!ctx.db) {
+        await dispose_active_session(ctx.db_file);
         const [db] = await init_db(ctx.config, false);
         ctx.db = db;
       }

package/build/vite/index.d.ts

@@ -1,6 +1,6 @@
 import type { Db } from '../lib/db.js';
 import type { PluginOption } from 'vite';
-import { type Adapter, type ConfigFile, type Config } from '../lib/index.js';
+import { type Adapter, type CompilerProxy, type ConfigFile, type Config } from '../lib/index.js';
 export type PluginConfig = {
     configPath?: string;
     adapter?: Adapter;
@@ -9,5 +9,6 @@ export type VitePluginContext = PluginConfig & {
     db: Db;
     db_file: string;
     config: Config;
+    compiler?: CompilerProxy;
 };
 export default function (opts?: PluginConfig): Promise<Array<PluginOption>>;

package/build/vite/index.js

@@ -2,7 +2,9 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
-import { get_config } from "../lib/index.js";
+import {
+  get_config
+} from "../lib/index.js";
 import { db_path } from "../router/conventions.js";
 import { document_hmr } from "./hmr.js";
 import { houdini } from "./houdini.js";

package/build/vite/schema.d.ts

@@ -1,5 +1,5 @@
 import type { PluginOption } from 'vite';
 import type { VitePluginContext } from './index.js';
-export declare function refresh_on_schema(_ctx: VitePluginContext): PluginOption;
+export declare function refresh_on_schema(ctx: VitePluginContext): PluginOption;
 export declare function poll_remote_schema(_ctx: VitePluginContext): PluginOption;
-export declare function watch_local_schema(_ctx: VitePluginContext): PluginOption;
+export declare function watch_local_schema(ctx: VitePluginContext): PluginOption;

package/build/vite/schema.js

@@ -3,9 +3,8 @@ import * as graphql from "graphql";
 import { fs, get_config, run_pipeline } from "../lib/index.js";
 import { pull_schema } from "../lib/schema.js";
 import { sleep } from "../lib/sleep.js";
-import { compiler } from "./hmr.js";
 const ownSchemaWrites = /* @__PURE__ */ new Set();
-function refresh_on_schema(_ctx) {
+function refresh_on_schema(ctx) {
   return {
     name: "houdini-refresh-on-schema",
     async handleHotUpdate({ file, server }) {
@@ -17,6 +16,7 @@ function refresh_on_schema(_ctx) {
         ownSchemaWrites.delete(file);
         return;
       }
+      const compiler = ctx.compiler;
       if (!compiler) {
         return;
       }
@@ -89,7 +89,7 @@ function poll_remote_schema(_ctx) {
     }
   };
 }
-function watch_local_schema(_ctx) {
+function watch_local_schema(ctx) {
   return {
     name: "houdini-watch-local-schema",
     // Write the serialized schema at startup so houdini-core's Schema hook sees
@@ -120,6 +120,7 @@ function watch_local_schema(_ctx) {
       ownSchemaWrites.add(write_target);
       await serialize_and_write(schema, write_target);
       setTimeout(() => ownSchemaWrites.delete(write_target), 2e3);
+      const compiler = ctx.compiler;
       if (!compiler) return;
       try {
         await compiler.pipeline_lock(

package/build/vite/session.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Coordinates the handoff between houdini dev sessions within one process.
+ *
+ * A vite restart creates the replacement server (and with it a fresh houdini
+ * session: plugin context, database connection, compiler, and Go plugin
+ * processes) *before* closing the old server. Without coordination the two
+ * sessions overlap on the shared orchestration database: the new session wipes
+ * the file and spawns its plugins while the old session's processes still hold
+ * it, so plugin registrations collide and the surviving session can end up
+ * pointing at plugin processes that no longer exist.
+ *
+ * This registry is deliberately module-level: its whole purpose is to pass
+ * ownership from one plugin-instance generation to the next, which no
+ * per-instance state can do. Each dev session registers a dispose callback
+ * keyed by its database file; the next session for that file (or the owning
+ * server's close event, whichever comes first) runs it exactly once.
+ */
+/**
+ * Register the active session for a database file. Returns a disposer bound to
+ * this registration: it runs the teardown at most once, and removes the
+ * registration only if it is still the active one (a replacement session may
+ * have already taken the slot).
+ */
+export declare function register_session(db_file: string, dispose: () => Promise<void>): () => Promise<void>;
+/**
+ * Dispose whatever session currently owns the database file (no-op when none).
+ * A new session calls this before it recreates the database and spawns its own
+ * plugin processes.
+ */
+export declare function dispose_active_session(db_file: string): Promise<void>;

package/build/vite/session.js

@@ -0,0 +1,29 @@
+const sessions = /* @__PURE__ */ new Map();
+function register_session(db_file, dispose) {
+  let running = null;
+  const entry = {
+    dispose: () => {
+      running ??= dispose();
+      return running;
+    }
+  };
+  sessions.set(db_file, entry);
+  return () => {
+    if (sessions.get(db_file) === entry) {
+      sessions.delete(db_file);
+    }
+    return entry.dispose();
+  };
+}
+async function dispose_active_session(db_file) {
+  const entry = sessions.get(db_file);
+  if (!entry) {
+    return;
+  }
+  sessions.delete(db_file);
+  await entry.dispose();
+}
+export {
+  dispose_active_session,
+  register_session
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini",
-  "version": "2.0.7",
+  "version": "2.0.8",
   "description": "The disappearing GraphQL clients",
   "keywords": [
     "typescript",
@@ -52,7 +52,7 @@
     "recast": "^0.23.11",
     "sql.js": "^1.14.1",
     "ws": "^8.21.0",
-    "houdini-core": "^2.0.5"
+    "houdini-core": "^2.0.6"
   },
   "peerDependencies": {
     "graphql": ">=16",