protobuf-rules-gen VS postgraphile

A long time ago, I was the PM on Firestore security rules, which was intended to solve both of those issues.

https://github.com/FirebaseExtended/protobuf-rules-gen was the closest we got: declaring types as protobufs (because Google, of course) and then generating both security rules to guarantee validity as well as client types that would match. I wanted to add proto annotations to do additional validity (e.g. add a regex to validate the phone number string was correct, do length checks on strings, etc.).

The short answer is that backend rules engines, either in their own DSL or bolted on to e.g. SQL, are pretty tough to get right, and have a super steep learning curve. IMO, AWS API Gateway with Lambda Authorizers get this most correct.

I was about to say “but this one is!” and realized I had confused PostgREST with PostGraphile. If you’re interested in GraphQL, you can check out PostGraphile here: https://github.com/graphile/postgraphile

If you point is to abstract all the CRUD/GraphQL application, Go isn’t needed. You can go with PostgREST or Postgraphile.

I've personally found Postgraphile to be fantastic. Nicer to use than Hasura and fully OSS: https://github.com/graphile/postgraphile/

Hi all, this sounds very cool. How does pg_graphql compare to Postgraphile? https://github.com/graphile/postgraphile (besides I guess running in the DB with PLpgSQL instead of as a NodeJS server)

Did you think about integrating Postgraphile with the Supabase ecosystem or have specific limitations with it?

Thanks!

If you’re open to learning Postgres, I’d recommend postgraphile (https://github.com/graphile/postgraphile). Been using it for the past 2.5 years and only have good things to say.

Both Postgraphile and Hasura generate SQL queries according to GraphQL. Anyone tried to implement a such GQL engine using Rust? What libs could come in handly when implementing a such thing?

I do not think graphql is a over engineered either, things like Postgraphile, Hasura will save lot of time when it comes to back-ends, even speed up the front-end since not having to wait for back-end devs to setup new API endpoints.

Give that this project looks dead, you should look into Hasura, or postgraphile.

This is cool but sadly looks abandoned.

Here's an active project that does something similar (introspects your postgres schema and runs a graphql API on top): https://github.com/graphile/postgraphile

Prisma is also interesting (but pulls more logic out of the DB).

My question with this type of logic-in-the-DB framework is how people are managing schema migrations and what infra they're running on as it's clearly a little less charted than, for instance, deploying a rails app (what I know). I really like the DRYness of writing the schema in one place and having that flow automatically into strongly typed models, API, etc with correct auth logix. This always seems like too much boilerplate with ActiveRecord and controllers.