houdini 2.0.0-next.8 → 2.0.0

package/build/lib/db.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import initSqlJs from "sql.js";
+class SqlJsDb {
+  _db;
+  _SQL;
+  filepath;
+  _lastRowsModified = 0;
+  constructor(db, SQL, filepath) {
+    this._db = db;
+    this._SQL = SQL;
+    this.filepath = filepath;
+  }
+  exec(sql) {
+    this._db.exec(sql);
+  }
+  run(sql, params) {
+    this._db.run(sql, params);
+    this._lastRowsModified = this._db.getRowsModified();
+  }
+  get(sql, params) {
+    const stmt = this._db.prepare(sql);
+    if (params !== void 0) stmt.bind(params);
+    const row = stmt.step() ? stmt.getAsObject() : void 0;
+    stmt.free();
+    return row;
+  }
+  all(sql, params) {
+    const stmt = this._db.prepare(sql);
+    if (params !== void 0) stmt.bind(params);
+    const rows = [];
+    while (stmt.step()) rows.push(stmt.getAsObject());
+    stmt.free();
+    return rows;
+  }
+  rowsModified() {
+    return this._lastRowsModified;
+  }
+  flush() {
+    if (!this.filepath || this.filepath === ":memory:") return;
+    const data = this._db.export();
+    mkdirSync(dirname(this.filepath), { recursive: true });
+    writeFileSync(this.filepath, Buffer.from(data));
+  }
+  reload() {
+    if (!this.filepath || this.filepath === ":memory:") return;
+    this._db.close();
+    this._db = existsSync(this.filepath) ? new this._SQL.Database(new Uint8Array(readFileSync(this.filepath))) : new this._SQL.Database();
+    this._db.run("PRAGMA journal_mode = DELETE");
+    this._db.run("PRAGMA foreign_keys = ON");
+    this._db.run("PRAGMA defer_foreign_keys = ON");
+  }
+  close() {
+    this._db.close();
+  }
+}
+class NativeDb {
+  _conn;
+  _lastChanges = 0;
+  filepath;
+  constructor(conn, filepath) {
+    this._conn = conn;
+    this.filepath = filepath;
+  }
+  exec(sql) {
+    this._conn.exec(sql);
+  }
+  run(sql, params) {
+    const stmt = this._conn.prepare(sql);
+    const result = params === void 0 ? stmt.run() : Array.isArray(params) ? stmt.run(...params) : stmt.run(this._norm(params));
+    this._lastChanges = result?.changes ?? 0;
+  }
+  get(sql, params) {
+    const stmt = this._conn.prepare(sql);
+    return params === void 0 ? stmt.get() : Array.isArray(params) ? stmt.get(...params) : stmt.get(this._norm(params));
+  }
+  all(sql, params) {
+    const stmt = this._conn.prepare(sql);
+    return params === void 0 ? stmt.all() : Array.isArray(params) ? stmt.all(...params) : stmt.all(this._norm(params));
+  }
+  rowsModified() {
+    return this._lastChanges;
+  }
+  // WAL-mode file connection is always current — no need to flush or reload.
+  flush() {
+  }
+  reload() {
+  }
+  close() {
+    this._conn.close();
+  }
+  // node:sqlite and bun:sqlite expect named params without the leading $ prefix,
+  // e.g. { name: val } for SQL $name. Strip it so callers can use { $name: val }
+  // consistently across both sql.js and native backends.
+  _norm(params) {
+    if (Array.isArray(params)) return params;
+    const out = {};
+    for (const [k, v] of Object.entries(params)) {
+      out[k.startsWith("$") ? k.slice(1) : k] = v;
+    }
+    return out;
+  }
+}
+async function openDb(filepath) {
+  if (process.env.HOUDINI_PLATFORM === "wasm") {
+    const SQL = await initSqlJs();
+    let db;
+    if (filepath !== ":memory:" && existsSync(filepath)) {
+      db = new SQL.Database(new Uint8Array(readFileSync(filepath)));
+    } else {
+      db = new SQL.Database();
+    }
+    db.run("PRAGMA journal_mode = DELETE");
+    db.run("PRAGMA foreign_keys = ON");
+    db.run("PRAGMA defer_foreign_keys = ON");
+    return new SqlJsDb(db, SQL, filepath);
+  }
+  let conn;
+  if (process.versions?.bun) {
+    const { Database } = await import("bun:sqlite");
+    conn = new Database(filepath, { create: true });
+  } else {
+    const { DatabaseSync } = await import("node:sqlite");
+    conn = new DatabaseSync(filepath);
+  }
+  conn.exec("PRAGMA journal_mode = WAL");
+  conn.exec("PRAGMA busy_timeout = 5000");
+  conn.exec("PRAGMA synchronous = off");
+  conn.exec("PRAGMA foreign_keys = ON");
+  conn.exec("PRAGMA defer_foreign_keys = ON");
+  return new NativeDb(conn, filepath);
+}
+export {
+  openDb
+};

