Class BethPersistedCache

packages/beth-stack/src/cache/new-persist.ts:140–204

}

export class BethPersistedCache {
  private config: GlobalCacheConfig = startingConfig;
  private primaryMap: Map<
    FunctionKey,
    {
      callBack: () => Promise<any>;
      tags: string[];
      location: "memory" | "json";
      argsMap: Map<
        any[],
        {
          argsKey: ArgKey;
          status:
            | "pending"
            | "unseeded"
            | "seeded"
            | "unseeded-error"
            | "seeded-error";
        }
      >;
    }
  > = new Map();
  private pendingMap: Map<ArgKey, Promise<any>> = new Map();
  private erroredMap: Map<ArgKey, any> = new Map();
  private inMemoryDataCache: BethMemoryCache = new BethMemoryCache();
  private jsonDataCache: BethJsonCache = new BethJsonCache();
  private intervals: Set<Timer> = new Set();
  private keys: Set<string> = new Set();

  constructor() {}

  public setConfig(config: Partial<GlobalCacheConfig>): void {}

  public clearAllIntervals(): void {
    this.intervals.forEach((interval) => clearInterval(interval));
  }
  public purgeAllCachedData(): void {
    this.primaryMap = new Map();
    this.erroredMap = new Map();
    this.inMemoryDataCache = new BethMemoryCache();
    this.jsonDataCache = new BethJsonCache();
    this.primaryMap.forEach((fnData, key) => {
      fnData.argsMap.forEach((fnData, key) => {
        fnData.status = "unseeded";
      });
    });
  }

  public initializeEntry(
    callBack: () => Promise<any>,
    key: FunctionKey,
    options?: CacheOptions,
  ): void {}
  public getCachedValue(key: string, ...args: any[]): any {}

  public async revalidateTag(tag: string): Promise<void> {}

  private logDebug(): void {}