DEV Community

I made Express faster than Fastify (100x faster JSON, also NestJS)

Jeongho Nam on April 03, 2023

Outline Hello, I am developer of typia, and studying fastify in nowadays. During the study, I could understand why fastify is faster t...

Read full post

Carlos Fuentes • Apr 8 '23

Nice work with typia, the job done has been amazing :)
Would you be willing to create a Fastify plugin for typia?
The results can be amazing! Happy to help you with it.

I’m part of Fastify team btw, in case you would like to share some thoughts or doubts about Fastify :)

Jeongho Nam • Apr 8 '23 • Edited

Got it, I'll try at next Sunday (not tomorrow).

Anyway, where the plugin would be placed in? Just in my github account? Or as a fastify repo?

Carlos Fuentes • Apr 9 '23

Sure thing!

Yeah, made everything within a repo of your authorship and once done, we can incorporate it at the list of community plugins :)
Feel free to ping me out if you want a second pair eyes!

Jeongho Nam • Apr 10 '23 • Edited

What is your github accout name?

I will write an issue on fastify repo tagging you, and need to debate about below:

import fastify from "fastify";
import typia from "typia";

const plugin = fastify().addSomePlugin();
plugin.post("/some-path", {
    schema: {
        body: typia.application<[MyRequestDto]>(),
        response: typia.application<[MyResponseDto]>(),
    },
});

At first, fastify provides plugin interfaces only through the JSON schema defition. As typia can generate JSON schema, it is possible to utilizing current plugin interface of fastify like above.

However, typia is a transformer library generating optimal code in the compilation time, utilizing pure TypeScript type. To maximize strength of typia and make users to be much convenient, I think below code would be should be possible.

import fastify from "fastify";
import typiaProvider from "@fastify/type-provider-typia";

const server = fastify();
const wrapper = typiaProvider.install(server);

wrapper.post<{
    query: SomeQueryDto;
    body: SomeRequestBodyDto;
    response: SomeResponseBodyDto;
}>("/some-path", (req, rep) => {
    req.query // -> type checked SomeQueryDto
    req.body // -> type checked SomeRequestBodyDto
    rep.send({ ... }); // -> faster stringify with type assertion (SomeResponseBodyDto)
    req.headers; // -> no type checking because not specified
});

The typiaProvider.post<T>() function will generate both type assertion (+ JSON serialization when response) and JSON schema definition for Swagger at the same time. Of course, above code requires modifications from plugin APIs of fastify. Therefore, I need to debate about it detaily as an issue.

p.s) I'm developing protobuf features, therefore when fastify accepts typia as a plugin, you can easily support protobuf typed routers very easily.

github.com/samchon/typia/wiki/Prot...

Carlos Fuentes • Apr 13 '23

Hey! Please reach out in GH as metcoder95!

Wow, that sounds interesting. What modifications are you looking for exactly?
In theory, the fastify.register should provide you access to the encapsulated context where the plugin is being added, and therefore decorate any possible route being register through fastify.<post | get | ...>.
But please, open an issue at fastify repo and we can help you sorting things out :)

Jeongho Nam • Apr 17 '23

Sorry for late.

I've been making guide documents of typia and nestia in nowaydays, and such documentation works had consumed much more time than what I'd expected. Therefore, could not develop the plugin in this weekend.

typia.io

Anyway, stuyding fastify, I understood that there're enormous things to develop to adjust transform library typia in fastify. There are already a lot of elements to be developed, so I'm going to make a fastify plugin like nestia, which can build SDK library.

Please wait for one to two months, then I'll take interesting plugin.

Carlos Fuentes • Apr 17 '23

Please, do not rush it. Happy to wait for the results, please let me know if you need any support or similar. Happy to support you with anything!

Jeongho Nam • May 9 '23 • Edited

Currently, succeeded to support fastify through nestia in NestJS.

nestia.io/docs/
github.com/samchon/nestia/tree/mas...

Now, only "Swagger to NestJS" converter project is left for me. It may requires 2~3 weeks, and I'll start the pure fastify plugin project after that. Also, I'll run benchmark fastify + typia, too. Thanks for waiting.

Carlos Fuentes • May 11 '23

Hey! That's amazing! Don't worry about the plugin, take your time :)

Melroy van den Berg • Mar 13

So at this point I'm wondering if the benefits of nestia for Fastify can't be embedded upstream (as in making it fast by default when just using fastify)?

Sergey Todyshev • Apr 16 '23

It would be nice if JSON.stringify function will be optimized on runtime level. And apparently this is doable.

Jeongho Nam • Apr 16 '23

Wow, you're planning to send a PR?

Sergey Todyshev • Apr 16 '23

It is huge effort. I can explain the idea some day :). It seems V8 devteam is not super interested in this now since they are busy enough with other stuff.

Jeongho Nam • Apr 17 '23

