@ts-rest/solid-query/index.esm.mjs

solid-query client integration for @ts-rest

import { createQuery, createInfiniteQuery, createMutation } from '@tanstack/solid-query';
import { isAppRoute, getRouteQuery, evaluateFetchApiArgs, fetchApi, isErrorResponse } from '@ts-rest/core';

const getRouteUseQuery = (route, clientArgs) => {
    return (queryKey, args, options) => {
        const dataFn = async ({ signal, }) => {
            const fetchApiArgs = evaluateFetchApiArgs(route, clientArgs, args);
            const result = await fetchApi({
                ...fetchApiArgs,
                fetchOptions: {
                    ...(signal && { signal }),
                    ...fetchApiArgs.fetchOptions,
                },
            });
            // If the response is not a 2XX, throw an error to be handled by solid-query
            if (isErrorResponse(result)) {
                throw result;
            }
            return result;
        };
        return createQuery(queryKey, dataFn, options);
    };
};
const getRouteUseInfiniteQuery = (route, clientArgs) => {
    return (queryKey, args, options) => {
        const dataFn = async (infiniteQueryParams) => {
            const resultingQueryArgs = args(infiniteQueryParams);
            const fetchApiArgs = evaluateFetchApiArgs(route, clientArgs, resultingQueryArgs);
            const result = await fetchApi({
                ...fetchApiArgs,
                fetchOptions: {
                    ...(infiniteQueryParams.signal && {
                        signal: infiniteQueryParams.signal,
                    }),
                    ...fetchApiArgs.fetchOptions,
                },
            });
            // If the response is not a 2XX, throw an error to be handled by solid-query
            if (isErrorResponse(result)) {
                throw result;
            }
            return result;
        };
        return createInfiniteQuery(queryKey, dataFn, options);
    };
};
const getRouteUseMutation = (route, clientArgs) => {
    return (options) => {
        const mutationFunction = async (args) => {
            const fetchApiArgs = evaluateFetchApiArgs(route, clientArgs, args);
            const result = await fetchApi(fetchApiArgs);
            // If the response is not a 2XX, throw an error to be handled by solid-query
            if (isErrorResponse(result)) {
                throw result;
            }
            return result;
        };
        return createMutation(mutationFunction, options);
    };
};
const initQueryClient = (router, args) => {
    return Object.fromEntries(Object.entries(router).map(([key, subRouter]) => {
        if (isAppRoute(subRouter)) {
            return [
                key,
                {
                    query: getRouteQuery(subRouter, args),
                    mutation: getRouteQuery(subRouter, args),
                    createQuery: getRouteUseQuery(subRouter, args),
                    createInfiniteQuery: getRouteUseInfiniteQuery(subRouter, args),
                    createMutation: getRouteUseMutation(subRouter, args),
                },
            ];
        }
        else {
            return [key, initQueryClient(subRouter, args)];
        }
    }));
};

export { initQueryClient };