pgtyped VS kysely

There is an implementation of SQL that operates on a table shaped type, entirely at type level. For your amusement: https://github.com/codemix/ts-sql

There are a bunch of more practical takes that codegen types from your database and generate types for your queries, eg: https://github.com/adelsz/pgtyped

To me the second approach seems much more pragmatic because you don’t need to run a SQL parser in a fairly potato interpreter on every build

ORMs suck, but raw SQL embedded in your code sucks too.

This might be good time to plug my TypeScript non-ORM: https://jawj.github.io/zapatos/.

I should say I also like what I've seen of https://kysely.dev/ and https://pgtyped.dev/.

Thank you for suggestions they helped me finding what I was looking for. I will either pick kysely or https://pgtyped.dev/, but first I will do some tests. Thanks!

Cool. How does this compare to SafeQL, PgTyped, and Postgres language server ?

I would instead rely on code generation like https://github.com/adelsz/pgtyped, because the embedded type-safe SQL will never fully cover all the features of vanilla SQL, for example Common Table Expression (CTE), window functions etc.

There's pgtyped, which I believe does almost the same as sqlc

https://github.com/adelsz/pgtyped

For Postgres there is https://github.com/adelsz/pgtyped, sounds pretty much like what you describe?

Avoiding the cost of learning EDSL that many Haskell DB libraries provide, I found out that only postgresql-typed and postgresql-simple allow to write only raw SQL queries easily. As I extensively use pgtyped for production Node.js application, I am thinking about using postgresql-typed. While I could find many resources for postgresql-simple, the same cannot be said try for postgresql-typed.

I would highly recommend trying out pgTyped if you want typesafe queries with postgres. It's fantastic!

Hello HN! I was recently introduced to Kysely (https://github.com/kysely-org/kysely), a type-safe Typescript SQL query builder, and instantly fell in love! I got inspired and wanted to make something similar for AWS DynamoDB.

Thus, I developed Tsynamo! Instead of calling it type-safe, I decided to go with type-friendly, because the library is still in an early stage, and is not 100% type-safe.

Under the hood, Tsynamo compiles the built queries into AWS SDK v3 commands. I feel that Tsynamo simplifies the AWS SDK API quite a lot since the developer doesn't have to mess around with condition/filter expressions or attribute names/values themselves, and as a bonus gets autocompletion for building the queries!

There's also a playground to test it out in your browser: https://try.tsynamo.dev. It might not have the most up-to-date API of the library in use yet, but you can get the library's main idea from there.

Since the project is still in its early stages, it doesn't yet have 100% support for all DynamoDB features, like querying indexes. The next steps will be increasing the support coverage and perhaps adding automatic type generation as inspired by kysely-codegen (https://github.com/RobinBlomberg/kysely-codegen).

Would love to get some feedback, thanks in advance!

How does this compare with my current favorite lite sqlite wrapper kysely? https://kysely.dev/

ORMs suck, but raw SQL embedded in your code sucks too.

This might be good time to plug my TypeScript non-ORM: https://jawj.github.io/zapatos/.

I should say I also like what I've seen of https://kysely.dev/ and https://pgtyped.dev/.

As we can see using Kysely with Nextjs is very simple, and it allows us to create queries in a simple way, create tables, create migrations, transactions, etc.

I've switched to kysely (https://kysely.dev) to just build SQL instead and it's nice to have full SQL access but still be type safe to my schema. Enjoying it so far.

Kysely looks like the thing most people would want. It's not a full ORM though - just a well-typed query builder.

https://kysely.dev/

Kysely