houdini 2.0.0-next.0 → 2.0.0-next.1

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) {
@@ -75726,6 +75733,7 @@ var Config = class {
   routesDir;
   schemaPollInterval;
   schemaPollTimeout;
+  schemaPollWriteToDisk = false;
   schemaPollHeaders;
   pluginMode = false;
   plugins = [];
@@ -75802,6 +75810,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 +75843,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 +75907,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 +76112,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 +76492,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 +79839,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 +81484,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 +85406,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 +86018,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.1",
   "description": "The disappearing GraphQL clients",
   "keywords": [
     "typescript",