houdini 1.5.2 → 1.5.4

package/build/codegen-esm/index.js

@@ -52331,7 +52331,7 @@ async function runPipeline(config, pipeline, target) {
 
 // src/lib/config.ts
 var import_minimatch8 = __toESM(require_minimatch(), 1);
-import * as graphql4 from "graphql";
+import * as graphql5 from "graphql";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 
 // src/runtime/imports/config.ts
@@ -58235,10 +58235,219 @@ import * as graphql from "graphql";
 
 // src/lib/router/manifest.ts
 var t = __toESM(require_lib5(), 1);
+import * as graphql3 from "graphql";
+
+// src/lib/graphql.ts
 import * as graphql2 from "graphql";
+import crypto2 from "node:crypto";
+function getRootType(type) {
+  if (graphql2.isNonNullType(type)) {
+    return getRootType(type.ofType);
+  }
+  if (graphql2.isListType(type)) {
+    return getRootType(type.ofType);
+  }
+  return type;
+}
+function hashOriginal({ document }) {
+  return hashDocument(document.originalString);
+}
+function hashRaw({ document }) {
+  return hashDocument(document.artifact?.raw);
+}
+function hashDocument(str) {
+  return crypto2.createHash("sha256").update(str || "").digest("hex");
+}
+function parentField(ancestors) {
+  return walkParentField([...ancestors].sort(() => -1));
+}
+function walkParentField(ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head) || head.kind === "SelectionSet") {
+    return walkParentField(ancestors);
+  }
+  return head;
+}
+function parentTypeFromAncestors(schema, filepath, ancestors) {
+  const parents = [...ancestors];
+  parents.reverse();
+  return walkAncestors(schema, filepath, parents);
+}
+function walkAncestors(schema, filepath, ancestors) {
+  let head = ancestors.shift();
+  if (Array.isArray(head)) {
+    return walkAncestors(schema, filepath, ancestors);
+  }
+  if (!head) {
+    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
+  }
+  if (head.kind === "OperationDefinition") {
+    const operationType = {
+      query: schema.getQueryType(),
+      mutation: schema.getMutationType(),
+      subscription: schema.getSubscriptionType()
+    }[head.operation];
+    if (!operationType) {
+      throw new HoudiniError({ filepath, message: "Could not find operation type" });
+    }
+    return operationType;
+  }
+  if (head.kind === "FragmentDefinition") {
+    const result = schema.getType(head.typeCondition.name.value);
+    if (!result) {
+      throw new HoudiniError({
+        filepath,
+        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
+      });
+    }
+    return result;
+  }
+  if (head.kind === "FragmentSpread") {
+    throw new Error("How the hell did this happen?");
+  }
+  const parent2 = walkAncestors(schema, filepath, ancestors);
+  if (head.kind === "InlineFragment") {
+    if (!head.typeCondition) {
+      return parent2;
+    }
+    const wrapper = schema.getType(head.typeCondition.name.value);
+    if (!wrapper) {
+      throw new HoudiniError({
+        filepath,
+        message: "Could not find type with name: " + head.typeCondition.name.value
+      });
+    }
+    return wrapper;
+  }
+  if (head.kind === "SelectionSet") {
+    return parent2;
+  }
+  const field = parent2.getFields()[head.name.value];
+  if (!field) {
+    throw new HoudiniError({
+      filepath,
+      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
+    });
+  }
+  return getRootType(field.type);
+}
+function definitionFromAncestors(ancestors) {
+  let parents = [...ancestors];
+  parents.shift();
+  let definition = parents.shift();
+  while (Array.isArray(definition) && definition) {
+    definition = parents.shift();
+  }
+  return { parents, definition };
+}
+function unwrapType(config, type, wrappers = [], convertRuntimeScalars) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config, type.type, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLNonNull) {
+    return unwrapType(config, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (wrappers[0] !== TypeWrapper.NonNull) {
+    wrappers.unshift(TypeWrapper.Nullable);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config, type.type, [TypeWrapper.List, ...wrappers]);
+  }
+  if (type instanceof graphql2.GraphQLList) {
+    return unwrapType(config, type.ofType, [TypeWrapper.List, ...wrappers]);
+  }
+  if (convertRuntimeScalars && config.configFile.features?.runtimeScalars?.[type.name.value]) {
+    type = config.schema.getType(
+      config.configFile.features?.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 };
+}
+function wrapType({
+  type,
+  wrappers
+}) {
+  const head = wrappers[0];
+  const tail = wrappers.slice(1);
+  let kind = graphql2.Kind.NAMED_TYPE;
+  if (head === TypeWrapper.List) {
+    kind = graphql2.Kind.LIST_TYPE;
+  } else if (head === TypeWrapper.NonNull) {
+    kind = graphql2.Kind.NON_NULL_TYPE;
+  }
+  if (kind === "NamedType") {
+    return {
+      kind,
+      name: {
+        kind: graphql2.Kind.NAME,
+        value: type.name
+      }
+    };
+  }
+  return {
+    kind,
+    type: wrapType({ type, wrappers: tail })
+  };
+}
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
+
+// src/lib/parse.ts
+var import_parser = __toESM(require_lib6(), 1);
+var import_recast = __toESM(require_main2(), 1);
+
+// src/lib/deepMerge.ts
+var import_deepmerge = __toESM(require_cjs(), 1);
+function deepMerge2(filepath, ...targets) {
+  try {
+    if (targets.length === 1) {
+      return targets[0];
+    } else if (targets.length === 2) {
+      return (0, import_deepmerge.default)(targets[0], targets[1], {
+        arrayMerge: (source, update) => [...new Set(source.concat(update))]
+      });
+    }
+    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
+  } catch (e) {
+    throw new HoudiniError({
+      filepath,
+      message: "could not merge: " + JSON.stringify(targets, null, 4),
+      description: e.message
+    });
+  }
+}
+
+// src/lib/parse.ts
+function parseJS(str, config) {
+  const defaultConfig = {
+    plugins: [
+      "typescript",
+      "importAssertions",
+      "decorators-legacy",
+      "explicitResourceManagement"
+    ],
+    sourceType: "module"
+  };
+  return (0, import_parser.parse)(str || "", config ? deepMerge2("", defaultConfig, config) : defaultConfig).program;
+}
+async function printJS(script, options) {
+  if (options?.pretty) {
+    return (0, import_recast.prettyPrint)(script, options);
+  } else {
+    return (0, import_recast.print)(script, options);
+  }
+}
 
 // src/lib/router/server.ts
-import * as graphql3 from "graphql";
+import * as graphql4 from "graphql";
 
 // src/runtime/lib/flatten.ts
 function flatten(source) {
@@ -60582,218 +60791,9 @@ var LogLevel = {
 // src/lib/config.ts
 var currentDir = dirname(fileURLToPath3(import.meta.url));
 var DEFAULT_CONFIG_PATH = join(process.cwd(), "houdini.config.js");
-var emptySchema = graphql4.buildSchema("type Query { hello: String }");
+var emptySchema = graphql5.buildSchema("type Query { hello: String }");
 var defaultDirectives = emptySchema.getDirectives().map((dir) => dir.name);
 
-// src/lib/graphql.ts
-import * as graphql5 from "graphql";
-import crypto2 from "node:crypto";
-function getRootType(type) {
-  if (graphql5.isNonNullType(type)) {
-    return getRootType(type.ofType);
-  }
-  if (graphql5.isListType(type)) {
-    return getRootType(type.ofType);
-  }
-  return type;
-}
-function hashOriginal({ document }) {
-  return hashDocument(document.originalString);
-}
-function hashRaw({ document }) {
-  return hashDocument(document.artifact?.raw);
-}
-function hashDocument(str) {
-  return crypto2.createHash("sha256").update(str || "").digest("hex");
-}
-function parentField(ancestors) {
-  return walkParentField([...ancestors].sort(() => -1));
-}
-function walkParentField(ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head) || head.kind === "SelectionSet") {
-    return walkParentField(ancestors);
-  }
-  return head;
-}
-function parentTypeFromAncestors(schema, filepath, ancestors) {
-  const parents = [...ancestors];
-  parents.reverse();
-  return walkAncestors(schema, filepath, parents);
-}
-function walkAncestors(schema, filepath, ancestors) {
-  let head = ancestors.shift();
-  if (Array.isArray(head)) {
-    return walkAncestors(schema, filepath, ancestors);
-  }
-  if (!head) {
-    throw new HoudiniError({ filepath, message: "Could not figure out type of field" });
-  }
-  if (head.kind === "OperationDefinition") {
-    const operationType = {
-      query: schema.getQueryType(),
-      mutation: schema.getMutationType(),
-      subscription: schema.getSubscriptionType()
-    }[head.operation];
-    if (!operationType) {
-      throw new HoudiniError({ filepath, message: "Could not find operation type" });
-    }
-    return operationType;
-  }
-  if (head.kind === "FragmentDefinition") {
-    const result = schema.getType(head.typeCondition.name.value);
-    if (!result) {
-      throw new HoudiniError({
-        filepath,
-        message: `Could not find definition for ${head.typeCondition.name.value} in the schema`
-      });
-    }
-    return result;
-  }
-  if (head.kind === "FragmentSpread") {
-    throw new Error("How the hell did this happen?");
-  }
-  const parent2 = walkAncestors(schema, filepath, ancestors);
-  if (head.kind === "InlineFragment") {
-    if (!head.typeCondition) {
-      return parent2;
-    }
-    const wrapper = schema.getType(head.typeCondition.name.value);
-    if (!wrapper) {
-      throw new HoudiniError({
-        filepath,
-        message: "Could not find type with name: " + head.typeCondition.name.value
-      });
-    }
-    return wrapper;
-  }
-  if (head.kind === "SelectionSet") {
-    return parent2;
-  }
-  const field = parent2.getFields()[head.name.value];
-  if (!field) {
-    throw new HoudiniError({
-      filepath,
-      message: `Could not find definition of ${head.name.value} in ${parent2.toString()}`
-    });
-  }
-  return getRootType(field.type);
-}
-function definitionFromAncestors(ancestors) {
-  let parents = [...ancestors];
-  parents.shift();
-  let definition = parents.shift();
-  while (Array.isArray(definition) && definition) {
-    definition = parents.shift();
-  }
-  return { parents, definition };
-}
-function unwrapType(config, type, wrappers = [], convertRuntimeScalars) {
-  if (type.kind === "NonNullType") {
-    return unwrapType(config, type.type, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLNonNull) {
-    return unwrapType(config, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (wrappers[0] !== TypeWrapper.NonNull) {
-    wrappers.unshift(TypeWrapper.Nullable);
-  }
-  if (type.kind === "ListType") {
-    return unwrapType(config, type.type, [TypeWrapper.List, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLList) {
-    return unwrapType(config, type.ofType, [TypeWrapper.List, ...wrappers]);
-  }
-  if (convertRuntimeScalars && config.configFile.features?.runtimeScalars?.[type.name.value]) {
-    type = config.schema.getType(
-      config.configFile.features?.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 };
-}
-function wrapType({
-  type,
-  wrappers
-}) {
-  const head = wrappers[0];
-  const tail = wrappers.slice(1);
-  let kind = graphql5.Kind.NAMED_TYPE;
-  if (head === TypeWrapper.List) {
-    kind = graphql5.Kind.LIST_TYPE;
-  } else if (head === TypeWrapper.NonNull) {
-    kind = graphql5.Kind.NON_NULL_TYPE;
-  }
-  if (kind === "NamedType") {
-    return {
-      kind,
-      name: {
-        kind: graphql5.Kind.NAME,
-        value: type.name
-      }
-    };
-  }
-  return {
-    kind,
-    type: wrapType({ type, wrappers: tail })
-  };
-}
-var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
-  TypeWrapper2["Nullable"] = "Nullable";
-  TypeWrapper2["List"] = "List";
-  TypeWrapper2["NonNull"] = "NonNull";
-  return TypeWrapper2;
-})(TypeWrapper || {});
-
-// src/lib/parse.ts
-var import_parser = __toESM(require_lib6(), 1);
-var import_recast = __toESM(require_main2(), 1);
-
-// src/lib/deepMerge.ts
-var import_deepmerge = __toESM(require_cjs(), 1);
-function deepMerge2(filepath, ...targets) {
-  try {
-    if (targets.length === 1) {
-      return targets[0];
-    } else if (targets.length === 2) {
-      return (0, import_deepmerge.default)(targets[0], targets[1], {
-        arrayMerge: (source, update) => [...new Set(source.concat(update))]
-      });
-    }
-    return deepMerge2(filepath, targets[0], deepMerge2(filepath, ...targets.slice(1)));
-  } catch (e) {
-    throw new HoudiniError({
-      filepath,
-      message: "could not merge: " + JSON.stringify(targets, null, 4),
-      description: e.message
-    });
-  }
-}
-
-// src/lib/parse.ts
-function parseJS(str, config) {
-  const defaultConfig = {
-    plugins: [
-      "typescript",
-      "importAssertions",
-      "decorators-legacy",
-      "explicitResourceManagement"
-    ],
-    sourceType: "module"
-  };
-  return (0, import_parser.parse)(str || "", config ? deepMerge2("", defaultConfig, config) : defaultConfig).program;
-}
-async function printJS(script, options) {
-  if (options?.pretty) {
-    return (0, import_recast.prettyPrint)(script, options);
-  } else {
-    return (0, import_recast.print)(script, options);
-  }
-}
-
 // src/lib/imports.ts
 var recast = __toESM(require_main2(), 1);
 var AST2 = recast.types.builders;
@@ -60922,18 +60922,18 @@ function scalarPropertyValue(config, filepath, missingScalars, target, body, fie
       return AST3.tsNeverKeyword();
     }
     const component = config.componentFields[field.parent][field.field];
-    const sourcePathRelative = path_exports.relative(
-      path_exports.join(config.projectRoot, "src"),
+    const sourcePathRelative = relative(
+      join(config.projectRoot, "src"),
       component.filepath
     );
-    let sourcePathParsed = path_exports.parse(sourcePathRelative);
-    let sourcePath = path_exports.join(sourcePathParsed.dir, sourcePathParsed.name);
+    let sourcePathParsed = parse(sourcePathRelative);
+    let sourcePath = join(sourcePathParsed.dir, sourcePathParsed.name);
     const localImport = ensureImports({
       config,
       body,
       import: "__component__" + component.fragment,
-      sourceModule: path_exports.join(
-        path_exports.relative(path_exports.dirname(filepath), config.projectRoot),
+      sourceModule: join(
+        relative(dirname(filepath), config.projectRoot),
         "src",
         sourcePath
       )
@@ -63848,6 +63848,16 @@ async function generatePluginIndex({
 }
 
 // src/codegen/generators/runtime/pluginRuntime.ts
+function moduleStatments(config) {
+  const importStatement = config.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
+  const exportDefaultStatement = config.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
+  const exportStarStatement = config.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
+  return {
+    importStatement,
+    exportDefaultStatement,
+    exportStarStatement
+  };
+}
 async function generatePluginRuntimes({
   config,
   docs
@@ -63863,7 +63873,7 @@ async function generatePluginRuntimes({
         return;
       }
       try {
-        await fs_exports.stat(runtime_path);
+        await stat(runtime_path);
       } catch {
         throw new HoudiniError({
           message: "Cannot find runtime to generate for " + plugin2.name,
@@ -63875,13 +63885,13 @@ async function generatePluginRuntimes({
       if (transformMap && typeof transformMap === "function") {
         transformMap = transformMap(docs, { config });
       }
-      await fs_exports.mkdirp(pluginDir);
-      await fs_exports.recursiveCopy(
+      await mkdirp(pluginDir);
+      await recursiveCopy(
         runtime_path,
         pluginDir,
         Object.fromEntries(
           Object.entries(transformMap).map(([key, value]) => [
-            path_exports.join(runtime_path, key),
+            join(runtime_path, key),
             (content) => value({
               config,
               content,
@@ -63928,21 +63938,21 @@ async function runtimeGenerator(config, docs) {
     exportStarStatement: exportStar
   } = moduleStatments(config);
   await Promise.all([
-    fs_exports.recursiveCopy(config.runtimeSource, config.runtimeDirectory, {
-      [path_exports.join(config.runtimeSource, "lib", "constants.js")]: (content) => {
+    recursiveCopy(config.runtimeSource, config.runtimeDirectory, {
+      [join(config.runtimeSource, "lib", "constants.js")]: (content) => {
         return content.replace("SITE_URL", siteURL);
       },
-      [path_exports.join(config.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
+      [join(config.runtimeSource, "imports", "pluginConfig.js")]: (content) => {
         return injectConfig({ config, importStatement, exportStatement, content });
       },
-      [path_exports.join(config.runtimeSource, "imports", "config.js")]: (content) => {
-        const configFilePath = path_exports.join(config.runtimeDirectory, "imports", "config.js");
-        const relativePath = path_exports.relative(path_exports.dirname(configFilePath), config.filepath);
+      [join(config.runtimeSource, "imports", "config.js")]: (content) => {
+        const configFilePath = join(config.runtimeDirectory, "imports", "config.js");
+        const relativePath = relative(dirname(configFilePath), config.filepath);
         return `${importStatement(relativePath, "config")}
 ${exportStatement("config")}
 `;
       },
-      [path_exports.join(config.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config, content, importStatement, exportStatement })
+      [join(config.runtimeSource, "client", "plugins", "injectedPlugins.js")]: (content) => injectPlugins({ config, content, importStatement, exportStatement })
     }),
     generatePluginRuntimes({
       config,
@@ -63952,16 +63962,6 @@ ${exportStatement("config")}
   ]);
   await generateGraphqlReturnTypes(config, docs);
 }
-function moduleStatments(config) {
-  const importStatement = config.module === "commonjs" ? importDefaultFrom : (where, as) => `import ${as} from '${where}'`;
-  const exportDefaultStatement = config.module === "commonjs" ? exportDefault : (as) => `export default ${as}`;
-  const exportStarStatement = config.module === "commonjs" ? exportStarFrom : (where) => `export * from '${where}'`;
-  return {
-    importStatement,
-    exportDefaultStatement,
-    exportStarStatement
-  };
-}
 
 // src/codegen/generators/typescript/documentTypes.ts
 var recast11 = __toESM(require_main2(), 1);

package/build/lib/config.d.ts

@@ -91,7 +91,9 @@ export declare class Config {
     createDirectories(): void;
     get compiledAssetsDir(): string;
     compiledAssetPath(filepath: string): string;
-    excludeFile(filepath: string): boolean;
+    excludeFile(filepath: string, { root }: {
+        root?: string;
+    }): boolean;
     includeFile(filepath: string, { root, ignore_plugins, }?: {
         root?: string;
         ignore_plugins?: boolean;

package/build/lib/router/conventions.d.ts

@@ -1,4 +1,4 @@
-import { type Config } from '..';
+import type { Config } from '../config';
 /** The location of the project's router */
 export declare function router_path(config: Config): string;
 /** The location of the page component */

package/build/lib/router/manifest.d.ts

@@ -1,5 +1,5 @@
-import { type Config } from '..';
 import type { ProjectManifest, PageManifest, QueryManifest } from '../../runtime/lib/types';
+import type { Config } from '../config';
 export type { ProjectManifest, PageManifest, QueryManifest };
 /**
  * Walk down the routes directory and build a normalized description of the project's

package/build/lib/typescript.d.ts

@@ -1,7 +1,7 @@
 import type { StatementKind, TSTypeKind } from 'ast-types/lib/gen/kinds';
 import * as graphql from 'graphql';
 import * as recast from 'recast';
-import { type Config } from '.';
+import type { Config } from './config';
 import { TypeWrapper } from './graphql';
 export declare function unwrappedTsTypeReference(config: Config, filepath: string, missingScalars: Set<string>, { type, wrappers, }: {
     type: graphql.GraphQLNamedType;