react-query-kit/build/lib/router.esm.js

🕊️ A toolkit for ReactQuery that make ReactQuery hooks more reusable and typesafe

import { createInfiniteQuery } from './createInfiniteQuery.esm.js';
import { createMutation } from './createMutation.esm.js';
import { createQuery } from './createQuery.esm.js';
import { createSuspenseInfiniteQuery } from './createSuspenseInfiniteQuery.esm.js';
import { createSuspenseQuery } from './createSuspenseQuery.esm.js';

const isRouterLeaf = value => {
  return !!value && typeof value._routerType === 'string';
};

const buildRouter = (keys, config) => {
  return Object.entries(config).reduce((acc, [key, opts]) => {
    if (!isRouterLeaf(opts)) {
      acc[key] = buildRouter([...keys, key], opts);
    } else {
      const type = opts._routerType;
      const options = { ...opts,
        [type === "m" ? "mutationKey" : "queryKey"]: [...keys, key]
      };

      if (type === "m") {
        acc[key] = {
          useMutation: createMutation(options),
          ...createMutation(options)
        };
        return acc;
      }

      acc[key] = type === "q" ? {
        useQuery: createQuery(options),
        useSuspenseQuery: createSuspenseQuery(options),
        ...createQuery(options)
      } : {
        useInfiniteQuery: createInfiniteQuery(options),
        useSuspenseInfiniteQuery: createSuspenseInfiniteQuery(options),
        ...createInfiniteQuery(options)
      };
    }

    return acc;
  }, {
    getKey: () => keys
  });
};

const router = (key, config) => {
  return buildRouter(Array.isArray(key) ? key : [key], config);
};

function query(options) {
  return { ...options,
    _routerType: 'q'
  };
}

function infiniteQuery(options) {
  return { ...options,
    _routerType: 'inf'
  };
}

function mutation(options) {
  return { ...options,
    _routerType: 'm'
  };
}

router.query = query;
router.infiniteQuery = infiniteQuery;
router.mutation = mutation;

export { router };
//# sourceMappingURL=router.esm.js.map