index.js

import { VueReactivity } from "./integrations";
import TanStackStateManager from "./TanStackStateManager";

export class QueryManager {
  constructor(config, Reactivity = VueReactivity) {
    this.reactivity = new Reactivity();
    this.stateManager = new TanStackStateManager(this.reactivity);
    this.invalidateQueries = this.stateManager.invalidateQuery;
    this.operations = new Map();
    return this.#initializeFromConfig(config);
  }

  #initializeFromConfig(config) {
    const instance = {};
    const getExactQueryKey = (key) => this.stateManager.queryStates[key]?.queryKey;

    Object.entries(config).forEach(([key, definition]) => {
      if (definition.type === "query") {
        instance[key] = this.#createQueryInterface(key, definition, getExactQueryKey);
      } else if (definition.type === "mutation") {
        instance[key] = this.#createMutationInterface(key, definition, getExactQueryKey);
      }
    });

    return instance;
  }

  #createQueryInterface(key, definition, getExactQueryKey) {
    return this.reactivity.create({
      ...this.stateManager.defineQuery(this.#define(definition, getExactQueryKey)),
      fetch: (payload, options = {}) =>
        this.#promisifyQuery({ key, definition, payload, options, getExactQueryKey }),
      fetchAsync: (payload, options = {}) =>
        this.#promisifyQuery({
          key,
          definition,
          payload,
          options: { ...options, throwError: true },
          getExactQueryKey,
        }),
      subscribe: (fn) => this.stateManager.registerGlobalSubscriber(key, fn),
    });
  }

  #createMutationInterface(key, definition, getExactQueryKey) {
    return this.reactivity.create({
      ...this.stateManager.defineMutation(this.#define(definition, getExactQueryKey)),
      mutate: (payload, options = {}) =>
        this.#promisifyMutation({
          key,
          definition,
          payload,
          options,
          getExactQueryKey,
        }),
      mutateAsync: (payload, options = {}) =>
        this.#promisifyMutation({
          key,
          definition,
          payload,
          options: { ...options, throwError: true },
          getExactQueryKey,
        }),
      subscribe: (fn) => this.stateManager.registerGlobalSubscriber(key, fn),
    });
  }

  #promisifyQuery({ key, definition, payload, options = {}, getExactQueryKey }) {
    const { refresh = false } = options;

    if (refresh && getExactQueryKey(key)) this.stateManager.queryClient.resetQueries(getExactQueryKey(key));
    const query = this.stateManager.defineQuery(definition.define(payload));

    if (this.operations.has(query.hash)) {
      return this.operations.get(query.hash);
    }

    const operation = this.#promisifyOperation(() => {
      if (query.state.data && !query.state.isStale && !query.state.isFetching) {
        return { immediate: true, data: query.state.data };
      }

      return {
        type: "query",
        operation: query,
        throwError: options.throwError ?? false,
        trigger: () => query.fetch(),
      };
    });

    this.operations.set(query.hash, operation);
    return operation;
  }

  #promisifyMutation({ definition, payload, options, getExactQueryKey }) {
    const mutation = this.stateManager.defineMutation(this.#define(definition, getExactQueryKey));
    if (this.operations.has(mutation.hash)) {
      return this.operations.get(mutation.hash);
    }
    const operation = this.#promisifyOperation(() => {
      return {
        type: "mutation",
        operation: mutation,
        throwError: options.throwError ?? false,
        trigger: () => mutation.mutate(payload),
      };
    });

    this.operations.set(mutation.hash, operation);
    return operation;
  }

  #promisifyOperation(operationFactory) {
    return new Promise((resolve, reject) => {
      const result = operationFactory();

      if (result.immediate) return resolve(result.data);

      const { operation, trigger, type, throwError } = result;
      const resolveOperation = (state) => {
        unsubscribe();
        this.operations.delete(operation.hash);
        if (throwError) {
          if (state.status === "success") resolve(state.data);
          else reject(state.error);
        } else {
          resolve(state.data ?? state.error);
        }
      };

      const isQuery = type === "query";
      const isMutation = type === "mutation";

      const unsubscribe = operation.subscribe((state) => {
        const isReadyQuery = isQuery && !state.isFetching && !state.isLoading;
        const isReadyMutation = isMutation && !state.isPending;
        if (isReadyQuery || isReadyMutation) resolveOperation(state);
      });

      trigger();
    });
  }

  #define(definition, getExactQueryKey) {
    const { options, ...rest } = definition.define();
    return {
      ...rest,
      options: this.#generateOptions(options, getExactQueryKey),
    };
  }

  #generateOptions(options, getExactQueryKey) {
    return typeof options === "function" ? options(this.stateManager.queryClient, getExactQueryKey) : options;
  }

  getExactQuery(key) {
    return this.stateManager.queries[key]?.queryHash;
  }
}