TypeScript and the Database: Who Owns the Types?

Rate this content
Bookmark

We all love writing types in TypeScript, but we often find ourselves having to write types in another language as well: SQL. This talk will present the choose-your-own-adventure story that you face when combining TypeScript and SQL and will walk you through the tradeoffs between the various options. Combined poorly, TypeScript and SQL can be duplicative and a source of headaches, but done well they can complement one another by addressing each other's weaknesses.

27 min
29 Apr, 2022

AI Generated Video Summary

The Talk discusses the use of TypeScript and SQL together in software development. It explores different approaches, such as using an ORM like TypeORM or a schema generator like pg2ts. Query builders like connects JS and tools like PGTyped are also discussed. The benefits and trade-offs of using TypeScript and SQL are highlighted, emphasizing the importance of finding a middle ground approach.

1. Working with a Database and Types

Short description:

I'm working on a new app with a database for books, authors, and reviews. The web server connects to the database, runs a query, and renders all the books. I encountered a bug and discovered the need for types. By defining a book interface and specifying the structure of the table, I resolved the type errors. Running a migration allowed me to handle the possibility of null values for the publication year.

So I'm working on this cool new app, so it has a database where I have books and their authors and book reviews. I've even got some data I've put in there, so I've got some of my favorite books. And I've got a cool web server here, so it connects to the database, it runs a query, and it renders all the books. So yeah, I think it's pretty good. Let's take a look.

So I think, seems like it maybe has a bug. So let's see what's going on here. Let's see. So I guess, what is the type of books? It's Any, it's query result Any, which means that book has an Any type. So maybe I should write, maybe I should use types to solve this problem, because this is TS Congress after all, so we can define a book interface. And let's look at the structure of this table. So we've got an ID, which is a string, and we've got created by, which is a string. And we've got title, which is a string, and we've got publication year. We're just gonna copy that. For the JavaScript people here, integers are a special kind of number. So let's just go number. And last but not least, we have contents, which is a string, or I think it could be null. And with the node-progress library, I believe you can specify a return type for a query. And hey, lo and behold, we have some type errors. So yeah, I think I just misspelled year. It should be publication year. So let's fix that. And now if we head over here, hey, what do you know? Pretty good. So types can definitely be useful when you're working with SQL. But it's not the full story.

So let's see what happens when you run a migration. So I realized that the publication year could actually be null if we don't know when it's published. So for example, who knows exactly when the Iliad and the Odyssey were published? So better just leave it as null. So let's run that. And we can confirm that.

2. Handling Database Schema Changes

Short description:

We encountered an issue when our data schema in the database changed, but the type we manually wrote didn't update accordingly. By making the publication year nullable, we resolved the error. TypeScript provided an error message when we attempted to subtract null, allowing us to fix the issue by adding a conditional.

Yep, we have our new books and publication year is null. So yeah, let's see what happens. Yep, null. And fun fact, in JavaScript 2022 minus null is in fact 22 because JavaScript. So the problem here is that we changed our data schema in the database, but this type that we wrote by hand didn't update to reflect that change. So really, publication year now is nullable. So it should be number or null. And once we make that change, then TypeScript gives us an error, right? So yeah, TypeScript is nice enough to say that you can't subtract null. And so I think here I have the fix here. We just add a conditional. Yeah, great. And let's see if that fixes things. Sure enough, it does. So once again, types can be very helpful, but there's also some potential problems here.

3. Using TypeScript and SQL with TypeORM

Short description:

I'm going to go over different approaches for using TypeScript and SQL together. We saw the naive approach of writing raw SQL and hand coding types, but it lacks a single source of truth. If the types and the database disagree, you don't know which one's right. The first choice is where you want the source of truth to be. If it's in TypeScript, you can use TypeORM, which defines tables through JavaScript classes. The server code uses the entity manager to query the database and catch errors. TypeORM can generate migrations based on changes in TypeScript.

So in this talk today, I'm going to go over different approaches for using TypeScript and SQL together, which I think is sort of a choose your own adventure approach. There's a lot of different ways to do it. By the way, if you like this talk, you can follow me on Twitter or check out my blog and my book.

