houdini 1.0.11 → 1.1.1-next.0

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

@@ -1,8 +1,9 @@
 import { computeKey } from "../lib";
-import { computeID, defaultConfigValues, keyFieldsForType } from "../lib/config";
+import { computeID, defaultConfigValues, keyFieldsForType, getCurrentConfig } from "../lib/config";
 import { deepEquals } from "../lib/deepEquals";
 import { flatten } from "../lib/flatten";
 import { getFieldsForType } from "../lib/selection";
+import { fragmentKey } from "../lib/types";
 import { GarbageCollector } from "./gc";
 import { ListManager } from "./lists";
 import { SchemaManager } from "./schema";
@@ -12,7 +13,7 @@ import { evaluateKey } from "./stuff";
 import { InMemorySubscriptions } from "./subscription";
 class Cache {
   _internal_unstable;
-  constructor(config) {
+  constructor({ disabled, ...config } = {}) {
     this._internal_unstable = new CacheInternal({
       cache: this,
       storage: new InMemoryStorage(),
@@ -20,9 +21,10 @@ class Cache {
       lists: new ListManager(this, rootID),
       lifetimes: new GarbageCollector(this),
       staleManager: new StaleManager(this),
-      schema: new SchemaManager(this)
+      schema: new SchemaManager(this),
+      disabled: disabled ?? typeof globalThis.window === "undefined"
     });
-    if (config) {
+    if (Object.keys(config).length > 0) {
       this.setConfig(defaultConfigValues(config));
     }
   }
@@ -41,7 +43,8 @@ class Cache {
           this._internal_unstable.getSelection({
             parent: spec.parentID || rootID,
             selection: spec.selection,
-            variables: spec.variables?.() || {}
+            variables: spec.variables?.() || {},
+            ignoreMasking: false
           }).data
         );
       }
@@ -116,16 +119,13 @@ class Cache {
   getFieldTime(id, field) {
     return this._internal_unstable.staleManager.getFieldTime(id, field);
   }
+  config() {
+    return this._internal_unstable.config;
+  }
 }
 class CacheInternal {
   _disabled = false;
-  config = defaultConfigValues({
-    plugins: {
-      "houdini-svelte": {
-        client: ""
-      }
-    }
-  });
+  _config;
   storage;
   subscriptions;
   lists;
@@ -140,7 +140,9 @@ class CacheInternal {
     cache,
     lifetimes,
     staleManager,
-    schema
+    schema,
+    disabled,
+    config
   }) {
     this.storage = storage;
     this.subscriptions = subscriptions;
@@ -149,7 +151,8 @@ class CacheInternal {
     this.lifetimes = lifetimes;
     this.staleManager = staleManager;
     this.schema = schema;
-    this._disabled = typeof globalThis.window === "undefined";
+    this._config = config;
+    this._disabled = disabled;
     try {
       if (process.env.HOUDINI_TEST === "true") {
         this._disabled = false;
@@ -157,8 +160,11 @@ class CacheInternal {
     } catch {
     }
   }
+  get config() {
+    return this._config ?? getCurrentConfig();
+  }
   setConfig(config) {
-    this.config = config;
+    this._config = config;
   }
   writeSelection({
     data,
@@ -435,12 +441,24 @@ class CacheInternal {
     selection,
     parent = rootID,
     variables,
-    stepsFromConnection = null
+    stepsFromConnection = null,
+    ignoreMasking
   }) {
     if (parent === null) {
       return { data: null, partial: false, stale: false, hasData: true };
     }
     const target = {};
+    if (selection.fragments) {
+      target[fragmentKey] = Object.fromEntries(
+        Object.entries(selection.fragments).map(([key, value]) => [
+          key,
+          {
+            parent,
+            variables: evaluateFragmentVariables(value, variables ?? {})
+          }
+        ])
+      );
+    }
     let hasData = false;
     let partial = false;
     let cascadeNull = false;
@@ -449,8 +467,11 @@ class CacheInternal {
     let targetSelection = getFieldsForType(selection, typename);
     for (const [
       attributeName,
-      { type, keyRaw, selection: fieldSelection, nullable, list }
+      { type, keyRaw, selection: fieldSelection, nullable, list, visible }
     ] of Object.entries(targetSelection)) {
+      if (!visible && !ignoreMasking) {
+        continue;
+      }
       const key = evaluateKey(keyRaw, variables);
       const { value } = this.storage.get(parent, key);
       const dt_field = this.staleManager.getFieldTime(parent, key);
@@ -490,7 +511,8 @@ class CacheInternal {
           fields: fieldSelection,
           variables,
           linkedList: value,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking: !!ignoreMasking
         });
         target[attributeName] = listValue.data;
         if (listValue.partial) {
@@ -507,7 +529,8 @@ class CacheInternal {
           parent: value,
           selection: fieldSelection,
           variables,
-          stepsFromConnection: nextStep
+          stepsFromConnection: nextStep,
+          ignoreMasking
         });
         target[attributeName] = objectFields.data;
         if (objectFields.partial) {
@@ -551,7 +574,8 @@ class CacheInternal {
     fields,
     variables,
     linkedList,
-    stepsFromConnection
+    stepsFromConnection,
+    ignoreMasking
   }) {
     const result = [];
     let partialData = false;
@@ -563,7 +587,8 @@ class CacheInternal {
           fields,
           variables,
           linkedList: entry,
-          stepsFromConnection
+          stepsFromConnection,
+          ignoreMasking
         });
         result.push(nestedValue.data);
         if (nestedValue.partial) {
@@ -584,7 +609,8 @@ class CacheInternal {
         parent: entry,
         selection: fields,
         variables,
-        stepsFromConnection
+        stepsFromConnection,
+        ignoreMasking
       });
       result.push(data);
       if (partial) {
@@ -687,8 +713,49 @@ class CacheInternal {
     }
   }
 }
+function evaluateFragmentVariables(variables, args) {
+  return Object.fromEntries(
+    Object.entries(variables).map(([key, value]) => [key, fragmentVariableValue(value, args)])
+  );
+}
+function fragmentVariableValue(value, args) {
+  if (value.kind === "StringValue") {
+    return value.value;
+  }
+  if (value.kind === "BooleanValue") {
+    return value.value;
+  }
+  if (value.kind === "EnumValue") {
+    return value.value;
+  }
+  if (value.kind === "FloatValue") {
+    return parseFloat(value.value);
+  }
+  if (value.kind === "IntValue") {
+    return parseInt(value.value, 10);
+  }
+  if (value.kind === "NullValue") {
+    return null;
+  }
+  if (value.kind === "Variable") {
+    return args[value.name.value];
+  }
+  if (value.kind === "ListValue") {
+    return value.values.map((value2) => fragmentVariableValue(value2, args));
+  }
+  if (value.kind === "ObjectValue") {
+    return value.fields.reduce(
+      (obj, field) => ({
+        ...obj,
+        [field.name.value]: fragmentVariableValue(field.value, args)
+      }),
+      {}
+    );
+  }
+}
 const rootID = "_ROOT_";
 export {
   Cache,
+  evaluateFragmentVariables,
   rootID
 };

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

@@ -266,7 +266,8 @@ class List {
         this.cache._internal_unstable.getSelection({
           parent: spec.parentID || this.manager.rootID,
           selection: spec.selection,
-          variables: spec.variables?.() || {}
+          variables: spec.variables?.() || {},
+          ignoreMasking: false
         }).data
       );
     }

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

@@ -19,7 +19,17 @@ class InMemorySubscriptions {
     const __typename = this.cache._internal_unstable.storage.get(parent, "__typename").value;
     let targetSelection = getFieldsForType(selection, __typename);
     for (const fieldSelection of Object.values(targetSelection || {})) {
-      const { keyRaw, selection: innerSelection, type, list, filters } = fieldSelection;
+      const {
+        keyRaw,
+        selection: innerSelection,
+        type,
+        list,
+        filters,
+        visible
+      } = fieldSelection;
+      if (!visible) {
+        continue;
+      }
       const key = evaluateKey(keyRaw, variables);
       let targetSelection2;
       if (innerSelection) {
@@ -93,7 +103,6 @@ class InMemorySubscriptions {
     const counts = this.referenceCounts[id][key];
     counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
     this.cache._internal_unstable.lifetimes.resetLifetime(id, key);
-    const { selection: innerSelection } = selection[1]?.[key] ?? {};
   }
   registerList({
     list,

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

@@ -46,6 +46,7 @@ export type ClientPluginContext = {
         forceNotify?: boolean;
         disableWrite?: boolean;
         disableRead?: boolean;
+        disableSubscriptions?: boolean;
         applyUpdates?: string[];
     };
     stuff: App.Stuff;

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

@@ -1,6 +1,6 @@
 import { getCurrentConfig } from "../lib/config";
 import { deepEquals } from "../lib/deepEquals";
-import { marshalInputs, unmarshalSelection } from "../lib/scalars";
+import { marshalInputs } from "../lib/scalars";
 import { Writable } from "../lib/store";
 import { ArtifactKind } from "../lib/types";
 import { cachePolicy } from "./plugins";
@@ -159,8 +159,8 @@ class DocumentStore extends Writable {
         handlers = {
           ...common,
           value,
-          resolve: (ctx2, data2) => {
-            return common.resolve(ctx2, data2 ?? value);
+          resolve: (ctx2, data) => {
+            return common.resolve(ctx2, data ?? value);
           }
         };
       } else if (direction === "error") {
@@ -220,25 +220,16 @@ class DocumentStore extends Writable {
         value
       );
     }
-    let data = value.data;
-    try {
-      data = unmarshalSelection(this.#configFile, this.#artifact.selection, data) ?? null;
-    } catch {
-    }
-    const finalValue = {
-      ...value,
-      data
-    };
     if (!ctx.promise.resolved) {
-      ctx.promise.resolve(finalValue);
+      ctx.promise.resolve(value);
       ctx.promise.resolved = true;
     }
     this.#lastContext = ctx.context.draft();
     this.#lastVariables = this.#lastContext.stuff.inputs.marshaled;
-    if (ctx.silenceEcho && finalValue.data === this.state.data) {
+    if (ctx.silenceEcho && value.data === this.state.data) {
       return;
     }
-    this.set(finalValue);
+    this.set(value);
   }
 }
 class ClientPluginContextWrapper {

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

@@ -4,6 +4,7 @@ import {
   fetch as fetchPlugin,
   mutation as mutationPlugin,
   query as queryPlugin,
+  fragment as fragmentPlugin,
   throwOnError as throwOnErrorPlugin,
   fetchParams as fetchParamsPlugin
 } from "./plugins";
@@ -25,7 +26,8 @@ class HoudiniClient {
         fetchParamsPlugin(fetchParams),
         pipeline ?? [
           queryPlugin,
-          mutationPlugin
+          mutationPlugin,
+          fragmentPlugin
         ].concat(
           plugins ?? [],
           pluginsFromPlugins,

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

@@ -1,8 +1,9 @@
 import cache from '../../cache';
-import type { Cache } from '../../cache/cache';
+import { Cache } from '../../cache/cache';
 import type { ClientPlugin } from '../documentStore';
-export declare const cachePolicy: ({ enabled, setFetching, cache: localCache, }: {
+export declare const cachePolicy: ({ enabled, setFetching, cache: localCache, serverSideFallback, }: {
     enabled: boolean;
     setFetching: (val: boolean) => void;
     cache?: Cache | undefined;
+    serverSideFallback?: boolean | undefined;
 }) => ClientPlugin;

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

@@ -1,9 +1,12 @@
 import cache from "../../cache";
+import { Cache } from "../../cache/cache";
 import { ArtifactKind, CachePolicy, DataSource } from "../../lib/types";
+const serverSide = typeof globalThis.window === "undefined";
 const cachePolicy = ({
   enabled,
   setFetching,
-  cache: localCache = cache
+  cache: localCache = cache,
+  serverSideFallback = true
 }) => () => {
   return {
     network(ctx, { initialValue, next, resolve, marshalVariables }) {
@@ -54,13 +57,26 @@ const cachePolicy = ({
     },
     afterNetwork(ctx, { resolve, value, marshalVariables }) {
       if (value.source !== DataSource.Cache && enabled && value.data && !ctx.cacheParams?.disableWrite) {
-        localCache.write({
+        const targetCache = serverSide && serverSideFallback ? new Cache({ disabled: false }) : localCache;
+        let layer;
+        if (!serverSide && ctx.cacheParams?.layer) {
+          layer = ctx.cacheParams.layer.id;
+        }
+        targetCache.write({
           ...ctx.cacheParams,
-          layer: ctx.cacheParams?.layer?.id,
+          layer,
           selection: ctx.artifact.selection,
           data: value.data,
           variables: marshalVariables(ctx)
         });
+        value = {
+          ...value,
+          data: targetCache.read({
+            selection: ctx.artifact.selection,
+            variables: marshalVariables(ctx),
+            ignoreMasking: serverSide
+          }).data
+        };
       }
       resolve(ctx, value);
     }

package/build/runtime-esm/client/plugins/fetch.js

@@ -1,8 +1,11 @@
-import { DataSource } from "../../lib/types";
+import { ArtifactKind, DataSource } from "../../lib/types";
 const fetch = (target) => {
   return () => {
     return {
-      async network(ctx, { client, resolve, marshalVariables }) {
+      async network(ctx, { client, initialValue, resolve, marshalVariables }) {
+        if (ctx.artifact.kind === ArtifactKind.Fragment) {
+          return resolve(ctx, initialValue);
+        }
         const fetch2 = ctx.fetch ?? globalThis.fetch;
         const fetchParams = {
           text: ctx.text,

package/build/runtime-esm/client/plugins/fragment.d.ts

@@ -0,0 +1,2 @@
+import type { ClientPlugin } from '../documentStore';
+export declare const fragment: ClientPlugin;

package/build/runtime-esm/client/plugins/fragment.js

@@ -0,0 +1,46 @@
+import cache from "../../cache";
+import { ArtifactKind, DataSource } from "../../lib/types";
+import { documentPlugin } from "../utils";
+const fragment = documentPlugin(ArtifactKind.Fragment, function() {
+  let subscriptionSpec = null;
+  return {
+    start(ctx, { next, resolve, variablesChanged, marshalVariables }) {
+      if (!ctx.stuff.parentID) {
+        return next(ctx);
+      }
+      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
+        if (subscriptionSpec) {
+          cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
+        }
+        const variables = marshalVariables(ctx);
+        subscriptionSpec = {
+          rootType: ctx.artifact.rootType,
+          selection: ctx.artifact.selection,
+          variables: () => variables,
+          parentID: ctx.stuff.parentID,
+          set: (newValue) => {
+            resolve(ctx, {
+              data: newValue,
+              errors: null,
+              fetching: false,
+              partial: false,
+              stale: false,
+              source: DataSource.Cache,
+              variables
+            });
+          }
+        };
+        cache.subscribe(subscriptionSpec, variables);
+      }
+      next(ctx);
+    },
+    cleanup() {
+      if (subscriptionSpec) {
+        cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
+      }
+    }
+  };
+});
+export {
+  fragment
+};

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

@@ -1,6 +1,7 @@
 export * from './fetch';
 export * from './cache';
 export * from './query';
+export * from './fragment';
 export * from './mutation';
 export * from './subscription';
 export * from './throwOnError';

package/build/runtime-esm/client/plugins/index.js

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./cache";
 export * from "./query";
+export * from "./fragment";
 export * from "./mutation";
 export * from "./subscription";
 export * from "./throwOnError";

package/build/runtime-esm/client/plugins/query.js

@@ -4,7 +4,6 @@ import { documentPlugin } from "../utils";
 const query = documentPlugin(ArtifactKind.Query, function() {
   let subscriptionSpec = null;
   let lastVariables = null;
-  let artifactName = "";
   return {
     start(ctx, { next }) {
       ctx.variables = {
@@ -14,8 +13,7 @@ const query = documentPlugin(ArtifactKind.Query, function() {
       next(ctx);
     },
     end(ctx, { resolve, marshalVariables, variablesChanged }) {
-      if (variablesChanged(ctx)) {
-        artifactName = ctx.artifact.name;
+      if (variablesChanged(ctx) && !ctx.cacheParams?.disableSubscriptions) {
         if (subscriptionSpec) {
           cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() || {});
         }
@@ -36,13 +34,13 @@ const query = documentPlugin(ArtifactKind.Query, function() {
             });
           }
         };
-        cache.subscribe(subscriptionSpec, lastVariables ?? {});
+        cache.subscribe(subscriptionSpec, lastVariables);
       }
       resolve(ctx);
     },
     cleanup() {
       if (subscriptionSpec) {
-        cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.() ?? {});
+        cache.unsubscribe(subscriptionSpec, subscriptionSpec.variables?.());
         lastVariables = null;
       }
     }

package/build/runtime-esm/lib/scalars.d.ts

@@ -10,6 +10,5 @@ export declare function marshalInputs<T>({ artifact, input, config, rootType, }:
     rootType?: string;
     config: ConfigFile;
 }): {} | null | undefined;
-export declare function unmarshalSelection(config: ConfigFile, selection: SubscriptionSelection, data: any): {} | null | undefined;
 export declare function isScalar(config: ConfigFile, type: string): boolean;
 export declare function parseScalar(config: ConfigFile, type: string, value?: string): string | number | boolean | undefined;

package/build/runtime-esm/lib/scalars.js

@@ -75,45 +75,6 @@ function marshalInputs({
     })
   );
 }
-function unmarshalSelection(config, selection, data) {
-  if (data === null || typeof data === "undefined") {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return data.map((val) => unmarshalSelection(config, selection, val));
-  }
-  const targetSelection = getFieldsForType(selection, data["__typename"]);
-  return Object.fromEntries(
-    Object.entries(data).map(([fieldName, value]) => {
-      const { type, selection: selection2 } = targetSelection[fieldName];
-      if (!type) {
-        return [fieldName, value];
-      }
-      if (selection2) {
-        return [
-          fieldName,
-          unmarshalSelection(config, selection2, value)
-        ];
-      }
-      if (value === null) {
-        return [fieldName, value];
-      }
-      if (config.scalars?.[type]?.marshal) {
-        const unmarshalFn = config.scalars[type]?.unmarshal;
-        if (!unmarshalFn) {
-          throw new Error(
-            `scalar type ${type} is missing an \`unmarshal\` function. see https://github.com/AlecAivazis/houdini#%EF%B8%8Fcustom-scalars`
-          );
-        }
-        if (Array.isArray(value)) {
-          return [fieldName, value.map(unmarshalFn)];
-        }
-        return [fieldName, unmarshalFn(value)];
-      }
-      return [fieldName, value];
-    })
-  );
-}
 function isScalar(config, type) {
   return ["String", "Boolean", "Float", "ID", "Int"].concat(Object.keys(config.scalars || {})).includes(type);
 }
@@ -153,6 +114,5 @@ export {
   isScalar,
   marshalInputs,
   marshalSelection,
-  parseScalar,
-  unmarshalSelection
+  parseScalar
 };

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

@@ -24,6 +24,7 @@ declare global {
                 changed: boolean;
             };
             optimisticResponse?: GraphQLObject;
+            parentID?: string;
         }
     }
 }
@@ -84,7 +85,7 @@ export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
         direction: 'forward' | 'backward' | 'both';
         mode: PaginateModes;
     };
-    pluginData?: Record<string, any>;
+    pluginData: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -128,6 +129,7 @@ export type GraphQLObject = {
 };
 export type GraphQLValue = number | string | boolean | null | GraphQLObject | GraphQLValue[] | undefined;
 export type SubscriptionSelection = {
+    fragments?: Record<string, ValueMap>;
     fields?: {
         [fieldName: string]: {
             type: string;
@@ -140,12 +142,11 @@ export type SubscriptionSelection = {
                 type: string;
             };
             updates?: string[];
-            filters?: {
-                [key: string]: {
-                    kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
-                    value: string | number | boolean;
-                };
-            };
+            visible?: boolean;
+            filters?: Record<string, {
+                kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
+                value: string | number | boolean;
+            }>;
             selection?: SubscriptionSelection;
             abstract?: boolean;
         };
@@ -189,4 +190,51 @@ export type RequestPayload<GraphQLObject = any> = {
 };
 export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
 export type ValueOf<Parent> = Parent[keyof Parent];
+export declare const fragmentKey = " $fragments";
+export type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
+export type ValueMap = Record<string, ValueNode>;
+interface IntValueNode {
+    readonly kind: 'IntValue';
+    readonly value: string;
+}
+interface FloatValueNode {
+    readonly kind: 'FloatValue';
+    readonly value: string;
+}
+interface StringValueNode {
+    readonly kind: 'StringValue';
+    readonly value: string;
+}
+interface BooleanValueNode {
+    readonly kind: 'BooleanValue';
+    readonly value: boolean;
+}
+interface NullValueNode {
+    readonly kind: 'NullValue';
+}
+interface EnumValueNode {
+    readonly kind: 'EnumValue';
+    readonly value: string;
+}
+interface ListValueNode {
+    readonly kind: 'ListValue';
+    readonly values: ReadonlyArray<ValueNode>;
+}
+interface ObjectValueNode {
+    readonly kind: 'ObjectValue';
+    readonly fields: ReadonlyArray<ObjectFieldNode>;
+}
+interface ObjectFieldNode {
+    readonly kind: 'ObjectField';
+    readonly name: NameNode;
+    readonly value: ValueNode;
+}
+interface NameNode {
+    readonly kind: 'Name';
+    readonly value: string;
+}
+interface VariableNode {
+    readonly kind: 'Variable';
+    readonly name: NameNode;
+}
 export {};