| 1 | {"version":3,"file":"policies.js","sourceRoot":"","sources":["../../../src/cache/inmemory/policies.ts"],"names":[],"mappings":"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","sourcesContent":["import { invariant, InvariantError } from '../../utilities/globals';\n\nimport {\n InlineFragmentNode,\n FragmentDefinitionNode,\n SelectionSetNode,\n FieldNode,\n} from 'graphql';\n\nimport {\n FragmentMap,\n storeKeyNameFromField,\n StoreValue,\n StoreObject,\n argumentsObjectFromField,\n Reference,\n isReference,\n getStoreKeyName,\n isNonNullObject,\n stringifyForDisplay,\n} from '../../utilities';\nimport {\n IdGetter,\n MergeInfo,\n NormalizedCache,\n ReadMergeModifyContext,\n} from \"./types\";\nimport {\n hasOwn,\n fieldNameFromStoreName,\n storeValueIsStoreObject,\n selectionSetMatchesResult,\n TypeOrFieldNameRegExp,\n defaultDataIdFromObject,\n isArray,\n} from './helpers';\nimport { cacheSlot } from './reactiveVars';\nimport { InMemoryCache } from './inMemoryCache';\nimport {\n SafeReadonly,\n FieldSpecifier,\n ToReferenceFunction,\n ReadFieldFunction,\n ReadFieldOptions,\n CanReadFunction,\n} from '../core/types/common';\nimport { WriteContext } from './writeToStore';\n\n// Upgrade to a faster version of the default stable JSON.stringify function\n// used by getStoreKeyName. This function is used when computing storeFieldName\n// strings (when no keyArgs has been configured for a field).\nimport { canonicalStringify } from './object-canon';\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier } from './key-extractor';\n\ngetStoreKeyName.setStringify(canonicalStringify);\n\nexport type TypePolicies = {\n [__typename: string]: TypePolicy;\n}\n\n// TypeScript 3.7 will allow recursive type aliases, so this should work:\n// type KeySpecifier = (string | KeySpecifier)[]\nexport type KeySpecifier = ReadonlyArray<string | KeySpecifier>;\n\nexport type KeyFieldsContext = {\n // The __typename of the incoming object, even if the __typename field was\n // aliased to another name in the raw result object. May be undefined when\n // dataIdFromObject is called for objects without __typename fields.\n typename: string | undefined;\n\n // The object to be identified, after processing to remove aliases and\n // normalize identifiable child objects with references.\n storeObject: StoreObject;\n\n // Handy tool for reading additional fields from context.storeObject, either\n // readField(\"fieldName\") to read storeObject[fieldName], or readField(\"name\",\n // objectOrReference) to read from another object or Reference. If you read a\n // field with a read function, that function will be invoked.\n readField: ReadFieldFunction;\n\n // If you are writing a custom keyFields function, and you plan to use the raw\n // result object passed as the first argument, you may also need access to the\n // selection set and available fragments for this object, just in case any\n // fields have aliases. Since this logic is tricky to get right, and these\n // context properties are not even always provided (for example, they are\n // omitted when calling cache.identify(object), where object is assumed to be\n // a StoreObject), we recommend you use context.storeObject (which has already\n // been de-aliased) and context.readField (which can read from references as\n // well as objects) instead of the raw result object in your keyFields\n // functions, or just rely on the internal implementation of keyFields:[...]\n // syntax to get these details right for you.\n selectionSet?: SelectionSetNode;\n fragmentMap?: FragmentMap;\n\n // Internal. May be set by the KeyFieldsFunction to report fields that were\n // involved in computing the ID. Never passed in by the caller.\n keyObject?: Record<string, any>;\n};\n\nexport type KeyFieldsFunction = (\n object: Readonly<StoreObject>,\n context: KeyFieldsContext,\n) => KeySpecifier | false | ReturnType<IdGetter>;\n\ntype KeyFieldsResult = Exclude<ReturnType<KeyFieldsFunction>, KeySpecifier>;\n\n// TODO Should TypePolicy be a generic type, with a TObject or TEntity\n// type parameter?\nexport type TypePolicy = {\n // Allows defining the primary key fields for this type, either using an\n // array of field names or a function that returns an arbitrary string.\n keyFields?: KeySpecifier | KeyFieldsFunction | false;\n\n // Allows defining a merge function (or merge:true/false shorthand) to\n // be used for merging objects of this type wherever they appear, unless\n // the parent field also defines a merge function/boolean (that is,\n // parent field merge functions take precedence over type policy merge\n // functions). In many cases, defining merge:true for a given type\n // policy can save you from specifying merge:true for all the field\n // policies where that type might be encountered.\n merge?: FieldMergeFunction | boolean;\n\n // In the rare event that your schema happens to use a different\n // __typename for the root Query, Mutation, and/or Schema types, you can\n // express your deviant preferences by enabling one of these options.\n queryType?: true,\n mutationType?: true,\n subscriptionType?: true,\n\n fields?: {\n [fieldName: string]:\n | FieldPolicy<any>\n | FieldReadFunction<any>;\n }\n};\n\nexport type KeyArgsFunction = (\n args: Record<string, any> | null,\n context: {\n typename: string;\n fieldName: string;\n field: FieldNode | null;\n variables?: Record<string, any>;\n },\n) => KeySpecifier | false | ReturnType<IdGetter>;\n\nexport type FieldPolicy<\n // The internal representation used to store the field's data in the\n // cache. Must be JSON-serializable if you plan to serialize the result\n // of cache.extract() using JSON.\n TExisting = any,\n // The type of the incoming parameter passed to the merge function,\n // typically matching the GraphQL response format, but with Reference\n // objects substituted for any identifiable child objects. Often the\n // same as TExisting, but not necessarily.\n TIncoming = TExisting,\n // The type that the read function actually returns, using TExisting\n // data and options.args as input. Usually the same as TIncoming.\n TReadResult = TIncoming,\n // Allows FieldFunctionOptions definition to be overwritten by the\n // developer\n TOptions extends FieldFunctionOptions = FieldFunctionOptions\n> = {\n keyArgs?: KeySpecifier | KeyArgsFunction | false;\n read?: FieldReadFunction<TExisting, TReadResult, TOptions>;\n merge?: FieldMergeFunction<TExisting, TIncoming, TOptions> | boolean;\n};\n\nexport type StorageType = Record<string, any>;\n\nfunction argsFromFieldSpecifier(spec: FieldSpecifier) {\n return spec.args !== void 0 ? spec.args :\n spec.field ? argumentsObjectFromField(spec.field, spec.variables) : null;\n}\n\nexport interface FieldFunctionOptions<\n TArgs = Record<string, any>,\n TVars = Record<string, any>,\n> {\n args: TArgs | null;\n\n // The name of the field, equal to options.field.name.value when\n // options.field is available. Useful if you reuse the same function for\n // multiple fields, and you need to know which field you're currently\n // processing. Always a string, even when options.field is null.\n fieldName: string;\n\n // The full field key used internally, including serialized key arguments.\n storeFieldName: string;\n\n // The FieldNode object used to read this field. Useful if you need to\n // know about other attributes of the field, such as its directives. This\n // option will be null when a string was passed to options.readField.\n field: FieldNode | null;\n\n variables?: TVars;\n\n // Utilities for dealing with { __ref } objects.\n isReference: typeof isReference;\n toReference: ToReferenceFunction;\n\n // A handy place to put field-specific data that you want to survive\n // across multiple read function calls. Useful for field-level caching,\n // if your read function does any expensive work.\n storage: StorageType;\n\n cache: InMemoryCache;\n\n // Helper function for reading other fields within the current object.\n // If a foreign object or reference is provided, the field will be read\n // from that object instead of the current object, so this function can\n // be used (together with isReference) to examine the cache outside the\n // current object. If a FieldNode is passed instead of a string, and\n // that FieldNode has arguments, the same options.variables will be used\n // to compute the argument values. Note that this function will invoke\n // custom read functions for other fields, if defined. Always returns\n // immutable data (enforced with Object.freeze in development).\n readField: ReadFieldFunction;\n\n // Returns true for non-normalized StoreObjects and non-dangling\n // References, indicating that readField(name, objOrRef) has a chance of\n // working. Useful for filtering out dangling references from lists.\n canRead: CanReadFunction;\n\n // Instead of just merging objects with { ...existing, ...incoming }, this\n // helper function can be used to merge objects in a way that respects any\n // custom merge functions defined for their fields.\n mergeObjects: MergeObjectsFunction;\n}\n\ntype MergeObjectsFunction = <T extends StoreObject | Reference>(\n existing: T,\n incoming: T,\n) => T;\n\nexport type FieldReadFunction<\n TExisting = any,\n TReadResult = TExisting,\n TOptions extends FieldFunctionOptions = FieldFunctionOptions\n> = (\n // When reading a field, one often needs to know about any existing\n // value stored for that field. If the field is read before any value\n // has been written to the cache, this existing parameter will be\n // undefined, which makes it easy to use a default parameter expression\n // to supply the initial value. This parameter is positional (rather\n // than one of the named options) because that makes it possible for the\n // developer to annotate it with a type, without also having to provide\n // a whole new type for the options object.\n existing: SafeReadonly<TExisting> | undefined,\n options: TOptions,\n) => TReadResult | undefined;\n\nexport type FieldMergeFunction<\n TExisting = any,\n TIncoming = TExisting,\n // Passing the whole FieldFunctionOptions makes the current definition\n // independent from its implementation\n TOptions extends FieldFunctionOptions = FieldFunctionOptions\n> = (\n existing: SafeReadonly<TExisting> | undefined,\n // The incoming parameter needs to be positional as well, for the same\n // reasons discussed in FieldReadFunction above.\n incoming: SafeReadonly<TIncoming>,\n options: TOptions,\n) => SafeReadonly<TExisting>;\n\nconst nullKeyFieldsFn: KeyFieldsFunction = () => void 0;\nconst simpleKeyArgsFn: KeyArgsFunction = (_args, context) => context.fieldName;\n\n// These merge functions can be selected by specifying merge:true or\n// merge:false in a field policy.\nconst mergeTrueFn: FieldMergeFunction<any> =\n (existing, incoming, { mergeObjects }) => mergeObjects(existing, incoming);\nconst mergeFalseFn: FieldMergeFunction<any> = (_, incoming) => incoming;\n\nexport type PossibleTypesMap = {\n [supertype: string]: string[];\n};\n\nexport class Policies {\n private typePolicies: {\n [__typename: string]: {\n keyFn?: KeyFieldsFunction;\n merge?: FieldMergeFunction<any>;\n fields: {\n [fieldName: string]: {\n keyFn?: KeyArgsFunction;\n read?: FieldReadFunction<any>;\n merge?: FieldMergeFunction<any>;\n };\n };\n };\n } = Object.create(null);\n\n private toBeAdded: {\n [__typename: string]: TypePolicy[];\n } = Object.create(null);\n\n // Map from subtype names to sets of supertype names. Note that this\n // representation inverts the structure of possibleTypes (whose keys are\n // supertypes and whose values are arrays of subtypes) because it tends\n // to be much more efficient to search upwards than downwards.\n private supertypeMap = new Map<string, Set<string>>();\n\n // Any fuzzy subtypes specified by possibleTypes will be converted to\n // RegExp objects and recorded here. Every key of this map can also be\n // found in supertypeMap. In many cases this Map will be empty, which\n // means no fuzzy subtype checking will happen in fragmentMatches.\n private fuzzySubtypes = new Map<string, RegExp>();\n\n public readonly cache: InMemoryCache;\n\n public readonly rootIdsByTypename: Record<string, string> = Object.create(null);\n public readonly rootTypenamesById: Record<string, string> = Object.create(null);\n\n public readonly usingPossibleTypes = false;\n\n constructor(private config: {\n cache: InMemoryCache;\n dataIdFromObject?: KeyFieldsFunction;\n possibleTypes?: PossibleTypesMap;\n typePolicies?: TypePolicies;\n }) {\n this.config = {\n dataIdFromObject: defaultDataIdFromObject,\n ...config,\n };\n\n this.cache = this.config.cache;\n\n this.setRootTypename(\"Query\");\n this.setRootTypename(\"Mutation\");\n this.setRootTypename(\"Subscription\");\n\n if (config.possibleTypes) {\n this.addPossibleTypes(config.possibleTypes);\n }\n\n if (config.typePolicies) {\n this.addTypePolicies(config.typePolicies);\n }\n }\n\n public identify(\n object: StoreObject,\n partialContext?: Partial<KeyFieldsContext>,\n ): [string?, StoreObject?] {\n const policies = this;\n\n const typename = partialContext && (\n partialContext.typename ||\n partialContext.storeObject?.__typename\n ) || object.__typename;\n\n // It should be possible to write root Query fields with writeFragment,\n // using { __typename: \"Query\", ... } as the data, but it does not make\n // sense to allow the same identification behavior for the Mutation and\n // Subscription types, since application code should never be writing\n // directly to (or reading directly from) those root objects.\n if (typename === this.rootTypenamesById.ROOT_QUERY) {\n return [\"ROOT_QUERY\"];\n }\n\n // Default context.storeObject to object if not otherwise provided.\n const storeObject = partialContext && partialContext.storeObject || object;\n\n const context: KeyFieldsContext = {\n ...partialContext,\n typename,\n storeObject,\n readField: partialContext && partialContext.readField || function () {\n const options = normalizeReadFieldOptions(arguments, storeObject);\n return policies.readField(options, {\n store: policies.cache[\"data\"],\n variables: options.variables,\n });\n },\n };\n\n let id: KeyFieldsResult;\n\n const policy = typename && this.getTypePolicy(typename);\n let keyFn = policy && policy.keyFn || this.config.dataIdFromObject;\n while (keyFn) {\n const specifierOrId = keyFn(object, context);\n if (isArray(specifierOrId)) {\n keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n } else {\n id = specifierOrId;\n break;\n }\n }\n\n id = id ? String(id) : void 0;\n return context.keyObject ? [id, context.keyObject] : [id];\n }\n\n public addTypePolicies(typePolicies: TypePolicies) {\n Object.keys(typePolicies).forEach(typename => {\n const {\n queryType,\n mutationType,\n subscriptionType,\n ...incoming\n } = typePolicies[typename];\n\n // Though {query,mutation,subscription}Type configurations are rare,\n // it's important to call setRootTypename as early as possible,\n // since these configurations should apply consistently for the\n // entire lifetime of the cache. Also, since only one __typename can\n // qualify as one of these root types, these three properties cannot\n // be inherited, unlike the rest of the incoming properties. That\n // restriction is convenient, because the purpose of this.toBeAdded\n // is to delay the processing of type/field policies until the first\n // time they're used, allowing policies to be added in any order as\n // long as all relevant policies (including policies for supertypes)\n // have been added by the time a given policy is used for the first\n // time. In other words, since inheritance doesn't matter for these\n // properties, there's also no need to delay their processing using\n // the this.toBeAdded queue.\n if (queryType) this.setRootTypename(\"Query\", typename);\n if (mutationType) this.setRootTypename(\"Mutation\", typename);\n if (subscriptionType) this.setRootTypename(\"Subscription\", typename);\n\n if (hasOwn.call(this.toBeAdded, typename)) {\n this.toBeAdded[typename].push(incoming);\n } else {\n this.toBeAdded[typename] = [incoming];\n }\n });\n }\n\n private updateTypePolicy(typename: string, incoming: TypePolicy) {\n const existing = this.getTypePolicy(typename);\n const { keyFields, fields } = incoming;\n\n function setMerge(\n existing: { merge?: FieldMergeFunction | boolean; },\n merge?: FieldMergeFunction | boolean,\n ) {\n existing.merge =\n typeof merge === \"function\" ? merge :\n // Pass merge:true as a shorthand for a merge implementation\n // that returns options.mergeObjects(existing, incoming).\n merge === true ? mergeTrueFn :\n // Pass merge:false to make incoming always replace existing\n // without any warnings about data clobbering.\n merge === false ? mergeFalseFn :\n existing.merge;\n }\n\n // Type policies can define merge functions, as an alternative to\n // using field policies to merge child objects.\n setMerge(existing, incoming.merge);\n\n existing.keyFn =\n // Pass false to disable normalization for this typename.\n keyFields === false ? nullKeyFieldsFn :\n // Pass an array of strings to use those fields to compute a\n // composite ID for objects of this typename.\n isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields) :\n // Pass a function to take full control over identification.\n typeof keyFields === \"function\" ? keyFields :\n // Leave existing.keyFn unchanged if above cases fail.\n existing.keyFn;\n\n if (fields) {\n Object.keys(fields).forEach(fieldName => {\n const existing = this.getFieldPolicy(typename, fieldName, true)!;\n const incoming = fields[fieldName];\n\n if (typeof incoming === \"function\") {\n existing.read = incoming;\n } else {\n const { keyArgs, read, merge } = incoming;\n\n existing.keyFn =\n // Pass false to disable argument-based differentiation of\n // field identities.\n keyArgs === false ? simpleKeyArgsFn :\n // Pass an array of strings to use named arguments to\n // compute a composite identity for the field.\n isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs) :\n // Pass a function to take full control over field identity.\n typeof keyArgs === \"function\" ? keyArgs :\n // Leave existing.keyFn unchanged if above cases fail.\n existing.keyFn;\n\n if (typeof read === \"function\") {\n existing.read = read;\n }\n\n setMerge(existing, merge);\n }\n\n if (existing.read && existing.merge) {\n // If we have both a read and a merge function, assume\n // keyArgs:false, because read and merge together can take\n // responsibility for interpreting arguments in and out. This\n // default assumption can always be overridden by specifying\n // keyArgs explicitly in the FieldPolicy.\n existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n }\n });\n }\n }\n\n private setRootTypename(\n which: \"Query\" | \"Mutation\" | \"Subscription\",\n typename: string = which,\n ) {\n const rootId = \"ROOT_\" + which.toUpperCase();\n const old = this.rootTypenamesById[rootId];\n if (typename !== old) {\n invariant(!old || old === which, `Cannot change root ${which} __typename more than once`);\n // First, delete any old __typename associated with this rootId from\n // rootIdsByTypename.\n if (old) delete this.rootIdsByTypename[old];\n // Now make this the only __typename that maps to this rootId.\n this.rootIdsByTypename[typename] = rootId;\n // Finally, update the __typename associated with this rootId.\n this.rootTypenamesById[rootId] = typename;\n }\n }\n\n public addPossibleTypes(possibleTypes: PossibleTypesMap) {\n (this.usingPossibleTypes as boolean) = true;\n Object.keys(possibleTypes).forEach(supertype => {\n // Make sure all types have an entry in this.supertypeMap, even if\n // their supertype set is empty, so we can return false immediately\n // from policies.fragmentMatches for unknown supertypes.\n this.getSupertypeSet(supertype, true);\n\n possibleTypes[supertype].forEach(subtype => {\n this.getSupertypeSet(subtype, true)!.add(supertype);\n const match = subtype.match(TypeOrFieldNameRegExp);\n if (!match || match[0] !== subtype) {\n // TODO Don't interpret just any invalid typename as a RegExp.\n this.fuzzySubtypes.set(subtype, new RegExp(subtype));\n }\n });\n });\n }\n\n private getTypePolicy(typename: string): Policies[\"typePolicies\"][string] {\n if (!hasOwn.call(this.typePolicies, typename)) {\n const policy: Policies[\"typePolicies\"][string] =\n this.typePolicies[typename] = Object.create(null);\n policy.fields = Object.create(null);\n\n // When the TypePolicy for typename is first accessed, instead of\n // starting with an empty policy object, inherit any properties or\n // fields from the type policies of the supertypes of typename.\n //\n // Any properties or fields defined explicitly within the TypePolicy\n // for typename will take precedence, and if there are multiple\n // supertypes, the properties of policies whose types were added\n // later via addPossibleTypes will take precedence over those of\n // earlier supertypes. TODO Perhaps we should warn about these\n // conflicts in development, and recommend defining the property\n // explicitly in the subtype policy?\n //\n // Field policy inheritance is atomic/shallow: you can't inherit a\n // field policy and then override just its read function, since read\n // and merge functions often need to cooperate, so changing only one\n // of them would be a recipe for inconsistency.\n //\n // Once the TypePolicy for typename has been accessed, its\n // properties can still be updated directly using addTypePolicies,\n // but future changes to supertype policies will not be reflected in\n // this policy, because this code runs at most once per typename.\n const supertypes = this.supertypeMap.get(typename);\n if (supertypes && supertypes.size) {\n supertypes.forEach(supertype => {\n const { fields, ...rest } = this.getTypePolicy(supertype);\n Object.assign(policy, rest);\n Object.assign(policy.fields, fields);\n });\n }\n }\n\n const inbox = this.toBeAdded[typename];\n if (inbox && inbox.length) {\n // Merge the pending policies into this.typePolicies, in the order they\n // were originally passed to addTypePolicy.\n inbox.splice(0).forEach(policy => {\n this.updateTypePolicy(typename, policy);\n });\n }\n\n return this.typePolicies[typename];\n }\n\n private getFieldPolicy(\n typename: string | undefined,\n fieldName: string,\n createIfMissing: boolean,\n ): {\n keyFn?: KeyArgsFunction;\n read?: FieldReadFunction<any>;\n merge?: FieldMergeFunction<any>;\n } | undefined {\n if (typename) {\n const fieldPolicies = this.getTypePolicy(typename).fields;\n return fieldPolicies[fieldName] || (\n createIfMissing && (fieldPolicies[fieldName] = Object.create(null)));\n }\n }\n\n private getSupertypeSet(\n subtype: string,\n createIfMissing: boolean,\n ): Set<string> | undefined {\n let supertypeSet = this.supertypeMap.get(subtype);\n if (!supertypeSet && createIfMissing) {\n this.supertypeMap.set(subtype, supertypeSet = new Set<string>());\n }\n return supertypeSet;\n }\n\n public fragmentMatches(\n fragment: InlineFragmentNode | FragmentDefinitionNode,\n typename: string | undefined,\n result?: Record<string, any>,\n variables?: Record<string, any>,\n ): boolean {\n if (!fragment.typeCondition) return true;\n\n // If the fragment has a type condition but the object we're matching\n // against does not have a __typename, the fragment cannot match.\n if (!typename) return false;\n\n const supertype = fragment.typeCondition.name.value;\n // Common case: fragment type condition and __typename are the same.\n if (typename === supertype) return true;\n\n if (this.usingPossibleTypes &&\n this.supertypeMap.has(supertype)) {\n const typenameSupertypeSet = this.getSupertypeSet(typename, true)!;\n const workQueue = [typenameSupertypeSet];\n const maybeEnqueue = (subtype: string) => {\n const supertypeSet = this.getSupertypeSet(subtype, false);\n if (supertypeSet &&\n supertypeSet.size &&\n workQueue.indexOf(supertypeSet) < 0) {\n workQueue.push(supertypeSet);\n }\n };\n\n // We need to check fuzzy subtypes only if we encountered fuzzy\n // subtype strings in addPossibleTypes, and only while writing to\n // the cache, since that's when selectionSetMatchesResult gives a\n // strong signal of fragment matching. The StoreReader class calls\n // policies.fragmentMatches without passing a result object, so\n // needToCheckFuzzySubtypes is always false while reading.\n let needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n let checkingFuzzySubtypes = false;\n\n // It's important to keep evaluating workQueue.length each time through\n // the loop, because the queue can grow while we're iterating over it.\n for (let i = 0; i < workQueue.length; ++i) {\n const supertypeSet = workQueue[i];\n\n if (supertypeSet.has(supertype)) {\n if (!typenameSupertypeSet.has(supertype)) {\n if (checkingFuzzySubtypes) {\n invariant.warn(`Inferring subtype ${typename} of supertype ${supertype}`);\n }\n // Record positive results for faster future lookup.\n // Unfortunately, we cannot safely cache negative results,\n // because new possibleTypes data could always be added to the\n // Policies class.\n typenameSupertypeSet.add(supertype);\n }\n return true;\n }\n\n supertypeSet.forEach(maybeEnqueue);\n\n if (needToCheckFuzzySubtypes &&\n // Start checking fuzzy subtypes only after exhausting all\n // non-fuzzy subtypes (after the final iteration of the loop).\n i === workQueue.length - 1 &&\n // We could wait to compare fragment.selectionSet to result\n // after we verify the supertype, but this check is often less\n // expensive than that search, and we will have to do the\n // comparison anyway whenever we find a potential match.\n selectionSetMatchesResult(fragment.selectionSet, result!, variables)) {\n // We don't always need to check fuzzy subtypes (if no result\n // was provided, or !this.fuzzySubtypes.size), but, when we do,\n // we only want to check them once.\n needToCheckFuzzySubtypes = false;\n checkingFuzzySubtypes = true;\n\n // If we find any fuzzy subtypes that match typename, extend the\n // workQueue to search through the supertypes of those fuzzy\n // subtypes. Otherwise the for-loop will terminate and we'll\n // return false below.\n this.fuzzySubtypes.forEach((regExp, fuzzyString) => {\n const match = typename.match(regExp);\n if (match && match[0] === typename) {\n maybeEnqueue(fuzzyString);\n }\n });\n }\n }\n }\n\n return false;\n }\n\n public hasKeyArgs(typename: string | undefined, fieldName: string) {\n const policy = this.getFieldPolicy(typename, fieldName, false);\n return !!(policy && policy.keyFn);\n }\n\n public getStoreFieldName(fieldSpec: FieldSpecifier): string {\n const { typename, fieldName } = fieldSpec;\n const policy = this.getFieldPolicy(typename, fieldName, false);\n let storeFieldName: Exclude<ReturnType<KeyArgsFunction>, KeySpecifier>;\n\n let keyFn = policy && policy.keyFn;\n if (keyFn && typename) {\n const context: Parameters<KeyArgsFunction>[1] = {\n typename,\n fieldName,\n field: fieldSpec.field || null,\n variables: fieldSpec.variables,\n };\n const args = argsFromFieldSpecifier(fieldSpec);\n while (keyFn) {\n const specifierOrString = keyFn(args, context);\n if (isArray(specifierOrString)) {\n keyFn = keyArgsFnFromSpecifier(specifierOrString);\n } else {\n // If the custom keyFn returns a falsy value, fall back to\n // fieldName instead.\n storeFieldName = specifierOrString || fieldName;\n break;\n }\n }\n }\n\n if (storeFieldName === void 0) {\n storeFieldName = fieldSpec.field\n ? storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n }\n\n // Returning false from a keyArgs function is like configuring\n // keyArgs: false, but more dynamic.\n if (storeFieldName === false) {\n return fieldName;\n }\n\n // Make sure custom field names start with the actual field.name.value\n // of the field, so we can always figure out which properties of a\n // StoreObject correspond to which original field names.\n return fieldName === fieldNameFromStoreName(storeFieldName)\n ? storeFieldName\n : fieldName + \":\" + storeFieldName;\n }\n\n public readField<V = StoreValue>(\n options: ReadFieldOptions,\n context: ReadMergeModifyContext,\n ): SafeReadonly<V> | undefined {\n const objectOrReference = options.from;\n if (!objectOrReference) return;\n\n const nameOrField = options.field || options.fieldName;\n if (!nameOrField) return;\n\n if (options.typename === void 0) {\n const typename = context.store.getFieldValue<string>(objectOrReference, \"__typename\");\n if (typename) options.typename = typename;\n }\n\n const storeFieldName = this.getStoreFieldName(options);\n const fieldName = fieldNameFromStoreName(storeFieldName);\n const existing = context.store.getFieldValue<V>(objectOrReference, storeFieldName);\n const policy = this.getFieldPolicy(options.typename, fieldName, false);\n const read = policy && policy.read;\n\n if (read) {\n const readOptions = makeFieldFunctionOptions(\n this,\n objectOrReference,\n options,\n context,\n context.store.getStorage(\n isReference(objectOrReference)\n ? objectOrReference.__ref\n : objectOrReference,\n storeFieldName,\n ),\n );\n\n // Call read(existing, readOptions) with cacheSlot holding this.cache.\n return cacheSlot.withValue(\n this.cache,\n read,\n [existing, readOptions],\n ) as SafeReadonly<V>;\n }\n\n return existing;\n }\n\n public getReadFunction(\n typename: string | undefined,\n fieldName: string,\n ): FieldReadFunction | undefined {\n const policy = this.getFieldPolicy(typename, fieldName, false);\n return policy && policy.read;\n }\n\n public getMergeFunction(\n parentTypename: string | undefined,\n fieldName: string,\n childTypename: string | undefined,\n ): FieldMergeFunction | undefined {\n let policy:\n | Policies[\"typePolicies\"][string]\n | Policies[\"typePolicies\"][string][\"fields\"][string]\n | undefined =\n this.getFieldPolicy(parentTypename, fieldName, false);\n let merge = policy && policy.merge;\n if (!merge && childTypename) {\n policy = this.getTypePolicy(childTypename);\n merge = policy && policy.merge;\n }\n return merge;\n }\n\n public runMergeFunction(\n existing: StoreValue,\n incoming: StoreValue,\n { field, typename, merge }: MergeInfo,\n context: WriteContext,\n storage?: StorageType,\n ) {\n if (merge === mergeTrueFn) {\n // Instead of going to the trouble of creating a full\n // FieldFunctionOptions object and calling mergeTrueFn, we can\n // simply call mergeObjects, as mergeTrueFn would.\n return makeMergeObjectsFunction(\n context.store,\n )(existing as StoreObject,\n incoming as StoreObject);\n }\n\n if (merge === mergeFalseFn) {\n // Likewise for mergeFalseFn, whose implementation is even simpler.\n return incoming;\n }\n\n // If cache.writeQuery or cache.writeFragment was called with\n // options.overwrite set to true, we still call merge functions, but\n // the existing data is always undefined, so the merge function will\n // not attempt to combine the incoming data with the existing data.\n if (context.overwrite) {\n existing = void 0;\n }\n\n return merge(existing, incoming, makeFieldFunctionOptions(\n this,\n // Unlike options.readField for read functions, we do not fall\n // back to the current object if no foreignObjOrRef is provided,\n // because it's not clear what the current object should be for\n // merge functions: the (possibly undefined) existing object, or\n // the incoming object? If you think your merge function needs\n // to read sibling fields in order to produce a new value for\n // the current field, you might want to rethink your strategy,\n // because that's a recipe for making merge behavior sensitive\n // to the order in which fields are written into the cache.\n // However, readField(name, ref) is useful for merge functions\n // that need to deduplicate child objects and references.\n void 0,\n { typename,\n fieldName: field.name.value,\n field,\n variables: context.variables },\n context,\n storage || Object.create(null),\n ));\n }\n}\n\nfunction makeFieldFunctionOptions(\n policies: Policies,\n objectOrReference: StoreObject | Reference | undefined,\n fieldSpec: FieldSpecifier,\n context: ReadMergeModifyContext,\n storage: StorageType,\n): FieldFunctionOptions {\n const storeFieldName = policies.getStoreFieldName(fieldSpec);\n const fieldName = fieldNameFromStoreName(storeFieldName);\n const variables = fieldSpec.variables || context.variables;\n const { toReference, canRead } = context.store;\n\n return {\n args: argsFromFieldSpecifier(fieldSpec),\n field: fieldSpec.field || null,\n fieldName,\n storeFieldName,\n variables,\n isReference,\n toReference,\n storage,\n cache: policies.cache,\n canRead,\n readField<T>() {\n return policies.readField<T>(\n normalizeReadFieldOptions(arguments, objectOrReference, variables),\n context,\n );\n },\n mergeObjects: makeMergeObjectsFunction(context.store),\n };\n}\n\nexport function normalizeReadFieldOptions(\n readFieldArgs: IArguments,\n objectOrReference: StoreObject | Reference | undefined,\n variables?: ReadMergeModifyContext[\"variables\"],\n): ReadFieldOptions {\n const {\n 0: fieldNameOrOptions,\n 1: from,\n length: argc,\n } = readFieldArgs;\n\n let options: ReadFieldOptions;\n\n if (typeof fieldNameOrOptions === \"string\") {\n options = {\n fieldName: fieldNameOrOptions,\n // Default to objectOrReference only when no second argument was\n // passed for the from parameter, not when undefined is explicitly\n // passed as the second argument.\n from: argc > 1 ? from : objectOrReference,\n };\n } else {\n options = { ...fieldNameOrOptions };\n // Default to objectOrReference only when fieldNameOrOptions.from is\n // actually omitted, rather than just undefined.\n if (!hasOwn.call(options, \"from\")) {\n options.from = objectOrReference;\n }\n }\n\n if (__DEV__ && options.from === void 0) {\n invariant.warn(`Undefined 'from' passed to readField with arguments ${\n stringifyForDisplay(Array.from(readFieldArgs))\n }`);\n }\n\n if (void 0 === options.variables) {\n options.variables = variables;\n }\n\n return options;\n}\n\nfunction makeMergeObjectsFunction(\n store: NormalizedCache,\n): MergeObjectsFunction {\n return function mergeObjects(existing, incoming) {\n if (isArray(existing) || isArray(incoming)) {\n throw new InvariantError(\"Cannot automatically merge arrays\");\n }\n\n // These dynamic checks are necessary because the parameters of a\n // custom merge function can easily have the any type, so the type\n // system cannot always enforce the StoreObject | Reference parameter\n // types of options.mergeObjects.\n if (isNonNullObject(existing) &&\n isNonNullObject(incoming)) {\n const eType = store.getFieldValue(existing, \"__typename\");\n const iType = store.getFieldValue(incoming, \"__typename\");\n const typesDiffer = eType && iType && eType !== iType;\n\n if (typesDiffer) {\n return incoming;\n }\n\n if (isReference(existing) &&\n storeValueIsStoreObject(incoming)) {\n // Update the normalized EntityStore for the entity identified by\n // existing.__ref, preferring/overwriting any fields contributed by the\n // newer incoming StoreObject.\n store.merge(existing.__ref, incoming);\n return existing;\n }\n\n if (storeValueIsStoreObject(existing) &&\n isReference(incoming)) {\n // Update the normalized EntityStore for the entity identified by\n // incoming.__ref, taking fields from the older existing object only if\n // those fields are not already present in the newer StoreObject\n // identified by incoming.__ref.\n store.merge(existing, incoming.__ref);\n return incoming;\n }\n\n if (storeValueIsStoreObject(existing) &&\n storeValueIsStoreObject(incoming)) {\n return { ...existing, ...incoming };\n }\n }\n\n return incoming;\n };\n}\n"]} |