houdini 2.0.0-next.2 → 2.0.0-next.23

package/build/lib/ast.js

@@ -0,0 +1,71 @@
+import * as recast from "recast";
+const _AST = recast.types.builders;
+function find_insert_index(script) {
+  let insert_index = script.body.findIndex((statement) => {
+    return statement.type !== "ImportDeclaration";
+  });
+  if (insert_index === -1) {
+    insert_index = script.body.length;
+  }
+  return insert_index;
+}
+function find_exported_fn(body, name) {
+  for (const statement of body) {
+    if (statement.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const exportDeclaration = statement;
+    if (exportDeclaration.declaration?.type === "FunctionDeclaration") {
+      const value = exportDeclaration.declaration;
+      if (value.id?.name === name) {
+        return {
+          declaration: exportDeclaration.declaration,
+          export: exportDeclaration
+        };
+      }
+    } else if (exportDeclaration.declaration?.type === "VariableDeclaration") {
+      const value = exportDeclaration.declaration;
+      if (value.declarations.length !== 1 || value.declarations[0].type !== "VariableDeclarator" || value.declarations[0].id.type !== "Identifier" || value.declarations[0].id.name !== name) {
+        continue;
+      }
+      const declaration = value.declarations[0];
+      let { init } = declaration;
+      if (!init) {
+        continue;
+      }
+      if (init.type === "TSSatisfiesExpression") {
+        init = init.expression;
+      }
+      if (init.type === "CallExpression" && init.arguments[0] && (init.arguments[0].type === "FunctionExpression" || init.arguments[0].type === "ArrowFunctionExpression")) {
+        init = init.arguments[0];
+      }
+      if (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression") {
+        return { declaration: init, export: exportDeclaration };
+      }
+      if (init.type === "Identifier" || init.type === "CallExpression") {
+        return { declaration: init, export: exportDeclaration };
+      }
+    } else {
+    }
+  }
+  const exported = body.find(
+    (expression) => expression.type === "ExportNamedDeclaration" && (expression.declaration?.type === "FunctionDeclaration" && expression.declaration.id?.name === name || expression.declaration?.type === "VariableDeclaration" && expression.declaration.declarations.length === 1 && expression.declaration.declarations[0].type === "Identifier" && expression.declaration.declarations[0].name === name)
+  );
+  if (!exported) {
+    return null;
+  }
+  return {
+    declaration: exported.declaration,
+    export: exported
+  };
+}
+function find_exported_id(program, name) {
+  return program.body.find(
+    (statement) => statement.type === "ExportNamedDeclaration" && statement.declaration?.type === "VariableDeclaration" && statement.declaration.declarations.length === 1 && statement.declaration.declarations[0].type === "VariableDeclarator" && statement.declaration.declarations[0].id.type === "Identifier" && statement.declaration.declarations[0].id.name === name
+  );
+}
+export {
+  find_exported_fn,
+  find_exported_id,
+  find_insert_index
+};

package/build/lib/codegen.d.ts

@@ -0,0 +1,55 @@
+import { type DatabaseSync } from 'node:sqlite';
+import * as conventions from '../router/conventions.js';
+import type { Config } from './config.js';
+import type { ProjectManifest } from './types';
+export type PluginSpec = {
+    name: string;
+    port: number;
+    directory: string;
+    hooks: Set<string>;
+    order: 'before' | 'after' | 'core';
+};
+export type Adapter = ((args: {
+    config: Config;
+    conventions: typeof conventions;
+    sourceDir: string;
+    publicBase: string;
+    outDir: string;
+    manifest: ProjectManifest;
+    adapterPath: string;
+}) => void | Promise<void>) & {
+    includePaths?: Record<string, string> | ((args: {
+        config: Config;
+    }) => Record<string, string>);
+    disableServer?: boolean;
+    pre?: (args: {
+        config: Config;
+        conventions: typeof conventions;
+        sourceDir: string;
+        publicBase: string;
+        outDir: string;
+    }) => Promise<void> | void;
+};
+export declare function connect_db(config: Config): [DatabaseSync, string];
+export declare function init_db(config: Config, preserve: boolean): Promise<[DatabaseSync, string]>;
+export type CompilerProxy = {
+    close: () => Promise<void>;
+    trigger_hook: (name: PipelineHook, opts?: {
+        parallel_safe?: boolean;
+        payload?: {};
+        task_id?: string;
+    }) => Promise<Record<string, any> | null>;
+    database_path: string;
+    run_pipeline: (options: RunPipelineOptions) => Promise<Record<PipelineHook, Record<string, any>>>;
+};
+export declare function plugin_db_key(name: string): string;
+export declare function codegen_setup(config: Config, mode: string, db: DatabaseSync, db_file: string): Promise<CompilerProxy>;
+export declare const PIPELINE_HOOKS: readonly ["Config", "AfterLoad", "Schema", "ExtractDocuments", "AfterExtract", "BeforeValidate", "Validate", "AfterValidate", "BeforeGenerate", "GenerateDocuments", "GenerateRuntime", "AfterGenerate"];
+export type PipelineHook = (typeof PIPELINE_HOOKS)[number];
+export type RunPipelineOptions = {
+    task_id?: string;
+    after?: PipelineHook;
+    start?: PipelineHook;
+    through?: PipelineHook;
+};
+export declare function run_pipeline(trigger_hook: CompilerProxy['trigger_hook'], options?: RunPipelineOptions): Promise<Record<PipelineHook, Record<string, any>>>;

package/build/lib/codegen.js

@@ -0,0 +1,522 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import sqlite from "node:sqlite";
+import { WebSocket } from "ws";
+import * as conventions from "../router/conventions.js";
+import { create_schema, write_config } from "./database.js";
+import { format_hook_error } from "./error.js";
+import * as fs from "./fs.js";
+import { Logger } from "./logger.js";
+import { LogLevel } from "./types.js";
+function connect_db(config) {
+  const filepath = conventions.db_path(config);
+  const db = new sqlite.DatabaseSync(filepath);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = off");
+  db.exec("PRAGMA cache_size = 10000");
+  db.exec("PRAGMA temp_store = memory");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA foreign_key = ON");
+  db.exec("PRAGMA defer_foreign_keys = ON");
+  db.exec(create_schema);
+  return [db, filepath];
+}
+async function init_db(config, preserve) {
+  const db_file = conventions.db_path(config);
+  if (!preserve) {
+    try {
+      await fs.remove(db_file);
+    } catch (_e) {
+    }
+    try {
+      await fs.remove(`${db_file}-shm`);
+    } catch (_e) {
+    }
+    try {
+      await fs.remove(`${db_file}-wal`);
+    } catch (_e) {
+    }
+  }
+  return [connect_db(config)[0], db_file];
+}
+function plugin_db_key(name) {
+  if (!name.startsWith("./") && !name.startsWith("../") && !path.isAbsolute(name)) {
+    return name;
+  }
+  return name.replace(/\./g, "_").replace(/\//g, "__");
+}
+async function codegen_setup(config, mode, db, db_file) {
+  const logger = new Logger(config.config_file.logLevel ?? LogLevel.Summary);
+  await fs.mkdirpSync(conventions.houdini_root(config));
+  const rawTransport = config.config_file.pluginTransport ?? "websocket";
+  const resolvedTransport = rawTransport.startsWith("env:") ? process.env[rawTransport.slice("env:".length)] ?? "websocket" : rawTransport;
+  const useStdio = resolvedTransport === "stdio";
+  const plugins = {};
+  const plugin_specs = [];
+  const spec_results = {};
+  const stdioStdin = /* @__PURE__ */ new Map();
+  const triggerHookRef = { fn: null };
+  const wait_for_plugin_db = (configKey, dbKey) => new Promise((resolve, reject) => {
+    const find_plugin = db.prepare("SELECT * FROM plugins WHERE name = ?");
+    const interval = setInterval(() => {
+      const row = find_plugin.get(dbKey);
+      if (row) {
+        clearInterval(interval);
+        db.prepare("UPDATE plugins set config = ? where name = ?").run(
+          JSON.stringify(
+            config.plugins.find((p) => p.name === configKey)?.config ?? {}
+          ),
+          dbKey
+        );
+        const spec = {
+          name: row.name,
+          port: row.port,
+          hooks: new Set(JSON.parse(row.hooks)),
+          order: row.plugin_order,
+          directory: config.plugins.find((p) => p.name === configKey)?.directory || ""
+        };
+        spec_results[configKey] = spec;
+        if (row.config_module) {
+          import(row.config_module).then((module) => {
+            if (module && typeof module.default === "function") {
+              config.config_file = module.default(config.config_file);
+            }
+            resolver(spec);
+          });
+        } else {
+          resolver(spec);
+        }
+      }
+    }, 10);
+    const timeout = setTimeout(() => {
+      clearInterval(interval);
+      reject(new Error(`Timeout waiting for plugin ${configKey} to register`));
+    }, 1e4);
+    const resolver = (spec) => {
+      clearTimeout(timeout);
+      resolve(spec);
+    };
+  });
+  const wait_for_plugin_stdio = (name, child) => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error(`Timeout waiting for plugin ${name} to register`));
+    }, 1e4);
+    const rl = createInterface({ input: child.stdout });
+    let registered = false;
+    rl.on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (!registered) {
+          if (msg.type !== "register") {
+            clearTimeout(timeout);
+            reject(new Error(`Plugin ${name} sent ${msg.type} before registering`));
+            return;
+          }
+          registered = true;
+          clearTimeout(timeout);
+          const spec = {
+            name: msg.name ?? plugin_db_key(name),
+            port: msg.port ?? 0,
+            hooks: new Set(msg.hooks ?? []),
+            order: msg.order,
+            directory: config.plugins.find((p) => p.name === name)?.directory || ""
+          };
+          spec_results[name] = spec;
+          db.prepare(
+            `INSERT OR IGNORE INTO plugins (name, hooks, port, plugin_order, include_runtime, config_module, client_plugins)
+							 VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            spec.name,
+            JSON.stringify([...spec.hooks]),
+            spec.port,
+            spec.order,
+            msg.includeRuntime ?? null,
+            msg.configModule ?? null,
+            msg.clientPlugins ?? null
+          );
+          db.prepare("UPDATE plugins SET config = ? WHERE name = ?").run(
+            JSON.stringify(
+              config.plugins.find((p) => p.name === name)?.config ?? {}
+            ),
+            spec.name
+          );
+          if (msg.configModule) {
+            import(msg.configModule).then((module) => {
+              if (module && typeof module.default === "function") {
+                config.config_file = module.default(config.config_file);
+              }
+              resolve(spec);
+            }).catch((err) => {
+              reject(
+                new Error(
+                  `Failed to load configModule for ${name}: ${err.message}`
+                )
+              );
+            });
+          } else {
+            resolve(spec);
+          }
+          return;
+        }
+        if (msg.type === "response") {
+          const pending = pendingRequests.get(msg.id);
+          if (!pending)
+            return;
+          clearTimeout(pending.timeout);
+          pendingRequests.delete(msg.id);
+          if (msg.error) {
+            const errors = Array.isArray(msg.error) ? msg.error : [msg.error];
+            errors.forEach((error) => {
+              format_hook_error(config.root_dir, error, name, pending.hook);
+            });
+            pending.reject(new Error(`Failed to call ${name}`));
+          } else {
+            pending.resolve(msg.result);
+          }
+        } else if (msg.type === "invoke") {
+          if (!triggerHookRef.fn) {
+            const reply = `${JSON.stringify({
+              id: msg.id,
+              type: "invoke_result",
+              error: { message: "orchestrator not ready" }
+            })}
+`;
+            child.stdin?.write(reply);
+            return;
+          }
+          triggerHookRef.fn(msg.hook, {
+            parallel_safe: msg.parallel,
+            payload: msg.payload,
+            task_id: msg.taskId
+          }).then((result) => {
+            const reply = JSON.stringify({ id: msg.id, type: "invoke_result", result }) + "\n";
+            child.stdin?.write(reply);
+          }).catch((err) => {
+            const reply = `${JSON.stringify({
+              id: msg.id,
+              type: "invoke_result",
+              error: { message: err.message }
+            })}
+`;
+            child.stdin?.write(reply);
+          });
+        }
+      } catch (err) {
+        if (!registered) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    });
+    rl.on("close", () => {
+      if (!registered) {
+        clearTimeout(timeout);
+        reject(new Error(`Plugin ${name} stdout closed before registering`));
+      } else {
+        for (const [id, pending] of pendingRequests.entries()) {
+          if (pending.plugin !== name)
+            continue;
+          clearTimeout(pending.timeout);
+          pendingRequests.delete(id);
+          pending.reject(new Error(`Plugin ${name} closed unexpectedly`));
+        }
+      }
+    });
+  });
+  db.prepare("DELETE FROM plugins").run();
+  logger.time("Start Plugins");
+  await Promise.all(
+    config.plugins.map(async (plugin) => {
+      let executable = plugin.executable;
+      const args = ["--database", db_file];
+      const jsExtensions = [".js", ".mjs", ".cjs"];
+      if (jsExtensions.includes(path.extname(plugin.executable))) {
+        executable = "node";
+        args.unshift(plugin.executable);
+      }
+      const dbKey = plugin_db_key(plugin.name);
+      args.push("--plugin-key", dbKey);
+      if (useStdio) {
+        args.push("--transport", "stdio");
+      }
+      logger.time(`Spawn ${plugin.name}`);
+      const child = spawn(executable, args, {
+        stdio: useStdio ? ["pipe", "pipe", "inherit"] : ["inherit", "inherit", "inherit"],
+        detached: process.platform !== "win32"
+      });
+      if (useStdio) {
+        stdioStdin.set(dbKey, child.stdin);
+        child.stdin.on("error", (err) => {
+          if (err.code !== "EPIPE") {
+            console.error(`[${plugin.name}] stdin error:`, err.message);
+          }
+        });
+      }
+      plugins[plugin.name] = {
+        process: child,
+        ...await (useStdio ? wait_for_plugin_stdio(plugin.name, child) : wait_for_plugin_db(plugin.name, dbKey))
+      };
+      logger.timeEnd(`Spawn ${plugin.name}`, LogLevel.Verbose);
+    })
+  );
+  for (const plugin of config.plugins) {
+    plugin_specs.push(spec_results[plugin.name]);
+  }
+  logger.timeEnd("Start Plugins", LogLevel.Summary);
+  const wsConnections = /* @__PURE__ */ new Map();
+  let messageCounter = 0;
+  const pendingRequests = /* @__PURE__ */ new Map();
+  async function getOrCreateWS(name, port) {
+    const existing = wsConnections.get(name);
+    if (existing && existing.readyState === WebSocket.OPEN) {
+      return existing;
+    }
+    return new Promise((resolve, reject) => {
+      const wsUrl = `ws://localhost:${port}/ws`;
+      const ws = new WebSocket(wsUrl);
+      ws.on("open", () => {
+        wsConnections.set(name, ws);
+        return resolve(ws);
+      });
+      ws.on("message", (data) => {
+        try {
+          const response = JSON.parse(data.toString());
+          const pending = pendingRequests.get(response.id);
+          if (!pending)
+            return;
+          clearTimeout(pending.timeout);
+          pendingRequests.delete(response.id);
+          switch (response.type) {
+            case "error":
+              console.error(`!   [${name}] ${response.error}`);
+              pending.reject(new Error(`${name}: ${response.error}`));
+              break;
+            case "response":
+              if (response.error) {
+                const errors = Array.isArray(response.error) ? response.error : [response.error];
+                errors.forEach((error) => {
+                  format_hook_error(config.root_dir, error, name, pending.hook);
+                });
+                pending.reject(new Error(`Failed to call ${name}`));
+              } else {
+                pending.resolve(response.result);
+              }
+              break;
+            default:
+              console.warn(`[${name}] Unknown message type: ${response.type}`);
+              pending.reject(new Error(`Unknown message type: ${response.type}`));
+          }
+        } catch (err) {
+          console.error(`Error processing WebSocket message for ${name}:`, err);
+        }
+      });
+      ws.on("error", (err) => {
+        console.error(`WebSocket error for ${name}:`, err);
+        wsConnections.delete(name);
+        reject(new Error(`WebSocket error for ${name}: ${err}`));
+      });
+      ws.on("close", () => {
+        wsConnections.delete(name);
+      });
+    });
+  }
+  const invoke_hook = async (name, hook, payload = {}, task_id) => {
+    const plugin = plugin_specs.find((spec) => spec.name === name);
+    if (!plugin) {
+      throw new Error(`unknown plugin: ${name}`);
+    }
+    const { port, directory } = plugin;
+    const messageId = String(++messageCounter);
+    const message = {
+      id: messageId,
+      type: "request",
+      hook,
+      payload,
+      taskId: task_id,
+      pluginDirectory: directory
+    };
+    if (useStdio) {
+      const stdin = stdioStdin.get(name);
+      if (!stdin) {
+        throw new Error(`No stdio channel for plugin ${name}`);
+      }
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingRequests.delete(messageId);
+          reject(new Error(`Request timeout for ${name}/${hook}`));
+        }, 3e4);
+        pendingRequests.set(messageId, { resolve, reject, timeout, hook, plugin: name });
+        stdin.write(`${JSON.stringify(message)}
+`);
+      });
+    } else {
+      const ws = await getOrCreateWS(name, port);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingRequests.delete(messageId);
+          reject(new Error(`WebSocket request timeout for ${name}/${hook}`));
+        }, 3e4);
+        pendingRequests.set(messageId, { resolve, reject, timeout, hook, plugin: name });
+        ws.send(JSON.stringify(message));
+      });
+    }
+  };
+  const trigger_hook = async (hook, {
+    parallel_safe,
+    payload,
+    task_id
+  } = {}) => {
+    const timeName = hook + (task_id ? ` (${task_id})` : "");
+    logger.time(timeName);
+    const plugins2 = plugin_specs.filter(({ hooks }) => hooks.has(hook));
+    const result = {};
+    try {
+      if (parallel_safe) {
+        await Promise.all(
+          plugins2.map(async (plugin) => {
+            result[plugin.name] = await invoke_hook(plugin.name, hook, payload, task_id);
+          })
+        );
+      } else {
+        for (const { name } of plugins2) {
+          result[name] = await invoke_hook(name, hook, payload, task_id);
+        }
+      }
+    } finally {
+      logger.timeEnd(timeName, task_id ? LogLevel.Verbose : LogLevel.Summary);
+    }
+    return result;
+  };
+  triggerHookRef.fn = trigger_hook;
+  await write_config(db, config, invoke_hook, plugin_specs, mode, logger);
+  await trigger_hook("Config");
+  await trigger_hook("AfterLoad");
+  await trigger_hook("Schema");
+  return {
+    database_path: db_file,
+    trigger_hook,
+    run_pipeline: (options) => run_pipeline(trigger_hook, options),
+    close: async () => {
+      for (const [name, ws] of wsConnections.entries()) {
+        try {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.close(1001, "shutdown");
+          }
+        } catch (err) {
+          console.error(`Error closing WebSocket for ${name}:`, err);
+        }
+      }
+      wsConnections.clear();
+      for (const [, stdin] of stdioStdin.entries()) {
+        try {
+          stdin.end();
+        } catch {
+        }
+      }
+      stdioStdin.clear();
+      for (const [, { timeout, reject }] of pendingRequests.entries()) {
+        clearTimeout(timeout);
+        reject(new Error("codegen closed"));
+      }
+      pendingRequests.clear();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      try {
+        db.close();
+      } catch {
+      }
+      await Promise.all(
+        Object.entries(plugins).map(async ([, plugin]) => {
+          if (plugin.process.pid) {
+            if (process.platform === "win32") {
+              try {
+                spawn("taskkill", [
+                  "/pid",
+                  plugin.process.pid.toString(),
+                  "/f",
+                  "/t"
+                ]);
+              } catch (_err) {
+              }
+            } else {
+              try {
+                process.kill(plugin.process.pid, 0);
+                process.kill(-plugin.process.pid, "SIGINT");
+              } catch {
+              }
+            }
+          }
+        })
+      );
+    }
+  };
+}
+const PIPELINE_HOOKS = [
+  "Config",
+  "AfterLoad",
+  "Schema",
+  "ExtractDocuments",
+  "AfterExtract",
+  "BeforeValidate",
+  "Validate",
+  "AfterValidate",
+  "BeforeGenerate",
+  "GenerateDocuments",
+  "GenerateRuntime",
+  "AfterGenerate"
+];
+async function run_pipeline(trigger_hook, options = {}) {
+  const { task_id, after, start, through } = options;
+  const results = {};
+  let startIndex = 0;
+  let endIndex = PIPELINE_HOOKS.length - 1;
+  if (after) {
+    const afterIndex = PIPELINE_HOOKS.indexOf(after);
+    if (afterIndex === -1) {
+      throw new Error(`Unknown hook: ${after}`);
+    }
+    startIndex = afterIndex + 1;
+  }
+  if (start) {
+    const index = PIPELINE_HOOKS.indexOf(start);
+    if (index === -1) {
+      throw new Error(`Unknown hook: ${after}`);
+    }
+    startIndex = index;
+  }
+  if (through) {
+    endIndex = PIPELINE_HOOKS.indexOf(through);
+    if (endIndex === -1) {
+      throw new Error(`Unknown hook: ${through}`);
+    }
+  }
+  if (startIndex > endIndex) {
+    return results;
+  }
+  for (let i = startIndex; i <= endIndex; i++) {
+    const hook = PIPELINE_HOOKS[i];
+    const opts = { task_id };
+    if (hook === "Validate" || hook === "GenerateDocuments") {
+      opts.parallel_safe = true;
+    }
+    if (hook === "GenerateDocuments" && i + 1 <= endIndex && PIPELINE_HOOKS[i + 1] === "GenerateRuntime") {
+      const [gdResult, grResult] = await Promise.all([
+        trigger_hook("GenerateDocuments", { task_id, parallel_safe: true }),
+        trigger_hook("GenerateRuntime", { task_id })
+      ]);
+      results.GenerateDocuments = gdResult;
+      results.GenerateRuntime = grResult;
+      i++;
+      continue;
+    }
+    results[hook] = await trigger_hook(hook, opts);
+  }
+  return results;
+}
+export {
+  PIPELINE_HOOKS,
+  codegen_setup,
+  connect_db,
+  init_db,
+  plugin_db_key,
+  run_pipeline
+};