pg-to-ts VS kanel

I have so far found: - kanel https://github.com/kristiandupont/kanel - and pg-to-ts https://github.com/danvk/pg-to-ts

There are many forks of schemats out there that add various features. Here’s mine: https://github.com/danvk/pg-to-ts

It copies Postgres comments over to JSDoc/TSDoc comments, emits some data about foreign key relationships and supports TS types for json/jsonb columns via @type comments. Feel free to copy any of those feature if you think they’re good ideas :)

I'll just quickly plug Kanel (https://github.com/kristiandupont/kanel) which I use to generate Typescript types from a Postgres database. I agree with the author to think migrations-first, though I prefer to write them in SQL to ensure I can utilize all the powerful features that Postgres has to offer.

With it, I only get types for the tables and views etc., so any join will be untyped if done client-side. This is still a big win in my opinion, and I much prefer it to normal ORM's.

I made a tool that generates Typescript types out of a live Postgres database. I've had a request for Kysely support (https://github.com/kristiandupont/kanel/issues/273), but I more or less forgot about it. I would love to hear if that would be helpful.

There are tools that will generate typescript types from a database. I made one for Postgres. But it also works at "compile time", i.e. it doesn't look at a live database. I am not sure if that is what you are asking?

That's interesting. I use Knex a lot and I agree that it's very easy to end up just writing what is basically an ORM on the spot. I haven't quite decided if I think it's a real problem though.

I created and use Kanel (https://github.com/kristiandupont/kanel) to generate Typescript types from my Postgres database which helps a lot. Knex itself has some attempt at type safety but it gets confused quite quickly, so that's where it's tempting to override things.

Interesting. Someone asked me if I supported it in Kanel. At the time it was hard to extend Kanel and then I just forgot but perhaps I should take another look at it. I am not exactly overwhelmed with the types that Knex offers even though it does make an honest attempt.

I have so far found: - kanel https://github.com/kristiandupont/kanel - and pg-to-ts https://github.com/danvk/pg-to-ts

I’ve written before about the way I let the Postgres schema act as the source of truth by generating types with Kanel (assisted by Schemalint). In addition to this, I mention a homemade framework that sort of resembles a server-side Redux. This gives me typesafe database queries that are automatically reflected all the way to the frontend. I am frequently asked to make it open source and that is still the plan. I just need to untangle it from the Submotion source code which just never seems to be high enough priority. I promise I will get around to it :-)

We are using Kanel[1] for this right now — is there an advantage to using this instead?

[1]: https://github.com/kristiandupont/kanel

Sure. I've been using this lib https://github.com/kristiandupont/kanel to get types from my pg database and it makes it a breeze to use raw sql + ts.