pgtyped

What do you use for runtime? I've used pgtyped in the past and it does a good job at taking raw SQL and generating the return types from runtime: https://github.com/adelsz/pgtyped

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 your typechecker interpreter on every build

Glad you are liking pgTyped. Transactions are supported as pgTyped is just a thin wrapper around node-postgres: https://github.com/adelsz/pgtyped/discussions/448

I wonder why pgtyped [1] was skipped [1] https://github.com/adelsz/pgtyped

How does this compare with pgTyped[1]? [1] https://github.com/adelsz/pgtyped

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?

You might also want to consider pgTyped (https://github.com/adelsz/pgtyped). It's supposed to make SQL and TS work together. I haven't gotten around to using it yet but I hear good things.

Update: This list can be brought down to 3, if Java is substituted with TypeScript(/WASM-target for the future?), with a type-safe SQL codegen library such as: https://github.com/adelsz/pgtyped Update update: Or reluctantly with Python instead, with a similar library such as PugSQL.

PgTyped is another high quality alternative: https://github.com/adelsz/pgtyped.

We're using a very similar lib for typescript: https://github.com/adelsz/pgtyped Would love to hear if any others of comparable or better quality exist for js/ts

I'm slowly moving in that direction. Recently started using (pg-typed)[1] in our projects and its amazing, as it gives you the types from the database into typescript, and not the "general types from tables", but the exact specific types for each individual query. Coupled with the same thing going the other direction where we get types from our api contracts (OpenAPI/Swagger) with (laminar)[2] means that our app is very close to the "if it compiles it will run" territory. ORMs do give you a lot of convenience though. Things like "run this additional query every time you request this entity" thing for example like for logical delete, which is unpleasant to replicate in your database. But Postgres is so freaking powerful its more of the fact that we don't know how to do it properly than it not offering a good solution. [1] https://github.co

If I'm understanding you, you might like pgtyped: https://github.com/adelsz/pgtyped (If you mean infer solely off of queries, I don't think that's possible unless you jam a bunch of type casts into the field selection part of the query.)

> A huge benefit of TypeORM is that you get full static type support in all of your queries, including in the returned results. When did I say I wanted to give up static typing? You can have both[1][2]. I would never give up static typing and would not have used Node if TypeScript/Flow were unavailable. > TypeORM in particular is well designed and quite awesome. I've used TypeORM extensively in production on multiple projects for years, including with a fairly large team. It has silent failures, and its API was unstable/unclear for a long time. It's been a very messy project for most of its lifetime. They couldn't even decide on an API for lazy-loading of relations, and there was some hidden API that was semi-supported and not type-checked. Partly because it's built on Node, it's very difficult to use a debugger to see the relevant frames