houdini 2.0.0-next.8 → 2.0.0

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

@@ -1,14 +0,0 @@
-import type { ConfigFile } from './config';
-import { type FragmentArtifact, type MutationArtifact, type QueryArtifact, type SubscriptionArtifact, type SubscriptionSelection } from './types';
-export declare function marshalSelection({ selection, data, }: {
-    selection: SubscriptionSelection;
-    data: any;
-}): {} | null | undefined;
-export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
-    artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact | FragmentArtifact;
-    input: unknown;
-    rootType?: string;
-    config: ConfigFile;
-}): {} | null | undefined;
-export declare function isScalar(config: ConfigFile, type: string): boolean;
-export declare function parseScalar(config: ConfigFile, type: string, value?: string): string | number | boolean | undefined;

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

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

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

@@ -1,19 +0,0 @@
-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/types.d.ts

@@ -1,417 +0,0 @@
-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';
-declare global {
-    namespace App {
-        interface Session {
-        }
-        interface Metadata {
-        }
-        interface Stuff {
-            inputs: {
-                init: boolean;
-                marshaled: Record<string, any>;
-                changed: boolean;
-            };
-            optimisticResponse?: GraphQLObject;
-            parentID?: string;
-            silenceLoading?: boolean;
-            mutationID?: number;
-        }
-    }
-}
-export type RuntimeScalarResolver = (args: {
-    session: App.Session;
-}) => any;
-export type Fragment<_Result> = {
-    readonly shape?: _Result;
-};
-export type Operation<_Result, _Input> = {
-    readonly result: _Result;
-    readonly input: _Input;
-};
-export type Maybe<T> = T | null | undefined;
-export type DocumentArtifact = FragmentArtifact | QueryArtifact | MutationArtifact | SubscriptionArtifact;
-export declare const ArtifactKind: {
-    readonly Query: "HoudiniQuery";
-    readonly Subscription: "HoudiniSubscription";
-    readonly Mutation: "HoudiniMutation";
-    readonly Fragment: "HoudiniFragment";
-};
-export type ArtifactKinds = ValuesOf<typeof ArtifactKind>;
-export declare const CompiledFragmentKind: "HoudiniFragment";
-export declare const CompiledMutationKind: "HoudiniMutation";
-export declare const CompiledQueryKind: "HoudiniQuery";
-export declare const CompiledSubscriptionKind: "HoudiniSubscription";
-export type CompiledDocumentKind = ArtifactKinds;
-export type QueryArtifact = BaseCompiledDocument<'HoudiniQuery'> & {
-    policy?: CachePolicies;
-    partial?: boolean;
-    enableLoadingState?: 'global' | 'local';
-    dedupe?: {
-        cancel: 'first' | 'last';
-        match: DedupeMatchModes;
-    };
-};
-export type MutationArtifact = BaseCompiledDocument<'HoudiniMutation'> & {
-    optimisticKeys?: boolean;
-    dedupe?: {
-        cancel: 'first' | 'last';
-        match: DedupeMatchModes;
-    };
-};
-export type FragmentArtifact = BaseCompiledDocument<'HoudiniFragment'> & {
-    enableLoadingState?: 'global' | 'local';
-};
-export type SubscriptionArtifact = BaseCompiledDocument<'HoudiniSubscription'>;
-export declare const RefetchUpdateMode: {
-    readonly append: "append";
-    readonly prepend: "prepend";
-    readonly replace: "replace";
-};
-export type RefetchUpdateModes = ValuesOf<typeof RefetchUpdateMode>;
-export type InputObject = {
-    fields: Record<string, string>;
-    types: Record<string, Record<string, string>>;
-    defaults: Record<string, any>;
-    runtimeScalars: Record<string, string>;
-};
-export type BaseCompiledDocument<_Kind extends ArtifactKinds> = {
-    name: string;
-    kind: _Kind;
-    raw: string;
-    hash: string;
-    selection: SubscriptionSelection;
-    rootType: string;
-    input?: InputObject;
-    hasComponents?: boolean;
-    stripVariables: Array<string>;
-    refetch?: {
-        path: string[];
-        method: 'cursor' | 'offset';
-        pageSize: number;
-        start?: string | number;
-        embedded: boolean;
-        targetType: string;
-        paginated: boolean;
-        direction: 'forward' | 'backward' | 'both';
-        mode: PaginateModes;
-    };
-    pluginData: Record<string, any>;
-};
-export type HoudiniFetchContext = {
-    variables: () => {};
-};
-type Filter = {
-    [key: string]: string | boolean | number;
-};
-export type ListWhen = {
-    must?: Filter;
-    must_not?: Filter;
-};
-export declare const DataSource: {
-    /**
-     * from the browser cache
-     */
-    readonly Cache: "cache";
-    /**
-     * from a browser side `fetch`
-     */
-    readonly Network: "network";
-    /**
-     * from a server side `fetch`
-     */
-    readonly Ssr: "ssr";
-};
-export type DataSources = ValuesOf<typeof DataSource>;
-export type MutationOperation = {
-    action: 'insert' | 'remove' | 'delete' | 'toggle';
-    list?: string;
-    type?: string;
-    parentID?: {
-        kind: string;
-        value: string;
-    };
-    position?: 'first' | 'last';
-    target?: 'all';
-    when?: ListWhen;
-};
-export type GraphQLObject = {
-    [key: string]: GraphQLValue;
-};
-export type GraphQLDefaultScalar = string | number | boolean;
-export type GraphQLValue = GraphQLDefaultScalar | null | GraphQLObject | GraphQLValue[] | undefined;
-export type GraphQLVariables = {
-    [key: string]: any;
-} | null;
-export type LoadingSpec = {
-    kind: 'continue';
-    list?: {
-        depth: number;
-        count: number;
-    };
-} | {
-    kind: 'value';
-    value?: any;
-    list?: {
-        depth: number;
-        count: number;
-    };
-};
-export type SubscriptionSelection = {
-    loadingTypes?: string[];
-    fragments?: Record<string, {
-        arguments: ValueMap;
-        loading?: boolean;
-    }>;
-    components?: Record<string, {
-        prop: string;
-        attribute: string;
-    }>;
-    fields?: {
-        [fieldName: string]: {
-            type: string;
-            keyRaw: string;
-            nullable?: boolean;
-            required?: boolean;
-            operations?: MutationOperation[];
-            list?: {
-                name: string;
-                connection: boolean;
-                type: string;
-            };
-            loading?: LoadingSpec;
-            directives?: {
-                name: string;
-                arguments: ValueMap;
-            }[];
-            updates?: string[];
-            visible?: boolean;
-            filters?: Record<string, {
-                kind: 'Boolean' | 'String' | 'Float' | 'Int' | 'Variable';
-                value: string | number | boolean;
-            }>;
-            selection?: SubscriptionSelection;
-            abstract?: boolean;
-            abstractHasRequired?: boolean;
-            component?: {
-                prop: string;
-                key: string;
-                fragment: string;
-                variables: ValueMap | null;
-            };
-            optimisticKey?: boolean;
-        };
-    };
-    abstractFields?: {
-        fields: {
-            [typeName: string]: SubscriptionSelection['fields'];
-        };
-        typeMap: {
-            [typeName: string]: string;
-        };
-    };
-};
-export type SubscriptionSpec = {
-    rootType: string;
-    selection: SubscriptionSelection;
-    set: (data: any) => void;
-    parentID?: string;
-    variables?: () => any;
-};
-export type FetchQueryResult<_Data> = {
-    result: RequestPayload<_Data | null>;
-    source: DataSources | null;
-};
-export type QueryResult<_Data = GraphQLObject, _Input = GraphQLVariables> = {
-    data: _Data | null;
-    errors: {
-        message: string;
-    }[] | null;
-    fetching: boolean;
-    partial: boolean;
-    stale: boolean;
-    source: DataSources | null;
-    variables: _Input | null;
-};
-export type RequestPayload<GraphQLObject = any> = {
-    data: GraphQLObject | null;
-    errors: {
-        message: string;
-    }[] | null;
-};
-export type NestedList<_Result = string> = (_Result | null | NestedList<_Result>)[];
-export type ValueOf<Parent> = Parent[keyof Parent];
-export declare const fragmentKey: " $fragments";
-export type ValueNode = VariableNode | IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | ListValueNode | ObjectValueNode;
-export type ValueMap = Record<string, ValueNode>;
-export type FetchParams<_Input> = {
-    variables?: _Input;
-    /**
-     * The policy to use when performing the fetch. If set to CachePolicy.NetworkOnly,
-     * a request will always be sent, even if the variables are the same as the last call
-     * to fetch.
-     */
-    policy?: CachePolicies;
-    /**
-     * An object that will be passed to the fetch function.
-     * You can do what you want with it!
-     */
-    metadata?: App.Metadata;
-    /**
-     * An abort controller to abort the operation
-     */
-    abortController?: AbortController;
-};
-export type FetchFn<_Data extends GraphQLObject, _Input = any> = (params?: FetchParams<_Input>) => Promise<QueryResult<_Data, _Input>>;
-export type CursorHandlers<_Data extends GraphQLObject, _Input> = {
-    loadNextPage: (args?: {
-        first?: number;
-        after?: string;
-        fetch?: typeof globalThis.fetch;
-        metadata?: {};
-    }) => Promise<QueryResult<_Data, _Input>>;
-    loadPreviousPage: (args?: {
-        last?: number;
-        before?: string;
-        fetch?: typeof globalThis.fetch;
-        metadata?: {};
-    }) => Promise<QueryResult<_Data, _Input>>;
-    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
-};
-export type OffsetHandlers<_Data extends GraphQLObject, _Input> = {
-    loadNextPage: (args?: {
-        limit?: number;
-        offset?: number;
-        metadata?: {};
-        fetch?: typeof globalThis.fetch;
-    }) => Promise<void>;
-    fetch(args?: FetchParams<_Input> | undefined): Promise<QueryResult<_Data, _Input>>;
-};
-export type PageInfo = {
-    startCursor: string | null;
-    endCursor: string | null;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
-};
-interface IntValueNode {
-    readonly kind: 'IntValue';
-    readonly value: string;
-}
-interface FloatValueNode {
-    readonly kind: 'FloatValue';
-    readonly value: string;
-}
-interface StringValueNode {
-    readonly kind: 'StringValue';
-    readonly value: string;
-}
-interface BooleanValueNode {
-    readonly kind: 'BooleanValue';
-    readonly value: boolean;
-}
-interface NullValueNode {
-    readonly kind: 'NullValue';
-}
-interface EnumValueNode {
-    readonly kind: 'EnumValue';
-    readonly value: string;
-}
-interface ListValueNode {
-    readonly kind: 'ListValue';
-    readonly values: ReadonlyArray<ValueNode>;
-}
-interface ObjectValueNode {
-    readonly kind: 'ObjectValue';
-    readonly fields: ReadonlyArray<ObjectFieldNode>;
-}
-interface ObjectFieldNode {
-    readonly kind: 'ObjectField';
-    readonly name: NameNode;
-    readonly value: ValueNode;
-}
-interface NameNode {
-    readonly kind: 'Name';
-    readonly value: string;
-}
-interface VariableNode {
-    readonly kind: 'Variable';
-    readonly name: NameNode;
-}
-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 instance of yoga defined */
-    local_yoga: 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;
-    }>;
-};

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

