@data-client/normalizr
Version:
Normalizes and denormalizes JSON according to schema for Redux and Flux applications
148 lines (143 loc) • 19 kB
JavaScript
import WeakDependencyMap from './WeakDependencyMap.js';
export default class GlobalCache {
constructor(getEntity, entityCache, resultCache) {
this.dependencies = [];
this.cycleCache = new Map();
this.cycleIndex = -1;
this.localCache = new Map();
this._getEntity = getEntity;
this.getCache = getEntityCaches(entityCache);
this.resultCache = resultCache;
}
getEntity(pk, schema, entity, computeValue) {
const key = schema.key;
const {
localCacheKey,
cycleCacheKey
} = this.getCacheKey(key);
if (!localCacheKey.get(pk)) {
const globalCache = this.getCache(pk, schema);
const [cacheValue, cachePath] = globalCache.get(entity, this._getEntity);
// TODO: what if this just returned the deps - then we don't need to store them
if (cachePath) {
localCacheKey.set(pk, cacheValue.value);
// TODO: can we store the cache values instead of tracking *all* their sources?
// this is only used for setting endpoints cache correctly. if we got this far we will def need to set as we would have already tried getting it
this.dependencies.push(...cacheValue.dependencies);
return cacheValue.value;
}
// if we don't find in denormalize cache then do full denormalize
else {
const trackingIndex = this.dependencies.length;
cycleCacheKey.set(pk, trackingIndex);
this.dependencies.push({
entity,
path: {
key,
pk
}
});
/** NON-GLOBAL_CACHE CODE */
computeValue(localCacheKey);
/** /END NON-GLOBAL_CACHE CODE */
cycleCacheKey.delete(pk);
// if in cycle, use the start of the cycle to track all deps
// otherwise, we use our own trackingIndex
const localKey = this.dependencies.slice(this.cycleIndex === -1 ? trackingIndex : this.cycleIndex);
const cacheValue = {
dependencies: localKey,
value: localCacheKey.get(pk)
};
globalCache.set(localKey, cacheValue);
// start of cycle - reset cycle detection
if (this.cycleIndex === trackingIndex) {
this.cycleIndex = -1;
}
}
} else {
// cycle detected
if (cycleCacheKey.has(pk)) {
this.cycleIndex = cycleCacheKey.get(pk);
} else {
// with no cycle, globalCacheEntry will have already been set
this.dependencies.push({
entity,
path: {
key,
pk
}
});
}
}
return localCacheKey.get(pk);
}
getCacheKey(key) {
if (!this.localCache.has(key)) {
this.localCache.set(key, new Map());
}
if (!this.cycleCache.has(key)) {
this.cycleCache.set(key, new Map());
}
const localCacheKey = this.localCache.get(key);
const cycleCacheKey = this.cycleCache.get(key);
return {
localCacheKey,
cycleCacheKey
};
}
/** Cache varies based on input (=== aka reference) */
getResults(input, cachable, computeValue) {
if (!cachable) {
return {
data: computeValue(),
paths: this.paths()
};
}
let [data, paths] = this.resultCache.get(input, this._getEntity);
if (paths === undefined) {
data = computeValue();
// we want to do this before we add our 'input' entry
paths = this.paths();
// for the first entry, `path` is ignored so empty members is fine
this.dependencies.unshift({
entity: input,
path: {
key: '',
pk: ''
}
});
this.resultCache.set(this.dependencies, data);
} else {
paths.shift();
}
return {
data,
paths
};
}
paths() {
return this.dependencies.map(dep => dep.path);
}
}
const getEntityCaches = entityCache => {
return (pk, schema) => {
var _ref;
const key = schema.key;
// collections should use the entities they collect over
// TODO: this should be based on a public interface
const entityInstance = (_ref = schema.cacheWith) != null ? _ref : schema;
if (!entityCache.has(key)) {
entityCache.set(key, new Map());
}
const entityCacheKey = entityCache.get(key);
if (!entityCacheKey.get(pk)) entityCacheKey.set(pk, new WeakMap());
const entityCachePk = entityCacheKey.get(pk);
let wem = entityCachePk.get(entityInstance);
if (!wem) {
wem = new WeakDependencyMap();
entityCachePk.set(entityInstance, wem);
}
return wem;
};
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["WeakDependencyMap","GlobalCache","constructor","getEntity","entityCache","resultCache","dependencies","cycleCache","Map","cycleIndex","localCache","_getEntity","getCache","getEntityCaches","pk","schema","entity","computeValue","key","localCacheKey","cycleCacheKey","getCacheKey","get","globalCache","cacheValue","cachePath","set","value","push","trackingIndex","length","path","delete","localKey","slice","has","getResults","input","cachable","data","paths","undefined","unshift","shift","map","dep","_ref","entityInstance","cacheWith","entityCacheKey","WeakMap","entityCachePk","wem"],"sources":["../../src/memo/globalCache.ts"],"sourcesContent":["import { EndpointsCache, EntityCache } from './types.js';\nimport WeakDependencyMap, { type Dep } from './WeakDependencyMap.js';\nimport type Cache from '../denormalize/cache.js';\nimport type { GetEntity } from '../denormalize/getEntities.js';\nimport type { EntityInterface } from '../interface.js';\nimport type { EntityPath } from '../types.js';\n\nexport default class GlobalCache implements Cache {\n  private dependencies: Dep<EntityPath>[] = [];\n  private cycleCache: Map<string, Map<string, number>> = new Map();\n  private cycleIndex = -1;\n  private localCache: Map<string, Map<string, any>> = new Map();\n\n  declare private getCache: (\n    pk: string,\n    schema: EntityInterface,\n  ) => WeakDependencyMap<EntityPath, object, any>;\n\n  declare private _getEntity: GetEntity;\n  declare private resultCache: EndpointsCache;\n\n  constructor(\n    getEntity: GetEntity,\n    entityCache: EntityCache,\n    resultCache: EndpointsCache,\n  ) {\n    this._getEntity = getEntity;\n    this.getCache = getEntityCaches(entityCache);\n    this.resultCache = resultCache;\n  }\n\n  getEntity(\n    pk: string,\n    schema: EntityInterface,\n    entity: any,\n    computeValue: (localCacheKey: Map<string, any>) => void,\n  ): object | undefined | symbol {\n    const key = schema.key;\n    const { localCacheKey, cycleCacheKey } = this.getCacheKey(key);\n\n    if (!localCacheKey.get(pk)) {\n      const globalCache: WeakDependencyMap<\n        EntityPath,\n        object,\n        EntityCacheValue\n      > = this.getCache(pk, schema);\n      const [cacheValue, cachePath] = globalCache.get(entity, this._getEntity);\n      // TODO: what if this just returned the deps - then we don't need to store them\n\n      if (cachePath) {\n        localCacheKey.set(pk, cacheValue.value);\n        // TODO: can we store the cache values instead of tracking *all* their sources?\n        // this is only used for setting endpoints cache correctly. if we got this far we will def need to set as we would have already tried getting it\n        this.dependencies.push(...cacheValue.dependencies);\n        return cacheValue.value;\n      }\n      // if we don't find in denormalize cache then do full denormalize\n      else {\n        const trackingIndex = this.dependencies.length;\n        cycleCacheKey.set(pk, trackingIndex);\n        this.dependencies.push({ entity, path: { key, pk } });\n\n        /** NON-GLOBAL_CACHE CODE */\n        computeValue(localCacheKey);\n        /** /END NON-GLOBAL_CACHE CODE */\n\n        cycleCacheKey.delete(pk);\n        // if in cycle, use the start of the cycle to track all deps\n        // otherwise, we use our own trackingIndex\n        const localKey = this.dependencies.slice(\n          this.cycleIndex === -1 ? trackingIndex : this.cycleIndex,\n        );\n        const cacheValue: EntityCacheValue = {\n          dependencies: localKey,\n          value: localCacheKey.get(pk),\n        };\n        globalCache.set(localKey, cacheValue);\n\n        // start of cycle - reset cycle detection\n        if (this.cycleIndex === trackingIndex) {\n          this.cycleIndex = -1;\n        }\n      }\n    } else {\n      // cycle detected\n      if (cycleCacheKey.has(pk)) {\n        this.cycleIndex = cycleCacheKey.get(pk)!;\n      } else {\n        // with no cycle, globalCacheEntry will have already been set\n        this.dependencies.push({ entity, path: { key, pk } });\n      }\n    }\n    return localCacheKey.get(pk);\n  }\n\n  private getCacheKey(key: string) {\n    if (!this.localCache.has(key)) {\n      this.localCache.set(key, new Map());\n    }\n    if (!this.cycleCache.has(key)) {\n      this.cycleCache.set(key, new Map());\n    }\n    const localCacheKey = this.localCache.get(key)!;\n    const cycleCacheKey = this.cycleCache.get(key)!;\n    return { localCacheKey, cycleCacheKey };\n  }\n\n  /** Cache varies based on input (=== aka reference) */\n  getResults(\n    input: any,\n    cachable: boolean,\n    computeValue: () => any,\n  ): {\n    data: any;\n    paths: EntityPath[];\n  } {\n    if (!cachable) {\n      return { data: computeValue(), paths: this.paths() };\n    }\n\n    let [data, paths] = this.resultCache.get(input, this._getEntity);\n\n    if (paths === undefined) {\n      data = computeValue();\n      // we want to do this before we add our 'input' entry\n      paths = this.paths();\n      // for the first entry, `path` is ignored so empty members is fine\n      this.dependencies.unshift({ entity: input, path: { key: '', pk: '' } });\n      this.resultCache.set(this.dependencies, data);\n    } else {\n      paths.shift();\n    }\n    return { data, paths };\n  }\n\n  protected paths() {\n    return this.dependencies.map(dep => dep.path);\n  }\n}\n\ninterface EntityCacheValue {\n  dependencies: Dep<EntityPath>[];\n  value: object | symbol | undefined;\n}\n\nconst getEntityCaches = (entityCache: EntityCache) => {\n  return (pk: string, schema: EntityInterface) => {\n    const key = schema.key;\n    // collections should use the entities they collect over\n    // TODO: this should be based on a public interface\n    const entityInstance: EntityInterface = (schema.cacheWith as any) ?? schema;\n\n    if (!entityCache.has(key)) {\n      entityCache.set(key, new Map());\n    }\n    const entityCacheKey = entityCache.get(key)!;\n    if (!entityCacheKey.get(pk))\n      entityCacheKey.set(\n        pk,\n        new WeakMap<\n          EntityInterface,\n          WeakDependencyMap<EntityPath, object, any>\n        >(),\n      );\n\n    const entityCachePk = entityCacheKey.get(pk) as WeakMap<\n      EntityInterface<any>,\n      WeakDependencyMap<EntityPath, object, any>\n    >;\n    let wem = entityCachePk.get(entityInstance) as WeakDependencyMap<\n      EntityPath,\n      object,\n      any\n    >;\n    if (!wem) {\n      wem = new WeakDependencyMap<EntityPath, object, any>();\n      entityCachePk.set(entityInstance, wem);\n    }\n\n    return wem;\n  };\n};\n"],"mappings":"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","ignoreList":[]}