houdini 2.0.0-next.9 → 2.0.0

package/build/runtime/{lib/types.d.ts → types.d.ts}

@@ -1,30 +1,21 @@
+import type { PaginateModes } from 'houdini';
+export type { ConfigFile, PaginateModes } from 'houdini';
 type ValuesOf<Target> = Target[keyof Target];
-export declare const CachePolicy: {
-    readonly CacheOrNetwork: "CacheOrNetwork";
-    readonly CacheOnly: "CacheOnly";
-    readonly NetworkOnly: "NetworkOnly";
-    readonly CacheAndNetwork: "CacheAndNetwork";
-    readonly NoCache: "NoCache";
-};
-export type CachePolicies = ValuesOf<typeof CachePolicy>;
 export declare const DedupeMatchMode: {
     readonly Variables: "Variables";
     readonly Operation: "Operation";
     readonly None: "None";
 };
 export type DedupeMatchModes = ValuesOf<typeof DedupeMatchMode>;
-export declare const PaginateMode: {
-    readonly Infinite: "Infinite";
-    readonly SinglePage: "SinglePage";
-};
-export type PaginateModes = ValuesOf<typeof PaginateMode>;
-export * from '../router/types';
+export * from '../router/types.js';
 declare global {
     namespace App {
         interface Session {
         }
         interface Metadata {
         }
+        interface GraphQLErrorExtensions {
+        }
         interface Stuff {
             inputs: {
                 init: boolean;
@@ -43,6 +34,7 @@ export type RuntimeScalarResolver = (args: {
 }) => any;
 export type Fragment<_Result> = {
     readonly shape?: _Result;
+    readonly ' $fragments'?: Record<string, unknown>;
 };
 export type Operation<_Result, _Input> = {
     readonly result: _Result;
@@ -80,6 +72,7 @@ export type MutationArtifact = BaseCompiledDocument<'HoudiniMutation'> & {
 };
 export type FragmentArtifact = BaseCompiledDocument<'HoudiniFragment'> & {
     enableLoadingState?: 'global' | 'local';
+    plural?: boolean;
 };
 export type SubscriptionArtifact = BaseCompiledDocument<'HoudiniSubscription'>;
 export declare const RefetchUpdateMode: {
@@ -94,7 +87,14 @@ export type InputObject = {
     defaults: Record<string, any>;
     runtimeScalars: Record<string, string>;
 };
-export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
+export type RedirectTemplate = ReadonlyArray<string | readonly string[]>;
+export type EndpointSpec = {
+    redirect?: RedirectTemplate;
+    multipart?: boolean;
+    id?: string;
+    fields?: readonly string[];
+};
+export type BaseCompiledDocument<_Kind extends ArtifactKinds> = Readonly<{
     name: string;
     kind: _Kind;
     raw: string;
@@ -102,10 +102,13 @@ export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
     selection: SubscriptionSelection;
     rootType: string;
     input?: InputObject;
+    endpoint?: EndpointSpec;
+    sessionPath?: string;
+    sessionMerge?: boolean;
     hasComponents?: boolean;
     stripVariables: Array<string>;
     refetch?: {
-        path: string[];
+        path: readonly string[];
         method: 'cursor' | 'offset';
         pageSize: number;
         start?: string | number;
@@ -115,13 +118,27 @@ export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
         direction: 'forward' | 'backward' | 'both';
         mode: PaginateModes;
     };
+    operations?: readonly RootOperation[];
     pluginData: Record<string, any>;
+}>;
+export type RootOperation = {
+    action: 'refetch';
+    type: string;
+    path: readonly string[];
 };
 export type HoudiniFetchContext = {
     variables: () => {};
 };
-type Filter = {
-    [key: string]: string | boolean | number;
+export type FetchContext = {
+    fetch: typeof globalThis.fetch;
+    metadata?: App.Metadata | null;
+    session: App.Session | null;
+};
+export type FilterValue = string | boolean | number | null | readonly FilterValue[] | {
+    [key: string]: FilterValue;
+};
+export type Filter = {
+    [key: string]: FilterValue;
 };
 export type ListWhen = {
     must?: Filter;
@@ -143,25 +160,29 @@ export declare const DataSource: {
 };
 export type DataSources = ValuesOf<typeof DataSource>;
 export type MutationOperation = {
-    action: 'insert' | 'remove' | 'delete' | 'toggle';
+    action: 'insert' | 'remove' | 'delete' | 'toggle' | 'upsert';
     list?: string;
     type?: string;
-    parentID?: {
-        kind: string;
-        value: string;
-    };
+    parentID?: ValueNode;
+    listID?: ValueNode;
     position?: 'first' | 'last';
     target?: 'all';
-    when?: ListWhen;
+    when?: {
+        must?: Record<string, ListFilter>;
+        must_not?: Record<string, ListFilter>;
+    };
 };
 export type GraphQLObject = {
     [key: string]: GraphQLValue;
 };
 export type GraphQLDefaultScalar = string | number | boolean;
-export type GraphQLValue = GraphQLDefaultScalar | null | GraphQLObject | GraphQLValue[] | undefined;
+type CacheComponentFields = CacheTypeDef extends {
+    componentFields: infer CF;
+} ? CF : never;
+export type GraphQLValue = GraphQLDefaultScalar | CacheTypeDef['scalars'] | CacheComponentFields | symbol | null | GraphQLObject | GraphQLValue[] | undefined;
 export type GraphQLVariables = {
     [key: string]: any;
-} | null;
+} | null | undefined;
 export type LoadingSpec = {
     kind: 'continue';
     list?: {
@@ -176,7 +197,17 @@ export type LoadingSpec = {
         count: number;
     };
 };
-export type SubscriptionSelection = {
+export type ListFilter = {
+    kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Enum' | 'Variable';
+    value: string | number | boolean;
+} | {
+    kind: 'Object';
+    value: Record<string, ListFilter>;
+} | {
+    kind: 'List';
+    value: readonly ListFilter[];
+};
+export type SubscriptionSelection = Readonly<{
     loadingTypes?: string[];
     fragments?: Record<string, {
         arguments: ValueMap;
@@ -187,28 +218,26 @@ export type SubscriptionSelection = {
         attribute: string;
     }>;
     fields?: {
-        [fieldName: string]: {
+        [fieldName: string]: Readonly<{
             type: string;
             keyRaw: string;
             nullable?: boolean;
             required?: boolean;
-            operations?: MutationOperation[];
+            operations?: readonly MutationOperation[];
             list?: {
                 name: string;
                 connection: boolean;
                 type: string;
+                includeListID?: boolean;
             };
             loading?: LoadingSpec;
-            directives?: {
+            directives?: readonly {
                 name: string;
                 arguments: ValueMap;
             }[];
-            updates?: string[];
+            updates?: readonly string[];
             visible?: boolean;
-            filters?: Record<string, {
-                kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
-                value: string | number | boolean;
-            }>;
+            filters?: Record<string, ListFilter>;
             selection?: SubscriptionSelection;
             abstract?: boolean;
             abstractHasRequired?: boolean;
@@ -219,7 +248,7 @@ export type SubscriptionSelection = {
                 variables: ValueMap | null;
             };
             optimisticKey?: boolean;
-        };
+        }>;
     };
     abstractFields?: {
         fields: {
@@ -229,34 +258,48 @@ export type SubscriptionSelection = {
             [typeName: string]: string;
         };
     };
+}>;
+export type CacheMessage<_Data = any> = {
+    kind: 'update';
+    data: _Data;
+} | {
+    kind: 'refetch';
 };
-export type SubscriptionSpec = {
+export type SubscriptionSpec = Readonly<{
     rootType: string;
+    kind?: ArtifactKinds;
     selection: SubscriptionSelection;
-    set: (data: any) => void;
+    onMessage: (message: CacheMessage) => void;
     parentID?: string;
     variables?: () => any;
-};
+}>;
 export type FetchQueryResult<_Data> = {
     result: RequestPayload<_Data | null>;
     source: DataSources | null;
 };
-export type QueryResult<_Data = GraphQLObject, _Input = GraphQLVariables> = {
+export type GraphQLError = {
+    message: string;
+    locations?: readonly {
+        line: number;
+        column: number;
+    }[];
+    path?: readonly (string | number)[];
+    extensions?: App.GraphQLErrorExtensions;
+};
+export type QueryResult<_Data = GraphQLObject, _Input = GraphQLVariables | undefined> = {
     data: _Data | null;
-    errors: {
-        message: string;
-    }[] | null;
+    errors: GraphQLError[] | null;
     fetching: boolean;
     partial: boolean;
     stale: boolean;
     source: DataSources | null;
     variables: _Input | null;
+    extensions?: Record<string, any>;
 };
 export type RequestPayload<GraphQLObject = any> = {
     data: GraphQLObject | null;
-    errors: {
-        message: string;
-    }[] | null;
+    errors: GraphQLError[] | null;
+    extensions?: Record<string, any>;
 };
 export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
 export type ValueOf<Parent> = Parent[keyof Parent];
@@ -359,59 +402,17 @@ interface VariableNode {
 export declare const PendingValue: unique symbol;
 export type LoadingType = typeof PendingValue;
 export declare function isPending(value: any): value is LoadingType;
-export type ProjectManifest = {
-    /** All of the pages in the project */
-    pages: Record<string, PageManifest>;
-    /** All of the layouts in the project */
-    layouts: Record<string, PageManifest>;
-    /** All of the page queries in the project */
-    page_queries: Record<string, QueryManifest>;
-    /** All of the layout queries in the project */
-    layout_queries: Record<string, QueryManifest>;
-    /** All of the artifacts in the project */
-    artifacts: string[];
-    /** Whether or not there is a local schema defined */
-    local_schema: boolean;
-    /** Whether or not there is a custom server defined */
-    local_server: boolean;
-    /** Information about componentFields defined in the project */
-    component_fields: Record<string, {
-        filepath: string;
-    }>;
-};
-export type PageManifest = {
-    id: string;
-    /** the name of every query that the page depends on */
-    queries: string[];
-    /** the list of queries that this page could potentially ask for */
-    query_options: string[];
-    /** the full url pattern of the page */
-    url: string;
-    /** the ids of layouts that wrap this page */
-    layouts: string[];
-    /** The filepath of the unit */
-    path: string;
-    /**
-     * The name and type of every route paramter that this page can use.
-     * null indicates the type is unknown (not constrained by a query)
-     **/
-    params: Record<string, {
-        type: string;
-        wrappers: string[];
-    } | null>;
-};
-export type QueryManifest = {
-    /** the name of the query */
-    name: string;
-    /** the url tied with the query */
-    url: string;
-    /** wether the query uses the loading directive (ie, wants a fallback) */
-    loading: boolean;
-    /** The filepath of the unit */
-    path: string;
-    /** The name and GraphQL type for the variables that this query cares about */
-    variables: Record<string, {
-        wrappers: string[];
-        type: string;
-    }>;
+export declare const CachePolicy: {
+    readonly CacheOrNetwork: "CacheOrNetwork";
+    readonly CacheOnly: "CacheOnly";
+    readonly NetworkOnly: "NetworkOnly";
+    readonly CacheAndNetwork: "CacheAndNetwork";
+    readonly NoCache: "NoCache";
 };
+export type CachePolicies = ValuesOf<typeof CachePolicy>;
+export interface CacheTypeDef {
+    types: {};
+    lists: {};
+    queries: [];
+    scalars: boolean | number | string | Date;
+}

package/build/{runtime-esm/lib → runtime}/types.js

@@ -1,20 +1,9 @@
-const CachePolicy = {
-  CacheOrNetwork: "CacheOrNetwork",
-  CacheOnly: "CacheOnly",
-  NetworkOnly: "NetworkOnly",
-  CacheAndNetwork: "CacheAndNetwork",
-  NoCache: "NoCache"
-};
 const DedupeMatchMode = {
   Variables: "Variables",
   Operation: "Operation",
   None: "None"
 };
-const PaginateMode = {
-  Infinite: "Infinite",
-  SinglePage: "SinglePage"
-};
-export * from "../router/types";
+export * from "../router/types.js";
 const ArtifactKind = {
   Query: "HoudiniQuery",
   Subscription: "HoudiniSubscription",
@@ -45,10 +34,17 @@ const DataSource = {
   Ssr: "ssr"
 };
 const fragmentKey = " $fragments";
-const PendingValue = Symbol("houdini_loading");
+const PendingValue = /* @__PURE__ */ Symbol("houdini_loading");
 function isPending(value) {
   return typeof value === "symbol";
 }
+const CachePolicy = {
+  CacheOrNetwork: "CacheOrNetwork",
+  CacheOnly: "CacheOnly",
+  NetworkOnly: "NetworkOnly",
+  CacheAndNetwork: "CacheAndNetwork",
+  NoCache: "NoCache"
+};
 export {
   ArtifactKind,
   CachePolicy,
@@ -58,7 +54,6 @@ export {
   CompiledSubscriptionKind,
   DataSource,
   DedupeMatchMode,
-  PaginateMode,
   PendingValue,
   RefetchUpdateMode,
   fragmentKey,

package/build/test/index.d.ts

@@ -1,26 +1,7 @@
-import type { Document } 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];
-};
-export declare function pipelineTest(config: Config, documents: string[], shouldPass: boolean, testBody?: ((result: Error | Error[]) => void) | ((docs: Document[]) => void)): () => Promise<void>;
-export declare function mockCollectedDoc(query: string, data?: Partial<Document>): Document;
+import type { ConfigFile } from 'houdini';
+import { Config } from 'houdini';
 export declare function clearMock(): void;
-export type Row = {
-    title: string;
-    pass: true;
-    documents: string[];
-    check?: (docs: Document[]) => void;
-    partial_config?: Partial<Config>;
-    nb_of_fail?: number;
-} | {
-    title: string;
-    pass: false;
-    documents: string[];
-    check?: (result: Error | Error[]) => void;
-    partial_config?: Partial<Config>;
-    nb_of_fail?: number;
-};
+export declare function testConfigFile({ plugins, ...config }?: Partial<ConfigFile>): ConfigFile;
+export declare function testConfig({ schema }?: {
+    schema?: string;
+}): Config;