houdini 1.2.2 → 1.2.4

package/build/runtime-cjs/lib/lru.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This file is a copy and paste of a very simple and effective LRU cache
+ * using javascript maps. It was copied under the MIT license found at the
+ * bottom of the page.
+ */
+/**
+ * JS maps (both plain objects and Map) maintain key insertion
+ * order, which means there is an easy way to simulate LRU behavior
+ * that should also perform quite well:
+ *
+ * To insert a new value, first delete the key from the inner _map,
+ * then _map.set(k, v). By deleting and reinserting, you ensure that the
+ * map sees the key as the last inserted key.
+ *
+ * Get does the same: if the key is present, delete and reinsert it.
+ */
+export declare class LRUCache<T> {
+    _capacity: number;
+    _map: Map<string, T>;
+    constructor(capacity?: number);
+    set(key: string, value: T): void;
+    get(key: string): T | null;
+    has(key: string): boolean;
+    delete(key: string): void;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}
+export declare function createLRUCache<T>(capacity?: number): LRUCache<T>;
+/**
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */

package/build/runtime-cjs/lib/lru.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lru_exports = {};
+__export(lru_exports, {
+  LRUCache: () => LRUCache,
+  createLRUCache: () => createLRUCache
+});
+module.exports = __toCommonJS(lru_exports);
+class LRUCache {
+  _capacity;
+  _map;
+  constructor(capacity = 1e3) {
+    this._capacity = capacity;
+    this._map = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this._map.delete(key);
+    this._map.set(key, value);
+    if (this._map.size > this._capacity) {
+      const firstKey = this._map.keys().next();
+      if (!firstKey.done) {
+        this._map.delete(firstKey.value);
+      }
+    }
+  }
+  get(key) {
+    const value = this._map.get(key);
+    if (value != null) {
+      this._map.delete(key);
+      this._map.set(key, value);
+    }
+    return value ?? null;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  delete(key) {
+    this._map.delete(key);
+  }
+  size() {
+    return this._map.size;
+  }
+  capacity() {
+    return this._capacity - this._map.size;
+  }
+  clear() {
+    this._map.clear();
+  }
+}
+function createLRUCache(capacity = 1e3) {
+  return new LRUCache(capacity);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCache,
+  createLRUCache
+});

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

@@ -316,4 +316,5 @@ interface VariableNode {
 }
 export declare const PendingValue: unique symbol;
 export type LoadingType = typeof PendingValue;
+export declare function isPending(value: any): value is LoadingType;
 export {};

package/build/runtime-cjs/lib/types.js

@@ -28,7 +28,8 @@ __export(types_exports, {
   PaginateMode: () => PaginateMode,
   PendingValue: () => PendingValue,
   RefetchUpdateMode: () => RefetchUpdateMode,
-  fragmentKey: () => fragmentKey
+  fragmentKey: () => fragmentKey,
+  isPending: () => isPending
 });
 module.exports = __toCommonJS(types_exports);
 const CachePolicy = {
@@ -63,6 +64,9 @@ const DataSource = {
 };
 const fragmentKey = " $fragments";
 const PendingValue = Symbol("houdini_loading");
+function isPending(value) {
+  return typeof value === "symbol";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArtifactKind,
@@ -75,5 +79,6 @@ const PendingValue = Symbol("houdini_loading");
   PaginateMode,
   PendingValue,
   RefetchUpdateMode,
-  fragmentKey
+  fragmentKey,
+  isPending
 });

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