package/build/lib/deepMerge.js

@@ -0,0 +1,23 @@
+import merge from "deepmerge";
+import { HoudiniError } from "./error.js";
+function deepMerge(filepath, ...targets) {
+  try {
+    if (targets.length === 1) {
+      return targets[0];
+    } else if (targets.length === 2) {
+      return merge(targets[0], targets[1], {
+        arrayMerge: (source, update) => [...new Set(source.concat(update))]
+      });
+    }
+    return deepMerge(filepath, targets[0], deepMerge(filepath, ...targets.slice(1)));
+  } catch (e) {
+    throw new HoudiniError({
+      filepath,
+      message: `could not merge: ${JSON.stringify(targets, null, 4)}`,
+      description: e.message
+    });
+  }
+}
+export {
+  deepMerge
+};

package/build/lib/error.d.ts

@@ -7,3 +7,19 @@ export declare class HoudiniError extends Error {
         description?: string | null;
     });
 }
+export declare function format_error(e: unknown, after?: (e: Error) => void): void;
+export type HookError = {
+    message: string;
+    detail: string;
+    locations: HookErrorLocation[];
+    kind: string;
+};
+type HookErrorLocation = {
+    filepath: string;
+    line: number;
+    column: number;
+};
+export declare function format_hook_error(rootDir: string, error: HookError, plugin: string, hook: string): void;
+export declare function format_codeblock(code: string[], lineNrStart: number): string;
+export declare function formatErrors(e: unknown, afterError?: (e: Error) => void): void;
+export {};

package/build/lib/error.js

@@ -0,0 +1,115 @@
+import { styleText } from "node:util";
+import { readFileSync } from "./fs.js";
+import * as path from "./path.js";
+class HoudiniError extends Error {
+  filepath = null;
+  description = null;
+  constructor({
+    filepath,
+    message,
+    description
+  }) {
+    super(message);
+    if (filepath) {
+      this.filepath = filepath;
+    }
+    if (description) {
+      this.description = description;
+    }
+  }
+}
+function format_error(e, after) {
+  const errors = Array.isArray(e) ? e : [e];
+  for (const error of errors) {
+    if ("filepath" in error && error.filepath) {
+      const relative = path.relative(process.cwd(), error.filepath);
+      console.error(`\u274C Encountered error in ${relative}`);
+      if (error.message) {
+        console.error(error.message);
+      }
+    } else {
+      console.error(`\u274C ${error.message}`);
+      if ("description" in error && error.description) {
+        console.error(`${error.description}`);
+      }
+    }
+    after?.(e);
+  }
+}
+function format_hook_error(rootDir, error, plugin, hook) {
+  let message = `-- ${styleText(
+    "red",
+    `${error.kind ?? "internal"} error during ${hook.toLowerCase()} @ ${plugin}`
+  )} -----------------------------
+`;
+  message += `${error.message}
+`;
+  message += "\n";
+  try {
+    if (error.locations) {
+      error.locations.forEach((location) => {
+        const filepath = location.filepath.includes(rootDir) ? location.filepath : path.join(rootDir, location.filepath);
+        const contents = readFileSync(filepath);
+        if (!contents) {
+          message += `${location.filepath}`;
+          return;
+        }
+        const lines = contents.split("\n");
+        message += `${location.filepath}:${location.line}:${location.column}
+`;
+        const extraLines = 3;
+        const startLine = Math.max(location.line - extraLines, 0);
+        const code = lines.slice(startLine - 1, location.line);
+        message += format_codeblock(code, startLine);
+        const gutterOffset = ` ${location.line} | `.length;
+        message += " ".repeat(gutterOffset);
+        message += " ".repeat(Math.max(location.column - 1, 0));
+        message += styleText("red", "^---- error reported here");
+        message += "\n";
+      });
+    }
+  } finally {
+  }
+  if (error.detail) {
+    message += `
+${error.detail}`;
+  }
+  console.error(message);
+}
+function format_codeblock(code, lineNrStart) {
+  let output = "";
+  const maxLineNrWidth = (lineNrStart + code.length).toString().length;
+  for (let i = 0; i < code.length; i++) {
+    const normalized = code[i].replaceAll("	", "    ");
+    const lineNr = (lineNrStart + i).toString();
+    const spacing = " ".repeat(maxLineNrWidth - lineNr.length);
+    output += ` ${spacing}${lineNr} | ${normalized}
+`;
+  }
+  return output;
+}
+function formatErrors(e, afterError) {
+  const errors = Array.isArray(e) ? e : [e];
+  for (const error of errors) {
+    if ("filepath" in error && error.filepath) {
+      const relative = path.relative(process.cwd(), error.filepath);
+      console.error(`\u274C Encountered error in ${relative}`);
+      if (error.message) {
+        console.error(error.message);
+      }
+    } else {
+      console.error(`\u274C ${error.message}`);
+      if ("description" in error && error.description) {
+        console.error(`${error.description}`);
+      }
+    }
+    afterError?.(e);
+  }
+}
+export {
+  HoudiniError,
+  formatErrors,
+  format_codeblock,
+  format_error,
+  format_hook_error
+};

