houdini 2.0.0-next.9 → 2.0.1

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

@@ -1,5 +1,5 @@
-import type { GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
-import { type Cache } from './cache';
+import type { GraphQLValue, ListFilter, SubscriptionSelection, SubscriptionSpec } from '../types.js';
+import type { Cache } from './index.js';
 export type FieldSelection = [
     SubscriptionSpec,
     Required<SubscriptionSelection>['fields'] | undefined
@@ -11,7 +11,7 @@ export declare class InMemorySubscriptions {
     private keyVersions;
     activeFields(parent: string): string[];
     copySubscribers(from: string, to: string): void;
-    add({ parent, spec, selection, variables, parentType, }: {
+    add({ parent, spec, selection, variables, parentType, masked, }: {
         parent: string;
         parentType?: string;
         spec: SubscriptionSpec;
@@ -19,12 +19,14 @@ export declare class InMemorySubscriptions {
         variables: {
             [key: string]: GraphQLValue;
         };
+        masked?: boolean;
     }): void;
-    addFieldSubscription({ id, key, selection, type, }: {
+    addFieldSubscription({ id, key, selection, type: _type, masked, }: {
         id: string;
         key: string;
         selection: FieldSelection;
         type: string;
+        masked?: boolean;
     }): void;
     registerList({ list, id, key, parentType, selection, filters, variables, }: {
         list: Required<Required<SubscriptionSelection>['fields'][string]>['list'];
@@ -35,18 +37,30 @@ export declare class InMemorySubscriptions {
         filters: Required<SubscriptionSelection>['fields'][string]['filters'];
         variables: Record<string, any>;
     }): void;
-    addMany({ parent, variables, subscribers, parentType, }: {
+    addMany({ parent, variables, subscribers, parentType, masked, }: {
         parent: string;
         variables: {};
         subscribers: FieldSelection[];
         parentType: string;
+        masked?: boolean;
     }): void;
     get(id: string, field: string): FieldSelection[];
-    getAll(id: string): FieldSelection[];
-    remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[]): void;
-    reset(): SubscriptionSpec[];
+    getMaskedParents(id: string, field: string): FieldSelection[];
+    getAll(id: string, { includeMaskedParents }?: {
+        includeMaskedParents?: boolean;
+    }): FieldSelection[];
+    remove(id: string, selection: SubscriptionSelection, targets: SubscriptionSpec[], variables: {}, visited?: string[], masked?: boolean): void;
+    reset(): Readonly<{
+        rootType: string;
+        kind?: import("../types.js").ArtifactKinds;
+        selection: SubscriptionSelection;
+        onMessage: (message: import("../types.js").CacheMessage) => void;
+        parentID?: string;
+        variables?: () => any;
+    }>[];
     private removeSubscribers;
     removeAllSubscribers(id: string, targets?: SubscriptionSpec[]): void;
     get size(): number;
-    findSubSelections(parentID: string, selection: SubscriptionSelection, variables: {}, searchTarget: string, selections?: SubscriptionSelection[]): Array<SubscriptionSelection>;
+    findSubSelections(parentID: string, selection: SubscriptionSelection, variables: {}, searchTarget: string, selections?: Array<SubscriptionSelection>): Array<SubscriptionSelection>;
 }
+export declare function filterValue(filter: ListFilter, variables: Record<string, any>): any;

package/build/{runtime-esm → runtime}/cache/subscription.js

@@ -1,6 +1,6 @@
-import { flatten } from "../lib/flatten";
-import { getFieldsForType } from "../lib/selection";
-import { evaluateKey, rootID } from "./stuff";
+import { flatten } from "../flatten.js";
+import { getFieldsForType } from "../selection.js";
+import { evaluateKey, rootID } from "./stuff.js";
 class InMemorySubscriptions {
   cache;
   constructor(cache) {
@@ -19,10 +19,11 @@ class InMemorySubscriptions {
     spec,
     selection,
     variables,
-    parentType
+    parentType,
+    masked = false
   }) {
-    const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-    let targetSelection = getFieldsForType(selection, __typename, false);
+    const __typename = this.cache._internal_unstable.storage.getTypename(parent);
+    const targetSelection = getFieldsForType(selection, __typename, false);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       const {
         keyRaw,
@@ -32,22 +33,20 @@ class InMemorySubscriptions {
         filters,
         visible
       } = fieldSelection;
-      if (!visible) {
-        continue;
-      }
+      const fieldMasked = masked || !visible;
       const key = evaluateKey(keyRaw, variables);
       let targetSelection2;
       if (innerSelection) {
-        const __typename2 = this.cache._internal_unstable.storage.get(parent, "__typename").value;
-        targetSelection2 = getFieldsForType(innerSelection, __typename2, false);
+        targetSelection2 = getFieldsForType(innerSelection, __typename, false);
       }
       this.addFieldSubscription({
         id: parent,
         key,
         selection: [spec, targetSelection2],
-        type
+        type,
+        masked: fieldMasked
       });
-      if (list) {
+      if (list && !fieldMasked) {
         this.registerList({
           list,
           filters,
@@ -63,7 +62,7 @@ class InMemorySubscriptions {
           parent,
           key
         );
-        let children = !Array.isArray(linkedRecord) ? [linkedRecord] : flatten(linkedRecord) || [];
+        const children = !Array.isArray(linkedRecord) ? [linkedRecord] : flatten(linkedRecord) || [];
         for (const child of children) {
           if (!child) {
             continue;
@@ -73,7 +72,8 @@ class InMemorySubscriptions {
             spec,
             selection: innerSelection,
             variables,
-            parentType: type
+            parentType: type,
+            masked: fieldMasked
           });
         }
       }
@@ -83,7 +83,8 @@ class InMemorySubscriptions {
     id,
     key,
     selection,
-    type
+    type: _type,
+    masked = false
   }) {
     const spec = selection[0];
     if (!this.subscribers.has(id)) {
@@ -93,21 +94,22 @@ class InMemorySubscriptions {
     if (!subscriber.has(key)) {
       subscriber.set(key, {
         selections: [],
-        referenceCounts: /* @__PURE__ */ new Map()
+        referenceCounts: /* @__PURE__ */ new Map(),
+        maskedParentSelections: [],
+        maskedParentReferenceCounts: /* @__PURE__ */ new Map()
       });
     }
     const subscriberField = subscriber.get(key);
+    const selections = masked ? subscriberField.maskedParentSelections : subscriberField.selections;
+    const referenceCounts = masked ? subscriberField.maskedParentReferenceCounts : subscriberField.referenceCounts;
     if (!this.keyVersions[key]) {
       this.keyVersions[key] = /* @__PURE__ */ new Set();
     }
     this.keyVersions[key].add(key);
-    if (!subscriberField.selections.some(([{ set }]) => set === spec.set)) {
-      subscriberField.selections.push([spec, selection[1]]);
+    if (!referenceCounts.has(spec.onMessage)) {
+      selections.push([spec, selection[1]]);
     }
-    subscriberField.referenceCounts.set(
-      spec.set,
-      (subscriberField.referenceCounts.get(spec.set) || 0) + 1
-    );
+    referenceCounts.set(spec.onMessage, (referenceCounts.get(spec.onMessage) || 0) + 1);
     this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
   }
   registerList({
@@ -123,14 +125,14 @@ class InMemorySubscriptions {
       name: list.name,
       connection: list.connection,
       recordID: id,
-      recordType: this.cache._internal_unstable.storage.get(id, "__typename")?.value || parentType,
+      recordType: this.cache._internal_unstable.storage.getTypename(id) || parentType,
       listType: list.type,
       key,
       selection,
-      filters: Object.entries(filters || {}).reduce((acc, [key2, { kind, value }]) => {
+      filters: Object.entries(filters || {}).reduce((acc, [key2, filter]) => {
         return {
           ...acc,
-          [key2]: kind !== "Variable" ? value : variables[value]
+          [key2]: filterValue(filter, variables)
         };
       }, {})
     });
@@ -140,7 +142,8 @@ class InMemorySubscriptions {
     parent,
     variables,
     subscribers,
-    parentType
+    parentType,
+    masked = false
   }) {
     for (const [spec, targetSelection] of subscribers) {
       for (const selection of Object.values(targetSelection ?? {})) {
@@ -149,17 +152,20 @@ class InMemorySubscriptions {
           keyRaw,
           selection: innerSelection,
           list,
-          filters
+          filters,
+          visible
         } = selection;
+        const fieldMasked = masked || !visible;
         const key = evaluateKey(keyRaw, variables);
         const fieldSelection = innerSelection ? getFieldsForType(innerSelection, parentType, false) : void 0;
         this.addFieldSubscription({
           id: parent,
           key,
           selection: [spec, fieldSelection],
-          type: linkedType
+          type: linkedType,
+          masked: fieldMasked
         });
-        if (list) {
+        if (list && !fieldMasked) {
           this.registerList({
             list,
             filters,
@@ -178,16 +184,14 @@ class InMemorySubscriptions {
             if (!linkedRecord) {
               continue;
             }
-            const __typename = this.cache._internal_unstable.storage.get(
-              linkedRecord,
-              "__typename"
-            ).value;
-            let targetSelection2 = getFieldsForType(childSelection, __typename, false);
+            const __typename = this.cache._internal_unstable.storage.getTypename(linkedRecord);
+            const targetSelection2 = getFieldsForType(childSelection, __typename, false);
             this.addMany({
               parent: linkedRecord,
               variables,
               subscribers: subscribers.map(([sub]) => [sub, targetSelection2]),
-              parentType: linkedType
+              parentType: linkedType,
+              masked: fieldMasked
             });
           }
         }
@@ -197,19 +201,23 @@ class InMemorySubscriptions {
   get(id, field) {
     return this.subscribers.get(id)?.get(field)?.selections || [];
   }
-  getAll(id) {
+  getMaskedParents(id, field) {
+    return this.subscribers.get(id)?.get(field)?.maskedParentSelections || [];
+  }
+  getAll(id, { includeMaskedParents = false } = {}) {
     return [...this.subscribers.get(id)?.values() || []].flatMap(
-      (fieldSub) => fieldSub.selections
+      (fieldSub) => includeMaskedParents ? fieldSub.selections.concat(fieldSub.maskedParentSelections) : fieldSub.selections
     );
   }
-  remove(id, selection, targets, variables, visited = []) {
+  remove(id, selection, targets, variables, visited = [], masked = false) {
     visited.push(id);
     const linkedIDs = [];
-    const __typename = this.cache._internal_unstable.storage.get(id, "__typename").value;
-    let targetSelection = getFieldsForType(selection, __typename, false);
+    const __typename = this.cache._internal_unstable.storage.getTypename(id);
+    const targetSelection = getFieldsForType(selection, __typename, false);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       const key = evaluateKey(fieldSelection.keyRaw, variables);
-      this.removeSubscribers(id, key, targets);
+      const fieldMasked = masked || !fieldSelection.visible;
+      this.removeSubscribers(id, key, targets, fieldMasked);
       if (!fieldSelection.selection) {
         continue;
       }
@@ -217,12 +225,12 @@ class InMemorySubscriptions {
       const links = !Array.isArray(previousValue) ? [previousValue] : flatten(previousValue);
       for (const link of links) {
         if (link !== null) {
-          linkedIDs.push([link, fieldSelection.selection || {}]);
+          linkedIDs.push([link, fieldSelection.selection || {}, fieldMasked]);
         }
       }
     }
-    for (const [linkedRecordID, linkFields] of linkedIDs) {
-      this.remove(linkedRecordID, linkFields, targets, visited);
+    for (const [linkedRecordID, linkFields, linkMasked] of linkedIDs) {
+      this.remove(linkedRecordID, linkFields, targets, variables, visited, linkMasked);
     }
   }
   reset() {
@@ -231,36 +239,51 @@ class InMemorySubscriptions {
       this.subscribers.delete(id);
     }
     const subscriptionSpecs = subscribers.flatMap(
-      ([_id, fields]) => [...fields.values()].flatMap((field) => field.selections.map(([spec]) => spec))
+      ([_id, fields]) => [...fields.values()].flatMap(
+        (field) => field.selections.concat(field.maskedParentSelections).map(([spec]) => spec)
+      )
     );
     return subscriptionSpecs;
   }
-  removeSubscribers(id, fieldName, specs) {
-    let targets = [];
+  removeSubscribers(id, fieldName, specs, preferMasked = false) {
+    const targets = [];
+    const maskedParentTargets = [];
     const subscriber = this.subscribers.get(id);
     if (!subscriber) {
       return;
     }
     const subscriberField = subscriber.get(fieldName);
+    if (!subscriberField) {
+      return;
+    }
     for (const spec of specs) {
-      const counts = subscriberField?.referenceCounts;
-      if (!counts?.has(spec.set)) {
+      const ordered = preferMasked ? [
+        [subscriberField.maskedParentReferenceCounts, maskedParentTargets],
+        [subscriberField.referenceCounts, targets]
+      ] : [
+        [subscriberField.referenceCounts, targets],
+        [subscriberField.maskedParentReferenceCounts, maskedParentTargets]
+      ];
+      const match = ordered.find(([counts2]) => counts2.has(spec.onMessage));
+      if (!match) {
         continue;
       }
-      const newVal = (counts.get(spec.set) || 0) - 1;
-      counts.set(spec.set, newVal);
+      const [counts, removed] = match;
+      const newVal = (counts.get(spec.onMessage) || 0) - 1;
+      counts.set(spec.onMessage, newVal);
       if (newVal <= 0) {
-        targets.push(spec.set);
-        counts.delete(spec.set);
-      }
-      if (counts.size === 0) {
-        subscriber.delete(fieldName);
+        removed.push(spec.onMessage);
+        counts.delete(spec.onMessage);
       }
     }
-    if (subscriberField) {
-      subscriberField.selections = this.get(id, fieldName).filter(
-        ([{ set }]) => !targets.includes(set)
-      );
+    subscriberField.selections = subscriberField.selections.filter(
+      ([{ onMessage }]) => !targets.includes(onMessage)
+    );
+    subscriberField.maskedParentSelections = subscriberField.maskedParentSelections.filter(
+      ([{ onMessage }]) => !maskedParentTargets.includes(onMessage)
+    );
+    if (subscriberField.referenceCounts.size === 0 && subscriberField.maskedParentReferenceCounts.size === 0) {
+      subscriber.delete(fieldName);
     }
     if (subscriber.size === 0) {
       this.subscribers.delete(id);
@@ -269,7 +292,7 @@ class InMemorySubscriptions {
   removeAllSubscribers(id, targets) {
     if (!targets) {
       targets = [...this.subscribers.get(id)?.values() || []].flatMap(
-        (spec) => spec.selections.flatMap((sel) => sel[0])
+        (fieldSub) => fieldSub.selections.concat(fieldSub.maskedParentSelections).flatMap((sel) => sel[0])
       );
     }
     for (const target of targets) {
@@ -294,8 +317,8 @@ class InMemorySubscriptions {
     return size;
   }
   findSubSelections(parentID, selection, variables, searchTarget, selections = []) {
-    const __typename = this.cache._internal_unstable.storage.get(parentID, "__typename").value;
-    let targetSelection = getFieldsForType(selection, __typename, false);
+    const __typename = this.cache._internal_unstable.storage.getTypename(parentID);
+    const targetSelection = getFieldsForType(selection, __typename, false);
     for (const fieldSelection of Object.values(targetSelection || {})) {
       if (!fieldSelection.selection) {
         continue;
@@ -320,6 +343,21 @@ class InMemorySubscriptions {
     return selections;
   }
 }
+function filterValue(filter, variables) {
+  if (filter.kind === "Variable") {
+    return variables[filter.value];
+  }
+  if (filter.kind === "Object") {
+    return Object.fromEntries(
+      Object.entries(filter.value).map(([key, value]) => [key, filterValue(value, variables)])
+    );
+  }
+  if (filter.kind === "List") {
+    return filter.value.map((value) => filterValue(value, variables));
+  }
+  return filter.value;
+}
 export {
-  InMemorySubscriptions
+  InMemorySubscriptions,
+  filterValue
 };

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

@@ -1,19 +1,17 @@
-/// <reference path="../../../../../houdini.d.ts" />
-import type { Cache } from '../cache/cache';
-import type { DocumentArtifact, GraphQLVariables, GraphQLObject, NestedList } from '../lib/types';
-import type { ClientHooks, ClientPlugin } from './documentStore';
-import { DocumentStore } from './documentStore';
-import type { FetchParamFn, ThrowOnErrorOperations, ThrowOnErrorParams } from './plugins';
-export { DocumentStore, type ClientPlugin, type SendParams } from './documentStore';
-export { fetch, mutation, query, subscription } from './plugins';
+import type { ConfigFile } from 'houdini';
+import type { Cache } from './cache/index.js';
+import type { ClientHooks, ClientPlugin } from './documentStore.js';
+import { DocumentStore } from './documentStore.js';
+import type { DocumentArtifact, GraphQLVariables, GraphQLObject, NestedList } from './types.js';
+export { DocumentStore } from './documentStore.js';
+export type { ClientPlugin, SendParams } from './documentStore.js';
 export type HoudiniClientConstructorArgs = {
+    config: () => ConfigFile;
     url?: string;
-    fetchParams?: FetchParamFn;
     plugins?: NestedList<ClientPlugin>;
     pipeline?: NestedList<ClientPlugin>;
-    throwOnError?: ThrowOnErrorParams;
 };
-export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact, _Input extends GraphQLVariables = GraphQLVariables> = {
+export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact, _Input extends GraphQLVariables | undefined = GraphQLVariables> = {
     artifact: _Artifact;
     enableCache?: boolean;
     cache?: Cache;
@@ -23,28 +21,23 @@ export type ObserveParams<_Data extends GraphQLObject, _Artifact extends Documen
 };
 export declare class HoudiniClient {
     url: string;
-    readonly throwOnError_operations: ThrowOnErrorOperations[];
-    private cache;
-    private throwOnError;
-    private fetchParams;
-    private pipeline;
-    private extraPlugins;
+    protected cache: Cache | null;
+    protected plugins: Array<ClientPlugin>;
+    protected config: ConfigFile;
+    componentCache: Record<string, any>;
+    constructor({ url, plugins, pipeline, config }?: HoudiniClientConstructorArgs);
     proxies: Record<string, (operation: {
         query: string;
         variables: any;
         operationName: string;
         session: App.Session | null | undefined;
     }) => Promise<any>>;
-    componentCache: Record<string, any>;
-    setCache(cache: Cache): void;
-    constructor({ url, fetchParams, plugins, pipeline, throwOnError, }?: HoudiniClientConstructorArgs);
-    get plugins(): ClientPlugin[];
-    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ enableCache, fetching, ...rest }: ObserveParams<_Data, DocumentArtifact, _Input>): DocumentStore<_Data, _Input>;
     registerProxy(url: string, handler: (operation: {
         query: string;
         variables: any;
         operationName: string;
         session: App.Session | null | undefined;
     }) => Promise<any>): void;
+    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables | undefined>({ enableCache, fetching, ...rest }: ObserveParams<_Data, DocumentArtifact, _Input>): DocumentStore<_Data, _Input>;
 }
 export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];

package/build/runtime/client.js

@@ -0,0 +1,86 @@
+import { resolveApiEndpoint } from "./config.js";
+import { DocumentStore } from "./documentStore.js";
+import { DocumentStore as DocumentStore2 } from "./documentStore.js";
+class HoudiniClient {
+  // the URL of the api
+  url;
+  cache = null;
+  plugins = [];
+  config;
+  // this is modified by page entries when they load in order to register the components source
+  componentCache = {};
+  constructor({ url, plugins, pipeline, config } = {
+    config: () => ({})
+  }) {
+    if (plugins && pipeline) {
+      throw new Error(
+        "A client cannot be given a pipeline and a list of plugins at the same time."
+      );
+    }
+    const serverPort = globalThis.process?.env?.HOUDINI_PORT ?? "5173";
+    this.url = url ?? (globalThis.window ? "" : `http://localhost:${serverPort}`) + resolveApiEndpoint(config());
+    this.plugins = flatten(plugins);
+    this.config = config();
+  }
+  proxies = {};
+  registerProxy(url, handler) {
+    this.proxies[url] = handler;
+  }
+  observe({
+    enableCache = true,
+    fetching = false,
+    ...rest
+  }) {
+    return new DocumentStore({
+      client: this,
+      plugins: createPluginHooks(this.plugins),
+      fetching,
+      enableCache,
+      config: this.config,
+      ...rest
+    });
+  }
+}
+function createPluginHooks(plugins) {
+  return plugins.reduce((hooks, plugin) => {
+    if (typeof plugin !== "function") {
+      throw new Error("Encountered client plugin that's not a function");
+    }
+    const result = plugin();
+    if (!result) {
+      return hooks;
+    }
+    if (!Array.isArray(result)) {
+      return hooks.concat(result);
+    }
+    for (const value of result) {
+      if (!value) {
+        continue;
+      }
+      if (typeof value === "function") {
+        return hooks.concat(createPluginHooks([value]));
+      }
+      hooks.push(value);
+    }
+    return hooks;
+  }, []);
+}
+function flatten(source) {
+  if (!source) {
+    return [];
+  }
+  return source.reduce((acc, element) => {
+    if (!element) {
+      return acc;
+    }
+    if (Array.isArray(element)) {
+      return acc.concat(flatten(element));
+    }
+    return acc.concat(element);
+  }, []);
+}
+export {
+  DocumentStore2 as DocumentStore,
+  HoudiniClient,
+  createPluginHooks
+};

package/build/runtime/coerce.d.ts

@@ -0,0 +1,4 @@
+export type Unmarshaler = (value: any) => any;
+export declare function isFile(value: any): value is Blob;
+export declare function decodeScalar(value: string): unknown;
+export declare function unmarshalValue(value: any, unmarshal?: Unmarshaler): any;

package/build/runtime/coerce.js

@@ -0,0 +1,31 @@
+function isFile(value) {
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return true;
+  }
+  if (typeof File !== "undefined" && value instanceof File) {
+    return true;
+  }
+  return false;
+}
+function decodeScalar(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function unmarshalValue(value, unmarshal) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => unmarshalValue(entry, unmarshal));
+  }
+  const decoded = typeof value === "string" ? decodeScalar(value) : value;
+  return unmarshal ? unmarshal(decoded) : decoded;
+}
+export {
+  decodeScalar,
+  isFile,
+  unmarshalValue
+};

package/build/runtime/config.d.ts

@@ -0,0 +1,20 @@
+import type { ConfigFile } from 'houdini';
+export declare const DEFAULT_AUTH_URL = "/_auth";
+export declare function setAuthUrl(url: string | undefined | null): void;
+export declare function getAuthUrl(): string;
+export declare const DEFAULT_API_ENDPOINT = "/_api";
+export declare function resolveApiEndpoint(config: ConfigFile & {
+    apiURL?: string;
+}): string;
+export declare const HOUDINI_SESSION_EVENT = "_houdini_session_";
+export type HoudiniSessionEventDetail = {
+    session: App.Session;
+    merge: boolean;
+};
+export declare function getMockConfig(): ConfigFile | null;
+export declare function setMockConfig(config: ConfigFile | null): void;
+export declare function defaultConfigValues(file: ConfigFile): ConfigFile;
+export declare function keyFieldsForType(configFile: ConfigFile, type: string): string[];
+export declare function entityRefetchVariables(configFile: ConfigFile, targetType: string | undefined | null, state: Record<string, any> | null | undefined): Record<string, any>;
+export declare function computeID(configFile: ConfigFile, type: string, data: any): string;
+export declare function getCurrentConfig(): ConfigFile;