@@ -8,6 +8,7 @@ import type { Layer, LayerID } from './storage';
 import { InMemoryStorage } from './storage';
 import { InMemorySubscriptions, type FieldSelection } from './subscription';
 export declare class Cache {
+    #private;
     _internal_unstable: CacheInternal;
     constructor({ disabled, ...config }?: ConfigFile & {
         disabled?: boolean;
@@ -33,7 +34,7 @@ export declare class Cache {
     subscribe(spec: SubscriptionSpec, variables?: {}): void;
     unsubscribe(spec: SubscriptionSpec, variables?: {}): void;
     list(name: string, parentID?: string, allLists?: boolean): ListCollection;
-    delete(id: string): void;
+    delete(id: string, layer?: Layer): void;
     setConfig(config: ConfigFile): void;
     markTypeStale(options?: {
         type: string;
@@ -46,6 +47,9 @@ export declare class Cache {
     }): void;
     getFieldTime(id: string, field: string): number | null | undefined;
     config(): ConfigFile;
+    serialize(): string;
+    hydrate(...args: Parameters<InMemoryStorage['hydrate']>): void;
+    clearLayer(layerID: Layer['id']): void;
 }
 declare class CacheInternal {
     private _disabled;

package/build/runtime-esm/cache/cache.js

@@ -33,20 +33,7 @@ class Cache {
   }) {
     const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
     const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).map((sub) => sub[0]);
-    const notified = [];
-    for (const spec of subscribers.concat(notifySubscribers)) {
-      if (!notified.includes(spec.set)) {
-        notified.push(spec.set);
-        spec.set(
-          this._internal_unstable.getSelection({
-            parent: spec.parentID || rootID,
-            selection: spec.selection,
-            variables: spec.variables?.() || {},
-            ignoreMasking: false
-          }).data
-        );
-      }
-    }
+    this.#notifySubscribers(subscribers.concat(notifySubscribers));
     return subscribers;
   }
   read(...args) {
@@ -85,10 +72,10 @@ class Cache {
     }
     return handler;
   }
-  delete(id) {
+  delete(id, layer) {
     this._internal_unstable.subscriptions.removeAllSubscribers(id);
-    this._internal_unstable.lists.removeIDFromAllLists(id);
-    this._internal_unstable.storage.delete(id);
+    this._internal_unstable.lists.removeIDFromAllLists(id, layer);
+    this._internal_unstable.storage.delete(id, layer);
   }
   setConfig(config) {
     this._internal_unstable.setConfig(config);
@@ -120,6 +107,76 @@ class Cache {
   config() {
     return this._internal_unstable.config;
   }
+  serialize() {
+    return this._internal_unstable.storage.serialize();
+  }
+  hydrate(...args) {
+    return this._internal_unstable.storage.hydrate(...args);
+  }
+  clearLayer(layerID) {
+    const layer = this._internal_unstable.storage.getLayer(layerID);
+    if (!layer) {
+      throw new Error("Cannot find layer with id: " + layerID);
+    }
+    const toNotify = [];
+    const allFields = [];
+    for (const target of [layer.fields, layer.links]) {
+      for (const [id, fields] of Object.entries(target)) {
+        allFields.push(
+          ...Object.entries(fields).map(([field, value]) => ({ id, field, value }))
+        );
+      }
+    }
+    const displayFields = [];
+    for (const pair of allFields) {
+      const { displayLayers } = this._internal_unstable.storage.get(pair.id, pair.field);
+      if (!displayLayers.includes(layerID)) {
+        continue;
+      }
+      displayFields.push(pair);
+    }
+    for (const [id, operation] of Object.entries(layer.operations)) {
+      if (operation.deleted) {
+        displayFields.push(
+          ...this._internal_unstable.subscriptions.activeFields(id).map((field) => ({ id, field }))
+        );
+      }
+      const fields = Object.keys(operation.fields ?? {});
+      if (fields.length > 0) {
+        displayFields.push(...fields.map((field) => ({ id, field })));
+      }
+    }
+    layer.clear();
+    for (const display of displayFields) {
+      const { field, id } = display;
+      const notify = !("value" in display) || this._internal_unstable.storage.get(id, field).value !== display.value;
+      if (notify) {
+        toNotify.push(
+          ...this._internal_unstable.subscriptions.get(id, field).map((sub) => sub[0])
+        );
+      }
+    }
+    this.#notifySubscribers(toNotify);
+  }
+  #notifySubscribers(subs) {
+    if (subs.length === 0) {
+      return;
+    }
+    const notified = [];
+    for (const spec of subs) {
+      if (!notified.includes(spec.set)) {
+        notified.push(spec.set);
+        spec.set(
+          this._internal_unstable.getSelection({
+            parent: spec.parentID || rootID,
+            selection: spec.selection,
+            variables: spec.variables?.() || {},
+            ignoreMasking: false
+          }).data
+        );
+      }
+    }
+  }
 }
 class CacheInternal {
   _disabled = false;
@@ -407,8 +464,16 @@ class CacheInternal {
               operation.position || "last",
               layer
             );
+          } else if (operation.action === "toggle" && target instanceof Object && fieldSelection && operation.list) {
+            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).toggleElement({
+              selection: fieldSelection,
+              data: target,
+              variables,
+              where: operation.position || "last",
+              layer
+            });
           } else if (operation.action === "remove" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).remove(target, variables);
+            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).remove(target, variables, layer);
           } else if (operation.action === "delete" && operation.type) {
             if (typeof target !== "string") {
               throw new Error("Cannot delete a record with a non-string ID");
@@ -417,15 +482,7 @@ class CacheInternal {
             if (!targetID) {
               continue;
             }
-            this.cache.delete(targetID);
-          } else if (operation.action === "toggle" && target instanceof Object && fieldSelection && operation.list) {
-            this.cache.list(operation.list, parentID, operation.target === "all").when(operation.when).toggleElement({
-              selection: fieldSelection,
-              data: target,
-              variables,
-              where: operation.position || "last",
-              layer
-            });
+            this.cache.delete(targetID, layer);
           }
         }
       }

package/build/runtime-esm/cache/lists.d.ts

@@ -21,7 +21,7 @@ export declare class ListManager {
         filters?: List['filters'];
         abstract?: boolean;
     }): void;