package/build/lib/fs.d.ts

@@ -1,18 +1,17 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import fsExtra from 'fs-extra';
-import type { Dirent } from 'node:fs';
-export declare function copyFileSync(src: string, dest: string): void | null;
-export declare function copyFile(src: string, dest: string): Promise<void | null>;
+import type { Dirent, Stats } from 'node:fs';
+export declare function copyFileSync(src: string, dest: string): undefined | null;
+export declare function copyFile(src: string, dest: string): Promise<undefined | null>;
 export declare function readFile(filepath: string, encoding?: BufferEncoding): Promise<string | null>;
 export declare function readFileSync(filepath: string): string | null;
 export declare function writeFile(filepath: string, data: string): Promise<void>;
-export declare function access(filepath: string): Promise<void | import("memfs/lib/Stats").Stats<number>>;
-export declare function mkdirp(filepath: string): Promise<void>;
-export declare function mkdirpSync(filepath: string): Promise<void>;
+export declare function access(filepath: string): Promise<void>;
+export declare function mkdirp(filepath: string): Promise<string | void>;
+export declare function mkdirpSync(filepath: string): Promise<string | void>;
 export declare function mkdir(filepath: string): Promise<void>;
 export declare function rmdir(filepath: string): Promise<unknown>;
-export declare function stat(filepath: string): Promise<import("memfs/lib/Stats").Stats<number> | fsExtra.Stats>;
+export declare function stat(filepath: string): Promise<Stats>;
+export declare function statSync(filepath: string): Stats;
 export declare function existsSync(dirPath: string): boolean;
 export declare function readdir(path: string, options?: never): Promise<string[]>;
 export declare function readdir(path: string, options?: fsExtra.ObjectEncodingOptions & {
@@ -29,7 +28,6 @@ export declare function snapshot(base?: string): {
 };
 export declare function glob(pattern: string): Promise<string[]>;
 export declare namespace glob {
-    var hasMagic: (pattern: string | string[], options?: import("glob").GlobOptions | undefined) => boolean;
+    var hasMagic: (pattern: string | string[], options?: import("glob/raw").GlobOptions) => boolean;
 }
-export declare function walk(dir: string): AsyncGenerator<string>;
 export {};

package/build/lib/fs.js

@@ -0,0 +1,245 @@
+import fsExtra from "fs-extra";
+import { glob as G } from "glob";
+import { fs as memfs, vol } from "memfs";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import { promisify } from "node:util";
+import { houdini_mode } from "./constants.js";
+import * as path from "./path.js";
+function copyFileSync(src, dest) {
+  if (houdini_mode.is_testing) {
+    try {
+      if (src.includes("build/runtime") || dest.includes("build/runtime")) {
+        fsExtra.copyFileSync(src, dest);
+        return;
+      }
+      memfs.copyFileSync(src, dest);
+      return;
+    } catch (_e) {
+      return null;
+    }
+  }
+  try {
+    fsExtra.copyFileSync(src, dest);
+    return;
+  } catch (_e) {
+  }
+  return null;
+}
+async function copyFile(src, dest) {
+  if (houdini_mode.is_testing) {
+    try {
+      if (src.includes("build/runtime") || dest.includes("build/runtime")) {
+        await fs.copyFile(src, dest);
+        return;
+      }
+      await memfs.copyFile(src, dest, (err) => {
+        throw err;
+      });
+      return;
+    } catch (_e) {
+      return null;
+    }
+  }
+  try {
+    await fs.copyFile(src, dest);
+    return;
+  } catch (_e) {
+  }
+  return null;
+}
+async function readFile(filepath, encoding) {
+  if (houdini_mode.is_testing) {
+    try {
+      if (filepath.includes("build/runtime")) {
+        return await fs.readFile(filepath, encoding ?? "utf-8");
+      }
+      return memfs.readFileSync(filepath, encoding ?? "utf-8").toString();
+    } catch (_e) {
+      return null;
+    }
+  }
+  try {
+    return await fs.readFile(filepath, "utf8");
+  } catch (_error) {
+  }
+  return null;
+}
+function readFileSync(filepath) {
+  if (houdini_mode.is_testing) {
+    try {
+      if (filepath.includes("build/runtime")) {
+        return fsExtra.readFileSync(filepath, "utf-8");
+      }
+      return memfs.readFileSync(filepath, "utf-8").toString();
+    } catch (_e) {
+      return null;
+    }
+  }
+  try {
+    return fsExtra.readFileSync(filepath, "utf-8");
+  } catch (_error) {
+  }
+  return null;
+}
+async function writeFile(filepath, data) {
+  const existingFileData = await readFile(filepath);
+  if (data === existingFileData) {
+    return;
+  }
+  if (houdini_mode.is_testing) {
+    memfs.mkdirSync(path.dirname(filepath), { recursive: true });
+    return memfs.writeFileSync(filepath, data);
+  }
+  return await fs.writeFile(filepath, data, "utf8");
+}
+async function access(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fs.access(filepath);
+  }
+  if (filepath.includes("build/runtime")) {
+    return await fs.access(filepath);
+  }
+  memfs.statSync(filepath);
+}
+async function mkdirp(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fsExtra.mkdirp(filepath);
+  }
+  return memfs.mkdirSync(filepath, { recursive: true });
+}
+async function mkdirpSync(filepath) {
+  if (!houdini_mode.is_testing) {
+    return fsExtra.mkdirpSync(filepath);
+  }
+  return memfs.mkdirSync(filepath, { recursive: true });
+}
+async function mkdir(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fs.mkdir(filepath);
+  }
+  return memfs.mkdirSync(filepath);
+}
+async function rmdir(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fs.rm(filepath, {
+      recursive: true
+    });
+  }
+  return await promisify(memfs.rmdir)(filepath);
+}
+async function stat(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fs.stat(filepath);
+  }
+  if (filepath.includes("build/runtime")) {
+    return await fs.stat(filepath);
+  }
+  return memfs.statSync(filepath);
+}
+function statSync(filepath) {
+  if (!houdini_mode.is_testing) {
+    return fsSync.statSync(filepath);
+  }
+  return memfs.statSync(filepath);
+}
+function existsSync(dirPath) {
+  if (!houdini_mode.is_testing) {
+    return fsExtra.existsSync(dirPath);
+  }
+  return memfs.existsSync(dirPath);
+}
+async function readdir(filepath, opts) {
+  if (!houdini_mode.is_testing) {
+    return await fs.readdir(filepath, opts);
+  }
+  if (filepath.includes("build/runtime")) {
+    return await fs.readdir(filepath, opts);
+  }
+  try {
+    return memfs.readdirSync(filepath, opts);
+  } catch {
+    return [];
+  }
+}
+async function remove(filepath) {
+  if (!houdini_mode.is_testing) {
+    return await fs.rm(filepath);
+  }
+  return vol.rmSync(filepath);
+}
+async function mock(target, filepath = "") {
+  await Promise.all(
+    Object.entries(target).map(async ([key, value]) => {
+      const childPath = path.join(filepath, key);
+      if (typeof value === "string") {
+        await writeFile(childPath, value);
+      } else {
+        await mkdirp(childPath);
+        return await mock(value, childPath);
+      }
+    })
+  );
+}
+async function recursiveCopy(source, target, transforms, notRoot) {
+  let parentDir = path.join(target, path.basename(source));
+  if (!notRoot) {
+    parentDir = path.join(parentDir, "..");
+  }
+  try {
+    await access(parentDir);
+  } catch (_e) {
+    await mkdirp(parentDir);
+  }
+  if ((await stat(source)).isDirectory()) {
+    await Promise.all(
+      (await readdir(source)).map(async (child) => {
+        const childPath = path.join(source, child);
+        if ((await stat(childPath)).isDirectory()) {
+          await recursiveCopy(childPath, parentDir, transforms, true);
+        } else {
+          const targetPath = path.join(parentDir, child);
+          if (transforms?.[childPath]) {
+            const original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
+          }
+        }
+      })
+    );
+  }
+}
+function snapshot(base) {
+  return Object.fromEntries(
+    Object.entries(vol.toJSON()).filter(([key]) => !base || key.startsWith(base)).map(([key, value]) => [!base ? key : key.substring(base.length), value])
+  );
+}
+async function glob(pattern) {
+  return await G(path.posixify(pattern));
+}
+glob.hasMagic = G.hasMagic;
+export {
+  access,
+  copyFile,
+  copyFileSync,
+  existsSync,
+  glob,
+  mkdir,
+  mkdirp,
+  mkdirpSync,
+  mock,
+  readFile,
+  readFileSync,
+  readdir,
+  recursiveCopy,
+  remove,
+  rmdir,
+  snapshot,
+  stat,
+  statSync,
+  writeFile
+};

