houdini 2.0.0-next.8 → 2.0.0

package/build/node/index.js

@@ -0,0 +1,402 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import http from "node:http";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { WebSocketServer } from "ws";
+import { openDb } from "../lib/db.js";
+class PluginError extends Error {
+  detail;
+  locations;
+  kind;
+  constructor(opts) {
+    super(opts.message);
+    this.detail = opts.detail;
+    this.locations = opts.locations;
+    this.kind = opts.kind;
+  }
+}
+function plugin(config) {
+  const { transport, database, pluginKey } = parseArgs();
+  if (transport === "stdio") {
+    void runStdio(config, database, pluginKey);
+  } else {
+    void runWebSocket(config, database, pluginKey);
+  }
+}
+async function runStdio(config, databasePath, pluginKey) {
+  const resolvedName = pluginKey || config.name;
+  const { pending, invokeCounter, rl } = makeStdioChannel();
+  const wireHooks = registeredHookNames(config).map(toWireName);
+  const reg = {
+    type: "register",
+    name: resolvedName,
+    hooks: wireHooks,
+    order: config.order
+  };
+  if (config.includeRuntime !== void 0) reg.includeRuntime = config.includeRuntime;
+  if (config.staticRuntime !== void 0) reg.includeStaticRuntime = config.staticRuntime;
+  if (config.configModule !== void 0) reg.configModule = config.configModule;
+  if (config.clientPlugins !== void 0) reg.clientPlugins = JSON.stringify(config.clientPlugins);
+  stdioWrite(reg);
+  const dbPromise = openDb(databasePath || ":memory:");
+  rl.on("line", async (line) => {
+    const db2 = await dbPromise;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (msg.type === "request") {
+      const ctx = {
+        taskId: msg.taskId ?? "",
+        pluginDirectory: msg.pluginDirectory ?? "",
+        db: db2,
+        invokeHook: makeInvokeHook(pending, invokeCounter, msg.taskId ?? "")
+      };
+      await dispatch(config, resolvedName, msg, ctx, (response) => stdioWrite(response));
+    } else if (msg.type === "invoke_result") {
+      resolveInvoke(pending, msg);
+    }
+  });
+  const db = await dbPromise;
+  rl.on("close", () => {
+    for (const { reject } of pending.values()) {
+      reject(new Error("stdin closed"));
+    }
+    pending.clear();
+    db.close();
+    process.exit(0);
+  });
+}
+async function runWebSocket(config, databasePath, pluginKey) {
+  if (!databasePath) {
+    process.stderr.write("node plugin: --database path is required in websocket mode\n");
+    process.exit(1);
+  }
+  const resolvedName = pluginKey || config.name;
+  const db = await openDb(databasePath);
+  const wireHooks = registeredHookNames(config).map(toWireName);
+  const wsInvokeHook = () => {
+    throw new Error("invokeHook is not supported in websocket transport");
+  };
+  const server = http.createServer((req, res) => {
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+    const hookName = (req.url ?? "/").slice(1);
+    const taskId = req.headers["x-task-id"] ?? "";
+    const pluginDirectory = req.headers["x-plugin-directory"] ?? "";
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", async () => {
+      let payload = {};
+      try {
+        if (body) payload = JSON.parse(body);
+      } catch {
+      }
+      const msg = { hook: hookName, payload, taskId, pluginDirectory, id: "" };
+      const ctx = {
+        taskId,
+        pluginDirectory,
+        db,
+        invokeHook: wsInvokeHook
+      };
+      await dispatch(config, resolvedName, msg, ctx, (response) => {
+        if (response.error) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response.error));
+        } else {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response.result ?? {}));
+        }
+      });
+    });
+  });
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  wss.on("connection", (ws) => {
+    ws.on("message", async (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch {
+        return;
+      }
+      if (msg.type !== "request") {
+        ws.send(
+          JSON.stringify({
+            id: msg.id,
+            type: "response",
+            error: { message: "expected request type" }
+          })
+        );
+        return;
+      }
+      const ctx = {
+        taskId: msg.taskId ?? "",
+        pluginDirectory: msg.pluginDirectory ?? "",
+        db,
+        invokeHook: wsInvokeHook
+      };
+      await dispatch(
+        config,
+        resolvedName,
+        msg,
+        ctx,
+        (response) => ws.send(JSON.stringify(response))
+      );
+    });
+    ws.on("close", () => {
+      db.close();
+      server.close();
+      process.exit(0);
+    });
+  });
+  server.on("error", (err) => {
+    process.stderr.write(`node plugin: server failed to start: ${err.message}
+`);
+    process.exit(1);
+  });
+  server.listen(0, () => {
+    const port = server.address().port;
+    db.run(
+      `INSERT INTO plugins (name, hooks, port, plugin_order, include_runtime, include_static_runtime, config_module, client_plugins)
+			 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        resolvedName,
+        JSON.stringify(wireHooks),
+        port,
+        config.order,
+        config.includeRuntime ?? null,
+        config.staticRuntime ?? null,
+        config.configModule ?? null,
+        config.clientPlugins ? JSON.stringify(config.clientPlugins) : null
+      ]
+    );
+    db.flush();
+  });
+  process.on("SIGINT", () => shutdown(db, server));
+  process.on("SIGTERM", () => shutdown(db, server));
+}
+async function dispatch(config, pluginName, msg, ctx, send) {
+  const normalized = msg.hook.toLowerCase();
+  const payload = msg.payload ?? {};
+  try {
+    let result;
+    switch (normalized) {
+      case "config": {
+        const handler = config.hooks.config;
+        result = handler ? await handler(ctx, payload) : void 0;
+        break;
+      }
+      case "afterload": {
+        result = await dispatchAfterLoad(config, pluginName, ctx, payload);
+        break;
+      }
+      case "generateruntime": {
+        result = await dispatchGenerateRuntime(config, pluginName, ctx, payload);
+        break;
+      }
+      case "indexfile": {
+        await dispatchIndexFile(config, pluginName, ctx, payload);
+        result = void 0;
+        break;
+      }
+      default: {
+        const hookKey = Object.keys(config.hooks).find(
+          (k) => k.toLowerCase() === normalized
+        );
+        const handler = hookKey ? config.hooks[hookKey] : void 0;
+        if (!handler) {
+          send({
+            id: msg.id,
+            type: "response",
+            error: { message: `no handler for hook ${msg.hook}` }
+          });
+          return;
+        }
+        result = await handler(ctx, payload);
+      }
+    }
+    send({ id: msg.id, type: "response", result: result ?? {} });
+  } catch (err) {
+    send({ id: msg.id, type: "response", error: serializeError(err) });
+  }
+}
+async function dispatchAfterLoad(config, pluginName, ctx, payload) {
+  if (config.hooks.config) {
+    const defaults = await config.hooks.config(ctx, payload);
+    if (defaults !== void 0) {
+      ctx.db.run("UPDATE plugins SET config = $config WHERE name = $name", {
+        $config: JSON.stringify(defaults),
+        $name: pluginName
+      });
+    }
+  }
+  if (config.staticRuntime) {
+    const { projectRoot, runtimeDir } = readProjectConfig(ctx.db);
+    const src = join(ctx.pluginDirectory, config.staticRuntime);
+    const dst = pluginStaticRuntimeDir(projectRoot, runtimeDir, pluginName);
+    await recursiveCopy(src, dst, config.transformStaticRuntime);
+  }
+  if (config.hooks.afterLoad) {
+    return await config.hooks.afterLoad(ctx, payload);
+  }
+  return void 0;
+}
+async function dispatchGenerateRuntime(config, pluginName, ctx, payload) {
+  const paths = [];
+  if (config.includeRuntime !== void 0) {
+    const { projectRoot, runtimeDir } = readProjectConfig(ctx.db);
+    const src = join(ctx.pluginDirectory, config.includeRuntime);
+    const dst = pluginRuntimeDir(projectRoot, runtimeDir, pluginName);
+    const copied = await recursiveCopy(src, dst, config.transformRuntime);
+    paths.push(...copied);
+  }
+  if (config.hooks.generateRuntime) {
+    const result = await config.hooks.generateRuntime(ctx, payload);
+    if (Array.isArray(result)) {
+      paths.push(...result);
+    }
+  }
+  return paths;
+}
+async function dispatchIndexFile(config, pluginName, ctx, payload) {
+  if (!config.hooks.indexFile) return;
+  const { projectRoot, runtimeDir } = readProjectConfig(ctx.db);
+  const targetPath = join(projectRoot, runtimeDir, "index.ts");
+  const content = await config.hooks.indexFile(ctx, { ...payload, filepath: targetPath });
+  if (typeof content === "string" && content) {
+    const existing = existsSync(targetPath) ? readFileSync(targetPath, "utf8") : "";
+    mkdirSync(dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, existing + "\n" + content, "utf8");
+  }
+}
+function readProjectConfig(db) {
+  const row = db.get(
+    "SELECT project_root, runtime_dir FROM config LIMIT 1"
+  );
+  return { projectRoot: row?.project_root ?? "", runtimeDir: row?.runtime_dir ?? "" };
+}
+function pluginRuntimeDir(projectRoot, runtimeDir, name) {
+  if (name === "houdini-core") {
+    return join(projectRoot, runtimeDir, "runtime");
+  }
+  return join(projectRoot, runtimeDir, "plugins", name, "runtime");
+}
+function pluginStaticRuntimeDir(projectRoot, runtimeDir, name) {
+  return join(projectRoot, runtimeDir, "plugins", name, "static");
+}
+async function recursiveCopy(src, dst, transform) {
+  const written = [];
+  if (!existsSync(src)) return written;
+  const walk = async (srcDir, dstDir) => {
+    mkdirSync(dstDir, { recursive: true });
+    for (const entry of readdirSync(srcDir)) {
+      const srcPath = join(srcDir, entry);
+      const dstPath = join(dstDir, entry);
+      if (statSync(srcPath).isDirectory()) {
+        await walk(srcPath, dstPath);
+      } else {
+        let content = readFileSync(srcPath, "utf8");
+        if (transform) content = await transform(srcPath, content);
+        mkdirSync(dirname(dstPath), { recursive: true });
+        writeFileSync(dstPath, content, "utf8");
+        written.push(dstPath);
+      }
+    }
+  };
+  await walk(src, dst);
+  return written;
+}
+function registeredHookNames(config) {
+  const names = /* @__PURE__ */ new Set();
+  names.add("config");
+  if (config.staticRuntime || config.hooks.afterLoad || config.hooks.config) {
+    names.add("afterLoad");
+  }
+  if (config.includeRuntime !== void 0 || config.hooks.generateRuntime || config.configModule !== void 0) {
+    names.add("generateRuntime");
+  }
+  for (const key of Object.keys(config.hooks)) {
+    if (typeof config.hooks[key] === "function") {
+      names.add(key);
+    }
+  }
+  return Array.from(names);
+}
+function makeStdioChannel() {
+  const pending = /* @__PURE__ */ new Map();
+  const invokeCounter = { value: 0 };
+  const rl = createInterface({ input: process.stdin });
+  return { pending, invokeCounter, rl };
+}
+function makeInvokeHook(pending, counter, taskId) {
+  return (hook, payload, opts) => new Promise((resolve, reject) => {
+    const id = `node-invoke-${++counter.value}`;
+    pending.set(id, { resolve, reject });
+    stdioWrite({
+      id,
+      type: "invoke",
+      hook: toWireName(hook),
+      payload: payload ?? {},
+      taskId,
+      parallel: opts?.parallel ?? false
+    });
+  });
+}
+function resolveInvoke(pending, msg) {
+  const entry = pending.get(msg.id);
+  if (!entry) return;
+  pending.delete(msg.id);
+  if (msg.error) {
+    const message = typeof msg.error === "string" ? msg.error : msg.error?.message ?? "invoke error";
+    entry.reject(new Error(message));
+  } else {
+    entry.resolve(msg.result ?? {});
+  }
+}
+function shutdown(db, server) {
+  try {
+    db.close();
+  } catch {
+  }
+  server.close();
+  process.exit(0);
+}
+function parseArgs() {
+  const argv = process.argv;
+  let transport = "websocket";
+  let database = "";
+  let pluginKey = "";
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--transport" && i + 1 < argv.length) transport = argv[++i];
+    else if (argv[i] === "--database" && i + 1 < argv.length) database = argv[++i];
+    else if (argv[i] === "--plugin-key" && i + 1 < argv.length) pluginKey = argv[++i];
+  }
+  return { transport, database, pluginKey };
+}
+function stdioWrite(obj) {
+  process.stdout.write(`${JSON.stringify(obj)}
+`);
+}
+function toWireName(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function serializeError(err) {
+  if (err instanceof PluginError) {
+    const out = { message: err.message };
+    if (err.detail) out.detail = err.detail;
+    if (err.locations) out.locations = err.locations;
+    if (err.kind) out.kind = err.kind;
+    return out;
+  }
+  if (err instanceof Error) return { message: err.message };
+  return { message: String(err) };
+}
+export {
+  PluginError,
+  plugin
+};

package/build/oauth/index.d.ts

@@ -0,0 +1,41 @@
+import * as oauth from 'oauth4webapi';
+export type OAuthUser = {
+    sub: string;
+    email?: string;
+    emailVerified?: boolean;
+    name?: string;
+    [key: string]: unknown;
+};
+export type OAuthTokens = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    scope?: string;
+    idToken?: string;
+};
+export type IdTokenClaims = oauth.IDToken;
+export type AuthorizationServer = oauth.AuthorizationServer;
+export type OAuthProvider = {
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+    pkce: 'S256' | false;
+    issuer?: string;
+    allowInsecureRequests?: boolean;
+    server: () => Promise<AuthorizationServer>;
+    user: (args: {
+        tokens: OAuthTokens;
+        claims?: IdTokenClaims;
+    }) => Promise<OAuthUser> | OAuthUser;
+};
+export type OAuthProviderConfig = {
+    clientId: string;
+    clientSecret: string;
+    scopes?: string[];
+    allowInsecureRequests?: boolean;
+};
+export declare function github(config: OAuthProviderConfig): OAuthProvider;
+export type OIDCProviderConfig = OAuthProviderConfig & {
+    issuer: string;
+};
+export declare function oidc(config: OIDCProviderConfig): OAuthProvider;

package/build/oauth/index.js

@@ -0,0 +1,108 @@
+import * as oauth from "oauth4webapi";
+function isLoopbackHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || host.endsWith(".localhost");
+}
+function insecureGate(requested, url) {
+  if (!requested) {
+    return false;
+  }
+  let host = "";
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (isLoopbackHost(host)) {
+    return true;
+  }
+  console.warn(
+    `[houdini] ignoring allowInsecureRequests for non-loopback OAuth host "${host}" \u2014 http is only permitted for local development`
+  );
+  return false;
+}
+function github(config) {
+  const as = {
+    issuer: "https://github.com",
+    authorization_endpoint: "https://github.com/login/oauth/authorize",
+    token_endpoint: "https://github.com/login/oauth/access_token"
+  };
+  return {
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes ?? ["read:user", "user:email"],
+    pkce: "S256",
+    allowInsecureRequests: insecureGate(config.allowInsecureRequests, as.token_endpoint),
+    // no `issuer` → non-OIDC: no id_token to validate, the user comes from the REST API
+    server: async () => as,
+    user: async ({ tokens }) => {
+      const headers = {
+        Authorization: `Bearer ${tokens.accessToken}`,
+        Accept: "application/vnd.github+json",
+        "User-Agent": "houdini"
+      };
+      const [user, emails] = await Promise.all([
+        // fail closed on a non-2xx /user (rate limit, revoked token): GitHub returns a JSON
+        // error body with no `id`, which would otherwise collapse to sub="undefined" and key
+        // every failed login to the same account. Throw so the callback denies instead.
+        fetch("https://api.github.com/user", { headers }).then((r) => {
+          if (!r.ok) {
+            throw new Error(`github /user request failed (${r.status})`);
+          }
+          return r.json();
+        }),
+        fetch("https://api.github.com/user/emails", { headers }).then((r) => r.json()).catch(() => [])
+      ]);
+      const verifiedEmail = Array.isArray(emails) ? emails.find((e) => e.primary && e.verified)?.email : void 0;
+      return {
+        sub: String(user.id),
+        email: verifiedEmail,
+        emailVerified: verifiedEmail ? true : void 0,
+        name: user.name ?? user.login,
+        login: user.login,
+        avatarUrl: user.avatar_url
+      };
+    }
+  };
+}
+function oidc(config) {
+  let cache = null;
+  const issuerUrl = new URL(config.issuer);
+  const allowInsecure = insecureGate(config.allowInsecureRequests, config.issuer);
+  return {
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    scopes: config.scopes ?? ["openid", "email", "profile"],
+    pkce: "S256",
+    issuer: config.issuer,
+    allowInsecureRequests: allowInsecure,
+    server: () => {
+      if (!cache) {
+        cache = oauth.discoveryRequest(issuerUrl, {
+          algorithm: "oidc",
+          [oauth.allowInsecureRequests]: allowInsecure
+        }).then((response) => oauth.processDiscoveryResponse(issuerUrl, response));
+        cache.catch(() => {
+          cache = null;
+        });
+      }
+      return cache;
+    },
+    user: ({ claims }) => {
+      if (!claims) {
+        throw new Error("oidc provider: the token response carried no id_token");
+      }
+      const verified = claims.email_verified === true;
+      const email = verified ? claims.email : void 0;
+      return {
+        sub: claims.sub,
+        email,
+        emailVerified: email ? true : void 0,
+        name: claims.name
+      };
+    }
+  };
+}
+export {
+  github,
+  oidc
+};