tRPC does not natively export OpenAPI documents, but the trpc-openapi package adds this functionality. We'll start this tutorial by adding trpc-openapi to a project, and then we'll add a script to generate an OpenAPI schema and save it as a file.

While trpc-openapi originally was used to expose REST endpoints of the tRPC router, we will use it to generate an OpenAPI specification for our API.

Sure it can, you can use https://github.com/prosepilot/trpc-openapi

You either have to go with react native or use https://github.com/jlalmes/trpc-openapi to generate rest endpoint using trpc. lol. Not sure how good the trpc-openapi package is though. Read somewhere it was missing stuff

As for exposing the API externally, neither (can) limit this but SvelteKit's API is generally considered to be an internal implementation detail that you don't use directly since it might change between versions. If you want to expose an API you should choose tRPC, probably alongside the OpenAPI plugin or something similar.

In essence, features of the language made for static type checking at compilation are possibly being left favour of tools that act like a superset of the language that provide the static build type checking and offer runtime type checking too. An example I recently saw was the trpc-openapi package which uses Zod for creating the types of the schema for the http request and responses, it takes a zod schema as that is what it can use when compiled to JavaScript to generate the types for the openapi file at runtime, there's scarcely a type or interface in sight when using it but you have full type safety.

Take a look at https://github.com/jlalmes/trpc-openapi which will give you a rest endpoint based on your trpc router. Ymmv in reality but basically this should give you some confidence that your trpc router can be called from another client (not just next).

Ok thanks, I did find a good example here https://github.com/jlalmes/trpc-openapi/blob/master/examples/with-nextjs/src/server/router.ts

There is an OpenAPI Extension for tRPC that can be used to create a more REST-like API from your procedures, and that in turn can be used for auto-generating documentation. But if my app needed to offer third-party API access, I would likely reach for GraphQL again.

tRPC is nice because you have type safety the whole way down. Someone has made a tRPC OpenaAPI for exposing tRPC procedures externally in the OpenAPI format https://github.com/jlalmes/trpc-openapi

import { unstable_noStore as noStore } from "next/cache"; import Link from "next/link"; import { CreatePost } from "~/app/_components/create-post"; import { getServerAuthSession } from "~/server/auth"; import { api } from "~/trpc/server"; export default async function Home() { noStore(); const hello = await api.post.hello.query({ text: "from tRPC" }); const session = await getServerAuthSession(); return (

Create T3span> App h1>

First Steps →h3>

Just the basics - Everything you need to know to set up your database and authentication. div> Link>

Documentation →h3>

Learn more about Create T3 App, the libraries it uses, and how to deploy it.div> Link> div>

{hello ? hello.greeting : "Loading tRPC query..."}p>

{session && Logged in as {session.user?.email}span>} p> {session ? "Sign out" : "Sign in"} Link> div> div> div> main> ); } async function CrudShowcase() { const session = await getServerAuthSession(); if (!session?.user) return null; const latestPost = await api.post.getLatest.query(); return (

{latestPost ? (

Your most recent post: {latestPost.name}p> ) : (

You have no posts yet.p> )} div> ); }

I thought he was making stuff up - "t3 stack vs t4 stack". But about 2 minutes in, I realized that I'd heard of a few things that he's talking about so I looked it up and they're real!

I think it's possible everything he's saying is true, more or less. LOL

t3: https://create.t3.gg

t4: https://t4stack.com

We start with a project that was bootstrapped with create-t3-app. For internationalization we use next-intl and set it up as described in the getting started guide. With this initial project setup we can jump into implementing localized error messages.

I used create-t3-app to scaffold the Next.js app, with TypeScript, Prisma, and "app router" enabled in the options. You can also use create-next-app for the job and install Prisma manually.

I agree that the quantity of publicly available code isn't the most reliable indicator of someone's seniority.

My issue with this individual arises from the discrepancy between his public claims of significant expertise in the content he produces. He positions himself as a highly experienced developer, attracting a large following of junior developers who take his advice at face value.

I am trying to collect data points supporting his claims of seniority. For instance, his website prominently features a statement that he is the creator of the T3 Stack. However, a review of the contributor statistics for the T3 Stack (https://github.com/t3-oss/create-t3-app/graphs/contributors)... minimal contributions from him, which raises questions about the validity of his claims.

I would recommend - https://create.t3.gg/

It uses the following, which as of late are pretty well know and common, so you can punch in your problems to stackoverflow, google, or chatgpt and get some pretty good answers.

It uses:

Nextjs (React), typescript, trpc (typescript rpc), auth, tailwind, and Prisma (ORM)

Though of course these could go out of fashion tomorrow, but I don't think the essential idea behind these libs and frameworks are that wacky, unique or unordinary.

Prisma ORM, is a little opinionated, and you could swap it out for Drizzle, which is basically typescript side sugared SQL.

TRPC might be also be a little sticky because it is tied to typescript, this is the tradeoff for the buttery smooth coupling for the fullstack experience. I think there exists a typed-rest solution out there, but haven't used it.

Personal anecdata, I used this stack for a little hobby project and it was FUN.

Open SaaS was built with Typescript, and because it’s a full-stack app, type safety from the back-end to the front-end can be a real lifesaver. I mean, some opinionated stacks have gotten hugely popular on this basis.

Let's start by creating a Next.js application. We will use the T3 stack (TypeScript, TailwindCSS, and Prisma ORM) for this tutorial to skip installing and configuring all the dependencies which is out of the scope of this article. You can find more information about the T3 stack.

https://github.com/t3-oss/create-t3-app

You still would need to add Stripe but there are so many examples publicly available that it should be straight forward