private readonly cacheReadThrough:()

in packages/sdk/src/FlagResolverClient.ts [112:174]
55 lines of code
5 McCabe index (conditional complexity)

  private readonly cacheReadThrough: (
    context: Context,
    supplier: () => Promise<ResolveFlagsResponse>,
  ) => Promise<{ response: ResolveFlagsResponse; isFromCache: boolean }>;

  constructor({
    fetchImplementation,
    clientSecret,
    sdk,
    applyDebounce,
    resolveTimeout,
    // todo refactor to move out environment
    environment,
    region,
    resolveBaseUrl,
    telemetry,
    logger,
    waitUntil,
    cacheProvider,
  }: FlagResolverClientOptions) {
    this.traceConsumer = telemetry.registerLibraryTraces({
      library: LibraryTraces_Library.LIBRARY_CONFIDENCE,
      version: sdk.version,
      id: LibraryTraces_TraceId.TRACE_ID_RESOLVE_LATENCY,
    });

    const fetchBuilder = new FetchBuilder();
    withTelemetryData(fetchBuilder, telemetry);
    if (environment === 'client') {
      withRequestLogic(fetchBuilder, logger);
    }

    this.fetchImplementation = fetchBuilder.build(fetchImplementation);

    this.clientSecret = clientSecret;
    this.sdk = sdk;
    this.applyDebounce = applyDebounce;
    if (resolveBaseUrl) {
      this.baseUrl = `${resolveBaseUrl}/v1`;
    } else {
      this.baseUrl = region ? `https://resolver.${region}.confidence.dev/v1` : 'https://resolver.confidence.dev/v1';
    }
    this.resolveTimeout = resolveTimeout;
    this.waitUntil = waitUntil;
    if (cacheProvider) {
      this.cacheReadThrough = (context, supplier) => {
        const cache = cacheProvider(this.clientSecret);
        let isFromCache = true; // Default to true, will be set to false if supplier is called

        // Create a wrapper supplier that sets the flag when called
        const wrappedSupplier = async () => {
          isFromCache = false;
          return supplier();
        };

        return cache.get(context, wrappedSupplier).then(response => {
          return { response, isFromCache };
        });
      };
    } else {
      this.cacheReadThrough = (_context, supplier) => supplier().then(response => ({ response, isFromCache: false }));
    }
  }