-    removeIDFromAllLists(id: string): void;
+    removeIDFromAllLists(id: string, layer?: Layer): void;
     deleteField(parentID: string, field: string): void;
 }
 export declare class List {
@@ -54,8 +54,8 @@ export declare class List {
         layer?: Layer;
     }): void;
     addToList(selection: SubscriptionSelection, data: {}, variables: {} | undefined, where: 'first' | 'last', layer?: Layer): void;
-    removeID(id: string, variables?: {}): true | undefined;
-    remove(data: {}, variables?: {}): true | undefined;
+    removeID(id: string, variables?: {}, layer?: Layer): true | undefined;
+    remove(data: {}, variables?: {}, layer?: Layer): true | undefined;
     listType(data: {
         __typename?: string;
     }): string;

package/build/runtime-esm/cache/lists.js

@@ -64,10 +64,10 @@ class ListManager {
     this.lists.get(list.name).get(parentID).lists.push(handler);
     this.listsByField.get(parentID).get(list.key).push(handler);
   }
-  removeIDFromAllLists(id) {
+  removeIDFromAllLists(id, layer) {
     for (const fieldMap of this.lists.values()) {
       for (const list of fieldMap.values()) {
-        list.removeID(id);
+        list.removeID(id, void 0, layer);
       }
     }
   }
@@ -164,6 +164,10 @@ class List {
                   updates: ["append", "prepend"],
                   selection: {
                     fields: {
+                      __typename: {
+                        keyRaw: "__typename",
+                        type: "String"
+                      },
                       node: {
                         type: listType,
                         keyRaw: "node",
@@ -188,7 +192,15 @@ class List {
       };
       insertData = {
         newEntry: {
-          edges: [{ node: { ...data, __typename: listType } }]
+          edges: [
+            {
+              __typename: listType + "Edge",
+              node: {
+                ...data,
+                __typename: listType
+              }
+            }
+          ]
         }
       };
     } else {
@@ -224,7 +236,7 @@ class List {
       layer: layer?.id
     });
   }
-  removeID(id, variables = {}) {
+  removeID(id, variables = {}, layer) {
     if (!this.validateWhen()) {
       return;
     }
@@ -271,7 +283,7 @@ class List {
       subscribers.map((sub) => sub[0]),
       variables
     );
-    this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID);
+    this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID, layer);
     for (const [spec] of subscribers) {
       spec.set(
         this.cache._internal_unstable.getSelection({
@@ -284,12 +296,12 @@ class List {
     }
     return true;
   }
-  remove(data, variables = {}) {
+  remove(data, variables = {}, layer) {
     const targetID = this.cache._internal_unstable.id(this.listType(data), data);
     if (!targetID) {
       return;
     }
-    return this.removeID(targetID, variables);
+    return this.removeID(targetID, variables, layer);
   }
   listType(data) {
     return data.__typename || this.type;
@@ -321,7 +333,7 @@ class List {
     layer,
     where
   }) {
-    if (!this.remove(data, variables)) {
+    if (!this.remove(data, variables, layer)) {
       this.addToList(selection, data, variables, where, layer);
     }
   }

package/build/runtime-esm/cache/storage.d.ts

@@ -8,8 +8,8 @@ export declare class InMemoryStorage {
     get nextRank(): number;
     createLayer(optimistic?: boolean): Layer;
     insert(id: string, field: string, location: OperationLocations, target: string): void;
-    remove(id: string, field: string, target: string): void;
-    delete(id: string): void;
+    remove(id: string, field: string, target: string, layerToUser?: Layer): void;
+    delete(id: string, layerToUser?: Layer): void;
     deleteField(id: string, field: string): void;
     getLayer(id: number): Layer;
     replaceID(replacement: {
@@ -25,6 +25,12 @@ export declare class InMemoryStorage {
     writeField(id: string, field: string, value: GraphQLValue): number;
     resolveLayer(id: number): void;
     get topLayer(): Layer;
+    serialize(): string;
+    hydrate(args?: {
+        rank: number;
+        fields: EntityFieldMap;
+        links: LinkMap;
+    }, layer?: Layer): void;
 }
 export declare class Layer {
     readonly id: LayerID;

package/build/runtime-esm/cache/storage.js

@@ -1,7 +1,7 @@
 import { flatten } from "../lib/flatten";
 class InMemoryStorage {
   data;
-  idCount = 0;
+  idCount = 1;
   rank = 0;
   constructor() {
     this.data = [];
@@ -21,11 +21,11 @@ class InMemoryStorage {
   insert(id, field, location, target) {
     return this.topLayer.insert(id, field, location, target);
   }
-  remove(id, field, target) {
-    return this.topLayer.remove(id, field, target);
+  remove(id, field, target, layerToUser = this.topLayer) {
+    return layerToUser.remove(id, field, target);
   }
-  delete(id) {
-    return this.topLayer.delete(id);
+  delete(id, layerToUser = this.topLayer) {
+    return layerToUser.delete(id);
   }
   deleteField(id, field) {
     return this.topLayer.deleteField(id, field);
@@ -159,6 +159,23 @@ class InMemoryStorage {
     }
     return this.data[this.data.length - 1];
   }
+  serialize() {
+    return JSON.stringify({
+      rank: this.rank,
+      fields: this.topLayer.fields,
+      links: this.topLayer.links
+    });
+  }
+  hydrate(args, layer) {
+    if (!args) {
+      return;
+    }
+    const { rank, fields, links } = args;
+    this.rank = rank;
+    layer ??= this.createLayer(true);
+    layer.fields = fields;
+    layer.links = links;
+  }
 }
 class Layer {
   id;

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

@@ -10,6 +10,7 @@ export declare class InMemorySubscriptions {
     private subscribers;
     private referenceCounts;
     private keyVersions;
+    activeFields(parent: string): string[];
     add({ parent, spec, selection, variables, parentType, }: {
         parent: string;
         parentType?: string;

package/build/runtime-esm/cache/subscription.js

@@ -9,6 +9,9 @@ class InMemorySubscriptions {
   subscribers = {};
   referenceCounts = {};
   keyVersions = {};
+  activeFields(parent) {
+    return Object.keys(this.subscribers[parent] || {});
+  }
   add({
     parent,
     spec,

package/build/runtime-esm/client/documentStore.d.ts

@@ -1,21 +1,27 @@
 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>> {
     #private;
+    readonly artifact: DocumentArtifact;
     pendingPromise: {
         then: (val: any) => void;
     } | null;
-    constructor({ artifact, plugins, pipeline, client, cache, initialValue, fetching, }: {
+    serverSideFallback?: boolean;
+    constructor({ artifact, plugins, pipeline, client, cache, enableCache, initialValue, initialVariables, fetching, }: {
         artifact: DocumentArtifact;
         plugins?: ClientHooks[];
         pipeline?: ClientHooks[];
         client: HoudiniClient | null;
-        cache?: boolean;
+        cache?: Cache;
+        enableCache?: boolean;
         initialValue?: _Data | null;
         fetching?: boolean;
+        serverSideFallback?: boolean;
+        initialVariables?: _Input;
     });
     send({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: SendParams): Promise<QueryResult<_Data, _Input>>;
     cleanup(): Promise<void>;
@@ -51,6 +57,7 @@ export type ClientPluginContext = {
         disableRead?: boolean;
         disableSubscriptions?: boolean;
         applyUpdates?: string[];
+        serverSideFallback?: boolean;
     };
     stuff: App.Stuff;
 };

package/build/runtime-esm/client/documentStore.js

@@ -9,20 +9,23 @@ const steps = {
   backwards: ["end", "afterNetwork"]
 };
 class DocumentStore extends Writable {
-  #artifact;
+  artifact;
   #client;
   #configFile;
   #plugins;
   #lastVariables;
   #lastContext = null;
   pendingPromise = null;
+  serverSideFallback;
   constructor({
     artifact,
     plugins,
     pipeline,
     client,
-    cache = true,
+    cache,
+    enableCache = true,
     initialValue,
+    initialVariables,
     fetching
   }) {
     fetching ??= artifact.kind === ArtifactKind.Query;
@@ -33,7 +36,7 @@ class DocumentStore extends Writable {
       stale: false,
       source: null,
       fetching,
-      variables: null
+      variables: initialVariables ?? null
     };
     super(initialState, () => {
       return () => {
@@ -41,13 +44,14 @@ class DocumentStore extends Writable {
         this.cleanup();
       };
     });
-    this.#artifact = artifact;
+    this.artifact = artifact;
     this.#client = client;
     this.#lastVariables = null;
     this.#configFile = getCurrentConfig();
     this.#plugins = pipeline ?? [
       cachePolicy({
-        enabled: cache,
+        cache,
+        enabled: enableCache,
         setFetching: (fetching2, data) => {
           this.update((state) => {
             const newState = { ...state, fetching: fetching2 };
@@ -74,9 +78,9 @@ class DocumentStore extends Writable {
   } = {}) {
     let context = new ClientPluginContextWrapper({
       config: this.#configFile,
-      text: this.#artifact.raw,
-      hash: this.#artifact.hash,
-      policy: policy ?? this.#artifact.policy,
+      text: this.artifact.raw,
+      hash: this.artifact.hash,
+      policy: policy ?? this.artifact.policy,
       variables: null,
       metadata,
       session,
@@ -89,7 +93,7 @@ class DocumentStore extends Writable {
         },
         ...stuff
       },
-      artifact: this.#artifact,
+      artifact: this.artifact,
       lastVariables: this.#lastVariables,
       cacheParams
     });

package/build/runtime-esm/client/index.d.ts

@@ -1,4 +1,5 @@
 /// <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';
@@ -12,10 +13,12 @@ export type HoudiniClientConstructorArgs = {
     pipeline?: NestedList<ClientPlugin>;
     throwOnError?: ThrowOnErrorParams;
 };
-export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact> = {
+export type ObserveParams<_Data extends GraphQLObject, _Artifact extends DocumentArtifact = DocumentArtifact, _Input extends GraphQLVariables = GraphQLVariables> = {
     artifact: _Artifact;
-    cache?: boolean;
+    enableCache?: boolean;
+    cache?: Cache;
     initialValue?: _Data | null;
+    initialVariables?: _Input;
     fetching?: boolean;
 };
 export declare class HoudiniClient {
@@ -23,6 +26,6 @@ export declare class HoudiniClient {
     readonly plugins: ClientPlugin[];
     readonly throwOnError_operations: ThrowOnErrorOperations[];
     constructor({ url, fetchParams, plugins, pipeline, throwOnError, }: HoudiniClientConstructorArgs);
-    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, cache, initialValue, fetching, }: ObserveParams<_Data>): DocumentStore<_Data, _Input>;
+    observe<_Data extends GraphQLObject, _Input extends GraphQLVariables>({ enableCache, fetching, ...rest }: ObserveParams<_Data, DocumentArtifact, _Input>): DocumentStore<_Data, _Input>;
 }
 export declare function createPluginHooks(plugins: ClientPlugin[]): ClientHooks[];