So we saw sort of the naive approach, which is writing a raw SQL and hand coding types for the results. There are some good things about this. As we saw, we do get some type safety. And another nice thing is that it doesn't really introduce any layers of indirection. You really are just dealing with very immediately with the SQL and with the types. The problem though is that we don't have a single source of truth, right? If the types and the database disagree, which is what we saw when we made publication year nullable, then you don't know which one's right. And that's the fundamental problem with this approach.

So the first choice you really need to make is where you want the source of truth to be. Should the source of truth for types be in the database or should the source of truth for the types be in TypeScript? If you want the source of truth to be in TypeScript, then that basically means that you're using an ORM. So let's take a look at what this example looks like using TypeORM. So TypeORM is one of the standard ORMs for JavaScript. ORM is Object Relational Mapper. So with TypeORM, we define this data source which says how to connect to our database and we provide a list of entities and they should look familiar. They correspond to the tables in our previous example. And instead of defining the tables through SQL, we define them through JavaScript classes and we provide these decorators to tell TypeORM that this should become a table and that these should become columns. And also a little bit about what type of column they are. So in cases where the TypeScript type is ambiguous, we need to provide SQL type information and we can also provide information about null ability. And for foreign relations, we can provide information about the relationship.

So let's take a look at what the server code looks like. So instead of running a raw SQL query, we get this entity manager and we tell it to find the book class and TypeORM knows to turn that into a select query on the book table. And what's nice about this is that the result type of this is an array of books which is exactly what you would want and so we have enough type information here to catch the error. So we can change this to publication year, and publication year, and let's see if we can load this over here. Hey, there you go. So what do migrations look like in this world? So let's go through the same process of, say that this column can be nullable and we also need to add null to its type. You can see that we've already gotten an error in our typescript, which is good. One of the cool things about an ORM is that it can actually generate the migrations for you. And so here it's going to detect what we've changed in our typescript and it's going to tell us that it has generated a migration.

4. Migration Process and Source of Truth

Short description:

So let's take a look at the migration process and fixing errors. By including information about entity relationships, we can pull in additional data from the database. ORMs solve the problem of keeping types and the database in sync, generate migrations, and simplify query writing. However, they can be a leaky abstraction, requiring knowledge of SQL, TypeScript, and the ORM. Fine-tuning query performance can add overhead, and other users may have issues with the source of truth in TypeScript.

So let's take a look at that. So it's kind of what you would expect, alter table, alter column, drop null. The down migration reverts it. Pray that you never have to run the down migration. So yeah, let's try running this migration. So it says it should commit. Great. And now let's fix this error about a possible null object. So I've got fix here. Okay. So let's give that a second. And once this loads, should hopefully have a fix. Yeah.

Great. Okay. So since we've included information about the relationships between the entities, we can also go sort of to the next level, we can tell type ORM to pull in the created by relation. And now we can add another column and we can do book.createdby.name. So this should pull in the name of the author in addition to publication date. Pretty cool. So that's what it looks like if you put the source of truth in TypeScript.

So there's some good things about this. ORMs definitely solve the problem of keeping your types and your database in sync. It's pretty nice that they generate migrations for you and the simple queries really are pretty direct to write in ORMs. And ORMs, you'll find a lot of dislike for them online, but it's pretty undeniable that they're very widely used. So on the downside, they are the classic example of a leaky abstraction. So the theory with an ORM is that you can treat the database as an implementation detail and you can just work in TypeScript. But in practice, that doesn't really work. To use an ORM effectively, you need to know SQL, you need to know TypeScript, and you need to know how to use the ORM. And so doing things like fine tuning the performance of a query, you wind up working with your ORM to try to produce a really specific SQL query, which is just kind of adding overhead. And also, if you work in an environment where there's multiple users of your database, the other users may have problems with your being, you're putting the source of truth in TypeScript rather than the database itself.

5. Generating TypeScript Schema Files

Short description:

If you're not using an ORM, having a TypeScript version of your schema is useful. Tools like Schema TS, PyST Schema TS, and pg2ts can generate TypeScript schema files from your database. pg2ts connects to your Postgres database and outputs an auto-generated DB schema file with interfaces for all tables. By using this approach, you ensure that the TypeScript schema file and the database never get out of sync, as the database is the source of truth.

There's also just a lot more churn in the flavor of the month with ORMs than there is with databases themselves. Postgres and MySQL have been around for decades now and are still quite popular.