package/build/lib/graphql.d.ts

@@ -1,38 +1,11 @@
 import * as graphql from 'graphql';
-import type { Document, Config } from '.';
-export declare function getRootType(type: graphql.GraphQLType): graphql.GraphQLType;
-export declare function processComponentFieldDirective(directive: graphql.DirectiveNode): {
-    field: string;
-    prop: string;
-    export?: string;
-    raw?: string;
-};
-export declare function hashOriginal({ document }: {
-    document: Document;
-}): string;
-export declare function hashRaw({ document }: {
-    document: Document;
-}): string;
-type GraphQLParentType = graphql.GraphQLObjectType | graphql.GraphQLInputObjectType | graphql.GraphQLInterfaceType;
-export declare function parentField(ancestors: readonly any[]): graphql.FieldNode | graphql.InlineFragmentNode | graphql.OperationDefinitionNode | graphql.FragmentDefinitionNode | null;
-export declare function parentTypeFromAncestors(schema: graphql.GraphQLSchema, filepath: string, ancestors: readonly any[]): GraphQLParentType;
-export declare function definitionFromAncestors(ancestors: readonly any[]): {
-    parents: (graphql.FieldNode | graphql.InlineFragmentNode | graphql.FragmentDefinitionNode | graphql.SelectionSetNode | graphql.OperationDefinitionNode)[];
-    definition: graphql.FragmentDefinitionNode | graphql.OperationDefinitionNode;
-};
-export declare function formatErrors(e: unknown, afterError?: (e: Error) => void): void;
-export declare function operation_requires_variables(operation: graphql.OperationDefinitionNode): boolean;
-export declare function unwrapType(config: Config, type: any, wrappers?: TypeWrapper[], convertRuntimeScalars?: boolean): {
-    type: graphql.GraphQLNamedType;
-    wrappers: TypeWrapper[];
-};
-export declare function wrapType({ type, wrappers, }: {
-    type: graphql.GraphQLNamedType;
-    wrappers: TypeWrapper[];
-}): graphql.TypeNode;
+import type { Config } from './config.js';
 export declare enum TypeWrapper {
     Nullable = "Nullable",
     List = "List",
     NonNull = "NonNull"
 }
