houdini 1.0.0-next.1 → 1.0.0-next.3

package/build/runtime-esm/imports/config.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigFile } from '../lib/config';
+declare const _default: ConfigFile;
+export default _default;

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

@@ -0,0 +1,4 @@
+var config_default = {};
+export {
+  config_default as default
+};

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

@@ -1,7 +1,8 @@
-import { Cache as InternalCache } from './cache/cache';
+import type { Cache as InternalCache } from './cache/cache';
 import type { CacheTypeDef } from './generated';
 import { Cache } from './public';
+export * from './client';
 export * from './lib';
-export declare function graphql(str: string | TemplateStringsArray): any;
+export declare function graphql<_Payload>(str: TemplateStringsArray): _Payload;
 export declare const cache: Cache<CacheTypeDef>;
 export declare function getCache(): InternalCache;

package/build/runtime-esm/index.js

@@ -1,5 +1,6 @@
 import _cache from "./cache";
 import { Cache } from "./public";
+export * from "./client";
 export * from "./lib";
 function graphql(str) {
   if (globalThis?.process?.env?.HOUDINI_PLUGIN) {

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

@@ -1,11 +1,11 @@
-import { GraphQLSchema } from 'graphql';
-import { CachePolicy } from './types';
+import type { GraphQLSchema } from 'graphql';
+import type { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
 export declare function setMockConfig(config: ConfigFile | null): void;
 export declare function defaultConfigValues(file: ConfigFile): ConfigFile;
 export declare function keyFieldsForType(configFile: ConfigFile, type: string): string[];
 export declare function computeID(configFile: ConfigFile, type: string, data: any): string;
-export declare function getCurrentConfig(): Promise<ConfigFile>;
+export declare function getCurrentConfig(): ConfigFile;
 export type ConfigFile = {
     /**
      * A glob pointing to all files that houdini should consider. Note, this must include .js files
@@ -31,10 +31,6 @@ export type ConfigFile = {
      * FYI: `schemaPath` or `schema` should be defined
      */
     schema?: string | GraphQLSchema;
-    /**
-     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
-     */
-    apiUrl?: string | ((env: Record<string, string | undefined>) => string);
     /**
      * An object describing custom scalars for your project. For more information: https://www.houdinigraphql.com/api/config#custom-scalars
      */
@@ -43,11 +39,6 @@ export type ConfigFile = {
      * A path that the generator will use to write schema.graphql and documents.gql files containing all of the internal fragment and directive definitions used in the project.
      */
     definitionsPath?: string;
-    /**
-     * One of "kit" or "svelte". Used to tell the preprocessor what kind of loading paradigm to generate for you. (default: `kit`)
-     * @deprecated please follow the steps here: http://www.houdinigraphql.com/guides/release-notes#0170
-     */
-    framework?: 'kit' | 'svelte';
     /**
      * One of "esm" or "commonjs". Tells the artifact generator what kind of modules to create. (default: `esm`)
      */
@@ -90,20 +81,9 @@ export type ConfigFile = {
      */
     defaultFragmentMasking?: 'enable' | 'disable';
     /**
-     * Configures the houdini plugin's schema polling behavior. By default, houdini will poll your APIs
-     * during development in order to keep it's definition of your schema up to date. The schemaPollingInterval
-     * config value sets the amount of time between each request in milliseconds (default 2 seconds).
-     * To limit the schema introspection to just on the start of the server, set schemaPollingInterval to 0.
-     * To disable the schema introspection, set schemaPollingInterval to null.
-     */
-    schemaPollInterval?: number | null;
-    /**
-     * An object containing the environment variables you want passed onto the api when polling for a new schema.
-     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
-     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
-     * logic you need
+     * Configure the dev environment to watch a remote schema for changes
      */
-    schemaPollHeaders?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+    watchSchema?: WatchSchemaConfig;
     /**
      * An object describing the plugins enabled for the project
      */
@@ -133,6 +113,25 @@ export type TypeConfig = {
         };
     };
 };
+export type WatchSchemaConfig = {
+    /**
+     * A url to use to pull the schema. For more information: https://www.houdinigraphql.com/api/cli#generate
+     */
+    url: string | ((env: Record<string, string | undefined>) => string);
+    /**
+     * sets the amount of time between each request in milliseconds (default 2 seconds).
+     * To limit the schema introspection to just on the start of the server, set interval to 0.
+     * To disable the schema introspection, set interval to null.
+     */
+    interval?: number | null;
+    /**
+     * An object containing the environment variables you want passed onto the api when polling for a new schema.
+     * The keys dictate the header names. If the value is a string, the corresponding environment variable will be used
+     * directly. If the value is a function, the current environment will be passed to your function so you can perform any
+     * logic you need
+     */
+    headers?: Record<string, string | ((env: Record<string, string | undefined>) => string)> | ((env: Record<string, string | undefined>) => Record<string, string>);
+};
 export type ScalarSpec = {
     type: string;
     marshal?: (val: any) => any;
@@ -140,4 +139,6 @@ export type ScalarSpec = {
 };
 export interface HoudiniPluginConfig {
 }
+export interface HoudiniClientPluginConfig {
+}
 export {};

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/index.d.ts

@@ -1,8 +1,7 @@
 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';

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

@@ -1,8 +1,7 @@
 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";

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;
 };
@@ -65,6 +81,7 @@ export type BaseCompiledDocument = {
         paginated: boolean;
         direction?: 'forward' | 'backwards';
     };
+    pluginsData?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -150,7 +167,7 @@ export type FetchQueryResult<_Data> = {
     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;
@@ -158,16 +175,12 @@ export type QueryResult<_Data, _Input, _Extra = {}> = {
     fetching: boolean;
     partial: 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 {};

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

@@ -1,19 +1,32 @@
-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 { CacheTypeDef, IDFields, QueryInput, QueryList, QueryValue, 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;
 }
-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,34 @@ 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
+    });
   }
-  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().`
-    );
+  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;
   }
-  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 { CacheTypeDef, FragmentList, FragmentValue, FragmentVariables, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;
     type: string;
@@ -10,22 +11,21 @@ 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>;
     }): void;
-    get<Field extends TypeFieldNames<Def, Type>>({ field, args, }: {
-        field: Field;
-        args?: ArgType<Def, Type, Field>;
-    }): FieldType<Def, Type, Field>;
     delete(): 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[];