So, what if you're not going to use an ORM? Well, then it's sort of undeniably useful to have a TypeScript version of your schema. So, you can go the other way. You can go from the database schema to TypeScript. So, let's take a look at that. So, let's look at the tools to generate TypeScript schema files from your database.

So, kind of the granddaddy in this space is Schema TS, which got a lot of stars. And then no changes in over four years. So, it also got a lot of forks. So, then there's this PyST Schema TS, which is about two years out of date now. So, there's a lot of forks. And I have one, as well, called pg2ts. And so, that's the one I'll be showing everyone today.

So, the idea with pg2ts is that you run a command and so, pg2ts generate, it connects to your Postgres database and it outputs this DB schema file. So, let's take a look at that DB schema file. So, auto-generated and it has interfaces for all of our tables. So, the nice thing about this is you don't have to write this book type by hand. So, let's plug that in, just like we did before. Let's go import, and now we should get a type error. Yep, so, it should be publication year and this should also be publication year. There we go. And let's see if that fixes the issue. Sure enough, it does.

So, superficially, this might not seem that different than what we did before, when we wrote out the type by hand, but the beauty of this is that in practice, you would run PGTTS as part of your continuous integration testing. And so, you would make sure that this TypeScript schema file and the database never got out of sync with each other. So, the database is the source of truth and this DB schema is derived from it. So, let's try running the migration. So, now, if we look at this publication year, it's nullable. And let's bring up our DB schema again.

6. Schema Generator and Query Builder

Short description:

I'm going to rerun PGTTS generate to scan the database again. The schema generator produces entities that correspond to database types in TypeScript and keeps them in sync. It adds a build step and requires manual type annotations for queries. If you're not using an ORM, a schema generator is recommended.

Okay. So, I'm just going to rerun PGTTS generate. So, it's going to scan our database again and lo and behold, publication year is now nullable. And so, now we also get a type error, same as before. So, that's what a schema generator does. So, it does a really good job of producing entities that correspond to your database types in your typescript and keeping them in sync. The downside is it does add a build step and you do have to manually add the type annotations for your queries. Unless you add some other process which we will talk about later on. But, in general, if you are not using an ORM, you should use a schema generator.

7. Using Connects JS for Query Building

Short description:

Once you've decided whether to use a query builder or raw SQL, connects JS is a popular choice for JavaScript and TypeScript. It automatically infers types and helps catch errors. By defining tables and using the connects types table, you can ensure the correct types are pulled in. Migrations can be used to handle schema changes, and more complex queries, like joining tables, are also possible.

So, once you've done that, kind of your next question is whether you want to use a query builder or write raw SQL. So, let's look at the query builder option.

So, connects JS is probably the most popular query builder for JavaScript and TypeScript. So, let's take a look at what this example looks like using connects. So, to query the database, we use this connects object and we tell it we want to look at the book table and we want to select everything from it. And connects is smart enough to figure out that it has a book type and we already get some type errors, which is what we wanted.

So, how does this work? So, I'm assuming that you're running pg2ts or something like that to get this book interface to find in TypeScript. That's an important building block. Then there's also this connects types table, which you can use to tell Kinects about your schema. So, you define this tables interface and it has a list of all your tables. And it's able to, if you query from one of these tables, it's able to pull in the correct types. So, that's pretty neat.

So, we can go ahead and fix the error here. And so, over here. Great. So, let's save that. And reload. Great. The bug's fixed.

So, let's take a look at what a migration looks like in this world. So, I'm gonna go ahead and run my migration. And so, now, as you might remember, the publication year is nullable. So, now, I have to regenerate the DB schema. So, now, if I go ahead and look in DB schema, yep, publication year is nullable. And sure enough, we have a type error in index.ts, which is exactly what we want. And so, we can go ahead and plug in the bug fix, and if we go over here, great, it's fixed.

So, you can also do slightly more elaborate queries with connects. So, here's an example of joining the books table on the author. So, let's plug that in. So, we're querying the books table as before, but now, we're going to join on the users table, joining the book.createdBy column to the users.id column, and if you look at the inferred type, it's book and users, the intersection type, which is actually exactly right.

8. Using Query Builders and PGTyped

Short description:

Let's add the author and see if it works. Query Builders provide accurate types without explicit annotations, but they can be complex. PGTyped is a tool that converts SQL queries into TypeScript types, generating a types file. It runs the query and returns the type as any. By adding the query type to the tagged template, we get a nice type and can fix any errors. PGTyped does introspection on the live database schema, allowing us to run migrations and handle nullable fields.

