houdini 0.18.3 → 0.19.0

package/build/lib/config.d.ts

@@ -3,12 +3,17 @@ import type { CustomPluginOptions, LoadResult, ObjectHook, PluginContext, Resolv
 import { ConfigFile, CachePolicy } from '../runtime/lib';
 import { TransformPage } from '../vite/houdini';
 import { CollectedGraphQLDocument } from './types';
+export type PluginMeta = Plugin & {
+    name: string;
+    include_runtime: boolean;
+    version: string;
+    directory: string;
+};
 export declare class Config {
     filepath: string;
     rootDir: string;
     projectRoot: string;
     schema: graphql.GraphQLSchema;
-    apiUrl?: string;
     schemaPath?: string;
     persistedQueryPath?: string;
     exclude: string[];
@@ -30,21 +35,19 @@ export declare class Config {
     configIsRoute: ((filepath: string) => boolean) | null;
     routesDir: string;
     schemaPollInterval: number | null;
-    schemaPollHeaders: Record<string, string | ((env: any) => string)>;
+    schemaPollHeaders: ((env: any) => Record<string, string>) | Record<string, string | ((env: any) => string)>;
     pluginMode: boolean;
-    plugins: (Plugin & {
-        name: string;
-        include_runtime: boolean;
-        version: string;
-        directory: string;
-    })[];
+    plugins: PluginMeta[];
     constructor({ filepath, loadFrameworkConfig, ...configFile }: ConfigFile & {
         filepath: string;
         loadFrameworkConfig?: boolean;
     });
+    apiURL(): Promise<string | undefined>;
     get include(): string[];
     pluginConfig<ConfigType extends {}>(name: string): ConfigType;
-    get pullHeaders(): any;
+    getEnv(): Promise<Record<string, string | undefined>>;
+    processEnvValues(env: Record<string, string | undefined>, value: string | ((env: any) => string)): string | undefined;
+    pullHeaders(): Promise<any>;
     sourceFiles(): Promise<string[]>;
     get artifactDirectory(): string;
     get artifactDirectoryName(): string;
@@ -135,14 +138,16 @@ export declare enum LogLevel {
     Quiet = "quiet"
 }
 export type PluginFactory = (args?: PluginConfig) => Promise<Plugin>;
+export declare const orderedPlugins: (plugins: PluginMeta[]) => PluginMeta[];
 export type Plugin = {
+    order?: 'before' | 'after' | 'core';
     extensions?: string[];
     transform_runtime?: Record<string, (args: {
         config: Config;
         content: string;
     }) => string>;
     after_load?: (config: Config) => Promise<void> | void;
-    extract_documents?: (filepath: string, content: string) => Promise<string[]> | string[];
+    extract_documents?: (config: Config, filepath: string, content: string) => Promise<string[]> | string[];
     generate?: GenerateHook;
     transform_file?: (page: TransformPage) => Promise<{
         code: string;
@@ -150,6 +155,18 @@ export type Plugin = {
         code: string;
     };
     index_file?: ModuleIndexTransform;
+    graphql_tag_return?: (args: {
+        config: Config;
+        doc: CollectedGraphQLDocument;
+        ensure_import: (import_args: {
+            identifier: string;
+            module: string;
+        }) => void;
+    }) => string | undefined;
+    env?: (args: {
+        env: any;
+        config: Config;
+    }) => Promise<Record<string, string>>;
     validate?: (args: {
         config: Config;
         documents: CollectedGraphQLDocument[];

package/build/lib-cjs/index.js

@@ -58299,6 +58299,7 @@ __export(lib_exports, {
   houdini_mode: () => houdini_mode,
   keyFieldsForType: () => keyFieldsForType,
   operation_requires_variables: () => operation_requires_variables,
+  orderedPlugins: () => orderedPlugins,
   parentTypeFromAncestors: () => parentTypeFromAncestors,
   parseJS: () => parseJS,
   parseJSON: () => parseJSON,
@@ -61970,6 +61971,46 @@ var ListCollection = class {
   }
 };
 
+// src/runtime/cache/schema.ts
+var SchemaManager = class {
+  cache;
+  fieldTypes = {};
+  constructor(cache) {
+    this.cache = cache;
+  }
+  setFieldType({
+    parent,
+    key,
+    type,
+    nullable = false,
+    link
+  }) {
+    let parensIndex = key.indexOf("(");
+    if (parensIndex !== -1) {
+      key = key.substring(0, parensIndex);
+    }
+    if (parent === rootID) {
+      parent = "Query";
+    } else if (parent.includes(":")) {
+      parent = parent.substring(0, parent.indexOf(":"));
+    }
+    if (!this.fieldTypes[parent]) {
+      this.fieldTypes[parent] = {};
+    }
+    this.fieldTypes[parent][key] = {
+      type,
+      nullable,
+      link: !!link
+    };
+  }
+  fieldType(type, field) {
+    return this.fieldTypes[type]?.[field] || null;
+  }
+  get config() {
+    return this.cache._internal_unstable.config;
+  }
+};
+
 // src/runtime/cache/storage.ts
 var InMemoryStorage = class {
   data;
@@ -62537,7 +62578,7 @@ var InMemorySubscriptions = class {
 };
 
 // src/runtime/cache/cache.ts
-var Cache2 = class {
+var Cache3 = class {
   _internal_unstable;
   constructor(config) {
     this._internal_unstable = new CacheInternal({
@@ -62545,7 +62586,8 @@ var Cache2 = class {
       storage: new InMemoryStorage(),
       subscriptions: new InMemorySubscriptions(this),
       lists: new ListManager(this, rootID),
-      lifetimes: new GarbageCollector(this)
+      lifetimes: new GarbageCollector(this),
+      schema: new SchemaManager(this)
     });
     if (config) {
       this.setConfig(defaultConfigValues(config));
@@ -62631,18 +62673,21 @@ var CacheInternal = class {
   lists;
   cache;
   lifetimes;
+  schema;
   constructor({
     storage,
     subscriptions,
     lists,
     cache,
-    lifetimes
+    lifetimes,
+    schema
   }) {
     this.storage = storage;
     this.subscriptions = subscriptions;
     this.lists = lists;
     this.cache = cache;
     this.lifetimes = lifetimes;
+    this.schema = schema;
     this._disabled = typeof globalThis.window === "undefined";
     try {
       if (process.env.HOUDINI_TEST === "true") {
@@ -62658,7 +62703,6 @@ var CacheInternal = class {
     data,
     selection,
     variables = {},
-    root = rootID,
     parent = rootID,
     applyUpdates = false,
     layer,
@@ -62681,9 +62725,17 @@ var CacheInternal = class {
         selection: fieldSelection,
         operations,
         abstract: isAbstract,
-        update
+        update,
+        nullable
       } = targetSelection[field];
       const key = evaluateKey(keyRaw, variables);
+      this.schema.setFieldType({
+        parent,
+        key: keyRaw,
+        type: linkedType,
+        nullable,
+        link: !!fieldSelection
+      });
       const currentSubscribers = this.subscriptions.get(parent, key);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
@@ -62752,7 +62804,6 @@ var CacheInternal = class {
         }
         if (linkedID) {
           this.writeSelection({
-            root,
             selection: fieldSelection,
             parent: linkedID,
             data: value,
@@ -63143,7 +63194,7 @@ var CacheInternal = class {
 var rootID = "_ROOT_";
 
 // src/runtime/cache/index.ts
-var cache_default = new Cache2();
+var cache_default = new Cache3();
 
 // src/runtime/lib/types.ts
 var CachePolicy = /* @__PURE__ */ ((CachePolicy2) => {
@@ -63361,6 +63412,7 @@ async function writeFile(filepath, data) {
     return;
   }
   if (houdini_mode.is_testing) {
+    import_memfs.fs.mkdirpSync(dirname(filepath));
     return import_memfs.fs.writeFileSync(filepath, data);
   }
   return await import_promises.default.writeFile(filepath, data, "utf8");
@@ -64728,7 +64780,6 @@ var Config = class {
   rootDir;
   projectRoot;
   schema;
-  apiUrl;
   schemaPath;
   persistedQueryPath;
   exclude;
@@ -64768,7 +64819,6 @@ var Config = class {
       schema,
       schemaPath = "./schema.graphql",
       exclude = [],
-      apiUrl,
       module: module2 = "esm",
       scalars,
       cacheBufferSize,
@@ -64799,11 +64849,6 @@ var Config = class {
       logLevel = LogLevel.Summary;
     }
     this.schemaPath = schemaPath;
-    if (apiUrl && apiUrl.startsWith("env:")) {
-      this.apiUrl = process.env[apiUrl.slice("env:".length)];
-    } else {
-      this.apiUrl = apiUrl;
-    }
     this.filepath = filepath;
     this.exclude = Array.isArray(exclude) ? exclude : [exclude];
     this.module = module2;
@@ -64833,6 +64878,13 @@ var Config = class {
       };
     }
   }
+  async apiURL() {
+    if (!this.configFile.apiUrl) {
+      return "";
+    }
+    const env = await this.getEnv();
+    return this.processEnvValues(env, this.configFile.apiUrl);
+  }
   get include() {
     if (this.configFile.include) {
       return Array.isArray(this.configFile.include) ? this.configFile.include : [this.configFile.include];
@@ -64845,23 +64897,43 @@ var Config = class {
   pluginConfig(name) {
     return this.configFile.plugins?.[name] ?? {};
   }
-  get pullHeaders() {
-    return Object.fromEntries(
+  async getEnv() {
+    let env = process.env;
+    for (const plugin of this.plugins) {
+      if (plugin.env) {
+        env = {
+          ...await plugin.env({ config: this, env })
+        };
+      }
+    }
+    return env;
+  }
+  processEnvValues(env, value) {
+    let headerValue;
+    if (typeof value === "function") {
+      headerValue = value(env);
+    } else if (value.startsWith("env:")) {
+      headerValue = env[value.slice("env:".length)];
+    } else {
+      headerValue = value;
+    }
+    return headerValue;
+  }
+  async pullHeaders() {
+    const env = await this.getEnv();
+    if (typeof this.schemaPollHeaders === "function") {
+      return this.schemaPollHeaders(env);
+    }
+    const headers = Object.fromEntries(
       Object.entries(this.schemaPollHeaders || {}).map(([key, value]) => {
-        let headerValue;
-        if (typeof value === "function") {
-          headerValue = value(process.env);
-        } else if (value.startsWith("env:")) {
-          headerValue = process.env[value.slice("env:".length)];
-        } else {
-          headerValue = value;
-        }
+        const headerValue = this.processEnvValues(env, value);
         if (!headerValue) {
           return [];
         }
         return [key, headerValue];
-      })
+      }).filter(([key]) => key)
     );
+    return headers;
   }
   async sourceFiles() {
     return [
@@ -65267,9 +65339,10 @@ async function getConfig({
       ...extraConfig,
       filepath: configPath
     });
+    const apiURL = await _config.apiURL();
     if (_config.schemaPath && !_config.schema) {
       let schemaOk = true;
-      if (_config.apiUrl) {
+      if (apiURL) {
         if (glob.hasMagic(_config.schemaPath)) {
           console.log(
             `\u26A0\uFE0F  Your houdini configuration contains an apiUrl and a path pointing to multiple files.
@@ -65277,7 +65350,7 @@ This will prevent your schema from being pulled.`
           );
         } else if (!await readFile(_config.schemaPath)) {
           console.log("\u231B Pulling schema from api");
-          schemaOk = await pullSchema(_config.apiUrl, _config.schemaPath);
+          schemaOk = await pullSchema(apiURL, _config.schemaPath);
         }
       }
       if (schemaOk && !noSchema) {
@@ -65288,10 +65361,11 @@ This will prevent your schema from being pulled.`
     reject(e2);
     throw e2;
   }
+  const plugins = [];
   for (const [pluginName, plugin_config] of Object.entries(_config.configFile.plugins ?? {})) {
     try {
       const pluginDirectory = _config.findModule(pluginName);
-      const { default: sveltePlugin } = await import((0, import_url.pathToFileURL)(pluginDirectory).toString() + "/build/plugin-esm/index.js");
+      const { default: pluginFactory } = await import((0, import_url.pathToFileURL)(pluginDirectory).toString() + "/build/plugin-esm/index.js");
       let include_runtime = false;
       try {
         await stat(join2(pluginDirectory, "build", "runtime-esm"));
@@ -65308,8 +65382,8 @@ This will prevent your schema from being pulled.`
         version = packageJSON.version;
       } catch {
       }
-      _config.plugins.push({
-        ...await sveltePlugin(plugin_config),
+      plugins.push({
+        ...await pluginFactory(plugin_config),
         name: pluginName,
         include_runtime,
         version,
@@ -65321,6 +65395,7 @@ This will prevent your schema from being pulled.`
       );
     }
   }
+  _config.plugins = orderedPlugins(plugins);
   await Promise.all(_config.plugins.map((plugin) => plugin.after_load?.(_config)));
   resolve2(_config);
   return _config;
@@ -65332,6 +65407,16 @@ var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2["Quiet"] = "quiet";
   return LogLevel2;
 })(LogLevel || {});
+var orderedPlugins = (plugins) => {
+  const ordered = plugins.filter(
+    (plugin) => plugin.order === "before" || plugin.order === void 0
+  );
+  ordered.push(
+    ...plugins.filter((plugin) => plugin.order === "core"),
+    ...plugins.filter((plugin) => plugin.order === "after")
+  );
+  return ordered;
+};
 
 // src/lib/graphql.ts
 var import_crypto = __toESM(require("crypto"), 1);
@@ -65640,47 +65725,69 @@ var graphql4 = __toESM(require_graphql2(), 1);
 async function find_graphql(config, parsedScript, walker) {
   await asyncWalk(parsedScript, {
     async enter(node, parent) {
-      if (node.type === "TaggedTemplateExpression" && node.tag.name === "graphql") {
+      if (node.type !== "TaggedTemplateExpression" && node.type !== "CallExpression") {
+        return;
+      }
+      let documentString;
+      if (node.type === "TaggedTemplateExpression") {
         const expr = node;
-        const tagContent = expr.quasi.quasis[0].value.raw;
-        const parsedTag = graphql4.parse(tagContent);
-        if (walker.where && !walker.where(parsedTag)) {
+        if (expr.tag.type !== "Identifier" || expr.tag.name !== "graphql") {
           return;
         }
-        const definition = config.extractDefinition(parsedTag);
-        const name = definition.name?.value;
-        if (!name) {
-          throw new Error("Could not find definition name");
+        documentString = expr.quasi.quasis[0].value.raw;
+      } else if (node.type === "CallExpression") {
+        const expr = node;
+        if (expr.callee.type !== "Identifier" || expr.callee.name !== "graphql" || expr.arguments.length !== 1) {
+          return;
         }
-        let kind;
-        if (definition.kind === "FragmentDefinition") {
-          kind = CompiledFragmentKind;
+        const argument = expr.arguments[0];
+        if (argument.type === "TemplateLiteral") {
+          documentString = argument.quasis[0].value.raw;
+        } else if (argument.type === "StringLiteral") {
+          documentString = argument.value;
         } else {
-          if (definition.operation === "query") {
-            kind = CompiledQueryKind;
-          } else if (definition.operation === "mutation") {
-            kind = CompiledMutationKind;
-          } else {
-            kind = CompiledSubscriptionKind;
-          }
+          return;
         }
-        walker.dependency?.(config.artifactPath(parsedTag));
-        await walker.tag({
-          parsedDocument: parsedTag,
-          node: {
-            ...node,
-            ...this,
-            remove: this.remove,
-            replaceWith: this.replace
-          },
-          artifact: {
-            name,
-            kind
-          },
-          parent,
-          tagContent
-        });
+      } else {
+        return;
       }
+      const parsedTag = graphql4.parse(documentString);
+      if (walker.where && !walker.where(parsedTag)) {
+        return;
+      }
+      const definition = config.extractDefinition(parsedTag);
+      const name = definition.name?.value;
+      if (!name) {
+        throw new Error("Could not find definition name");
+      }
+      let kind;
+      if (definition.kind === "FragmentDefinition") {
+        kind = CompiledFragmentKind;
+      } else {
+        if (definition.operation === "query") {
+          kind = CompiledQueryKind;
+        } else if (definition.operation === "mutation") {
+          kind = CompiledMutationKind;
+        } else {
+          kind = CompiledSubscriptionKind;
+        }
+      }
+      walker.dependency?.(config.artifactPath(parsedTag));
+      await walker.tag({
+        parsedDocument: parsedTag,
+        node: {
+          ...node,
+          ...this,
+          remove: this.remove,
+          replaceWith: this.replace
+        },
+        artifact: {
+          name,
+          kind
+        },
+        parent,
+        tagContent: documentString
+      });
     }
   });
 }
@@ -65714,6 +65821,7 @@ async function find_graphql(config, parsedScript, walker) {
   houdini_mode,
   keyFieldsForType,
   operation_requires_variables,
+  orderedPlugins,
   parentTypeFromAncestors,
   parseJS,
   parseJSON,