Something went wrong. Try again.
[READ-ONLY] Mirror of https://github.com/Rowan-Paul/vodcreator. vodcreator.rowanpaulflynn.com
Something went wrong. Try again.
4.0 kB · 135 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136/** * YOU PROBABLY DON'T NEED TO EDIT THIS FILE, UNLESS: * 1. You want to modify request context (see Part 1). * 2. You want to create a new middleware or type of procedure (see Part 3). * * TL;DR - This is where all the tRPC server stuff is created and plugged in. The pieces you will * need to use are documented accordingly near the end. */
// Hard boundary: importing this module from a client component is a build error// rather than a runtime crash in the browser. See docs/adr/0001-trpc-server-boundary.mdimport "server-only";
import { initTRPC, TRPCError } from "@trpc/server";import superjson from "superjson";import { ZodError } from "zod";
import { auth } from "@/server/auth";
/** * 1. CONTEXT * * This section defines the "contexts" that are available in the backend API. * * These allow you to access things when processing a request, like the database, the session, etc. * * This helper generates the "internals" for a tRPC context. The API handler and RSC clients each * wrap this and provides the required context. * * @see https://trpc.io/docs/server/context */export const createTRPCContext = async (opts: { headers: Headers }) => { const session = await auth();
return { session, ...opts, };};
/** * 2. INITIALIZATION * * This is where the tRPC API is initialized, connecting the context and transformer. We also parse * ZodErrors so that you get typesafety on the frontend if your procedure fails due to validation * errors on the backend. */const t = initTRPC.context<typeof createTRPCContext>().create({ transformer: superjson, errorFormatter({ shape, error }) { return { ...shape, data: { ...shape.data, zodError: error.cause instanceof ZodError ? error.cause.flatten() : null, }, }; },});
/** * Create a server-side caller. * * @see https://trpc.io/docs/server/server-side-calls */export const createCallerFactory = t.createCallerFactory;
/** * 3. ROUTER & PROCEDURE (THE IMPORTANT BIT) * * These are the pieces you use to build your tRPC API. You should import these a lot in the * "/src/server/api/routers" directory. */
/** * This is how you create new routers and sub-routers in your tRPC API. * * @see https://trpc.io/docs/router */export const createTRPCRouter = t.router;
/** * Middleware for timing procedure execution and adding an artificial delay in development. * * You can remove this if you don't like it, but it can help catch unwanted waterfalls by simulating * network latency that would occur in production but not in local development. */const timingMiddleware = t.middleware(async ({ next, path }) => { const start = Date.now();
if (t._config.isDev && process.env.TRPC_SIMULATE_LATENCY === "true") { // artificial delay in dev const waitMs = Math.floor(Math.random() * 400) + 100; await new Promise((resolve) => setTimeout(resolve, waitMs)); }
const result = await next();
const end = Date.now(); console.log(`[TRPC] ${path} took ${end - start}ms to execute`);
return result;});
/** * Public (unauthenticated) procedure * * This is the base piece you use to build new queries and mutations on your tRPC API. It does not * guarantee that a user querying is authorized, but you can still access user session data if they * are logged in. */export const publicProcedure = t.procedure.use(timingMiddleware);
/** * Protected (authenticated) procedure * * If you want a query or mutation to ONLY be accessible to logged in users, use this. It verifies * the session is valid and guarantees `ctx.session.user` is not null. * * @see https://trpc.io/docs/procedures */export const protectedProcedure = t.procedure .use(timingMiddleware) .use(({ ctx, next }) => { if (!ctx.session?.user) { throw new TRPCError({ code: "UNAUTHORIZED" }); } return next({ ctx: { // infers the `session` as non-nullable session: { ...ctx.session, user: ctx.session.user }, }, }); });