So, let's go ahead and add the author. I think it comes out as name, and if we save, we should be able to load. Yep, so it worked, pretty cool.

Okay, so how does Query Builder stack up against some of the other solutions we've looked at? So, I think the nice thing here is that you definitely get accurate types, and you don't have to plug them in by hand. It's able to use the DB schema and your queries to get you accurate types without explicit annotations, which is great, but unfortunately, Query Builders are another classic example of a leaky abstraction. So, in order to use a Query Builder, especially for more complicated queries, you really need to know your TypeScript, you really need to know your SQL, and you really need to know your Query Builder. So, you know, if we look at the Connex docs, they claim their TypeScript support is best effort. I think they're underselling it a little bit. I think it's actually quite good. But if you look at some of these queries, it's not totally clear to me that the Query Builder syntax is any simpler or more complicated than the Postgres SQL syntax. And at that point, the thing that runs is SQL and so you should probably just be writing the SQL anyway.

So what if you're not going to use a Query Builder? Well, then we have another option, which is a tool to convert your SQL queries directly into TypeScript types. So there's a few tools like this and we'll look at PGTyped. PGTyped is a tool that reads SQL queries and generates TypeScript types for you. So it has some nice docs here. So let's take a look at how it can help us. So with PGTyped, you import this SQL tag and you add it to your SQL queries and then you pass in your database pool and any parameters to the query and it runs the query for you. And the type comes back as any. So yeah, what's the point of that? So the interesting thing here is that we can run PGTyped and it will generate a um types file for us so we can take a look at this. So this has the result type of the query and if we had parameters on the query it would include that too. And the idea is that you add this query type to the tagged template and we have to import it. And there you go and now we have a nice type and it shows the error so you know we can fix that. Fix it and there you go. So what's interesting here is I didn't run, I didn't generate a db schema it's just doing introspection on this query against our live database schema. So we can try running a migration. So let's go ahead and do that. So we can just double check that our book, yep, publication year is nullable and so we don't have an error yet but if we go back and we rerun pgTyped now it knows that publication year is nullable and so we need to need to plug in a more careful expression there. So let's give that a shot. Yep, there we go. And so we can also try a more complicated query here.

9. Using CreedlyTyped and PGTyped

Short description:

Here I manually join the author to pull out the author name from the other table. Running pgTyped again with the updated query provides the correct type. Although raw SQL with types is great, there are downsides like imperfect type inference and the need for a build step. The query results can be a bit duck typey, resulting in different types for the same query. The sweet spot lies between SQL to TS conversion and query builders. CreedlyTyped generates simple queries, while PGTyped handles more complex ones. Let's explore CreedlyTyped and PGTyped by creating a typedDB and using the tables object from our db schema.

So here I'm manually joining the author so that I can get that. So I can pull out the author name from the other table, from the user's table. So now that I've changed my query, I need to run pgTyped again. And if I look at this query, now it has authorName and it has the right type. And so I can go in here and I can add my authorName. And let me look. Server will restart, and there you go, we have the authornames.

Okay, so how does this stack up? So the great thing is that you just get to write raw SQL and you get types back for your queries. There are a few downsides though. Not all types come back perfectly. So there are some issues around detecting when a column in the results of a query can be null. As with some of the other approaches, it adds a build step. The queries are a little bit, the query results are a little bit duck typey. So if you run the exact same query in two different places, you'll get two distinct types. They'll be compatible. And so with structural typing, that's fine. But I think it's usually nicer to work with the DB schema. And it just feels like a lot of fuss sometimes for really simple queries that you have to write out this SQL tagged statement and then add a type that you generate to them. So I think that between SQL to TS conversion and the query builders, there is kind of a sweet spot.

So I want to show you what that looks like. There's a few approaches. So Zapatos is one example. But I'm going to show you PGTyped and CreedlyTyped, which is a tool that I built. So the idea with CreedlyTyped is that it generates all the simple queries for you. But if your query stops being simple, if it gets more complicated, then you should just run something like PGTyped. It makes no attempt to model those queries. So let's take a look. So we're going to create a typedDB. And we're going to pass it a tables object from our db schema, which is generated as before. And then instead of generating the GetBooks query this way, we're going to do getbooks equals typedDB.table.

