houdini 0.18.2 → 0.19.0

package/build/lib-esm/index.js

@@ -61932,6 +61932,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;
@@ -62499,7 +62539,7 @@ var InMemorySubscriptions = class {
 };
 
 // src/runtime/cache/cache.ts
-var Cache2 = class {
+var Cache3 = class {
   _internal_unstable;
   constructor(config) {
     this._internal_unstable = new CacheInternal({
@@ -62507,7 +62547,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));
@@ -62593,18 +62634,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") {
@@ -62620,7 +62664,6 @@ var CacheInternal = class {
     data,
     selection,
     variables = {},
-    root = rootID,
     parent = rootID,
     applyUpdates = false,
     layer,
@@ -62643,9 +62686,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);
@@ -62714,7 +62765,6 @@ var CacheInternal = class {
         }
         if (linkedID) {
           this.writeSelection({
-            root,
             selection: fieldSelection,
             parent: linkedID,
             data: value,
@@ -63105,7 +63155,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) => {
@@ -63323,6 +63373,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 fs.writeFile(filepath, data, "utf8");
@@ -64689,7 +64740,6 @@ var Config = class {
   rootDir;
   projectRoot;
   schema;
-  apiUrl;
   schemaPath;
   persistedQueryPath;
   exclude;
@@ -64729,7 +64779,6 @@ var Config = class {
       schema,
       schemaPath = "./schema.graphql",
       exclude = [],
-      apiUrl,
       module = "esm",
       scalars,
       cacheBufferSize,
@@ -64760,11 +64809,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 = module;
@@ -64794,6 +64838,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];
@@ -64806,23 +64857,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 [
@@ -65228,9 +65299,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.
@@ -65238,7 +65310,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) {
@@ -65249,10 +65321,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(pathToFileURL(pluginDirectory).toString() + "/build/plugin-esm/index.js");
+      const { default: pluginFactory } = await import(pathToFileURL(pluginDirectory).toString() + "/build/plugin-esm/index.js");
       let include_runtime = false;
       try {
         await stat(join2(pluginDirectory, "build", "runtime-esm"));
@@ -65269,8 +65342,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,
@@ -65282,6 +65355,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;
@@ -65293,6 +65367,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 graphql3 = __toESM(require_graphql2(), 1);
@@ -65601,47 +65685,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
+      });
     }
   });
 }
@@ -65674,6 +65780,7 @@ export {
   houdini_mode,
   keyFieldsForType,
   operation_requires_variables,
+  orderedPlugins,
   parentTypeFromAncestors,
   parseJS,
   parseJSON,

package/build/runtime/cache/cache.d.ts

@@ -2,6 +2,7 @@ import { ConfigFile } from '../lib/config';
 import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
 import { ListCollection, ListManager } from './lists';
+import { SchemaManager } from './schema';
 import { InMemoryStorage, Layer, LayerID } from './storage';
 import { InMemorySubscriptions } from './subscription';
 export declare class Cache {
@@ -37,15 +38,17 @@ declare class CacheInternal {
     lists: ListManager;
     cache: Cache;
     lifetimes: GarbageCollector;
-    constructor({ storage, subscriptions, lists, cache, lifetimes, }: {
+    schema: SchemaManager;
+    constructor({ storage, subscriptions, lists, cache, lifetimes, schema, }: {
         storage: InMemoryStorage;
         subscriptions: InMemorySubscriptions;
         lists: ListManager;
         cache: Cache;
         lifetimes: GarbageCollector;
+        schema: SchemaManager;
     });
     setConfig(config: ConfigFile): void;
-    writeSelection({ data, selection, variables, root, parent, applyUpdates, layer, toNotify, forceNotify, }: {
+    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, }: {
         data: {
             [key: string]: GraphQLValue;
         };

package/build/runtime/cache/schema.d.ts

@@ -0,0 +1,21 @@
+import { ConfigFile } from '../lib';
+import { Cache } from './cache';
+export type TypeInfo = {
+    type: string;
+    nullable: boolean;
+    link: boolean;
+};
+export declare class SchemaManager {
+    cache: Cache;
+    fieldTypes: Record<string, Record<string, TypeInfo>>;
+    constructor(cache: Cache);
+    setFieldType({ parent, key, type, nullable, link, }: {
+        parent: string;
+        key: string;
+        type: string;
+        nullable?: boolean;
+        link?: boolean;
+    }): void;
+    fieldType(type: string, field: string): TypeInfo;
+    get config(): ConfigFile;
+}

package/build/runtime/generated.d.ts

@@ -0,0 +1,4 @@
+export type CacheTypeDef = {
+    types: {};
+    lists: {};
+};

package/build/runtime/index.d.ts

@@ -1,4 +1,7 @@
-import type { Cache } from './cache/cache';
+import { Cache as InternalCache } from './cache/cache';
+import type { CacheTypeDef } from './generated';
+import { Cache } from './public';
 export * from './lib';
-export declare function graphql(str: TemplateStringsArray): any;
-export declare function getCache(): Cache;
+export declare function graphql(str: string | TemplateStringsArray): any;
+export declare const cache: Cache<CacheTypeDef>;
+export declare function getCache(): InternalCache;

package/build/runtime/lib/config.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { GraphQLSchema } from 'graphql';
 import { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
@@ -35,7 +34,7 @@ export type ConfigFile = {
     /**
      * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
      */
-    apiUrl?: string;
+    apiUrl?: string | ((env: Record<string, string | undefined>) => string);
     /**
      * An object describing custom scalars for your project. For more information: https://www.houdinigraphql.com/api/config#custom-scalars
      */
@@ -104,7 +103,7 @@ export type ConfigFile = {
      * directly. If the value is a function, the current environment will be passed to your function so you can perform any
      * logic you need
      */
-    schemaPollHeaders?: Record<string, string | ((env: NodeJS.ProcessEnv) => string)>;
+    schemaPollHeaders?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
     /**
      * An object describing the plugins enabled for the project
      */
@@ -114,6 +113,11 @@ export type ConfigFile = {
      * @default process.cwd()
      */
     projectDir?: string;
+    /**
+     * For now, the cache's imperative API is considered unstable. In order to suppress the warning,
+     * you must enable this flag.
+     */
+    acceptImperativeInstability?: boolean;
 };
 type ScalarMap = {
     [typeName: string]: ScalarSpec;
@@ -121,7 +125,7 @@ type ScalarMap = {
 export type TypeConfig = {
     [typeName: string]: {
         keys?: string[];
-        resolve: {
+        resolve?: {
             queryField: string;
             arguments?: (data: any) => {
                 [key: string]: any;

package/build/runtime/lib/network.d.ts

@@ -4,7 +4,7 @@ import { CachePolicy, GraphQLObject, MutationArtifact, QueryArtifact, FetchQuery
 export declare class HoudiniClient {
     private fetchFn;
     socket: SubscriptionHandler | null | undefined;
-    constructor(networkFn: RequestHandler<any>, subscriptionHandler?: SubscriptionHandler | null);
+    constructor(requestHandler: RequestHandler<any>, subscriptionHandler?: SubscriptionHandler | null);
     handleMultipart(params: FetchParams, args: Parameters<FetchContext['fetch']>): Parameters<FetchContext['fetch']> | undefined;
     sendRequest<_Data>(ctx: FetchContext, params: FetchParams): Promise<RequestPayloadMagic<_Data>>;
 }
@@ -53,7 +53,7 @@ export type FetchContext = {
 export type RequestHandlerArgs = FetchContext & FetchParams & {
     session?: App.Session;
 };
-export type RequestHandler<_Data> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
+export type RequestHandler<_Data = any> = (args: RequestHandlerArgs) => Promise<RequestPayload<_Data>>;
 export declare function executeQuery<_Data extends GraphQLObject, _Input extends {}>({ client, artifact, variables, session, setFetching, cached, fetch, metadata, }: {
     client: HoudiniClient;
     artifact: QueryArtifact | MutationArtifact;

package/build/runtime/lib/types.d.ts

@@ -161,10 +161,10 @@ export type QueryResult<_Data, _Input, _Extra = {}> = {
     variables: _Input;
 } & _Extra;
 export type RequestPayload<_Data = any> = {
-    data: _Data;
+    data: _Data | null;
     errors: {
         message: string;
-    }[];
+    }[] | null;
 };
 export type RequestPayloadMagic<_Data = any> = {
     ssr: boolean;

package/build/runtime/public/cache.d.ts

@@ -0,0 +1,19 @@
+import { Cache as _Cache } from '../cache/cache';
+import { SchemaManager, TypeInfo } from '../cache/schema';
+import { ListCollection } from './list';
+import { Record } from './record';
+import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';
+export declare class Cache<Def extends CacheTypeDef> {
+    _internal_unstable: _Cache;
+    constructor(cache: _Cache);
+    validateInstabilityWarning(): void;
+    setFieldType(...args: Parameters<SchemaManager['setFieldType']>): void;
+    get root(): Record<Def, '__ROOT__'>;
+    get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
+    get config(): import("..").ConfigFile;
+    list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
+        parentID?: string;
+        allLists?: boolean;
+    }): ListCollection<Def, Name>;
+}
+export declare function _typeInfo<Def extends CacheTypeDef>(cache: Cache<Def>, type: string, field: string): TypeInfo;

package/build/runtime/public/index.d.ts

@@ -0,0 +1 @@
+export { Cache } from './cache';

package/build/runtime/public/list.d.ts

@@ -0,0 +1,18 @@
+import { Cache } from './cache';
+import { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
+export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
+    #private;
+    constructor({ parentID, allLists, when, cache, name, }: {
+        name: ValidLists<Def>;
+        parentID?: string;
+        allLists?: boolean;
+        when?: ListFilters<Def, ListName>;
+        cache: Cache<Def>;
+    });
+    append(...records: ListType<Def, ListName>[]): void;
+    prepend(...records: ListType<Def, ListName>[]): void;
+    toggle(where: 'first' | 'last', ...records: ListType<Def, ListName>[]): void;
+    when(filter: ListFilters<Def, ListName>): ListCollection<Def, ListName>;
+    remove(...records: ListType<Def, ListName>[]): void;
+    [Symbol.iterator](): Generator<string, void, unknown>;
+}

package/build/runtime/public/record.d.ts

@@ -0,0 +1,31 @@
+import { Cache } from './cache';
+import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
+export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
+    #private;
+    type: string;
+    idFields: {};
+    constructor({ cache, type, id, idFields, }: {
+        cache: Cache<Def>;
+        type: string;
+        idFields: {};
+        id: string;
+    });
+    set<Field extends TypeFieldNames<Def, Type>>({ field, args, value, }: {
+        field: Field;
+        args?: ArgType<Def, Type, Field>;
+        value: FieldType<Def, Type, Field>;
+    }): void;
+    get<Field extends TypeFieldNames<Def, Type>>({ field, args, }: {
+        field: Field;
+        args?: ArgType<Def, Type, Field>;
+    }): FieldType<Def, Type, Field>;
+    delete(): void;
+}
+export declare function computeKey({ field, args }: {
+    field: string;
+    args?: {
+        [key: string]: any;
+    };
+}): string;
+export declare const stringifyObjectWithNoQuotesOnKeys: (obj_from_json: {}) => string;
+export declare function marshalNestedList(list: any[]): any[];