houdini 1.0.0-next.1 → 1.0.0-next.2

package/build/runtime-esm/client/utils/documentPlugins.js

@@ -0,0 +1,32 @@
+const documentPlugin = (kind, source) => {
+  return () => {
+    const sourceHandlers = source();
+    const enterWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.next(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    const exitWrapper = (handler) => {
+      return !handler ? void 0 : (ctx, handlers) => {
+        if (ctx.artifact.kind !== kind) {
+          return handlers.resolve(ctx);
+        }
+        return handler(ctx, handlers);
+      };
+    };
+    return {
+      start: enterWrapper(sourceHandlers.start),
+      network: enterWrapper(sourceHandlers.network),
+      afterNetwork: exitWrapper(sourceHandlers.afterNetwork),
+      end: exitWrapper(sourceHandlers.end),
+      catch: sourceHandlers.catch ? (ctx, handlers) => sourceHandlers.catch(ctx, handlers) : void 0,
+      cleanup: (...args) => sourceHandlers.cleanup?.(...args)
+    };
+  };
+};
+export {
+  documentPlugin
+};

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

@@ -0,0 +1 @@
+export * from './documentPlugins';

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

@@ -0,0 +1 @@
+export * from "./documentPlugins";

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,6 +1,7 @@
-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 const cache: Cache<CacheTypeDef>;

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
@@ -140,4 +140,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 { 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, }: {
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
     artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
     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,5 +1,5 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+import type { SchemaManager, TypeInfo } from '../cache/schema';
 import { ListCollection } from './list';
 import { Record } from './record';
 import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';

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,4 +1,4 @@
-import { keyFieldsForType } from "../lib";
+import { keyFieldsForType } from "../lib/config";
 import { _typeInfo } from "./cache";
 import { Record } from "./record";
 class ListCollection {

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

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;

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

@@ -1,5 +1,5 @@
 import { rootID } from "../cache/cache";
-import { keyFieldsForType } from "../lib";
+import { keyFieldsForType } from "../lib/config";
 import { _typeInfo } from "./cache";
 class Record {
   #id;

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

@@ -1,5 +1,5 @@
 import { Cache } from '../cache';
-import { Record } from '../record';
+import type { Record } from '../record';
 type CacheTypeDef = {
     types: {
         __ROOT__: {

package/build/test/index.d.ts

@@ -1,6 +1,7 @@
-import { Config, CollectedGraphQLDocument } from '../lib';
-import { ConfigFile } from '../runtime/lib/config';
-export declare function testConfigFile(config?: Partial<ConfigFile>): ConfigFile;
+import type { CollectedGraphQLDocument } from '../lib';
+import { Config } from '../lib';
+import type { ConfigFile } from '../runtime/lib/config';
+export declare function testConfigFile({ plugins, ...config }?: Partial<ConfigFile>): ConfigFile;
 export declare function testConfig(config?: Partial<ConfigFile>): Config;
 export type Partial<T> = {
     [P in keyof T]?: T[P];