10. Using TypeScript and SQL: Benefits and Trade-offs

Short description:

This section discusses the benefits of using TypeScript and SQL together. It highlights a middle ground approach where rawSQL is used for complex queries, providing accurate types. For simpler queries, accurate types can be obtained based on the DB schema. However, there are downsides, such as the need for a build step and the temptation to rely too heavily on simple generated queries. The talk concludes by emphasizing the importance of being aware of the trade-offs involved in working with SQL and TypeScript.

It knows about our tables. And we're just going to generate a select. And we just call this with our db pool. And great. So it knows about the types, the types reference our db schema. We don't have this because we haven't done a join.

And so if we go over here, yep, it works. And you can add some slightly more complicated things like if you want to do a join. It actually pulls it in as a, what is it? Created by. Yeah, created by. It actually pulls it in as a sub-object. So it's author.name. And yep, there we go.

Okay, so how does this stack up? I think pretty well. I think it's a good middle ground. For complicated queries, you just get to write rawSQL and you get accurate types. But for the simpler queries, which in my main application are something like 70% of the queries. You don't have to go through much process and you get accurate types based on your DB schema. There are some downsides. It does still add a build step. And I think there's sometimes the temptation to use the simple generated queries more often than you should. So instead of running 10 simple queries, you should probably move some of that logic into Postgres and just run one query.

So that's the talk. There's a lot of choices to make when you're working with SQL and TypeScript and none of the options are perfect. But I think the important thing is just to be conscious of which approach you're taking and understand the trade-offs. Hope you enjoyed the talk. Check out my book and my blog and follow me on Twitter.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Vue.js London 2023Vue.js London 2023
30 min
Stop Writing Your Routes
The more you keep working on an application, the more complicated its routing becomes, and the easier it is to make a mistake. ""Was the route named users or was it user?"", ""Did it have an id param or was it userId?"". If only TypeScript could tell you what are the possible names and params. If only you didn't have to write a single route anymore and let a plugin do it for you. In this talk we will go through what it took to bring automatically typed routes for Vue Router.
React Day Berlin 2023React Day Berlin 2023
21 min
React's Most Useful Types
We don't think of React as shipping its own types. But React's types are a core part of the framework - overseen by the React team, and co-ordinated with React's major releases.In this live coding talk, we'll look at all the types you've been missing out on. How do you get the props type from a component? How do you know what ref a component takes? Should you use React.FC? And what's the deal with JSX.Element?You'll walk away with a bunch of exciting ideas to take to your React applications, and hopefully a new appreciation for the wonders of React and TypeScript working together.
TypeScript Congress 2023TypeScript Congress 2023
31 min
Making Magic: Building a TypeScript-First Framework
I'll dive into the internals of Nuxt to describe how we've built a TypeScript-first framework that is deeply integrated with the user's IDE and type checking setup to offer end-to-end full-stack type safety, hints for layouts, middleware and more, typed runtime configuration options and even typed routing. Plus, I'll highlight what I'm most excited about doing in the days to come and how TypeScript makes that possible not just for us but for any library author.
React Advanced Conference 2021React Advanced Conference 2021
6 min
Full-stack & typesafe React (+Native) apps with tRPC.io
Why are we devs so obsessed with decoupling things that are coupled nature? tRPC is a library that replaces the need for GraphQL or REST for internal APIs. When using it, you simply write backend functions whose input and output shapes are instantly inferred in your frontend without any code generation; making writing API schemas a thing of the past. It's lightweight, not tied to React, HTTP-cacheable, and can be incrementally adopted. In this talk, I'll give a glimpse of the DX you can get from tRPC and how (and why) to get started.
TypeScript Congress 2022TypeScript Congress 2022
10 min
How to properly handle URL slug changes in Next.js
If you're using a headless CMS for storing content, you also work with URL slugs, the last parts of any URL. The problem is, content editors are able to freely change the slugs which can cause 404 errors, lost page ranks, broken links, and in the end confused visitors on your site. In this talk, I will present a solution for keeping a history of URL slugs in the CMS and explain how to implement a proper redirect mechanism (using TypeScript!) for dynamically generated pages on a Next.js website.

Add to the talk notes: https://github.com/ondrabus/kontent-boilerplate-next-js-ts-congress-2022 

Workshops on related topic

