You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
97 lines
5.0 KiB
97 lines
5.0 KiB
4 months ago
|
import type { InlineFragmentNode, FragmentDefinitionNode, SelectionSetNode, FieldNode } from "graphql";
|
||
|
import type { FragmentMap, StoreValue, StoreObject, Reference } from "../../utilities/index.js";
|
||
|
import { isReference } from "../../utilities/index.js";
|
||
|
import type { IdGetter, MergeInfo, ReadMergeModifyContext } from "./types.js";
|
||
|
import type { InMemoryCache } from "./inMemoryCache.js";
|
||
|
import type { SafeReadonly, FieldSpecifier, ToReferenceFunction, ReadFieldFunction, ReadFieldOptions, CanReadFunction } from "../core/types/common.js";
|
||
|
import type { WriteContext } from "./writeToStore.js";
|
||
|
export type TypePolicies = {
|
||
|
[__typename: string]: TypePolicy;
|
||
|
};
|
||
|
export type KeySpecifier = ReadonlyArray<string | KeySpecifier>;
|
||
|
export type KeyFieldsContext = {
|
||
|
typename: string | undefined;
|
||
|
storeObject: StoreObject;
|
||
|
readField: ReadFieldFunction;
|
||
|
selectionSet?: SelectionSetNode;
|
||
|
fragmentMap?: FragmentMap;
|
||
|
keyObject?: Record<string, any>;
|
||
|
};
|
||
|
export type KeyFieldsFunction = (object: Readonly<StoreObject>, context: KeyFieldsContext) => KeySpecifier | false | ReturnType<IdGetter>;
|
||
|
export type TypePolicy = {
|
||
|
keyFields?: KeySpecifier | KeyFieldsFunction | false;
|
||
|
merge?: FieldMergeFunction | boolean;
|
||
|
queryType?: true;
|
||
|
mutationType?: true;
|
||
|
subscriptionType?: true;
|
||
|
fields?: {
|
||
|
[fieldName: string]: FieldPolicy<any> | FieldReadFunction<any>;
|
||
|
};
|
||
|
};
|
||
|
export type KeyArgsFunction = (args: Record<string, any> | null, context: {
|
||
|
typename: string;
|
||
|
fieldName: string;
|
||
|
field: FieldNode | null;
|
||
|
variables?: Record<string, any>;
|
||
|
}) => KeySpecifier | false | ReturnType<IdGetter>;
|
||
|
export type FieldPolicy<TExisting = any, TIncoming = TExisting, TReadResult = TIncoming, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = {
|
||
|
keyArgs?: KeySpecifier | KeyArgsFunction | false;
|
||
|
read?: FieldReadFunction<TExisting, TReadResult, TOptions>;
|
||
|
merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;
|
||
|
};
|
||
|
export type StorageType = Record<string, any>;
|
||
|
export interface FieldFunctionOptions<TArgs = Record<string, any>, TVars = Record<string, any>> {
|
||
|
args: TArgs | null;
|
||
|
fieldName: string;
|
||
|
storeFieldName: string;
|
||
|
field: FieldNode | null;
|
||
|
variables?: TVars;
|
||
|
isReference: typeof isReference;
|
||
|
toReference: ToReferenceFunction;
|
||
|
storage: StorageType;
|
||
|
cache: InMemoryCache;
|
||
|
readField: ReadFieldFunction;
|
||
|
canRead: CanReadFunction;
|
||
|
mergeObjects: MergeObjectsFunction;
|
||
|
}
|
||
|
type MergeObjectsFunction = <T extends StoreObject | Reference>(existing: T, incoming: T) => T;
|
||
|
export type FieldReadFunction<TExisting = any, TReadResult = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, options: TOptions) => TReadResult | undefined;
|
||
|
export type FieldMergeFunction<TExisting = any, TIncoming = TExisting, TOptions extends FieldFunctionOptions = FieldFunctionOptions> = (existing: SafeReadonly<TExisting> | undefined, incoming: SafeReadonly<TIncoming>, options: TOptions) => SafeReadonly<TExisting>;
|
||
|
export type PossibleTypesMap = {
|
||
|
[supertype: string]: string[];
|
||
|
};
|
||
|
export declare class Policies {
|
||
|
private config;
|
||
|
private typePolicies;
|
||
|
private toBeAdded;
|
||
|
private supertypeMap;
|
||
|
private fuzzySubtypes;
|
||
|
readonly cache: InMemoryCache;
|
||
|
readonly rootIdsByTypename: Record<string, string>;
|
||
|
readonly rootTypenamesById: Record<string, string>;
|
||
|
readonly usingPossibleTypes = false;
|
||
|
constructor(config: {
|
||
|
cache: InMemoryCache;
|
||
|
dataIdFromObject?: KeyFieldsFunction;
|
||
|
possibleTypes?: PossibleTypesMap;
|
||
|
typePolicies?: TypePolicies;
|
||
|
});
|
||
|
identify(object: StoreObject, partialContext?: Partial<KeyFieldsContext>): [string?, StoreObject?];
|
||
|
addTypePolicies(typePolicies: TypePolicies): void;
|
||
|
private updateTypePolicy;
|
||
|
private setRootTypename;
|
||
|
addPossibleTypes(possibleTypes: PossibleTypesMap): void;
|
||
|
private getTypePolicy;
|
||
|
private getFieldPolicy;
|
||
|
private getSupertypeSet;
|
||
|
fragmentMatches(fragment: InlineFragmentNode | FragmentDefinitionNode, typename: string | undefined, result?: Record<string, any>, variables?: Record<string, any>): boolean;
|
||
|
hasKeyArgs(typename: string | undefined, fieldName: string): boolean;
|
||
|
getStoreFieldName(fieldSpec: FieldSpecifier): string;
|
||
|
readField<V = StoreValue>(options: ReadFieldOptions, context: ReadMergeModifyContext): SafeReadonly<V> | undefined;
|
||
|
getReadFunction(typename: string | undefined, fieldName: string): FieldReadFunction | undefined;
|
||
|
getMergeFunction(parentTypename: string | undefined, fieldName: string, childTypename: string | undefined): FieldMergeFunction | undefined;
|
||
|
runMergeFunction(existing: StoreValue, incoming: StoreValue, { field, typename, merge }: MergeInfo, context: WriteContext, storage?: StorageType): any;
|
||
|
}
|
||
|
export declare function normalizeReadFieldOptions(readFieldArgs: IArguments, objectOrReference: StoreObject | Reference | undefined, variables?: ReadMergeModifyContext["variables"]): ReadFieldOptions;
|
||
|
export {};
|
||
|
//# sourceMappingURL=policies.d.ts.map
|