Is it really possible to enhance native JSON.stringify() function?

Sergey Todyshev • Apr 17 '23 • Edited

Sure, let me give you a "strange" clue. You can take a look on history of how JSON serialization was improved in .NET world. Similar way native JS objects can have some internal methods for reading and writing from reader/writer objects (that hides content streaming under the hood). After that JSON.stringify and JSON.parse are just tiny wrapper under internal JSON serialization pipeline. But again this work should be done in JS engine (v8 or deno). Hope this helps 😄

Saleumsack • Apr 10 '23

Great article!

carrot-farm • Apr 4 '23

잘보고 있습니다.!

Jeongho Nam • Apr 4 '23

엌... 태양토끼님 반갑읍니다

Jeongho Nam • Apr 28 '23

As I've promised, wrote an article introducing how to use typia in NestJS.

dev.to/samchon/nestia-boost-up-you...

eram • Jun 17 '23 • Edited

Hi. One thing I don't get in your benchmarks: in your Fastify code you are running with a schema validator, but in your Express code you are only replacing the default JSON parsing. How is that even comparable?

Jeongho Nam • Jun 17 '23 • Edited

Benchmark program of current article does not have request body data. It has only response body data. Therefore, if your "schema validator" means a response data validation before JSON serialization, I wanna say that typia.isStringify() and typia.assertStringify() are doing it.

Otherwise, you're meaning request DTO validation, and what you want to say is "this benchmark program does not handle request DTO validation", I want to introduce below article. Although below article's benchmark program is not measuring the pure request DTO validation logic of fastify, I think it may helpful for you.

dev.to/samchon/nestia-make-nestjs-...

By the way, reading your comment, I think that I should enhance above linked article's benchmark program. I'll add pure-fastify component in the benchmark pogram, so that resolve your question clearly. By the enhancement, five componets would be compared:

NestJS + express
NestJS + fastify
NestJS + nestia + express
NestJS + nestia + fastify
pure fastify

Jeongho Nam • Jun 18 '23

github.com/samchon/nestia/tree/mas...

Benchmark result

Guri do Código • Jul 15 '23

And how is the development of the plugin for fastify going?

Jeongho Nam • Jul 18 '23

Plan to start at 2023-09. Sorry for delaying

github.com/samchon/schedules/blob/...

Guri do Código • Jul 19 '23 • Edited

Thanks, and do you intend to support SWC?

Jeongho Nam • Jul 20 '23

Not possible to support SWC, because it removes every types like Babel

Olyno • Apr 5 '23

Amazing work! I have one question: why did you create external dependencies instead of creating a pull request to the different projects mentioned (NestJS and Express)?

Jeongho Nam • Apr 6 '23

About NestJS

NestJS has used class-validator, class-transformer and @nestjs/swagger for many years.

Unless those libraries have lots problems especially in productivity and performance, too much time have passed and strong dependencies had been occured.

Therefore, I think nestia can't be standard feature of NestJS, because of ordinary (legacy) projects.

About Express

express does not restrict any special validation and serialization logic.

Therefore, whatever user choose, it is up to the user.

Olyno • Apr 7 '23

Sorry if I wasn't clear. What I meant was that even if NestJS is buried in old code, why not make a big pull request including the Nestia parts? It's a lot of work, but would improvde the DX of a lot of developers

Jeongho Nam • Apr 8 '23 • Edited

Had tried very long time ago ToT.

I got answered that it would better to make a 3rd party library, and it is the nestia.

github.com/samchon/nestia

KhanhND • Apr 6 '23

I think you can 1.000.000x faster with you using protobuf

Jeongho Nam • Apr 6 '23 • Edited

You must be a genius who can see the future.

Next version of typia will support protobuf features like below.

export function message<T>(): string; // Protocol Buffer message
export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder
export function assertEncode<T>(input: T): Uint8Array; // safe encoder

For example, I'll introduce a directory storing protobuf schema files generated by the next version of typia.message<T>() function:

github.com/samchon/typia/tree/feat...

p.s) Protobuf is not such faster as you think. I'll come back with new benchmark after the next version.

KhanhND • Apr 6 '23

I suggest you can use option on proto file for gen code. "option optimize_for = CODE_SIZE;"

Jeongho Nam • Apr 6 '23

Yes, current typia.message<T>() function writes too much long name. I need to make it shorter.

tamusjroyce • Apr 4 '23

How do these compare on deno instead of node?

Jeongho Nam • Apr 4 '23 • Edited

Because I do not use deno, I do not know how it would be.

Also, deno does not support standard TypeScript compiler, it is hard (possible but not easy to configure) to test in the deno environment.

Pedro Pimienta M. • Apr 5 '23

Deno dont support Typescript?

Jeongho Nam • Apr 6 '23

Dono does not support TypeScript compiler API