houdini 2.0.0-next.9 → 2.0.1

package/build/runtime/config.js

@@ -0,0 +1,88 @@
+const DEFAULT_AUTH_URL = "/_auth";
+let _authUrl;
+function setAuthUrl(url) {
+  _authUrl = url || void 0;
+}
+function getAuthUrl() {
+  return _authUrl ?? DEFAULT_AUTH_URL;
+}
+const DEFAULT_API_ENDPOINT = "/_api";
+function resolveApiEndpoint(config) {
+  return config.url ?? config.apiURL ?? DEFAULT_API_ENDPOINT;
+}
+const HOUDINI_SESSION_EVENT = "_houdini_session_";
+let mockConfig = null;
+function getMockConfig() {
+  return mockConfig;
+}
+function setMockConfig(config) {
+  mockConfig = config;
+}
+function defaultConfigValues(file) {
+  return {
+    defaultKeys: ["id"],
+    ...file,
+    types: {
+      Node: {
+        keys: ["id"],
+        resolve: {
+          queryField: "node",
+          arguments: (node) => ({ id: node.id })
+        }
+      },
+      ...file.types
+    }
+  };
+}
+function keyFieldsForType(configFile, type) {
+  const withDefault = defaultConfigValues(configFile);
+  return withDefault.types?.[type]?.keys || withDefault.defaultKeys;
+}
+function entityRefetchVariables(configFile, targetType, state) {
+  if (!targetType || targetType === "Query" || !state) {
+    return {};
+  }
+  const config = defaultConfigValues(configFile);
+  const typeConfig = config.types?.[targetType];
+  if (typeConfig?.resolve?.arguments) {
+    return typeConfig.resolve.arguments(state) ?? {};
+  }
+  const keys = keyFieldsForType(config, targetType);
+  return Object.fromEntries(keys.map((key) => [key, state[key]]));
+}
+function computeID(configFile, type, data) {
+  const fields = keyFieldsForType(configFile, type);
+  let id = "";
+  for (const field of fields) {
+    id += `${data[field]}__`;
+  }
+  return id.slice(0, -2);
+}
+let _configFile = null;
+function getCurrentConfig() {
+  const mockConfig2 = getMockConfig();
+  if (mockConfig2) {
+    return mockConfig2;
+  }
+  if (_configFile) {
+    return _configFile;
+  }
+  const defaultConfig = defaultConfigValues({});
+  _configFile = defaultConfig;
+  return defaultConfig;
+}
+export {
+  DEFAULT_API_ENDPOINT,
+  DEFAULT_AUTH_URL,
+  HOUDINI_SESSION_EVENT,
+  computeID,
+  defaultConfigValues,
+  entityRefetchVariables,
+  getAuthUrl,
+  getCurrentConfig,
+  getMockConfig,
+  keyFieldsForType,
+  resolveApiEndpoint,
+  setAuthUrl,
+  setMockConfig
+};

package/build/runtime/{lib/constants.d.ts → constants.d.ts}

@@ -3,4 +3,4 @@ export declare const siteURL = "SITE_URL";
  * @param focus example "#0160"
  */
 export declare const InfoReleaseNote: (focus?: string) => string;
-export declare const OutdatedFunctionInlineInfo: (type: 'query' | 'paginatedQuery' | 'mutation' | 'subscription', name: string) => string;
+export declare const OutdatedFunctionInlineInfo: (type: "query" | "paginatedQuery" | "mutation" | "subscription", name: string) => string;

package/build/runtime/{client/documentStore.d.ts → documentStore.d.ts}

