Recommended way to implement non-entity endpoints (e.g. authentication)

[c3n21]

Hi 👋

What’s the recommended way to implement endpoints that don’t map neatly to an Ent entity, such as an authentication flow (e.g. POST /login returning a JWT)?

For CRUD endpoints entrest is perfect, but in this case I’d need to define custom request/response DTOs and business logic.

My current thought is to use something like Huma to define those endpoints and then merge its generated OpenAPI spec with the one from entrest (which seems feasible based on the Config options).

Is there a more idiomatic way to handle these kinds of endpoints directly within entrest, or is relying on an external library the recommended approach?

Thanks for your work on this project! 🙏

[lrstanley]

For most projects I've made using entrest, there are typically not many endpoints which fall outside of CRUD, so I explicitly document those manually in a base-openapi.json file (example), which then gets merged in like normal. I haven't personally used Huma much, so I can't attest to what it might export in its openapi spec that might conflict when merged with the entrest one, but if you want to try it out and let me know, would definitely be curious.

[c3n21]

So I took some time to investigate my use case and it turned out to be quite decent for my taste

package main

import (
	"entgo.io/ent/entc"
	"entgo.io/ent/entc/gen"
	"github.com/go-chi/chi/v5"
	"github.com/lrstanley/entrest"
	"log"
	"os"
)

func main() {
        // register your routes with Huma
	api := routes.Register(chi.NewRouter())
        // by default Huma creates an OpenApi 3.1 Spec, so we need to downgrade it to make it compatible with entrest, otherwise it will panic
	downgradedApiSpec, err := api.OpenAPI().Downgrade()
	if err != nil {
		log.Fatalf("failed to downgrade OpenAPI spec: %v", err)
	}

	// Write OpenAPI spec to file
	openapiFile, err := os.Create("test-openapi.json")
	if err != nil {
		log.Fatalf("failed to create OpenAPI file: %v", err)
	}
	defer openapiFile.Close()

	_, err = openapiFile.Write(downgradedApiSpec)
	if err != nil {
		log.Fatalf("failed to write OpenAPI spec: %v", err)
	}
	log.Println("OpenAPI spec written to openapi.json")

	finalOpenapiFile, err := os.Create("openapi.json")
	if err != nil {
		log.Fatalf("failed to create OpenAPI file: %v", err)
	}

	defer finalOpenapiFile.Close()

	ex, err := entrest.NewExtension(&entrest.Config{
		Writer:       finalOpenapiFile,
		Handler:      entrest.HandlerStdlib,
		WithTesting:  true,
		StrictMutate: true,
		SpecFromPath: "./test-openapi.json",
	})
	if err != nil {
		log.Fatalf("creating entrest extension: %v", err)
	}

	err = entc.Generate(
		"./internal/database/schema/",
		&gen.Config{
			Target:   "./pkg/ent",
			Schema:   "<your module>/internal/database/schema",
			Package:  "<your module>/pkg/ent",
			Features: []gen.Feature{gen.FeatureVersionedMigration},
		},
		entc.Extensions(ex),
	)
	if err != nil {
		log.Fatalf("failed to run ent codegen: %v", err)
	}
}

This way when running go generate -x ./... it will produce an OAS with Huma's routes inside.

The bad thing about go generate -x ./... is that it will create the openapi.json in generate.go's directory.

To circumvent this I had to make this script as a normal main entrypoint so that I could just run

go run <the command>.go