@trpc/react-query/dist/server/ssgProxy.js

The tRPC React library

'use strict';

var reactQuery = require('@tanstack/react-query');
var client = require('@trpc/client');
var unstableInternals = require('@trpc/client/unstable-internals');
var unstableCoreDoNotImport = require('@trpc/server/unstable-core-do-not-import');
var getQueryKey = require('../internals/getQueryKey.js');
var utilsProxy = require('../shared/proxy/utilsProxy.js');
require('react');
require('../internals/context.js');
var queryClient = require('../shared/queryClient.js');

/**
 * Create functions you can use for server-side rendering / static generation
 * @see https://trpc.io/docs/v11/client/nextjs/server-side-helpers
 */ function createServerSideHelpers(opts) {
    const queryClient$1 = queryClient.getQueryClient(opts);
    const transformer = unstableInternals.getTransformer(opts.transformer);
    const resolvedOpts = (()=>{
        if ('router' in opts) {
            const { ctx, router } = opts;
            return {
                serialize: transformer.output.serialize,
                query: (queryOpts)=>{
                    return unstableCoreDoNotImport.callProcedure({
                        router,
                        path: queryOpts.path,
                        getRawInput: async ()=>queryOpts.input,
                        ctx,
                        type: 'query',
                        signal: undefined
                    });
                }
            };
        }
        const { client: client$1 } = opts;
        const untypedClient = client$1 instanceof client.TRPCUntypedClient ? client$1 : client.getUntypedClient(client$1);
        return {
            query: (queryOpts)=>untypedClient.query(queryOpts.path, queryOpts.input),
            serialize: (obj)=>transformer.output.serialize(obj)
        };
    })();
    function _dehydrate(opts = {
        shouldDehydrateQuery (query) {
            if (query.state.status === 'pending') {
                return false;
            }
            // makes sure to serialize errors
            return true;
        }
    }) {
        const before = unstableCoreDoNotImport.run(()=>{
            const dehydrated = reactQuery.dehydrate(queryClient$1, opts);
            return {
                ...dehydrated,
                queries: dehydrated.queries.map((query)=>{
                    if (query.promise) {
                        const { promise: _, ...rest } = query;
                        return rest;
                    }
                    return query;
                })
            };
        });
        const after = resolvedOpts.serialize(before);
        return after;
    }
    const proxy = unstableCoreDoNotImport.createRecursiveProxy((opts)=>{
        const args = opts.args;
        const input = args[0];
        const arrayPath = [
            ...opts.path
        ];
        const utilName = arrayPath.pop();
        const queryFn = ()=>resolvedOpts.query({
                path: arrayPath.join('.'),
                input
            });
        const queryKey = getQueryKey.getQueryKeyInternal(arrayPath, input, utilsProxy.getQueryType(utilName));
        const helperMap = {
            queryOptions: ()=>{
                const args1 = args[1];
                return {
                    ...args1,
                    queryKey,
                    queryFn
                };
            },
            infiniteQueryOptions: ()=>{
                const args1 = args[1];
                return {
                    ...args1,
                    queryKey,
                    queryFn
                };
            },
            fetch: ()=>{
                const args1 = args[1];
                return queryClient$1.fetchQuery({
                    ...args1,
                    queryKey,
                    queryFn
                });
            },
            fetchInfinite: ()=>{
                const args1 = args[1];
                return queryClient$1.fetchInfiniteQuery({
                    ...args1,
                    queryKey,
                    queryFn,
                    initialPageParam: args1?.initialCursor ?? null
                });
            },
            prefetch: ()=>{
                const args1 = args[1];
                return queryClient$1.prefetchQuery({
                    ...args1,
                    queryKey,
                    queryFn
                });
            },
            prefetchInfinite: ()=>{
                const args1 = args[1];
                return queryClient$1.prefetchInfiniteQuery({
                    ...args1,
                    queryKey,
                    queryFn,
                    initialPageParam: args1?.initialCursor ?? null
                });
            }
        };
        return helperMap[utilName]();
    });
    return unstableCoreDoNotImport.createFlatProxy((key)=>{
        if (key === 'queryClient') return queryClient$1;
        if (key === 'dehydrate') return _dehydrate;
        return proxy[key];
    });
}

exports.createServerSideHelpers = createServerSideHelpers;