React Advanced Conference 2021React Advanced Conference 2021
174 min
React, TypeScript, and TDD
Featured WorkshopFree
ReactJS is wildly popular and thus wildly supported. TypeScript is increasingly popular, and thus increasingly supported.

The two together? Not as much. Given that they both change quickly, it's hard to find accurate learning materials.

React+TypeScript, with JetBrains IDEs? That three-part combination is the topic of this series. We'll show a little about a lot. Meaning, the key steps to getting productive, in the IDE, for React projects using TypeScript. Along the way we'll show test-driven development and emphasize tips-and-tricks in the IDE.
React Advanced Conference 2022React Advanced Conference 2022
148 min
Best Practices and Advanced TypeScript Tips for React Developers
Featured Workshop
Are you a React developer trying to get the most benefits from TypeScript? Then this is the workshop for you.In this interactive workshop, we will start at the basics and examine the pros and cons of different ways you can declare React components using TypeScript. After that we will move to more advanced concepts where we will go beyond the strict setting of TypeScript. You will learn when to use types like any, unknown and never. We will explore the use of type predicates, guards and exhaustive checking. You will learn about the built-in mapped types as well as how to create your own new type map utilities. And we will start programming in the TypeScript type system using conditional types and type inferring.
Remix Conf Europe 2022Remix Conf Europe 2022
195 min
How to Solve Real-World Problems with Remix
Featured Workshop
- Errors? How to render and log your server and client errorsa - When to return errors vs throwb - Setup logging service like Sentry, LogRocket, and Bugsnag- Forms? How to validate and handle multi-page formsa - Use zod to validate form data in your actionb - Step through multi-page forms without losing data- Stuck? How to patch bugs or missing features in Remix so you can move ona - Use patch-package to quickly fix your Remix installb - Show tool for managing multiple patches and cherry-pick open PRs- Users? How to handle multi-tenant apps with Prismaa - Determine tenant by host or by userb - Multiple database or single database/multiple schemasc - Ensures tenant data always separate from others
GraphQL Galaxy 2020GraphQL Galaxy 2020
106 min
Relational Database Modeling for GraphQL
WorkshopFree
In this workshop we'll dig deeper into data modeling. We'll start with a discussion about various database types and how they map to GraphQL. Once that groundwork is laid out, the focus will shift to specific types of databases and how to build data models that work best for GraphQL within various scenarios.
Table of contentsPart 1 - Hour 1      a. Relational Database Data Modeling      b. Comparing Relational and NoSQL Databases      c. GraphQL with the Database in mindPart 2 - Hour 2      a. Designing Relational Data Models      b. Relationship, Building MultijoinsTables      c. GraphQL & Relational Data Modeling Query Complexities
Prerequisites      a. Data modeling tool. The trainer will be using dbdiagram      b. Postgres, albeit no need to install this locally, as I'll be using a Postgres Dicker image, from Docker Hub for all examples      c. Hasura
JSNation Live 2021JSNation Live 2021
156 min
Building a Hyper Fast Web Server with Deno
WorkshopFree
Deno 1.9 introduced a new web server API that takes advantage of Hyper, a fast and correct HTTP implementation for Rust. Using this API instead of the std/http implementation increases performance and provides support for HTTP2. In this workshop, learn how to create a web server utilizing Hyper under the hood and boost the performance for your web apps.
TypeScript Congress 2023TypeScript Congress 2023
131 min
Practice TypeScript Techniques Building React Server Components App
Workshop
In this hands-on workshop, Maurice will personally guide you through a series of exercises designed to empower you with a deep understanding of React Server Components and the power of TypeScript. Discover how to optimize your applications, improve performance, and unlock new possibilities.
 
During the workshop, you will:
- Maximize code maintainability and scalability with advanced TypeScript practices
- Unleash the performance benefits of React Server Components, surpassing traditional approaches
- Turbocharge your TypeScript with the power of Mapped Types
- Make your TypeScript types more secure with Opaque Types
- Explore the power of Template Literal Types when using Mapped Types
 
Maurice will virtually be by your side, offering comprehensive guidance and answering your questions as you navigate each exercise. By the end of the workshop, you'll have mastered React Server Components, armed with a newfound arsenal of TypeScript knowledge to supercharge your React applications.
 
Don't miss this opportunity to elevate your React expertise to new heights. Join our workshop and unlock the potential of React Server Components with TypeScript. Your apps will thank you.