houdini 1.0.0-next.1 → 1.0.0-next.11

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

@@ -1,9 +1,10 @@
+import config from "../imports/config";
 let mockConfig = null;
 function getMockConfig() {
   return mockConfig;
 }
-function setMockConfig(config) {
-  mockConfig = config;
+function setMockConfig(config2) {
+  mockConfig = config2;
 }
 function defaultConfigValues(file) {
   return {
@@ -32,12 +33,12 @@ function computeID(configFile, type, data) {
   }
   return id.slice(0, -2);
 }
-async function getCurrentConfig() {
+function getCurrentConfig() {
   const mockConfig2 = getMockConfig();
   if (mockConfig2) {
     return mockConfig2;
   }
-  return defaultConfigValues((await import("HOUDINI_CONFIG_PATH")).default);
+  return defaultConfigValues(config);
 }
 export {
   computeID,

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

@@ -0,0 +1,2 @@
+import type { NestedList } from './types';
+export declare function flatten<T>(source?: NestedList<T>): T[];

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

@@ -0,0 +1,17 @@
+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 {
+  flatten
+};

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

@@ -1,8 +1,8 @@
 export * from './config';
 export * from './constants';
 export * from './deepEquals';
-export * from './errors';
 export * from './log';
-export * from './network';
 export * from './scalars';
 export * from './types';
+export * from './store';
+export * from './key';

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

@@ -1,8 +1,8 @@
 export * from "./config";
 export * from "./constants";
 export * from "./deepEquals";
-export * from "./errors";
 export * from "./log";
-export * from "./network";
 export * from "./scalars";
 export * from "./types";
+export * from "./store";
+export * from "./key";

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

@@ -0,0 +1,6 @@
+export declare const computeKey: ({ field, args }: {
+    field: string;
+    args?: {
+        [key: string]: any;
+    } | undefined;
+}) => string;

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

@@ -0,0 +1,17 @@
+const 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(", ")}}`;
+};
+export {
+  computeKey
+};

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

@@ -1,14 +1,15 @@
-import { ConfigFile } from './config';
-import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+import type { ConfigFile } from './config';
+import type { FragmentArtifact, MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
 export declare function marshalSelection({ selection, data, }: {
     selection: SubscriptionSelection;
     data: any;
 }): Promise<{} | null | undefined>;
-export declare function marshalInputs<T>({ artifact, input, rootType, }: {
-    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
+    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact | FragmentArtifact;
     input: unknown;
     rootType?: string;
-}): Promise<{} | null | undefined>;
+    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;

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

@@ -4,7 +4,7 @@ async function marshalSelection({
   selection,
   data
 }) {
-  const config = await getCurrentConfig();
+  const config = getCurrentConfig();
   if (data === null || typeof data === "undefined") {
     return data;
   }
@@ -39,12 +39,12 @@ async function marshalSelection({
     )
   );
 }
-async function marshalInputs({
+function marshalInputs({
   artifact,
   input,
+  config,
   rootType = "@root"
 }) {
-  const config = await getCurrentConfig();
   if (input === null || typeof input === "undefined") {
     return input;
   }
@@ -53,30 +53,26 @@ async function marshalInputs({
   }
   const fields = rootType === "@root" ? artifact.input.fields : artifact.input.types[rootType];
   if (Array.isArray(input)) {
-    return await Promise.all(
-      input.map(async (val) => await marshalInputs({ artifact, input: val, rootType }))
-    );
+    return input.map((val) => marshalInputs({ artifact, input: val, rootType, config }));
   }
   return Object.fromEntries(
-    await Promise.all(
-      Object.entries(input).map(async ([fieldName, value]) => {
-        const type = fields?.[fieldName];
-        if (!type) {
-          return [fieldName, value];
-        }
-        const marshalFn = config.scalars?.[type]?.marshal;
-        if (marshalFn) {
-          if (Array.isArray(value)) {
-            return [fieldName, value.map(marshalFn)];
-          }
-          return [fieldName, marshalFn(value)];
-        }
-        if (isScalar(config, type) || !artifact.input.types[type]) {
-          return [fieldName, value];
+    Object.entries(input).map(([fieldName, value]) => {
+      const type = fields?.[fieldName];
+      if (!type) {
+        return [fieldName, value];
+      }
+      const marshalFn = config.scalars?.[type]?.marshal;
+      if (marshalFn) {
+        if (Array.isArray(value)) {
+          return [fieldName, value.map(marshalFn)];
         }
-        return [fieldName, await marshalInputs({ artifact, input: value, rootType: type })];
-      })
-    )
+        return [fieldName, marshalFn(value)];
+      }
+      if (isScalar(config, type) || !artifact.input.types[type]) {
+        return [fieldName, value];
+      }
+      return [fieldName, marshalInputs({ artifact, input: value, rootType: type, config })];
+    })
   );
 }
 function unmarshalSelection(config, selection, data) {

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

@@ -1,2 +1,2 @@
-import { SubscriptionSelection } from './types';
+import type { SubscriptionSelection } from './types';
 export declare function getFieldsForType(selection: SubscriptionSelection, __typename: string | undefined | null): Required<SubscriptionSelection>['fields'];

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

@@ -0,0 +1,19 @@
+export declare class Writable<T> {
+    #private;
+    state: T;
+    constructor(value: T, start?: StartStopNotifier<T>);
+    set(new_value: T): void;
+    update(fn: Updater<T>): void;
+    subscribe(run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+/** Start and stop notification callbacks. */
+type StartStopNotifier<T> = (set: Subscriber<T>) => Unsubscriber | void;
+/** Callback to inform of a value updates. */
+export type Subscriber<T> = (value: T) => void;
+/** Unsubscribes from value updates. */
+export type Unsubscriber = () => void;
+/** Callback to update a value. */
+type Updater<T> = (value: T) => T;
+/** Cleanup logic callback. */
+type Invalidator<T> = (value?: T) => void;
+export {};

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

@@ -0,0 +1,57 @@
+const subscriber_queue = [];
+const noop = () => {
+};
+class Writable {
+  state;
+  #subscribers;
+  #stop;
+  #start;
+  constructor(value, start = noop) {
+    this.state = value;
+    this.#subscribers = /* @__PURE__ */ new Set();
+    this.#stop = null;
+    this.#start = start;
+  }
+  set(new_value) {
+    if (safe_not_equal(this.state, new_value)) {
+      this.state = new_value;
+      if (this.#stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of this.#subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, this.state);
+        }
+        if (run_queue) {
+          for (let i = 0; i < subscriber_queue.length; i += 2) {
+            subscriber_queue[i][0](subscriber_queue[i + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  update(fn) {
+    this.set(fn(this.state));
+  }
+  subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    this.#subscribers.add(subscriber);
+    if (this.#subscribers.size === 1) {
+      this.#stop = this.#start(this.set) || noop;
+    }
+    run(this.state);
+    return () => {
+      this.#subscribers.delete(subscriber);
+      if (this.#subscribers.size === 0) {
+        this.#stop?.();
+        this.#stop = null;
+      }
+    };
+  }
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+export {
+  Writable
+};

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

@@ -4,6 +4,22 @@ export declare enum CachePolicy {
     NetworkOnly = "NetworkOnly",
     CacheAndNetwork = "CacheAndNetwork"
 }
+declare global {
+    namespace App {
+        interface Session {
+        }
+        interface Metadata {
+        }
+        interface Stuff {
+            inputs: {
+                init: boolean;
+                marshaled: Record<string, any>;
+                changed: boolean;
+            };
+            optimisticResponse?: GraphQLObject;
+        }
+    }
+}
 export type Fragment<_Result> = {
     readonly shape?: _Result;
 };
@@ -55,7 +71,6 @@ export type BaseCompiledDocument = {
     rootType: string;
     input?: InputObject;
     refetch?: {
-        update: RefetchUpdateMode;
         path: string[];
         method: 'cursor' | 'offset';
         pageSize: number;
@@ -63,8 +78,9 @@ export type BaseCompiledDocument = {
         embedded: boolean;
         targetType: string;
         paginated: boolean;
-        direction?: 'forward' | 'backwards';
+        direction: 'forward' | 'backward' | 'both';
     };
+    plugin_data?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -118,7 +134,7 @@ export type SubscriptionSelection = {
                 connection: boolean;
                 type: string;
             };
-            update?: RefetchUpdateMode;
+            updates?: string[];
             filters?: {
                 [key: string]: {
                     kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
@@ -148,26 +164,24 @@ export type SubscriptionSpec = {
 export type FetchQueryResult<_Data> = {
     result: RequestPayload<_Data | null>;
     source: DataSource | null;
-    partial: boolean;
 };
-export type QueryResult<_Data, _Input, _Extra = {}> = {
+export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
     errors: {
         message: string;
     }[] | null;
     fetching: boolean;
     partial: boolean;
+    stale: boolean;
     source: DataSource | null;
-    variables: _Input;
-} & _Extra;
-export type RequestPayload<_Data = any> = {
-    data: _Data | null;
+    variables: _Input | null;
+};
+export type RequestPayload<GraphQLObject = any> = {
+    data: GraphQLObject | null;
     errors: {
         message: string;
     }[] | null;
 };
-export type RequestPayloadMagic<_Data = any> = {
-    ssr: boolean;
-    body: RequestPayload<_Data>;
-};
+export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
+export type ValueOf<Parent> = Parent[keyof Parent];
 export {};

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

@@ -1,19 +1,39 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+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.d.ts

@@ -1,5 +1,5 @@
-import { Cache } from './cache';
-import { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
+import type { Cache } from './cache';
+import type { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
 export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
     #private;
     constructor({ parentID, allLists, when, cache, name, }: {

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

@@ -1,5 +1,3 @@
-import { keyFieldsForType } from "../lib";
-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 { Cache } from './cache';
-import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
+import type { FragmentArtifact } from '../lib/types';
+import type { Cache } from './cache';
+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[];