@data-client/normalizr
Version:
Normalizes and denormalizes JSON according to schema for Redux and Flux applications
85 lines (79 loc) • 14 kB
JavaScript
import GlobalCache from './globalCache.js';
import WeakDependencyMap from './WeakDependencyMap.js';
import buildQueryKey from '../buildQueryKey.js';
import { getEntityCaches } from './entitiesCache.js';
import { MemoPolicy } from './Policy.js';
import { getDependency } from '../delegate/BaseDelegate.js';
import getUnvisit from '../denormalize/unvisit.js';
// TODO: make MemoCache generic on the arguments sent to Delegate constructor
/** Singleton to store the memoization cache for denormalization methods */
export default class MemoCache {
constructor(policy = MemoPolicy) {
/** Cache for every entity based on its dependencies and its own input */
/** Caches the final denormalized form based on input, entities */
this.endpoints = new WeakDependencyMap();
/** Caches the queryKey based on schema, args, and any used entities or indexes */
this.queryKeys = new Map();
this.policy = policy;
this._getCache = getEntityCaches(new Map());
}
/** Compute denormalized form maintaining referential equality for same inputs */
denormalize(schema, input, entities, args = []) {
// we already vary based on input, so we don't need endpointKey? TODO: verify
// if (!this.endpoints[endpointKey])
// this.endpoints[endpointKey] = new WeakDependencyMap<EntityPath>();
// undefined means don't do anything
if (schema === undefined) {
return {
data: input,
paths: []
};
}
if (input === undefined) {
return {
data: undefined,
paths: []
};
}
const getEntity = this.policy.getEntities(entities);
return getUnvisit(getEntity, new GlobalCache(getEntity, this._getCache, this.endpoints), args)(schema, input);
}
/** Compute denormalized form maintaining referential equality for same inputs */
query(schema, args, state,
// NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
argsKey = JSON.stringify(args)) {
const input = this.buildQueryKey(schema, args, state, argsKey);
if (!input) {
return {
data: undefined,
paths: []
};
}
return this.denormalize(schema, input, state.entities, args);
}
buildQueryKey(schema, args, state,
// NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
argsKey = JSON.stringify(args)) {
// This is redundant for buildQueryKey checks, but that was is used for recursion so we still need the checks there
// TODO: If we make each recursive call include cache lookups, we combine these checks together
// null is object so we need double check
if (typeof schema !== 'object' && typeof schema.queryKey !== 'function' || !schema) return schema;
// cache lookup: argsKey -> schema -> ...touched indexes or entities
let queryCache = this.queryKeys.get(argsKey);
if (!queryCache) {
queryCache = new WeakDependencyMap();
this.queryKeys.set(argsKey, queryCache);
}
const baseDelegate = new this.policy.QueryDelegate(state);
// eslint-disable-next-line prefer-const
let [value, paths] = queryCache.get(schema, getDependency(baseDelegate));
// paths undefined is the only way to truly tell nothing was found (the value could have actually been undefined)
if (!paths) {
const [delegate, dependencies] = baseDelegate.tracked(schema);
value = buildQueryKey(delegate)(schema, args);
queryCache.set(dependencies, value);
}
return value;
}
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["GlobalCache","WeakDependencyMap","buildQueryKey","getEntityCaches","MemoPolicy","getDependency","getUnvisit","MemoCache","constructor","policy","endpoints","queryKeys","Map","_getCache","denormalize","schema","input","entities","args","undefined","data","paths","getEntity","getEntities","query","state","argsKey","JSON","stringify","queryKey","queryCache","get","set","baseDelegate","QueryDelegate","value","delegate","dependencies","tracked"],"sources":["../../src/memo/MemoCache.ts"],"sourcesContent":["import GlobalCache from './globalCache.js';\nimport WeakDependencyMap from './WeakDependencyMap.js';\nimport buildQueryKey from '../buildQueryKey.js';\nimport { GetEntityCache, getEntityCaches } from './entitiesCache.js';\nimport { MemoPolicy } from './Policy.js';\nimport { getDependency } from '../delegate/BaseDelegate.js';\nimport type { INVALID } from '../denormalize/symbol.js';\nimport getUnvisit from '../denormalize/unvisit.js';\nimport type {\n  EntityPath,\n  NormalizedIndex,\n  QueryPath,\n  Schema,\n} from '../interface.js';\nimport type { DenormalizeNullable, NormalizeNullable } from '../types.js';\nimport type { IMemoPolicy, EndpointsCache } from './types.js';\n\n// TODO: make MemoCache generic on the arguments sent to Delegate constructor\n\n/** Singleton to store the memoization cache for denormalization methods */\nexport default class MemoCache {\n  /** Cache for every entity based on its dependencies and its own input */\n  declare protected _getCache: GetEntityCache;\n  /** Caches the final denormalized form based on input, entities */\n  protected endpoints: EndpointsCache = new WeakDependencyMap<EntityPath>();\n  /** Caches the queryKey based on schema, args, and any used entities or indexes */\n  protected queryKeys: Map<string, WeakDependencyMap<QueryPath>> = new Map();\n\n  declare protected policy: IMemoPolicy;\n\n  constructor(policy: IMemoPolicy = MemoPolicy) {\n    this.policy = policy;\n    this._getCache = getEntityCaches(new Map());\n  }\n\n  /** Compute denormalized form maintaining referential equality for same inputs */\n  denormalize<S extends Schema>(\n    schema: S | undefined,\n    input: unknown,\n    entities: any,\n    args: readonly any[] = [],\n  ): {\n    data: DenormalizeNullable<S> | typeof INVALID;\n    paths: EntityPath[];\n  } {\n    // we already vary based on input, so we don't need endpointKey? TODO: verify\n    // if (!this.endpoints[endpointKey])\n    //   this.endpoints[endpointKey] = new WeakDependencyMap<EntityPath>();\n\n    // undefined means don't do anything\n    if (schema === undefined) {\n      return { data: input as any, paths: [] };\n    }\n    if (input === undefined) {\n      return { data: undefined as any, paths: [] };\n    }\n    const getEntity = this.policy.getEntities(entities);\n\n    return getUnvisit(\n      getEntity,\n      new GlobalCache(getEntity, this._getCache, this.endpoints),\n      args,\n    )(schema, input);\n  }\n\n  /** Compute denormalized form maintaining referential equality for same inputs */\n  query<S extends Schema>(\n    schema: S,\n    args: readonly any[],\n    state: StateInterface,\n    // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now\n    argsKey: string = JSON.stringify(args),\n  ): {\n    data: DenormalizeNullable<S> | typeof INVALID;\n    paths: EntityPath[];\n  } {\n    const input = this.buildQueryKey(schema, args, state, argsKey);\n\n    if (!input) {\n      return { data: undefined as any, paths: [] };\n    }\n\n    return this.denormalize(schema, input, state.entities, args);\n  }\n\n  buildQueryKey<S extends Schema>(\n    schema: S,\n    args: readonly any[],\n    state: StateInterface,\n    // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now\n    argsKey: string = JSON.stringify(args),\n  ): NormalizeNullable<S> {\n    // This is redundant for buildQueryKey checks, but that was is used for recursion so we still need the checks there\n    // TODO: If we make each recursive call include cache lookups, we combine these checks together\n    // null is object so we need double check\n    if (\n      (typeof schema !== 'object' &&\n        typeof (schema as any).queryKey !== 'function') ||\n      !schema\n    )\n      return schema as any;\n\n    // cache lookup: argsKey -> schema -> ...touched indexes or entities\n    let queryCache = this.queryKeys.get(argsKey) as\n      | WeakDependencyMap<QueryPath, object, any>\n      | undefined;\n    if (!queryCache) {\n      queryCache = new WeakDependencyMap<QueryPath>();\n      this.queryKeys.set(argsKey, queryCache);\n    }\n\n    const baseDelegate = new this.policy.QueryDelegate(state);\n    // eslint-disable-next-line prefer-const\n    let [value, paths] = queryCache.get(\n      schema as any,\n      getDependency(baseDelegate),\n    );\n\n    // paths undefined is the only way to truly tell nothing was found (the value could have actually been undefined)\n    if (!paths) {\n      const [delegate, dependencies] = baseDelegate.tracked(schema);\n\n      value = buildQueryKey(delegate)(schema, args);\n      queryCache.set(dependencies, value);\n    }\n    return value;\n  }\n}\n\ntype StateInterface = {\n  entities:\n    | Record<string, Record<string, any> | undefined>\n    | {\n        getIn(k: string[]): any;\n      };\n  indexes:\n    | NormalizedIndex\n    | {\n        getIn(k: string[]): any;\n      };\n};\n"],"mappings":"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","ignoreList":[]}