houdini 1.0.0-next.2 → 1.0.0-next.21

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

@@ -118,6 +118,9 @@ function isScalar(config, type) {
   return ["String", "Boolean", "Float", "ID", "Int"].concat(Object.keys(config.scalars || {})).includes(type);
 }
 function parseScalar(config, type, value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
   if (type === "Boolean") {
     return value === "true";
   }
@@ -128,10 +131,18 @@ function parseScalar(config, type, value) {
     return value;
   }
   if (type === "Int") {
-    return parseInt(value, 10);
+    const result = parseInt(value, 10);
+    if (Number.isNaN(result)) {
+      return void 0;
+    }
+    return result;
   }
   if (type === "Float") {
-    return parseFloat(value);
+    const result = parseFloat(value);
+    if (Number.isNaN(result)) {
+      return void 0;
+    }
+    return result;
   }
   if (config.scalars?.[type]?.marshal) {
     return config.scalars[type]?.marshal(value);

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

@@ -1,9 +1,11 @@
-export declare enum CachePolicy {
-    CacheOrNetwork = "CacheOrNetwork",
-    CacheOnly = "CacheOnly",
-    NetworkOnly = "NetworkOnly",
-    CacheAndNetwork = "CacheAndNetwork"
-}
+export declare const CachePolicy: {
+    readonly CacheOrNetwork: "CacheOrNetwork";
+    readonly CacheOnly: "CacheOnly";
+    readonly NetworkOnly: "NetworkOnly";
+    readonly CacheAndNetwork: "CacheAndNetwork";
+};
+type ValuesOf<Target> = Target[keyof Target];
+export type CachePolicies = ValuesOf<typeof CachePolicy>;
 declare global {
     namespace App {
         interface Session {
@@ -29,49 +31,44 @@ export type Operation<_Result, _Input> = {
 };
 export type Maybe<T> = T | null | undefined;
 export type DocumentArtifact = FragmentArtifact | QueryArtifact | MutationArtifact | SubscriptionArtifact;
-export declare enum ArtifactKind {
-    Query = "HoudiniQuery",
-    Subscription = "HoudiniSubscription",
-    Mutation = "HoudiniMutation",
-    Fragment = "HoudiniFragment"
-}
-export declare const CompiledFragmentKind = ArtifactKind.Fragment;
-export declare const CompiledMutationKind = ArtifactKind.Mutation;
-export declare const CompiledQueryKind = ArtifactKind.Query;
-export declare const CompiledSubscriptionKind = ArtifactKind.Subscription;
-export type CompiledDocumentKind = ArtifactKind;
-export type QueryArtifact = BaseCompiledDocument & {
-    kind: ArtifactKind.Query;
-    policy?: CachePolicy;
+export declare const ArtifactKind: {
+    readonly Query: "HoudiniQuery";
+    readonly Subscription: "HoudiniSubscription";
+    readonly Mutation: "HoudiniMutation";
+    readonly Fragment: "HoudiniFragment";
+};
+export type ArtifactKinds = ValuesOf<typeof ArtifactKind>;
+export declare const CompiledFragmentKind: "HoudiniFragment";
+export declare const CompiledMutationKind: "HoudiniMutation";
+export declare const CompiledQueryKind: "HoudiniQuery";
+export declare const CompiledSubscriptionKind: "HoudiniSubscription";
+export type CompiledDocumentKind = ArtifactKinds;
+export type QueryArtifact = BaseCompiledDocument<'HoudiniQuery'> & {
+    policy?: CachePolicies;
     partial?: boolean;
 };
-export type MutationArtifact = BaseCompiledDocument & {
-    kind: ArtifactKind.Mutation;
-};
-export type FragmentArtifact = BaseCompiledDocument & {
-    kind: ArtifactKind.Fragment;
-};
-export type SubscriptionArtifact = BaseCompiledDocument & {
-    kind: ArtifactKind.Subscription;
+export type MutationArtifact = BaseCompiledDocument<'HoudiniMutation'>;
+export type FragmentArtifact = BaseCompiledDocument<'HoudiniFragment'>;
+export type SubscriptionArtifact = BaseCompiledDocument<'HoudiniSubscription'>;
+export declare const RefetchUpdateMode: {
+    readonly append: "append";
+    readonly prepend: "prepend";
+    readonly replace: "replace";
 };
-export declare enum RefetchUpdateMode {
-    append = "append",
-    prepend = "prepend",
-    replace = "replace"
-}
+export type RefetchUpdateModes = ValuesOf<typeof RefetchUpdateMode>;
 export type InputObject = {
     fields: Record<string, string>;
     types: Record<string, Record<string, string>>;
 };
-export type BaseCompiledDocument = {
+export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
     name: string;
+    kind: _Kind;
     raw: string;
     hash: string;
     selection: SubscriptionSelection;
     rootType: string;
     input?: InputObject;
     refetch?: {
-        update: RefetchUpdateMode;
         path: string[];
         method: 'cursor' | 'offset';
         pageSize: number;
@@ -79,9 +76,9 @@ export type BaseCompiledDocument = {
         embedded: boolean;
         targetType: string;
         paginated: boolean;
-        direction?: 'forward' | 'backwards';
+        direction: 'forward' | 'backward' | 'both';
     };
-    pluginsData?: Record<string, any>;
+    pluginData?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -93,20 +90,21 @@ export type ListWhen = {
     must?: Filter;
     must_not?: Filter;
 };
-export declare enum DataSource {
+export declare const DataSource: {
     /**
      * from the browser cache
      */
-    Cache = "cache",
+    readonly Cache: "cache";
     /**
      * from a browser side `fetch`
      */
-    Network = "network",
+    readonly Network: "network";
     /**
      * from a server side `fetch`
      */
-    Ssr = "ssr"
-}
+    readonly Ssr: "ssr";
+};
+export type DataSources = ValuesOf<typeof DataSource>;
 export type MutationOperation = {
     action: 'insert' | 'remove' | 'delete' | 'toggle';
     list?: string;
@@ -135,7 +133,7 @@ export type SubscriptionSelection = {
                 connection: boolean;
                 type: string;
             };
-            update?: RefetchUpdateMode;
+            updates?: string[];
             filters?: {
                 [key: string]: {
                     kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
@@ -164,8 +162,7 @@ export type SubscriptionSpec = {
 };
 export type FetchQueryResult<_Data> = {
     result: RequestPayload<_Data | null>;
-    source: DataSource | null;
-    partial: boolean;
+    source: DataSources | null;
 };
 export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
@@ -174,8 +171,9 @@ export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     }[] | null;
     fetching: boolean;
     partial: boolean;
-    source: DataSource | null;
-    variables: _Input | null;
+    stale: boolean;
+    source: DataSources | null;
+    variables: _Input | {};
 };
 export type RequestPayload<GraphQLObject = any> = {
     data: GraphQLObject | null;
@@ -183,4 +181,6 @@ export type RequestPayload<GraphQLObject = any> = {
         message: string;
     }[] | null;
 };
+export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
+export type ValueOf<Parent> = Parent[keyof Parent];
 export {};

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

@@ -1,33 +1,29 @@
-var CachePolicy = /* @__PURE__ */ ((CachePolicy2) => {
-  CachePolicy2["CacheOrNetwork"] = "CacheOrNetwork";
-  CachePolicy2["CacheOnly"] = "CacheOnly";
-  CachePolicy2["NetworkOnly"] = "NetworkOnly";
-  CachePolicy2["CacheAndNetwork"] = "CacheAndNetwork";
-  return CachePolicy2;
-})(CachePolicy || {});
-var ArtifactKind = /* @__PURE__ */ ((ArtifactKind2) => {
-  ArtifactKind2["Query"] = "HoudiniQuery";
-  ArtifactKind2["Subscription"] = "HoudiniSubscription";
-  ArtifactKind2["Mutation"] = "HoudiniMutation";
-  ArtifactKind2["Fragment"] = "HoudiniFragment";
-  return ArtifactKind2;
-})(ArtifactKind || {});
-const CompiledFragmentKind = "HoudiniFragment" /* Fragment */;
-const CompiledMutationKind = "HoudiniMutation" /* Mutation */;
-const CompiledQueryKind = "HoudiniQuery" /* Query */;
-const CompiledSubscriptionKind = "HoudiniSubscription" /* Subscription */;
-var RefetchUpdateMode = /* @__PURE__ */ ((RefetchUpdateMode2) => {
-  RefetchUpdateMode2["append"] = "append";
-  RefetchUpdateMode2["prepend"] = "prepend";
-  RefetchUpdateMode2["replace"] = "replace";
-  return RefetchUpdateMode2;
-})(RefetchUpdateMode || {});
-var DataSource = /* @__PURE__ */ ((DataSource2) => {
-  DataSource2["Cache"] = "cache";
-  DataSource2["Network"] = "network";
-  DataSource2["Ssr"] = "ssr";
-  return DataSource2;
-})(DataSource || {});
+const CachePolicy = {
+  CacheOrNetwork: "CacheOrNetwork",
+  CacheOnly: "CacheOnly",
+  NetworkOnly: "NetworkOnly",
+  CacheAndNetwork: "CacheAndNetwork"
+};
+const ArtifactKind = {
+  Query: "HoudiniQuery",
+  Subscription: "HoudiniSubscription",
+  Mutation: "HoudiniMutation",
+  Fragment: "HoudiniFragment"
+};
+const CompiledFragmentKind = ArtifactKind.Fragment;
+const CompiledMutationKind = ArtifactKind.Mutation;
+const CompiledQueryKind = ArtifactKind.Query;
+const CompiledSubscriptionKind = ArtifactKind.Subscription;
+const RefetchUpdateMode = {
+  append: "append",
+  prepend: "prepend",
+  replace: "replace"
+};
+const DataSource = {
+  Cache: "cache",
+  Network: "network",
+  Ssr: "ssr"
+};
 export {
   ArtifactKind,
   CachePolicy,

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

@@ -1,19 +1,39 @@
 import type { Cache as _Cache } from '../cache/cache';
-import type { SchemaManager, TypeInfo } from '../cache/schema';
+import { type QueryArtifact } from '../lib';
 import { ListCollection } from './list';
 import { Record } from './record';
-import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';
+import type { ArgType, CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, TypeFieldNames, TypeNames, ValidLists } from './types';
 export declare class Cache<Def extends CacheTypeDef> {
     _internal_unstable: _Cache;
     constructor(cache: _Cache);
     validateInstabilityWarning(): void;
-    setFieldType(...args: Parameters<SchemaManager['setFieldType']>): void;
-    get root(): Record<Def, '__ROOT__'>;
     get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
-    get config(): import("..").ConfigFile;
+    get config(): import("../lib").ConfigFile;
     list<Name extends ValidLists<Def>>(name: Name, { parentID, allLists }?: {
         parentID?: string;
         allLists?: boolean;
     }): ListCollection<Def, Name>;
+    read<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, }: {
+        query: _Query;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): {
+        data: QueryValue<QueryList<Def>, _Query> | null;
+        partial: boolean;
+    };
+    write<_Query extends {
+        artifact: QueryArtifact;
+    }>({ query, variables, data, }: {
+        query: _Query;
+        data: QueryValue<QueryList<Def>, _Query>;
+        variables?: QueryInput<QueryList<Def>, _Query>;
+    }): void;
+    /**
+     * Mark some elements of the cache stale.
+     */
+    markStale<_Type extends TypeNames<Def>, _Field extends TypeFieldNames<Def, _Type>>(type?: _Type, options?: {
+        field?: _Field;
+        when?: ArgType<Def, _Type, _Field>;
+    }): void;
 }
-export declare function _typeInfo<Def extends CacheTypeDef>(cache: Cache<Def>, type: string, field: string): TypeInfo;

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

@@ -1,4 +1,4 @@
-import { rootID } from "../cache/cache";
+import { marshalInputs } from "../lib";
 import { ListCollection } from "./list";
 import { Record } from "./record";
 class Cache {
@@ -12,19 +12,6 @@ class Cache {
 Please acknowledge this by setting acceptImperativeInstability to true in your config file.`);
     }
   }
-  setFieldType(...args) {
-    this.validateInstabilityWarning();
-    this._internal_unstable._internal_unstable.schema.setFieldType(...args);
-  }
-  get root() {
-    this.validateInstabilityWarning();
-    return new Record({
-      cache: this,
-      type: "Query",
-      id: rootID,
-      idFields: {}
-    });
-  }
   get(type, data) {
     this.validateInstabilityWarning();
     let recordID = this._internal_unstable._internal_unstable.id(type, data);
@@ -42,6 +29,7 @@ Please acknowledge this by setting acceptImperativeInstability to true in your c
     return this._internal_unstable._internal_unstable.config;
   }
   list(name, { parentID, allLists } = {}) {
+    this.validateInstabilityWarning();
     return new ListCollection({
       cache: this,
       name,
@@ -49,24 +37,37 @@ Please acknowledge this by setting acceptImperativeInstability to true in your c
       allLists
     });
   }
-}
-function _typeInfo(cache, type, field) {
-  if (field === "__typename") {
-    return {
-      type: "String",
-      nullable: false,
-      link: false
-    };
+  read({
+    query,
+    variables
+  }) {
+    this.validateInstabilityWarning();
+    return this._internal_unstable.read({
+      selection: query.artifact.selection,
+      variables
+    });
+  }
+  write({
+    query,
+    variables,
+    data
+  }) {
+    this.validateInstabilityWarning();
+    this._internal_unstable.write({
+      selection: query.artifact.selection,
+      data,
+      variables: marshalInputs({
+        config: this.config,
+        artifact: query.artifact,
+        input: variables
+      }) ?? {}
+    });
+    return;
   }
-  const info = cache._internal_unstable._internal_unstable.schema.fieldType(type, field);
-  if (!info) {
-    throw new Error(
-      `Unknown field: ${field} for type ${type}. Please provide type information using setFieldType().`
-    );
+  markStale(type, options) {
+    return this._internal_unstable.markTypeStale(type ? { ...options, type } : void 0);
   }
-  return info;
 }
 export {
-  Cache,
-  _typeInfo
+  Cache
 };

package/build/runtime-esm/public/list.js

@@ -1,5 +1,3 @@
-import { keyFieldsForType } from "../lib/config";
-import { _typeInfo } from "./cache";
 import { Record } from "./record";
 class ListCollection {
   #parentID;
@@ -60,7 +58,7 @@ class ListCollection {
     return new ListCollection({
       parentID: this.#parentID,
       allLists: this.#allLists,
-      when: this.#when,
+      when: filter,
       cache: this.#cache,
       name: this.#name
     });
@@ -96,36 +94,16 @@ class ListCollection {
     }
   }
   #listOperationPayload(records) {
-    const selection = {
-      abstractFields: {
-        fields: {},
-        typeMap: {}
-      }
-    };
+    let selection = this.#collection.selection;
+    const connectionSelection = selection.fields?.["edges"]?.selection?.fields?.node.selection;
+    if (connectionSelection) {
+      selection = connectionSelection;
+    }
     const data = [];
     for (const record of records) {
       if (!(record instanceof Record)) {
         throw new Error("You must provide a Record to a list operation");
       }
-      const keys = keyFieldsForType(this.#cache.config, record.type);
-      selection.abstractFields.fields[record.type] = keys.reduce(
-        (acc, key) => {
-          const keyInfo = _typeInfo(this.#cache, record.type, key);
-          return {
-            ...acc,
-            [key]: {
-              type: keyInfo.type,
-              keyRaw: key
-            }
-          };
-        },
-        {
-          __typename: {
-            type: "String",
-            keyRaw: "__typename"
-          }
-        }
-      );
       data.push({ __typename: record.type, ...record.idFields });
     }
     return {

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

@@ -1,5 +1,6 @@
+import type { FragmentArtifact } from '../lib/types';
 import type { Cache } from './cache';
-import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
+import type { ArgType, CacheTypeDef, FragmentList, FragmentValue, FragmentVariables, TypeFieldNames, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;
     type: string;
@@ -10,22 +11,30 @@ export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<De
         idFields: {};
         id: string;
     });
-    set<Field extends TypeFieldNames<Def, Type>>({ field, args, value, }: {
-        field: Field;
-        args?: ArgType<Def, Type, Field>;
-        value: FieldType<Def, Type, Field>;
+    read<_Fragment extends {
+        artifact: FragmentArtifact;
+    }>({ fragment, variables, }: {
+        fragment: _Fragment;
+        variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>;
+    }): {
+        data: FragmentValue<FragmentList<Def, Type>, _Fragment> | null;
+        partial: boolean;
+    };
+    write<_Fragment extends {
+        artifact: FragmentArtifact;
+    }, _Variable>(args: {
+        fragment: _Fragment;
+        data: FragmentValue<FragmentList<Def, Type>, _Fragment>;
+        variables?: FragmentVariables<FragmentList<Def, Type>, _Fragment>;
+        forceStale?: boolean;
     }): void;
-    get<Field extends TypeFieldNames<Def, Type>>({ field, args, }: {
-        field: Field;
-        args?: ArgType<Def, Type, Field>;
-    }): FieldType<Def, Type, Field>;
     delete(): void;
+    /**
+     * Mark some elements of the record stale in the cache.
+     * @param field
+     * @param when
+     */
+    markStale<Field extends TypeFieldNames<Def, Type>>(field?: Field, { when, }?: {
+        when?: ArgType<Def, Type, Field>;
+    }): void;
 }
-export declare function computeKey({ field, args }: {
-    field: string;
-    args?: {
-        [key: string]: any;
-    };
-}): string;
-export declare const stringifyObjectWithNoQuotesOnKeys: (obj_from_json: {}) => string;
-export declare function marshalNestedList(list: any[]): any[];