Function createRequest

src/_minimal/utils/reactive.ts:7–97

(
  parameter: Ref<Parameter<F>>,
  fn: F,
  options: {
    cache?: {
      prefix: string;
      ttl: number;
      refetchTtl: number;
      keyFn?: (param: Ref<Parameter<F>>) => string;
    };
    executeCondition?: (param: Ref<Parameter<F>>) => boolean;
    keepData?: boolean;
  } = {},
)

type Parameter<G> = G extends (arg: infer G) => any ? G : never;

export function createRequest<F extends (arg: any) => Promise<any>>(
  parameter: Ref<Parameter<F>>,
  fn: F,
  options: {
    cache?: {
      prefix: string;
      ttl: number;
      refetchTtl: number;
      keyFn?: (param: Ref<Parameter<F>>) => string;
    };
    executeCondition?: (param: Ref<Parameter<F>>) => boolean;
    keepData?: boolean;
  } = {},
) {
  let id = 0;

  const result = reactive({
    loading: true,
    temporaryCache: false,
    cache: false,
    data: null as null | Awaited<ReturnType<F>>,
    error: null as null | Error,
    execute: () => Promise.resolve(),
  });

  const execute = async (params: Ref<Parameter<F>>, forceFresh = false) => {
    result.loading = true;
    result.temporaryCache = false;
    result.error = null;
    if (!options.keepData) result.data = null;
    const tempId = Math.random();
    id = tempId;

    let state;
    let cache;
    if (options.cache) {
      cache = new Cache(
        options.cache.prefix +
          (options.cache.keyFn ? options.cache.keyFn(params) : JSON.stringify(params.value)),
        options.cache.ttl,
        true,
        options.cache.refetchTtl,
      );

      if (forceFresh) {
        cache.clearValue();
      } else {
        state = await cache.fullState();
        if (state.hasValue) {
          result.data = state.value.data;
          result.loading = false;
          result.cache = true;
          result.temporaryCache = state.refetch;
        }
      }
    }

    if (state && !state.refetch && state.hasValue) return Promise.resolve();