@@ -1,10 +1,9 @@
-import type { HoudiniClient } from '.';
-import type { Cache } from '../cache/cache';
-import type { Layer } from '../cache/storage';
-import type { ConfigFile } from '../lib/config';
-import { Writable } from '../lib/store';
-import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies, GraphQLVariables } from '../lib/types';
-export declare class DocumentStore<_Data extends GraphQLObject, _Input extends GraphQLVariables> extends Writable<QueryResult<_Data, _Input>> {
+import type { ConfigFile } from 'houdini';
+import type { HoudiniClient } from './index.js';
+import type { Layer } from './cache/storage.js';
+import { Writable } from './store.js';
+import type { DocumentArtifact, QueryResult, GraphQLObject, SubscriptionSpec, CachePolicies, GraphQLVariables } from './types.js';
+export declare class DocumentStore<_Data extends GraphQLObject, _Input extends GraphQLVariables | undefined> extends Writable<QueryResult<_Data, _Input>> {
     #private;
     readonly artifact: DocumentArtifact;
     pendingPromise: {
@@ -12,19 +11,24 @@ export declare class DocumentStore<_Data extends GraphQLObject, _Input extends G
     } | null;
     serverSideFallback?: boolean;
     controllerKey(variables: any): string;
-    constructor({ artifact, plugins, pipeline, client, cache, enableCache, initialValue, initialVariables, fetching, }: {
+    constructor({ artifact, plugins, client, initialValue, initialVariables, fetching, proxies, config, }: {
         artifact: DocumentArtifact;
         plugins?: ClientHooks[];
-        pipeline?: ClientHooks[];
         client: HoudiniClient | null;
-        cache?: Cache;
         enableCache?: boolean;
         initialValue?: _Data | null;
         fetching?: boolean;
         serverSideFallback?: boolean;
         initialVariables?: _Input;
+        proxies?: Record<string, (operation: {
+            query: string;
+            variables: any;
+            operationName: string;
+            session: App.Session | null | undefined;
+        }) => Promise<any>>;
+        config: ConfigFile;
     });
-    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, abortController, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
+    send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, initialState, silenceEcho, abortController, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
     cleanup(): Promise<void>;
     getFetch(getSession: () => App.Session | null | undefined): (input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>;
 }
@@ -45,6 +49,7 @@ export type ClientPluginContext = {
     name: string;
     text: string;
     hash: string;
+    documentStore: DocumentStore<any, any>;
     artifact: DocumentArtifact;
     policy?: CachePolicies;
     fetch?: Fetch;
@@ -60,6 +65,7 @@ export type ClientPluginContext = {
         disableWrite?: boolean;
         disableRead?: boolean;
         disableSubscriptions?: boolean;
+        disablePartial?: boolean;
         applyUpdates?: string[];
         serverSideFallback?: boolean;
     };
@@ -101,6 +107,7 @@ export type SendParams = {
     stuff?: Partial<App.Stuff>;
     cacheParams?: ClientPluginContext['cacheParams'];
     setup?: boolean;
+    initialState?: QueryResult;
     silenceEcho?: boolean;
     abortController?: AbortController;
 };

package/build/{runtime-esm/client → runtime}/documentStore.js

@@ -1,17 +1,16 @@
-import { getCurrentConfig } from "../lib/config";
-import { deepEquals } from "../lib/deepEquals";
-import { marshalInputs } from "../lib/scalars";
-import { Writable } from "../lib/store";
-import { ArtifactKind, DedupeMatchMode } from "../lib/types";
-import { cachePolicy } from "./plugins";
+import { deepEquals } from "./deepEquals.js";
+import { marshalInputs } from "./scalars.js";
+import { Writable } from "./store.js";
+import { ArtifactKind, DedupeMatchMode } from "./types.js";
 const steps = {
   forward: ["start", "beforeNetwork", "network"],
   backwards: ["end", "afterNetwork"]
 };
-let inflightRequests = {};
+const inflightRequests = {};
 class DocumentStore extends Writable {
   artifact;
   #client;
+  #proxies = {};
   #configFile;
   // the list of instantiated plugins
   #plugins;
@@ -30,13 +29,12 @@ class DocumentStore extends Writable {
   constructor({
     artifact,
     plugins,
-    pipeline,
     client,
-    cache,
-    enableCache = true,
     initialValue,
     initialVariables,
-    fetching
+    fetching,
+    proxies = {},
+    config
   }) {
     fetching ??= artifact.kind === ArtifactKind.Query;
     const initialState = {
@@ -57,24 +55,9 @@ class DocumentStore extends Writable {
     this.artifact = artifact;
     this.#client = client;
     this.#lastVariables = null;
-    this.#configFile = getCurrentConfig();
-    this.#plugins = pipeline ?? [
-      // cache policy needs to always come first so that it can be the first network to fire
-      cachePolicy({
-        cache,
-        enabled: enableCache,
-        setFetching: (fetching2, data) => {
-          this.update((state) => {
-            const newState = { ...state, fetching: fetching2 };
-            if (fetching2 && data) {
-              newState.data = data;
-            }
-            return newState;
-          });
-        }
-      })(),
-      ...plugins ?? []
-    ];
+    this.#configFile = config;
+    this.#plugins = plugins ?? [];
+    this.#proxies = proxies;
   }
   // used by the client to send a new set of variables to the pipeline
   async send({
@@ -86,15 +69,17 @@ class DocumentStore extends Writable {
     stuff,
     cacheParams,
     setup = false,
+    initialState,
     silenceEcho = false,
     abortController = new AbortController()
   } = {}) {
     if ("dedupe" in this.artifact && this.artifact.dedupe && this.artifact.dedupe.match !== "None") {
       const dedupeKey = this.controllerKey(variables);
-      if (inflightRequests[dedupeKey]) {
+      const existingRequest = inflightRequests[dedupeKey];
+      if (existingRequest && !existingRequest.controller.signal.aborted) {
         if (this.artifact.dedupe.cancel === "first") {
-          inflightRequests[dedupeKey].controller.abort();
-          inflightRequests[dedupeKey].controller = abortController;
+          existingRequest.controller.abort();
+          existingRequest.controller = abortController;
         } else {
           abortController.abort();
         }
@@ -108,6 +93,7 @@ class DocumentStore extends Writable {
     let context = new ClientPluginContextWrapper({
       abortController,
       config: this.#configFile,
+      documentStore: this,
       name: this.artifact.name,
       text: this.artifact.raw,
       hash: this.artifact.hash,
@@ -134,6 +120,7 @@ class DocumentStore extends Writable {
     const promise = new Promise((resolve, reject) => {
       const state = {
         setup,
+        initialState,
         currentStep: 0,
         index: 0,
         silenceEcho,
@@ -141,6 +128,7 @@ class DocumentStore extends Writable {
           resolved: false,
           resolve,
           reject,
+          // biome-ignore lint/suspicious/noThenProperty: thenable required for await support
           then: (...args) => promise.then(...args)
         },
         // patch the context with new variables
@@ -151,9 +139,11 @@ class DocumentStore extends Writable {
       }
       this.#step("forward", state);
     });
-    const response = await promise;
-    delete inflightRequests[this.controllerKey(variables)];
-    return response;
+    try {
+      return await promise;
+    } finally {
+      delete inflightRequests[this.controllerKey(variables)];
+    }
   }
   async cleanup() {
     for (const plugin of this.#plugins) {
@@ -173,12 +163,14 @@ class DocumentStore extends Writable {
         url = new URL(input.url).pathname;
       }
       if (input instanceof Request) {
-        const body = await input.json();
-        if (!Array.isArray(body)) {
-          queries = [body];
+        if ((input.headers.get("content-type") ?? "").includes("application/json")) {
+          const body = await input.clone().json();
+          if (!Array.isArray(body)) {
+            queries = [body];
+          }
         }
-      } else {
-        const body = JSON.parse(init?.body);
+      } else if (typeof init?.body === "string") {
+        const body = JSON.parse(init.body);
         if (!Array.isArray(body)) {
           queries = [body];
         }
@@ -186,10 +178,10 @@ class DocumentStore extends Writable {
       if (!url || queries.length === 0) {
         return await globalThis.fetch(input, init);
       }
-      if (this.#client?.proxies[url]) {
+      if (this.#proxies[url]) {
         const result = await Promise.all(
           queries.map(
-            (q) => this.#client?.proxies[url]({
+            (q) => this.#proxies[url]({
               ...q,
               session: getSession()
             })
@@ -209,12 +201,12 @@ class DocumentStore extends Writable {
       step = (i) => i - 1;
     }
     for (let index = ctx.index; valid(index); index = step(index)) {
-      let target = this.#plugins[index]?.[hook];
+      const target = this.#plugins[index]?.[hook];
       if (!target) {
         continue;
       }
       const draft = ctx.context.draft();
-      let variablesRefChanged = (newContext) => newContext.variables !== draft.variables;
+      const variablesRefChanged = (newContext) => newContext.variables !== draft.variables;
       const common = {
         initialValue: this.state,
         client: this.#client,
@@ -265,9 +257,9 @@ class DocumentStore extends Writable {
         handlers = {
           ...common,
           value,
-          resolve: (ctx2, data) => {
+          resolve: ((ctx2, data) => {
             return common.resolve(ctx2, data ?? value);
-          }
+          })
         };
       } else if (direction === "error") {
         handlers = {
@@ -282,9 +274,11 @@ class DocumentStore extends Writable {
           throw abortError;
         }
         const result = target(draft, handlers);
-        result?.catch((err) => {
-          this.#step("error", { ...ctx, index: index - 1 }, err);
-        });
+        if (result) {
+          result?.catch((err) => {
+            this.#step("error", { ...ctx, index: index - 1 }, err);
+          });
+        }
       } catch (err) {
         this.#step("error", { ...ctx, index: index - 1 }, err);
       }
@@ -292,22 +286,24 @@ class DocumentStore extends Writable {
     }
     if (direction === "forward") {
       if (ctx.setup) {
-        return this.#step(
+        this.#step(
           "backwards",
           {
             ...ctx,
             currentStep: 0,
             index: this.#plugins.length
           },
-          this.state
+          ctx.initialState ?? this.state
         );
+        return;
       }
       if (ctx.currentStep <= steps.forward.length - 2) {
-        return this.#step("forward", {
+        this.#step("forward", {
           ...ctx,
           currentStep: ctx.currentStep + 1,
           index: 0
         });
+        return;
       }
       throw new Error(
         "Called next() on last possible plugin. Your chain is missing a plugin that calls resolve()."
@@ -321,7 +317,7 @@ class DocumentStore extends Writable {
       return;
     }
     if (ctx.currentStep > 0) {
-      return this.#step(
+      this.#step(
         "backwards",
         {
           ...ctx,
@@ -330,6 +326,7 @@ class DocumentStore extends Writable {
         },
         value
       );
+      return;
     }
     if (!ctx.silenceEcho || value.data !== this.state.data) {
       this.set(value);
@@ -386,7 +383,7 @@ class ClientPluginContextWrapper {
       ...values
     };
     const val = values.variables;
-    let changed = {};
+    const changed = {};
     for (const [name, value] of Object.entries(val ?? {})) {
       if (value !== source.variables?.[name]) {
         changed[name] = value;
@@ -398,11 +395,11 @@ class ClientPluginContextWrapper {
         ...ctx.stuff.inputs
       }
     };
-    const firstInit = !ctx.stuff.inputs || !ctx.stuff.inputs.init;
+    const firstInit = !ctx.stuff.inputs?.init;
     const hasChanged = Object.keys(changed).length > 0 || firstInit;
     if (hasChanged) {
       const newVariables = {
-        ...ctx.stuff.inputs?.marshaled,
+        ...source.stuff.inputs?.marshaled,
         ...marshalInputs({
           artifact,
           input: changed,

package/build/runtime/endpoint.d.ts

@@ -0,0 +1,14 @@
+import type { RedirectTemplate } from './types.js';
+/**
+ * interpolateRedirect builds an @endpoint redirect URL from its parsed template and the
+ * mutation result. Literal segments are emitted verbatim; interpolation paths are resolved
+ * against the data and URL-encoded (closing the open-redirect hole at the value level, on
+ * top of the compiler's build-time relative-path check).
+ *
+ * Returns `null` when any interpolation path resolves to null/undefined — the caller then
+ * skips the redirect and falls back to PRG-back-to-the-page rather than navigating to
+ * `/users/undefined`. Shared by the server form handler and the client form hook so both
+ * paths produce the same target.
+ */
+export declare function interpolateRedirect(template: RedirectTemplate, data: any): string | null;
+export declare function valueAtPath(data: any, path: readonly string[]): any;

package/build/runtime/endpoint.js

@@ -0,0 +1,29 @@
+function interpolateRedirect(template, data) {
+  let url = "";
+  for (const part of template) {
+    if (typeof part === "string") {
+      url += part;
+      continue;
+    }
+    const value = valueAtPath(data, part);
+    if (value === null || value === void 0) {
+      return null;
+    }
+    url += encodeURIComponent(String(value));
+  }
+  return url;
+}
+function valueAtPath(data, path) {
+  let cursor = data;
+  for (const key of path) {
+    if (cursor == null) {
+      return void 0;
+    }
+    cursor = cursor[key];
+  }
+  return cursor;
+}
+export {
+  interpolateRedirect,
+  valueAtPath
+};

package/build/{runtime-cjs/lib → runtime}/flatten.d.ts

@@ -1,2 +1,2 @@
-import type { NestedList } from './types';
+import type { NestedList } from './types.js';
 export declare function flatten<T>(source?: NestedList<T>): T[];

package/build/runtime/formData.d.ts

@@ -0,0 +1,24 @@
+import type { ConfigFile } from 'houdini';
+import type { InputObject } from './types.js';
+/**
+ * coerceFormData turns a browser FormData into GraphQL variables, driven by a document's
+ * compiled `input` metadata. It is the single coercion shared by the client (enhanced
+ * form submit) and the server (no-JS form endpoint) so the two paths can't drift.
+ *
+ * It is a domain wrapper over the shared coercion core (`unmarshalValue`): it folds the
+ * flat FormData keys into the right shape, applies the form-specific rules below, and
+ * hands custom-scalar leaves to the core. The result holds **rich** runtime values (e.g.
+ * Dates), so the normal mutation send re-marshals them — no special, marshal-bypassing
+ * code path is needed.
+ *
+ * Form-specific rules:
+ *   - an unchecked checkbox is absent from FormData → a missing Boolean becomes `false`
+ *   - an empty string is "absent" for numbers/enums/custom scalars → `null` (but a real
+ *     "" is kept for String/ID)
+ *   - File/Blob values pass through untouched for multipart handling
+ *
+ * Field-name conventions:
+ *   - `.` nests:        name="input.address.city"
+ *   - trailing `[]`:    name="tags[]"   (a scalar list; repeat the field per item)
+ */
+export declare function coerceFormData(formData: FormData, input: InputObject, config?: ConfigFile, allowedFields?: readonly string[]): Record<string, any>;

package/build/runtime/formData.js

@@ -0,0 +1,93 @@
+import { isFile, unmarshalValue } from "./coerce.js";
+import { getCurrentConfig } from "./config.js";
+function coerceFormData(formData, input, config = getCurrentConfig(), allowedFields) {
+  const raw = foldFormData(formData, allowedFields ? new Set(allowedFields) : void 0);
+  return coerceObject(raw, input.fields, input, config);
+}
+function foldFormData(formData, allowed) {
+  const root = {};
+  formData.forEach((value, key) => {
+    if (allowed && !allowed.has(key)) {
+      return;
+    }
+    const segments = key.split(".");
+    let cursor = root;
+    segments.forEach((segment, i) => {
+      const isLast = i === segments.length - 1;
+      const isList = segment.endsWith("[]");
+      const name = isList ? segment.slice(0, -2) : segment;
+      if (!isLast) {
+        cursor[name] = cursor[name] ?? {};
+        cursor = cursor[name];
+        return;
+      }
+      if (isList) {
+        cursor[name] = cursor[name] ?? [];
+        cursor[name].push(value);
+      } else {
+        cursor[name] = value;
+      }
+    });
+  });
+  return root;
+}
+function coerceObject(raw, fields, input, config) {
+  const result = {};
+  for (const [field, type] of Object.entries(fields)) {
+    const value = raw?.[field];
+    const nestedFields = input.types[type];
+    if (nestedFields) {
+      if (Array.isArray(value)) {
+        result[field] = value.map(
+          (entry) => coerceObject(entry, nestedFields, input, config)
+        );
+      } else if (value !== void 0) {
+        result[field] = coerceObject(value, nestedFields, input, config);
+      }
+      continue;
+    }
+    if (value === void 0) {
+      if (type === "Boolean") {
+        result[field] = false;
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      result[field] = value.map((entry) => coerceLeaf(entry, type, config));
+    } else {
+      result[field] = coerceLeaf(value, type, config);
+    }
+  }
+  return result;
+}
+function coerceLeaf(value, type, config) {
+  if (isFile(value)) {
+    return value;
+  }
+  const text = typeof value === "string" ? value : String(value);
+  if (config.scalars?.[type]) {
+    return text === "" ? null : unmarshalValue(text, config.scalars[type]?.unmarshal);
+  }
+  switch (type) {
+    case "Int": {
+      if (text === "") return null;
+      const parsed = Number.parseInt(text, 10);
+      return Number.isNaN(parsed) ? null : parsed;
+    }
+    case "Float": {
+      if (text === "") return null;
+      const parsed = Number.parseFloat(text);
+      return Number.isNaN(parsed) ? null : parsed;
+    }
+    case "Boolean":
+      return text === "true" || text === "on" || text === "1";
+    case "String":
+    case "ID":
+      return text;
+    default:
+      return text === "" ? null : text;
+  }
+}
+export {
+  coerceFormData
+};

package/build/runtime/index.d.ts

@@ -1,8 +1,16 @@
-import type { Cache as InternalCache } from './cache/cache';
-import type { CacheTypeDef } from './generated';
-import { Cache } from './public';
-export * from './client';
-export * from './lib';
-export declare function graphql<_Payload, _Result = _Payload>(str: TemplateStringsArray): _Result;
-export declare const cache: Cache<CacheTypeDef>;
-export declare function getCache(): InternalCache;
+export * from './client.js';
+export { decodeScalar, unmarshalValue, type Unmarshaler } from './coerce.js';
+export { deepEquals } from './deepEquals.js';
+export { interpolateRedirect, valueAtPath } from './endpoint.js';
+export { coerceFormData } from './formData.js';
+export { buildGraphQLBody } from './multipart.js';
+export * from './scalars.js';
+export * from './types.js';
+export { computeID, keyFieldsForType, entityRefetchVariables, setMockConfig, getMockConfig, getCurrentConfig, getAuthUrl, setAuthUrl, DEFAULT_AUTH_URL, resolveApiEndpoint, DEFAULT_API_ENDPOINT, HOUDINI_SESSION_EVENT, type HoudiniSessionEventDetail, } from './config.js';
+export { getFieldsForType } from './selection.js';
+export { flatten } from './flatten.js';
+export * from './pageInfo.js';
+export * from './pagination.js';
+export * from './constants.js';
+export * from './log.js';
+export { LRUCache, createLRUCache } from './lru.js';

package/build/runtime/index.js

@@ -0,0 +1,54 @@
+export * from "./client.js";
+import { decodeScalar, unmarshalValue } from "./coerce.js";
+import { deepEquals } from "./deepEquals.js";
+import { interpolateRedirect, valueAtPath } from "./endpoint.js";
+import { coerceFormData } from "./formData.js";
+import { buildGraphQLBody } from "./multipart.js";
+export * from "./scalars.js";
+export * from "./types.js";
+import {
+  computeID,
+  keyFieldsForType,
+  entityRefetchVariables,
+  setMockConfig,
+  getMockConfig,
+  getCurrentConfig,
+  getAuthUrl,
+  setAuthUrl,
+  DEFAULT_AUTH_URL,
+  resolveApiEndpoint,
+  DEFAULT_API_ENDPOINT,
+  HOUDINI_SESSION_EVENT
+} from "./config.js";
+import { getFieldsForType } from "./selection.js";
+import { flatten } from "./flatten.js";
+export * from "./pageInfo.js";
+export * from "./pagination.js";
+export * from "./constants.js";
+export * from "./log.js";
+import { LRUCache, createLRUCache } from "./lru.js";
+export {
+  DEFAULT_API_ENDPOINT,
+  DEFAULT_AUTH_URL,
+  HOUDINI_SESSION_EVENT,
+  LRUCache,
+  buildGraphQLBody,
+  coerceFormData,
+  computeID,
+  createLRUCache,
+  decodeScalar,
+  deepEquals,
+  entityRefetchVariables,
+  flatten,
+  getAuthUrl,
+  getCurrentConfig,
+  getFieldsForType,
+  getMockConfig,
+  interpolateRedirect,
+  keyFieldsForType,
+  resolveApiEndpoint,
+  setAuthUrl,
+  setMockConfig,
+  unmarshalValue,
+  valueAtPath
+};