houdini 1.0.0-next.2 → 1.0.0-next.20

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[];

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

@@ -1,6 +1,6 @@
 import { rootID } from "../cache/cache";
+import { marshalInputs } from "../lib";
 import { keyFieldsForType } from "../lib/config";
-import { _typeInfo } from "./cache";
 class Record {
   #id;
   #cache;
@@ -24,199 +24,42 @@ class Record {
       }
     }
   }
-  set({
-    field,
-    args,
-    value
+  read({
+    fragment,
+    variables
   }) {
-    this.#cache.validateInstabilityWarning();
-    const key = computeKey({ field, args });
-    const typeInfo = _typeInfo(this.#cache, this.type, field);
-    let newValue;
-    if (typeInfo.link) {
-      const keys = keyFieldsForType(this.#cache.config, typeInfo.type);
-      typeInfo.selection = {
-        fields: keys.reduce(
-          (acc, key2) => {
-            const keyInfo = _typeInfo(this.#cache, typeInfo.type, key2);
-            return {
-              ...acc,
-              [key2]: {
-                type: keyInfo.type,
-                keyRaw: key2
-              }
-            };
-          },
-          {
-            __typename: {
-              type: "String",
-              keyRaw: "__typename"
-            }
-          }
-        )
-      };
-    }
-    if (!typeInfo.link) {
-      const fnMarshal = this.#cache.config.scalars?.[typeInfo.type]?.marshal;
-      if (fnMarshal) {
-        newValue = fnMarshal(value);
-      } else {
-        newValue = value;
-      }
-    } else if (value instanceof Record) {
-      newValue = {
-        ...value.idFields,
-        __typename: value.type
-      };
-    } else if (Array.isArray(value)) {
-      newValue = marshalNestedList(value);
-    } else if (value !== null) {
-      throw new Error("Value must be a RecordProxy if the field is a link to another record");
-    }
-    this.#cache._internal_unstable._internal_unstable.lifetimes.resetLifetime(this.#id, key);
-    this.#cache._internal_unstable.write({
+    return this.#cache._internal_unstable.read({
+      selection: fragment.artifact.selection,
       parent: this.#id,
-      selection: {
-        fields: {
-          [field]: {
-            keyRaw: key,
-            ...typeInfo
-          }
-        }
-      },
-      data: {
-        [field]: newValue
-      }
+      variables: marshalInputs({
+        config: this.#cache.config,
+        artifact: fragment.artifact,
+        input: variables
+      }) ?? void 0
     });
   }
-  get({
-    field,
-    args
-  }) {
-    this.#cache.validateInstabilityWarning();
-    const key = computeKey({ field, args });
-    const typeInfo = _typeInfo(this.#cache, this.type, field);
-    if (typeInfo.link) {
-      const keys = keyFieldsForType(this.#cache.config, typeInfo.type);
-      typeInfo.selection = {
-        fields: keys.reduce(
-          (acc, key2) => {
-            const keyInfo = _typeInfo(this.#cache, typeInfo.type, key2);
-            return {
-              ...acc,
-              [key2]: {
-                type: keyInfo.type,
-                keyRaw: key2
-              }
-            };
-          },
-          {
-            __typename: {
-              type: "String",
-              keyRaw: "__typename"
-            }
-          }
-        )
-      };
-    }
-    const result = this.#cache._internal_unstable.read({
+  write(args) {
+    this.#cache._internal_unstable.write({
+      data: args.data,
+      selection: args.fragment.artifact.selection,
       parent: this.#id,
-      selection: {
-        fields: {
-          [field]: {
-            keyRaw: key,
-            ...typeInfo
-          }
-        }
-      }
-    });
-    if (!typeInfo.link) {
-      return result.data?.[field] ?? (typeInfo.nullable ? null : void 0);
-    }
-    const data = result.data?.[field] || {};
-    let finalResult = unmarshalNestedList(
-      this.#cache,
-      !Array.isArray(data) ? [data] : data
-    ).map((val) => {
-      if (typeInfo.nullable && (val === null || Object.keys(val).length === 0)) {
-        return null;
-      }
-      return val;
+      variables: marshalInputs({
+        config: this.#cache.config,
+        artifact: args.fragment.artifact,
+        input: args.variables
+      }) ?? void 0,
+      forceStale: args.forceStale
     });
-    return Array.isArray(data) ? finalResult : finalResult[0];
   }
   delete() {
     this.#cache._internal_unstable.delete(this.#id);
   }
-}
-function computeKey({ field, args }) {
-  const keys = Object.keys(args ?? {});
-  keys.sort();
-  return args && keys.length > 0 ? `${field}(${keys.map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(args[key])}`).join(", ")})` : field;
-}
-const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
-  if (Array.isArray(obj_from_json)) {
-    return `[${obj_from_json.map((obj) => `${stringifyObjectWithNoQuotesOnKeys(obj)}`).join(", ")}]`;
-  }
-  if (typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null) {
-    return JSON.stringify(obj_from_json).replace(/"([^"]+)":/g, "$1: ");
-  }
-  return `{${Object.keys(obj_from_json).map((key) => `${key}: ${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`).join(", ")}}`;
-};
-function marshalNestedList(list) {
-  const newValue = [];
-  for (const inner of list) {
-    if (Array.isArray(inner)) {
-      newValue.push(marshalNestedList(inner));
-    } else if (inner instanceof Record) {
-      newValue.push({ ...inner.idFields, __typename: inner.type });
-    } else {
-      newValue.push(inner);
-    }
-  }
-  return newValue;
-}
-function unmarshalNestedList(cache, list) {
-  const newValue = [];
-  for (const inner of list) {
-    if (Array.isArray(inner)) {
-      newValue.push(unmarshalNestedList(cache, inner));
-    } else if (inner === null) {
-      newValue.push(null);
-    } else if (inner.__typename) {
-      const type = inner.__typename;
-      let recordID = cache._internal_unstable._internal_unstable.id(type, inner);
-      if (!recordID) {
-        throw new Error("todo");
-      }
-      const typename = cache._internal_unstable.read({
-        selection: {
-          fields: {
-            __typename: {
-              keyRaw: "__typename",
-              type: "String"
-            }
-          }
-        },
-        parent: recordID
-      }).data?.__typename;
-      newValue.push(
-        new Record({
-          cache,
-          type: type || typename,
-          idFields: inner,
-          id: recordID
-        })
-      );
-    } else {
-      newValue.push(inner);
-    }
+  markStale(field, {
+    when
+  } = {}) {
+    this.#cache._internal_unstable.markRecordStale(this.#id, { field, when });
   }
-  return newValue;
 }
 export {
-  Record,
-  computeKey,
-  marshalNestedList,
-  stringifyObjectWithNoQuotesOnKeys
+  Record
 };

package/build/runtime-esm/public/tests/test.d.ts

@@ -1,9 +1,11 @@
+import { type SubscriptionSelection, type FragmentArtifact, type QueryArtifact } from '../../lib';
 import { Cache } from '../cache';
 import type { Record } from '../record';
-type CacheTypeDef = {
+export type CacheTypeDefTest = {
     types: {
         __ROOT__: {
             idFields: {};
+            fragments: [];
             fields: {
                 test: {
                     type: number | null;
@@ -14,23 +16,23 @@ type CacheTypeDef = {
                     args: never;
                 };
                 viewer: {
-                    type: Record<CacheTypeDef, 'User'> | null;
+                    type: Record<CacheTypeDefTest, 'User'> | null;
                     args: never;
                 };
                 pets: {
-                    type: (Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>)[];
+                    type: (Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>)[];
                     args: never;
                 };
                 listOfLists: {
-                    type: ((Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null | (null | Record<CacheTypeDef, 'User'>)[])[] | Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'> | null)[];
+                    type: ((Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null | (null | Record<CacheTypeDefTest, 'User'>)[])[] | Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'> | null)[];
                     args: never;
                 };
                 users: {
-                    type: Record<CacheTypeDef, 'User'>[] | null;
+                    type: Record<CacheTypeDefTest, 'User'>[] | null;
                     args: never;
                 };
                 pet: {
-                    type: Record<CacheTypeDef, 'Cat'> | Record<CacheTypeDef, 'User'>;
+                    type: Record<CacheTypeDefTest, 'Cat'> | Record<CacheTypeDefTest, 'User'>;
                     args: never;
                 };
             };
@@ -39,13 +41,26 @@ type CacheTypeDef = {
             idFields: {
                 id: string;
             };
+            fragments: [
+                [
+                    {
+                        artifact: FragmentArtifact;
+                    },
+                    {
+                        firstName: string;
+                    },
+                    {
+                        pattern: string;
+                    }
+                ]
+            ];
             fields: {
                 firstName: {
                     type: string;
                     args: never;
                 };
                 parent: {
-                    type: Record<CacheTypeDef, 'User'>;
+                    type: Record<CacheTypeDefTest, 'User'>;
                     args: never;
                 };
                 id: {
@@ -62,13 +77,14 @@ type CacheTypeDef = {
             idFields: {
                 id: string;
             };
+            fragments: [];
             fields: {
                 name: {
                     type: string | null;
                     args: never;
                 };
                 parent: {
-                    type: Record<CacheTypeDef, 'User'> | null;
+                    type: Record<CacheTypeDefTest, 'User'> | null;
                     args: never;
                 };
                 id: {
@@ -85,6 +101,7 @@ type CacheTypeDef = {
             idFields: {
                 id: string;
             };
+            fragments: [];
             fields: {
                 name: {
                     type: string | null;
@@ -97,6 +114,26 @@ type CacheTypeDef = {
             };
         };
     };
+    queries: [
+        [
+            {
+                artifact: QueryArtifact;
+            },
+            {
+                viewer: {
+                    id: string;
+                    firstName: string;
+                    __typename: string;
+                    parent: {
+                        id: string;
+                        firstName: string;
+                        __typename: string;
+                    };
+                };
+            },
+            any
+        ]
+    ];
     lists: {
         All_Pets: {
             types: 'User' | 'Cat';
@@ -110,5 +147,10 @@ type CacheTypeDef = {
         };
     };
 };
-export declare const testCache: () => Cache<CacheTypeDef>;
-export {};
+export declare const testCache: () => Cache<CacheTypeDefTest>;
+export declare const testFragment: (selection: SubscriptionSelection) => {
+    artifact: FragmentArtifact;
+};
+export declare const testQuery: (selection: SubscriptionSelection) => {
+    artifact: QueryArtifact;
+};