index.ts

import { type Requester } from '@logto/js';
import { trySafe, type Nullable, conditional } from '@silverhand/essentials';

import {
  type CacheKey,
  type Navigate,
  type PersistKey,
  type Storage,
  type StorageKey,
  type ClientAdapter,
  type InferStorageKey,
} from './types.js';

// Track in-flight cache writes per cache storage instance. A WeakMap keeps this helper from
// extending the lifetime of adapter-provided cache stores.
const runningCacheGetters = new WeakMap<Storage<CacheKey>, Map<CacheKey, Promise<unknown>>>();

const getRunningCacheGetterMap = (cache: Storage<CacheKey>) => {
  const runningGetterMap = runningCacheGetters.get(cache);

  if (runningGetterMap) {
    return runningGetterMap;
  }

  const newRunningGetterMap = new Map<CacheKey, Promise<unknown>>();
  runningCacheGetters.set(cache, newRunningGetterMap);
  return newRunningGetterMap;
};

export class ClientAdapterInstance implements ClientAdapter {
  /*
   * Implement `ClientAdapter`. Its properties are assigned by
   * `Object.assign()` in the constructor.
   */
  requester!: Requester;
  storage!: Storage<StorageKey | PersistKey>;
  unstable_cache?: Storage<CacheKey> | undefined;
  navigate!: Navigate;
  generateState!: () => string | Promise<string>;
  generateCodeVerifier!: () => string | Promise<string>;
  generateCodeChallenge!: (codeVerifier: string) => string | Promise<string>;
  /* END OF IMPLEMENTATION */

  constructor(adapter: ClientAdapter) {
    // eslint-disable-next-line @silverhand/fp/no-mutating-assign
    Object.assign(this, adapter);
  }

  async setStorageItem(key: InferStorageKey<typeof this.storage>, value: Nullable<string>) {
    if (!value) {
      await this.storage.removeItem(key);
      return;
    }

    await this.storage.setItem(key, value);
  }

  /**
   * Try to get the string value from the cache and parse as JSON.
   * Return the parsed value if it is an object, return `undefined` otherwise.
   *
   * @param key The cache key to get value from.
   */
  async getCachedObject<T>(key: CacheKey): Promise<T | undefined> {
    const cached = await trySafe(async () => {
      const data = await this.unstable_cache?.getItem(key);
      // It's actually `unknown`
      // eslint-disable-next-line no-restricted-syntax
      return conditional(data && (JSON.parse(data) as unknown));
    });

    if (cached && typeof cached === 'object') {
      // Trust cache for now
      // eslint-disable-next-line no-restricted-syntax
      return cached as T;
    }
  }

  /**
   * Try to get the value from the cache first, if it doesn't exist in cache,
   * run the getter function and store the result into cache.
   *
   * @param key The cache key to get value from.
   */
  async getWithCache<T>(key: CacheKey, getter: () => Promise<T>): Promise<T> {
    const cached = await this.getCachedObject<T>(key);

    if (cached) {
      return cached;
    }

    const { unstable_cache: cache } = this;

    if (!cache) {
      return getter();
    }

    const runningGetterMap = getRunningCacheGetterMap(cache);
    const runningGetter = runningGetterMap.get(key);

    if (runningGetter) {
      // Another client sharing the same cache storage is already populating this key. Wait for it
      // instead of issuing a duplicate discovery request.
      try {
        await runningGetter;
      } catch {
        // The in-flight getter rejected before writing to cache. Fall through to the cache check
        // and the current caller's getter below.
      }

      const cachedResult = await this.getCachedObject<T>(key);

      if (cachedResult) {
        return cachedResult;
      }

      // The in-flight getter may fail before writing to cache. Retry through the same population
      // path so a successful recovery is stored for later callers.
      return this.getWithCache(key, getter);
    }

    const newRunningGetter = (async () => {
      const result = await getter();
      await cache.setItem(key, JSON.stringify(result));
      return result;
    })();
    runningGetterMap.set(key, newRunningGetter);

    try {
      return await newRunningGetter;
    } finally {
      runningGetterMap.delete(key);
    }
  }
}

export * from './types.js';