houdini 2.0.0-next.0 → 2.0.0-next.2

package/build/vite-esm/index.js

@@ -72461,7 +72461,7 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
 }
 
 // src/lib/introspection.ts
-async function pullSchema(url, fetchTimeout, schemaPath, headers, skipWriting) {
+async function pullSchema(url, fetchTimeout, schemaPath, headers, writeToDisk = true) {
   let content = "";
   try {
     const fetchWithTimeout = (url2, timeoutMs, options) => {
@@ -72499,8 +72499,15 @@ async function pullSchema(url, fetchTimeout, schemaPath, headers, skipWriting) {
     } else {
       fileData = JSON.stringify(jsonSchema);
     }
-    if (!skipWriting) {
-      await writeFile(schemaPath, fileData);
+    if (writeToDisk) {
+      try {
+        await writeFile(schemaPath, fileData);
+      } catch (e2) {
+        console.warn(
+          `\u26A0\uFE0F  Couldn't write your pulled schema to disk: ${e2.message}
+	If this is expected, please set watchSchema.writePolledSchema to false in your config file.`
+        );
+      }
     }
     return fileData;
   } catch (e2) {
@@ -74983,20 +74990,21 @@ var CacheInternal = class {
       } else if (Array.isArray(value) && // make typescript happy
       (typeof previousValue === "undefined" || previousValue === null || Array.isArray(previousValue))) {
         let oldIDs = [...previousValue || []];
-        const emptyEdges = !updates ? [] : oldIDs.map((id) => {
-          if (!id) {
-            return "";
-          }
-          const { value: cursorField } = this.storage.get(id, "cursor");
-          if (cursorField) {
-            return "";
-          }
-          const { value: node } = this.storage.get(id, "node");
-          if (!node) {
-            return "";
-          }
-          return node;
-        });
+        if (updates?.includes("append") || updates?.includes("prepend")) {
+          oldIDs = oldIDs.filter((id) => {
+            for (const layer2 of this.storage.data) {
+              for (const operation of Object.values(layer2.operations)) {
+                if (operation.fields?.[key])
+                  for (const listOperation of operation.fields[key]) {
+                    if ("id" in listOperation && listOperation.id === id) {
+                      return false;
+                    }
+                  }
+              }
+            }
+            return true;
+          });
+        }
         let linkedIDs = [];
         const { newIDs, nestedIDs } = this.extractNestedListIDs({
           value,
@@ -75015,39 +75023,45 @@ var CacheInternal = class {
           layer.writeLink(parent2, key, linkedIDs);
         };
         if (applyUpdates && updates) {
-          if (key === "edges") {
-            const newNodeIDs = [];
-            for (const id of newIDs) {
+          const filterIDs = (keep, insert) => {
+            const existingIDs = /* @__PURE__ */ new Set();
+            for (const id of keep) {
               if (!id) {
                 continue;
               }
               const { value: node } = this.storage.get(id, "node");
-              if (typeof node !== "string") {
+              if (!node) {
                 continue;
               }
-              if (!node || !this.storage.get(node, "__typename")) {
+              const nodeID = this.storage.get(node, "id");
+              if (!nodeID) {
                 continue;
               }
-              newNodeIDs.push(node);
+              existingIDs.add(nodeID.value);
             }
-            oldIDs = oldIDs.filter((id) => {
+            return insert.filter((id) => {
               if (!id) {
                 return true;
               }
-              const { value: value2 } = this.storage.get(id, "node");
-              const node = value2;
-              if (newNodeIDs.includes(node) && emptyEdges.includes(node)) {
-                return false;
+              const { value: node } = this.storage.get(id, "node");
+              if (!node) {
+                return true;
               }
-              return true;
+              const nodeID = this.storage.get(node, "id");
+              if (!nodeID) {
+                return true;
+              }
+              return !existingIDs.has(nodeID.value);
             });
-          }
+          };
           for (const update of applyUpdates) {
             if (update !== "replace" && !updates.includes(update)) {
               continue;
             }
             if (update === "prepend") {
-              linkedIDs = newIDs.concat(oldIDs);
+              linkedIDs = newIDs.concat(
+                filterIDs(newIDs, oldIDs)
+              );
               if (layer?.optimistic) {
                 action = () => {
                   for (const id of newIDs) {
@@ -75058,7 +75072,7 @@ var CacheInternal = class {
                 };
               }
             } else if (update === "append") {
-              linkedIDs = oldIDs.concat(newIDs);
+              linkedIDs = filterIDs(newIDs, oldIDs).concat(newIDs);
               if (layer?.optimistic) {
                 action = () => {
                   for (const id of newIDs) {
@@ -75726,6 +75740,7 @@ var Config = class {
   routesDir;
   schemaPollInterval;
   schemaPollTimeout;
+  schemaPollWriteToDisk = false;
   schemaPollHeaders;
   pluginMode = false;
   plugins = [];
@@ -75802,6 +75817,7 @@ var Config = class {
     this.routesDir = join2(this.projectRoot, "src", "routes");
     this.schemaPollInterval = watchSchema?.interval === void 0 ? 2e3 : watchSchema.interval;
     this.schemaPollTimeout = watchSchema?.timeout ?? 3e4;
+    this.schemaPollWriteToDisk = watchSchema?.writePolledSchema ?? true;
     this.schemaPollHeaders = watchSchema?.headers ?? {};
     this.rootDir = join2(this.projectRoot, this.runtimeDir);
     this.persistedQueriesPath = persistedQueriesPath ?? join2(this.rootDir, "persisted_queries.json");
@@ -75834,11 +75850,17 @@ var Config = class {
     const include = [`src/**/*{${extensions.join(",")}}`];
     for (const plugin2 of this.plugins) {
       const runtimeDir = this.pluginRuntimeSource(plugin2);
-      if (!runtimeDir) {
+      const staticDir = this.pluginStaticRuntimeSource(plugin2);
+      if (!runtimeDir && !staticDir) {
         continue;
       }
-      const includePath = relative(this.projectRoot, runtimeDir);
-      include.push(`${includePath}/**/*{${extensions.join(",")}}`);
+      for (const dir of [runtimeDir, staticDir]) {
+        if (!dir) {
+          continue;
+        }
+        const includePath = relative(this.projectRoot, dir);
+        include.push(`${includePath}/**/*{${extensions.join(",")}}`);
+      }
     }
     return include;
   }
@@ -75892,6 +75914,15 @@ var Config = class {
       typeof plugin2.includeRuntime === "string" ? plugin2.includeRuntime : plugin2.includeRuntime?.[this.module]
     );
   }
+  pluginStaticRuntimeSource(plugin2) {
+    if (!plugin2.staticRuntime) {
+      return null;
+    }
+    return join2(
+      dirname(plugin2.filepath),
+      typeof plugin2.staticRuntime === "string" ? plugin2.staticRuntime : plugin2.staticRuntime?.[this.module]
+    );
+  }
   async sourceFiles() {
     return [
       ...new Set(
@@ -76088,6 +76119,9 @@ var Config = class {
   pluginRuntimeDirectory(name) {
     return join2(this.pluginDirectory(name), "runtime");
   }
+  pluginStaticRuntimeDirectory(name) {
+    return join2(this.pluginDirectory(name), "static");
+  }
   get pluginRootDirectory() {
     return houdini_mode.is_testing ? "../../../" : join2(this.rootDir, "plugins");
   }
@@ -76465,17 +76499,20 @@ async function getConfig({
     if (!_config.localSchema && _config.schemaPath && !_config.schema) {
       let schemaOk = true;
       if (apiURL) {
-        if (glob2.hasMagic(_config.schemaPath)) {
+        if (glob2.hasMagic(_config.schemaPath) && _config.schemaPollWriteToDisk) {
           console.log(
             `\u26A0\uFE0F  Your houdini configuration contains an apiUrl and a path pointing to multiple files.
-	This will prevent your schema from being pulled.`
+	This will prevent your schema from being written to disk. If this is expected, please set the writePolledSchema value to false.`
           );
+          _config.schemaPollWriteToDisk = false;
         } else if (!await readFile(_config.schemaPath)) {
           console.log("\u231B Pulling schema from api");
           schemaOk = await pullSchema(
             apiURL,
             _config.schemaPollTimeout,
-            _config.schemaPath
+            _config.schemaPath,
+            {},
+            _config.schemaPollWriteToDisk
           ) !== null;
         }
       }
@@ -79809,6 +79846,50 @@ function moduleStatments(config2) {
     exportStarStatement
   };
 }
+async function generateStaticRuntimes({ config: config2 }) {
+  if (houdini_mode.is_testing) {
+    return;
+  }
+  const { importStatement, exportDefaultStatement, exportStarStatement } = moduleStatments(config2);
+  await Promise.all(
+    config2.plugins.filter((plugin2) => plugin2.staticRuntime).map(async (plugin2) => {
+      const runtime_path = config2.pluginStaticRuntimeSource(plugin2);
+      if (!runtime_path) {
+        return;
+      }
+      try {
+        await stat(runtime_path);
+      } catch {
+        throw new HoudiniError({
+          message: "Cannot find runtime to generate for " + plugin2.name,
+          description: "Maybe it was bundled?"
+        });
+      }
+      const pluginDir = config2.pluginStaticRuntimeDirectory(plugin2.name);
+      let transformMap = plugin2.transformRuntime ?? {};
+      if (transformMap && typeof transformMap === "function") {
+        transformMap = transformMap([], { config: config2 });
+      }
+      await mkdirp(pluginDir);
+      await recursiveCopy(
+        runtime_path,
+        pluginDir,
+        Object.fromEntries(
+          Object.entries(transformMap).map(([key, value]) => [
+            join2(runtime_path, key),
+            (content) => value({
+              config: config2,
+              content,
+              importStatement,
+              exportDefaultStatement,
+              exportStarStatement
+            })
+          ])
+        )
+      );
+    })
+  );
+}
 async function generatePluginRuntimes({
   config: config2,
   docs
@@ -81410,6 +81491,11 @@ async function writeIndexFile2(config2, docs) {
         module: relative2(config2.pluginRuntimeDirectory(plugin2.name))
       });
     }
+    if (plugin2.staticRuntime) {
+      body += exportStar({
+        module: relative2(config2.pluginStaticRuntimeDirectory(plugin2.name))
+      });
+    }
   }
   await fs_exports.writeFile(path_exports.join(config2.rootDir, "index.js"), body);
 }
@@ -85327,6 +85413,7 @@ async function componentFields2(config2, docs) {
 
 // src/codegen/index.ts
 async function compile(config2) {
+  await generateStaticRuntimes({ config: config2 });
   const documents = await collectDocuments(config2);
   return await runPipeline2(config2, documents);
 }
@@ -85938,7 +86025,8 @@ function watch_remote_schema(opts = {}) {
             apiURL,
             config2.schemaPollTimeout,
             config2.schemaPath ?? path_exports.resolve(process.cwd(), "schema.json"),
-            await config2.pullHeaders()
+            await config2.pullHeaders(),
+            config2.schemaPollWriteToDisk
           );
           nbPullError = schemaState ? 0 : nbPullError + 1;
         } catch (e2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini",
-  "version": "2.0.0-next.0",
+  "version": "2.0.0-next.2",
   "description": "The disappearing GraphQL clients",
   "keywords": [
     "typescript",