@ts-rest/solid-query/index.cjs.js

solid-query client integration for @ts-rest

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var solidQuery = require('@tanstack/solid-query');
var core = require('@ts-rest/core');

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

exports.initQueryClient = initQueryClient;