@@ -1,43 +0,0 @@
-import type { Cache as _Cache } from '../cache/cache';
-import { type QueryArtifact } from '../lib';
-import { ListCollection } from './list';
-import { Record } from './record';
-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;
-    get<T extends TypeNames<Def>>(type: T, data: IDFields<Def, T>): Record<Def, T>;
-    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;
-    /**
-     * Reset the entire cache by clearing all records and lists
-     */
-    reset(): void;
-}

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

@@ -1,88 +0,0 @@
-import { getCurrentConfig, marshalInputs } from "../lib";
-import { ListCollection } from "./list";
-import { Record } from "./record";
-class Cache {
-  _internal_unstable;
-  constructor(cache) {
-    this._internal_unstable = cache;
-  }
-  // if the user is using the imperative API, we want the ability to break the API
-  // with any minor version. In order to do this, we require them to accept this contract
-  // through their config file
-  validateInstabilityWarning() {
-    if (!this.config.acceptImperativeInstability && !this.config.features?.imperativeCache) {
-      console.warn(`\u26A0\uFE0F  The imperative cache API is considered unstable and will change in any minor version release
-Please acknowledge this by enabling the imperative cache feature flage in your config file.
-For more information: https://houdinigraphql.com/api/cache`);
-    }
-  }
-  // return the record proxy for the given type/id combo
-  get(type, data) {
-    this.validateInstabilityWarning();
-    let recordID = this._internal_unstable._internal_unstable.id(type, data);
-    if (!recordID) {
-      throw new Error("todo");
-    }
-    return new Record({
-      cache: this,
-      type,
-      id: recordID,
-      idFields: data
-    });
-  }
-  get config() {
-    return getCurrentConfig();
-  }
-  list(name, { parentID, allLists } = {}) {
-    this.validateInstabilityWarning();
-    return new ListCollection({
-      cache: this,
-      name,
-      parentID,
-      allLists
-    });
-  }
-  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,
-      // @ts-expect-error
-      data,
-      variables: marshalInputs({
-        config: this.config,
-        artifact: query.artifact,
-        input: variables
-      }) ?? {}
-    });
-    return;
-  }
-  /**
-   * Mark some elements of the cache stale.
-   */
-  markStale(type, options) {
-    return this._internal_unstable.markTypeStale(type ? { ...options, type } : void 0);
-  }
-  /**
-   * Reset the entire cache by clearing all records and lists
-   */
-  reset() {
-    return this._internal_unstable.reset();
-  }
-}
-export {
-  Cache
-};

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

@@ -1 +0,0 @@
-export { Cache } from './cache';

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

@@ -1,4 +0,0 @@
-import { Cache } from "./cache";
-export {
-  Cache
-};

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

@@ -1,18 +0,0 @@
-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, }: {
-        name: ValidLists<Def>;
-        parentID?: string;
-        allLists?: boolean;
-        when?: ListFilters<Def, ListName>;
-        cache: Cache<Def>;
-    });
-    append(...records: ListType<Def, ListName>[]): void;
-    prepend(...records: ListType<Def, ListName>[]): void;
-    toggle(where: 'first' | 'last', ...records: ListType<Def, ListName>[]): void;
-    when(filter: ListFilters<Def, ListName>): ListCollection<Def, ListName>;
-    remove(...records: ListType<Def, ListName>[]): void;
-    [Symbol.iterator](): Generator<string, void, unknown>;
-}