-export {};
+export declare function unwrapType(config: Config, type: any, wrappers?: TypeWrapper[], convertRuntimeScalars?: boolean): {
+    type: graphql.GraphQLNamedType;
+    wrappers: TypeWrapper[];
+};

package/build/lib/graphql.js

@@ -0,0 +1,36 @@
+import * as graphql from "graphql";
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
+function unwrapType(config, type, wrappers = [], convertRuntimeScalars) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config, type.type, ["NonNull" /* NonNull */, ...wrappers]);
+  }
+  if (type instanceof graphql.GraphQLNonNull) {
+    return unwrapType(config, type.ofType, ["NonNull" /* NonNull */, ...wrappers]);
+  }
+  if (wrappers[0] !== "NonNull" /* NonNull */) {
+    wrappers.unshift("Nullable" /* Nullable */);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config, type.type, ["List" /* List */, ...wrappers]);
+  }
+  if (type instanceof graphql.GraphQLList) {
+    return unwrapType(config, type.ofType, ["List" /* List */, ...wrappers]);
+  }
+  if (convertRuntimeScalars && config.config_file.runtimeScalars?.[type.name.value]) {
+    type = config.schema.getType(config.config_file.runtimeScalars?.[type.name.value].type);
+  }
+  const namedType = config.schema.getType(type.name.value || type.name);
+  if (!namedType) {
+    throw new Error(`Unknown type: ${type.name.value}` || type.name);
+  }
+  return { type: namedType, wrappers };
+}
+export {
+  TypeWrapper,
+  unwrapType
+};