camzalewski/personal-site
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

Use custom ent codegen plugin for admin.

Browse source
This commit is contained in:
mikestefanello 2025-04-08 14:02:45 -04:00
parent 9139942794
commit ce9b58bf4a
33 changed files with 750 additions and 13452 deletions
Download patch file Download diff file Expand all files Collapse all files

70
ent/admin/extension.go Normal file
View file

@ -0,0 +1,70 @@
package admin
import (
"embed"
"strings"
"text/template"
"unicode"
"entgo.io/ent/entc"
"entgo.io/ent/entc/gen"
)
var (
//go:embed templates
templateDir embed.FS
)
type Extension struct {
entc.DefaultExtension
}
func (*Extension) Templates() []*gen.Template {
return []*gen.Template{
gen.MustParse(
gen.NewTemplate("admin").
Funcs(template.FuncMap{
"fieldName": fieldName,
"fieldLabel": fieldLabel,
}).
ParseFS(templateDir, "templates/*tmpl"),
),
}
}
func fieldName(name string) string {
if len(name) == 0 {
return name
}
parts := strings.Split(name, "_")
for i := 0; i < len(parts); i++ {
parts[i] = upperFirst(parts[i])
}
return strings.Join(parts, "")
}
func fieldLabel(name string) string {
if len(name) == 0 {
return name
}
out := strings.ReplaceAll(name, "_", " ")
return upperFirst(out)
}
func upperFirst(s string) string {
if len(s) == 0 {
return s
}
out := []rune(s)
out[0] = unicode.ToUpper(out[0])
return string(out)
}
/*
TODO:
1) How to handle fields like password that need to be transformed or omitted, etc?
2) Should we use the HTML datetime format and string fields rather than time.Time?
*/

262
ent/admin/handler.go Normal file
View file

@ -0,0 +1,262 @@
// Code generated by ent, DO NOT EDIT.
package admin
import (
"fmt"
"strconv"
"entgo.io/ent/dialect/sql"
"github.com/labstack/echo/v4"
"github.com/mikestefanello/pagoda/ent"
"github.com/mikestefanello/pagoda/ent/passwordtoken"
"github.com/mikestefanello/pagoda/ent/user"
)
type Handler struct {
client *ent.Client
itemsPerPage int
}
func NewHandler(client *ent.Client, itemsPerPage int) *Handler {
return &Handler{
client: client,
itemsPerPage: itemsPerPage,
}
}
func (h *Handler) Create(ctx echo.Context, entityType string) error {
switch entityType {
case "PasswordToken":
return h.PasswordTokenCreate(ctx)
case "User":
return h.UserCreate(ctx)
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Get(ctx echo.Context, entityType string, id int) error {
// TODO
switch entityType {
case "PasswordToken":
return h.PasswordTokenGet(ctx, id)
case "User":
return h.UserGet(ctx, id)
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Delete(ctx echo.Context, entityType string, id int) error {
switch entityType {
case "PasswordToken":
return h.PasswordTokenDelete(ctx, id)
case "User":
return h.UserDelete(ctx, id)
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Update(ctx echo.Context, entityType string, id int) error {
switch entityType {
case "PasswordToken":
return h.PasswordTokenUpdate(ctx, id)
case "User":
return h.UserUpdate(ctx, id)
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) List(ctx echo.Context, entityType string) (*EntityList, error) {
switch entityType {
case "PasswordToken":
return h.PasswordTokenList(ctx)
case "User":
return h.UserList(ctx)
default:
return nil, fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) PasswordTokenCreate(ctx echo.Context) error {
var payload PasswordToken
if err := ctx.Bind(&payload); err != nil {
return err
}
op := h.client.PasswordToken.Create()
op.SetHash(payload.Hash)
op.SetCreatedAt(payload.CreatedAt)
op.SetUserID(payload.User)
_, err := op.Save(ctx.Request().Context())
return err
}
func (h *Handler) PasswordTokenUpdate(ctx echo.Context, id int) error {
entity, err := h.client.PasswordToken.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
var payload PasswordToken
if err = ctx.Bind(&payload); err != nil {
return err
}
op := entity.Update()
op.SetHash(payload.Hash)
op.SetCreatedAt(payload.CreatedAt)
op.SetUserID(payload.User)
_, err = op.Save(ctx.Request().Context())
return err
}
func (h *Handler) PasswordTokenDelete(ctx echo.Context, id int) error {
return h.client.PasswordToken.DeleteOneID(id).
Exec(ctx.Request().Context())
}
func (h *Handler) PasswordTokenList(ctx echo.Context) (*EntityList, error) {
res, err := h.client.PasswordToken.
Query().
Limit(h.itemsPerPage + 1).
Offset(h.getOffset(ctx)).
Order(passwordtoken.ByID(sql.OrderDesc())).
All(ctx.Request().Context())
if err != nil {
return nil, err
}
list := &EntityList{
Columns: []string{
"Created at",
// "User", ?
},
Entities: make([]EntityValues, 0, len(res)),
HasNextPage: len(res) > h.itemsPerPage,
}
for i := 0; i < len(res)-1; i++ {
list.Entities = append(list.Entities, EntityValues{
ID: res[i].ID,
Values: []string{
fmt.Sprint(res[i].CreatedAt),
// TODO User ?
},
})
}
return list, err
}
func (h *Handler) PasswordTokenGet(ctx echo.Context, id int) error {
_, err := h.client.PasswordToken.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
// TODO
return nil
}
func (h *Handler) UserCreate(ctx echo.Context) error {
var payload User
if err := ctx.Bind(&payload); err != nil {
return err
}
op := h.client.User.Create()
op.SetName(payload.Name)
op.SetEmail(payload.Email)
op.SetPassword(payload.Password)
op.SetVerified(payload.Verified)
op.SetCreatedAt(payload.CreatedAt)
_, err := op.Save(ctx.Request().Context())
return err
}
func (h *Handler) UserUpdate(ctx echo.Context, id int) error {
entity, err := h.client.User.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
var payload User
if err = ctx.Bind(&payload); err != nil {
return err
}
op := entity.Update()
op.SetName(payload.Name)
op.SetEmail(payload.Email)
op.SetPassword(payload.Password)
op.SetVerified(payload.Verified)
_, err = op.Save(ctx.Request().Context())
return err
}
func (h *Handler) UserDelete(ctx echo.Context, id int) error {
return h.client.User.DeleteOneID(id).
Exec(ctx.Request().Context())
}
func (h *Handler) UserList(ctx echo.Context) (*EntityList, error) {
res, err := h.client.User.
Query().
Limit(h.itemsPerPage + 1).
Offset(h.getOffset(ctx)).
Order(user.ByID(sql.OrderDesc())).
All(ctx.Request().Context())
if err != nil {
return nil, err
}
list := &EntityList{
Columns: []string{
"Name",
"Email",
"Verified",
"Created at",
},
Entities: make([]EntityValues, 0, len(res)),
HasNextPage: len(res) > h.itemsPerPage,
}
for i := 0; i <= len(res)-1; i++ {
list.Entities = append(list.Entities, EntityValues{
ID: res[i].ID,
Values: []string{
res[i].Name,
res[i].Email,
fmt.Sprint(res[i].Verified),
fmt.Sprint(res[i].CreatedAt),
},
})
}
return list, err
}
func (h *Handler) UserGet(ctx echo.Context, id int) error {
_, err := h.client.User.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
// TODO
return nil
}
func (h *Handler) getOffset(ctx echo.Context) int {
if page, err := strconv.Atoi(ctx.QueryParam("page")); err == nil {
if page > 1 {
return (page - 1) * h.itemsPerPage
}
}
return 0
}

215
ent/admin/templates/handler.tmpl Normal file
View file

@ -0,0 +1,215 @@
{{/* Tell Intellij/GoLand to enable the autocompletion based on the *gen.Graph type. */}}
{{/* gotype: entgo.io/ent/entc/gen.Graph */}}
{{ define "admin/handler" }}
// Code generated by ent, DO NOT EDIT.
{{- $pkg := base $.Config.Package }}
package admin
import (
"fmt"
"strconv"
"entgo.io/ent/dialect/sql"
"github.com/labstack/echo/v4"
"{{ $.Config.Package }}"
{{- range $n := $.Nodes }}
"{{ $.Config.Package }}/{{ $n.Package }}"
{{- end }}
)
type Handler struct {
client *{{ $pkg }}.Client
itemsPerPage int
}
func NewHandler(client *{{ $pkg }}.Client, itemsPerPage int) *Handler {
return &Handler{
client: client,
itemsPerPage: itemsPerPage,
}
}
func (h *Handler) Create(ctx echo.Context, entityType string) error {
switch entityType {
{{- range $n := $.Nodes }}
case "{{ $n.Name }}":
return h.{{ $n.Name }}Create(ctx)
{{- end }}
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Get(ctx echo.Context, entityType string, id int) error {
// TODO
switch entityType {
{{- range $n := $.Nodes }}
case "{{ $n.Name }}":
return h.{{ $n.Name }}Get(ctx, id)
{{- end }}
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Delete(ctx echo.Context, entityType string, id int) error {
switch entityType {
{{- range $n := $.Nodes }}
case "{{ $n.Name }}":
return h.{{ $n.Name }}Delete(ctx, id)
{{- end }}
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) Update(ctx echo.Context, entityType string, id int) error {
switch entityType {
{{- range $n := $.Nodes }}
case "{{ $n.Name }}":
return h.{{ $n.Name }}Update(ctx, id)
{{- end }}
default:
return fmt.Errorf("unsupported entity type: %s", entityType)
}
}
func (h *Handler) List(ctx echo.Context, entityType string) (*EntityList, error) {
switch entityType {
{{- range $n := $.Nodes }}
case "{{ $n.Name }}":
return h.{{ $n.Name }}List(ctx)
{{- end }}
default:
return nil, fmt.Errorf("unsupported entity type: %s", entityType)
}
}
{{ range $n := $.Nodes }}
func (h *Handler) {{ $n.Name }}Create(ctx echo.Context) error {
var payload {{ $n.Name }}
if err := ctx.Bind(&payload); err != nil {
return err
}
op := h.client.{{ $n.Name }}.Create()
{{- range $f := $n.Fields }}
op.Set{{ fieldName $f.Name }}(payload.{{ fieldName $f.Name }})
{{- end }}
{{- range $e := $n.Edges }}
{{- if not $e.Inverse}}
op.Set{{ fieldName $e.Name }}ID(payload.{{ fieldName $e.Name }})
{{- end }}
{{- end }}
_, err := op.Save(ctx.Request().Context())
return err
}
func (h *Handler) {{ $n.Name }}Update(ctx echo.Context, id int) error {
entity, err := h.client.{{ $n.Name }}.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
var payload {{ $n.Name }}
if err = ctx.Bind(&payload); err != nil {
return err
}
op := entity.Update()
{{- range $f := $n.Fields }}
{{- if not $f.Immutable }}
op.Set{{ fieldName $f.Name }}(payload.{{ fieldName $f.Name }})
{{- end }}
{{- end }}
{{- range $e := $n.Edges }}
{{- if not $e.Inverse}}
op.Set{{ fieldName $e.Name }}ID(payload.{{ fieldName $e.Name }})
{{- end }}
{{- end }}
_, err = op.Save(ctx.Request().Context())
return err
}
func (h *Handler) {{ $n.Name }}Delete(ctx echo.Context, id int) error {
return h.client.{{ $n.Name }}.DeleteOneID(id).
Exec(ctx.Request().Context())
}
func (h *Handler) {{ $n.Name }}List(ctx echo.Context) (*EntityList, error) {
res, err := h.client.{{ $n.Name }}.
Query().
Limit(h.itemsPerPage+1).
Offset(h.getOffset(ctx)).
Order({{ $n.Package }}.ByID(sql.OrderDesc())).
All(ctx.Request().Context())
if err != nil {
return nil, err
}
list := &EntityList{
Columns: []string{
{{- range $f := $n.Fields }}
{{- if not $f.Sensitive }}
"{{ fieldLabel $f.Name }}",
{{- end }}
{{- end }}
{{- range $e := $n.Edges }}
{{- if not $e.Inverse}}
// "{{ fieldLabel $e.Name }}", ?
{{- end }}
{{- end }}
},
Entities: make([]EntityValues, 0, len(res)),
HasNextPage: len(res) > h.itemsPerPage,
}
for i := 0; i <= len(res)-1; i++ {
list.Entities = append(list.Entities, EntityValues{
ID: res[i].ID,
Values: []string{
{{- range $f := $n.Fields }}
{{- if not $f.Sensitive }}
{{- if eq $f.Type.String "string" }}
res[i].{{ fieldName $f.Name }},
{{- else }}
fmt.Sprint(res[i].{{ fieldName $f.Name }}),
{{- end }}
{{- end }}
{{- end }}
{{- range $e := $n.Edges }}
{{- if not $e.Inverse}}
// TODO {{ fieldName $e.Name }} ?
{{- end }}
{{- end }}
},
})
}
return list, err
}
func (h *Handler) {{ $n.Name }}Get(ctx echo.Context, id int) error {
_, err := h.client.{{ $n.Name }}.Get(ctx.Request().Context(), id)
if err != nil {
return err
}
// TODO
return nil
}
{{ end }}
func (h *Handler) getOffset(ctx echo.Context) int {
if page, err := strconv.Atoi(ctx.QueryParam("page")); err == nil {
if page > 1 {
return (page-1) * h.itemsPerPage
}
}
return 0
}
{{ end }}

34
ent/admin/templates/types.tmpl Normal file
View file

@ -0,0 +1,34 @@
{{/* Tell Intellij/GoLand to enable the autocompletion based on the *gen.Graph type. */}}
{{/* gotype: entgo.io/ent/entc/gen.Graph */}}
{{ define "admin/types" }}
// Code generated by ent, DO NOT EDIT.
package admin
{{ range $n := $.Nodes }}
type {{ $n.Name }} struct {
// Fields.
{{- range $f := $n.Fields }}
{{ fieldName $f.Name }} {{ $f.Type }} `form:"{{ $f.Name }}"`
{{- end }}
// Edges.
{{- range $e := $n.Edges }}
{{- if not $e.Inverse}}
{{ fieldName $e.Name }} int `form:"{{ $e.Name }}"`
{{- end }}
{{- end }}
}
{{ end }}
type EntityList struct {
Columns []string
Entities []EntityValues
HasNextPage bool
}
type EntityValues struct {
ID int
Values []string
}
{{ end }}

33
ent/admin/types.go Normal file
View file

@ -0,0 +1,33 @@
// Code generated by ent, DO NOT EDIT.
package admin
import "time"
type PasswordToken struct {
// Fields.
Hash string `form:"hash"`
CreatedAt time.Time `form:"created_at"`
// Edges.
User int `form:"user"`
}
type User struct {
// Fields.
Name string `form:"name"`
Email string `form:"email"`
Password string `form:"password"`
Verified bool `form:"verified"`
CreatedAt time.Time `form:"created_at"`
// Edges.
}
type EntityList struct {
Columns []string
Entities []EntityValues
HasNextPage bool
}
type EntityValues struct {
ID int
Values []string
}

36
ent/entc.go
View file

@ -1,44 +1,22 @@
//go:build ignore
// +build ignore
package main
import (
"log"
"ariga.io/ogent"
"entgo.io/contrib/entoas"
"entgo.io/ent/entc"
"entgo.io/ent/entc/gen"
"github.com/ogen-go/ogen"
"github.com/mikestefanello/pagoda/ent/admin"
)
var returnAllErrors = gen.MustParse(gen.NewTemplate("").Parse(`
{{ define "ogent/ogent/helper/error" }}{{/* gotype: entgo.io/ent/entc/gen.typeScope */}}
{{- $pkg := base $.Type.Config.Package }}
if err != nil {
{{- with $.Scope.Tx }}
if rErr := {{ . }}.Rollback(); rErr != nil {
return nil, fmt.Errorf("%w: %v", err, rErr)
}
{{- end }}
// Let the server handle the error.
return nil, err
}
{{ end }}
`))
func main() {
spec := new(ogen.Spec)
oas, err := entoas.NewExtension(entoas.Spec(spec))
err := entc.Generate("./schema",
&gen.Config{},
entc.Extensions(&admin.Extension{}),
)
if err != nil {
log.Fatalf("creating entoas extension: %v", err)
}
ogent, err := ogent.NewExtension(spec, ogent.Templates(returnAllErrors))
if err != nil {
log.Fatalf("creating ogent extension: %v", err)
}
err = entc.Generate("./schema", &gen.Config{}, entc.Extensions(ogent, oas))
if err != nil {
log.Fatalf("running ent codegen: %v", err)
log.Fatal("running ent codegen:", err)
}
}

1
ent/generate.go
View file

@ -1,4 +1,3 @@
package ent
//go:generate go run -mod=mod entc.go
//go:generate sed -i -e "s/json:\"/form:\"/g" ogent/oas_schemas_gen.go

277
ent/ogent/oas_cfg_gen.go
View file

@ -1,277 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"net/http"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/metric/instrument"
"go.opentelemetry.io/otel/trace"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/otelogen"
)
var (
// Allocate option closure once.
clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
// Allocate option closure once.
serverSpanKind = trace.WithSpanKind(trace.SpanKindServer)
)
type (
optionFunc[C any] func(*C)
otelOptionFunc func(*otelConfig)
)
type otelConfig struct {
TracerProvider trace.TracerProvider
Tracer trace.Tracer
MeterProvider metric.MeterProvider
Meter metric.Meter
}
func (cfg *otelConfig) initOTEL() {
if cfg.TracerProvider == nil {
cfg.TracerProvider = otel.GetTracerProvider()
}
if cfg.MeterProvider == nil {
cfg.MeterProvider = metric.NewNoopMeterProvider()
}
cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
trace.WithInstrumentationVersion(otelogen.SemVersion()),
)
cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name)
}
// ErrorHandler is error handler.
type ErrorHandler = ogenerrors.ErrorHandler
type serverConfig struct {
otelConfig
NotFound http.HandlerFunc
MethodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)
ErrorHandler ErrorHandler
Prefix string
Middleware Middleware
MaxMultipartMemory int64
}
// ServerOption is server config option.
type ServerOption interface {
applyServer(*serverConfig)
}
var _ = []ServerOption{
(optionFunc[serverConfig])(nil),
(otelOptionFunc)(nil),
}
func (o optionFunc[C]) applyServer(c *C) {
o(c)
}
func (o otelOptionFunc) applyServer(c *serverConfig) {
o(&c.otelConfig)
}
func newServerConfig(opts ...ServerOption) serverConfig {
cfg := serverConfig{
NotFound: http.NotFound,
MethodNotAllowed: func(w http.ResponseWriter, r *http.Request, allowed string) {
w.Header().Set("Allow", allowed)
w.WriteHeader(http.StatusMethodNotAllowed)
},
ErrorHandler: ogenerrors.DefaultErrorHandler,
Middleware: nil,
MaxMultipartMemory: 32 << 20, // 32 MB
}
for _, opt := range opts {
opt.applyServer(&cfg)
}
cfg.initOTEL()
return cfg
}
type baseServer struct {
cfg serverConfig
requests instrument.Int64Counter
errors instrument.Int64Counter
duration instrument.Int64Histogram
}
func (s baseServer) notFound(w http.ResponseWriter, r *http.Request) {
s.cfg.NotFound(w, r)
}
func (s baseServer) notAllowed(w http.ResponseWriter, r *http.Request, allowed string) {
s.cfg.MethodNotAllowed(w, r, allowed)
}
func (cfg serverConfig) baseServer() (s baseServer, err error) {
s = baseServer{cfg: cfg}
if s.requests, err = s.cfg.Meter.Int64Counter(otelogen.ServerRequestCount); err != nil {
return s, err
}
if s.errors, err = s.cfg.Meter.Int64Counter(otelogen.ServerErrorsCount); err != nil {
return s, err
}
if s.duration, err = s.cfg.Meter.Int64Histogram(otelogen.ServerDuration); err != nil {
return s, err
}
return s, nil
}
type clientConfig struct {
otelConfig
Client ht.Client
}
// ClientOption is client config option.
type ClientOption interface {
applyClient(*clientConfig)
}
var _ = []ClientOption{
(optionFunc[clientConfig])(nil),
(otelOptionFunc)(nil),
}
func (o optionFunc[C]) applyClient(c *C) {
o(c)
}
func (o otelOptionFunc) applyClient(c *clientConfig) {
o(&c.otelConfig)
}
func newClientConfig(opts ...ClientOption) clientConfig {
cfg := clientConfig{
Client: http.DefaultClient,
}
for _, opt := range opts {
opt.applyClient(&cfg)
}
cfg.initOTEL()
return cfg
}
type baseClient struct {
cfg clientConfig
requests instrument.Int64Counter
errors instrument.Int64Counter
duration instrument.Int64Histogram
}
func (cfg clientConfig) baseClient() (c baseClient, err error) {
c = baseClient{cfg: cfg}
if c.requests, err = c.cfg.Meter.Int64Counter(otelogen.ClientRequestCount); err != nil {
return c, err
}
if c.errors, err = c.cfg.Meter.Int64Counter(otelogen.ClientErrorsCount); err != nil {
return c, err
}
if c.duration, err = c.cfg.Meter.Int64Histogram(otelogen.ClientDuration); err != nil {
return c, err
}
return c, nil
}
// Option is config option.
type Option interface {
ServerOption
ClientOption
}
// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.TracerProvider = provider
}
})
}
// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the metric.NewNoopMeterProvider is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.MeterProvider = provider
}
})
}
// WithClient specifies http client to use.
func WithClient(client ht.Client) ClientOption {
return optionFunc[clientConfig](func(cfg *clientConfig) {
if client != nil {
cfg.Client = client
}
})
}
// WithNotFound specifies Not Found handler to use.
func WithNotFound(notFound http.HandlerFunc) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if notFound != nil {
cfg.NotFound = notFound
}
})
}
// WithMethodNotAllowed specifies Method Not Allowed handler to use.
func WithMethodNotAllowed(methodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if methodNotAllowed != nil {
cfg.MethodNotAllowed = methodNotAllowed
}
})
}
// WithErrorHandler specifies error handler to use.
func WithErrorHandler(h ErrorHandler) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if h != nil {
cfg.ErrorHandler = h
}
})
}
// WithPathPrefix specifies server path prefix.
func WithPathPrefix(prefix string) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
cfg.Prefix = prefix
})
}
// WithMiddleware specifies middlewares to use.
func WithMiddleware(m ...Middleware) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
switch len(m) {
case 0:
cfg.Middleware = nil
case 1:
cfg.Middleware = m[0]
default:
cfg.Middleware = middleware.ChainMiddlewares(m...)
}
})
}
// WithMaxMultipartMemory specifies limit of memory for storing file parts.
// File parts which can't be stored in memory will be stored on disk in temporary files.
func WithMaxMultipartMemory(max int64) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if max > 0 {
cfg.MaxMultipartMemory = max
}
})
}

1116
ent/ogent/oas_client_gen.go
View file

File diff suppressed because it is too large Load diff

1288
ent/ogent/oas_handlers_gen.go
View file

File diff suppressed because it is too large Load diff

50
ent/ogent/oas_interfaces_gen.go
View file

@ -1,50 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
type CreatePasswordTokenRes interface {
createPasswordTokenRes()
}
type CreateUserRes interface {
createUserRes()
}
type DeletePasswordTokenRes interface {
deletePasswordTokenRes()
}
type DeleteUserRes interface {
deleteUserRes()
}
type ListPasswordTokenRes interface {
listPasswordTokenRes()
}
type ListUserOwnerRes interface {
listUserOwnerRes()
}
type ListUserRes interface {
listUserRes()
}
type ReadPasswordTokenRes interface {
readPasswordTokenRes()
}
type ReadPasswordTokenUserRes interface {
readPasswordTokenUserRes()
}
type ReadUserRes interface {
readUserRes()
}
type UpdatePasswordTokenRes interface {
updatePasswordTokenRes()
}
type UpdateUserRes interface {
updateUserRes()
}

2834
ent/ogent/oas_json_gen.go
View file

File diff suppressed because it is too large Load diff

10
ent/ogent/oas_middleware_gen.go
View file

@ -1,10 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"github.com/ogen-go/ogen/middleware"
)
// Middleware is middleware type.
type Middleware = middleware.Middleware

947
ent/ogent/oas_parameters_gen.go
View file

@ -1,947 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"net/http"
"net/url"
"github.com/go-faster/errors"
"github.com/ogen-go/ogen/conv"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
)
// DeletePasswordTokenParams is parameters of deletePasswordToken operation.
type DeletePasswordTokenParams struct {
// ID of the PasswordToken.
ID int
}
func unpackDeletePasswordTokenParams(packed middleware.Parameters) (params DeletePasswordTokenParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeDeletePasswordTokenParams(args [1]string, r *http.Request) (params DeletePasswordTokenParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// DeleteUserParams is parameters of deleteUser operation.
type DeleteUserParams struct {
// ID of the User.
ID int
}
func unpackDeleteUserParams(packed middleware.Parameters) (params DeleteUserParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeDeleteUserParams(args [1]string, r *http.Request) (params DeleteUserParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// ListPasswordTokenParams is parameters of listPasswordToken operation.
type ListPasswordTokenParams struct {
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListPasswordTokenParams(packed middleware.Parameters) (params ListPasswordTokenParams) {
{
key := middleware.ParameterKey{
Name: "page",
In: "query",
}
if v, ok := packed[key]; ok {
params.Page = v.(OptInt)
}
}
{
key := middleware.ParameterKey{
Name: "itemsPerPage",
In: "query",
}
if v, ok := packed[key]; ok {
params.ItemsPerPage = v.(OptInt)
}
}
return params
}
func decodeListPasswordTokenParams(args [0]string, r *http.Request) (params ListPasswordTokenParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode query: page.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.Page.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: false,
Max: 0,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.Page.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "page",
In: "query",
Err: err,
}
}
// Decode query: itemsPerPage.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotItemsPerPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.ItemsPerPage.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: true,
Max: 255,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.ItemsPerPage.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "itemsPerPage",
In: "query",
Err: err,
}
}
return params, nil
}
// ListUserParams is parameters of listUser operation.
type ListUserParams struct {
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListUserParams(packed middleware.Parameters) (params ListUserParams) {
{
key := middleware.ParameterKey{
Name: "page",
In: "query",
}
if v, ok := packed[key]; ok {
params.Page = v.(OptInt)
}
}
{
key := middleware.ParameterKey{
Name: "itemsPerPage",
In: "query",
}
if v, ok := packed[key]; ok {
params.ItemsPerPage = v.(OptInt)
}
}
return params
}
func decodeListUserParams(args [0]string, r *http.Request) (params ListUserParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode query: page.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.Page.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: false,
Max: 0,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.Page.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "page",
In: "query",
Err: err,
}
}
// Decode query: itemsPerPage.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotItemsPerPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.ItemsPerPage.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: true,
Max: 255,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.ItemsPerPage.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "itemsPerPage",
In: "query",
Err: err,
}
}
return params, nil
}
// ListUserOwnerParams is parameters of listUserOwner operation.
type ListUserOwnerParams struct {
// ID of the User.
ID int
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListUserOwnerParams(packed middleware.Parameters) (params ListUserOwnerParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
{
key := middleware.ParameterKey{
Name: "page",
In: "query",
}
if v, ok := packed[key]; ok {
params.Page = v.(OptInt)
}
}
{
key := middleware.ParameterKey{
Name: "itemsPerPage",
In: "query",
}
if v, ok := packed[key]; ok {
params.ItemsPerPage = v.(OptInt)
}
}
return params
}
func decodeListUserOwnerParams(args [1]string, r *http.Request) (params ListUserOwnerParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
// Decode query: page.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "page",
In: "query",
Err: err,
}
}
// Decode query: itemsPerPage.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotItemsPerPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "itemsPerPage",
In: "query",
Err: err,
}
}
return params, nil
}
// ReadPasswordTokenParams is parameters of readPasswordToken operation.
type ReadPasswordTokenParams struct {
// ID of the PasswordToken.
ID int
}
func unpackReadPasswordTokenParams(packed middleware.Parameters) (params ReadPasswordTokenParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadPasswordTokenParams(args [1]string, r *http.Request) (params ReadPasswordTokenParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// ReadPasswordTokenUserParams is parameters of readPasswordTokenUser operation.
type ReadPasswordTokenUserParams struct {
// ID of the PasswordToken.
ID int
}
func unpackReadPasswordTokenUserParams(packed middleware.Parameters) (params ReadPasswordTokenUserParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadPasswordTokenUserParams(args [1]string, r *http.Request) (params ReadPasswordTokenUserParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// ReadUserParams is parameters of readUser operation.
type ReadUserParams struct {
// ID of the User.
ID int
}
func unpackReadUserParams(packed middleware.Parameters) (params ReadUserParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadUserParams(args [1]string, r *http.Request) (params ReadUserParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// UpdatePasswordTokenParams is parameters of updatePasswordToken operation.
type UpdatePasswordTokenParams struct {
// ID of the PasswordToken.
ID int
}
func unpackUpdatePasswordTokenParams(packed middleware.Parameters) (params UpdatePasswordTokenParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeUpdatePasswordTokenParams(args [1]string, r *http.Request) (params UpdatePasswordTokenParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// UpdateUserParams is parameters of updateUser operation.
type UpdateUserParams struct {
// ID of the User.
ID int
}
func unpackUpdateUserParams(packed middleware.Parameters) (params UpdateUserParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeUpdateUserParams(args [1]string, r *http.Request) (params UpdateUserParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}

268
ent/ogent/oas_request_decoders_gen.go
View file

@ -1,268 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"io"
"mime"
"net/http"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"go.uber.org/multierr"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/validate"
)
func (s *Server) decodeCreatePasswordTokenRequest(r *http.Request) (
req *CreatePasswordTokenReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreatePasswordTokenReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeCreateUserRequest(r *http.Request) (
req *CreateUserReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreateUserReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdatePasswordTokenRequest(r *http.Request) (
req *UpdatePasswordTokenReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdatePasswordTokenReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdateUserRequest(r *http.Request) (
req *UpdateUserReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdateUserReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}

68
ent/ogent/oas_request_encoders_gen.go
View file

@ -1,68 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"net/http"
"github.com/go-faster/jx"
ht "github.com/ogen-go/ogen/http"
)
func encodeCreatePasswordTokenRequest(
req *CreatePasswordTokenReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeCreateUserRequest(
req *CreateUserReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdatePasswordTokenRequest(
req *UpdatePasswordTokenReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdateUserRequest(
req *UpdateUserReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}

2053
ent/ogent/oas_response_decoders_gen.go
View file

File diff suppressed because it is too large Load diff

780
ent/ogent/oas_response_encoders_gen.go
View file

@ -1,780 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"net/http"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
)
func encodeCreatePasswordTokenResponse(response CreatePasswordTokenRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *PasswordTokenCreate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeCreateUserResponse(response CreateUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UserCreate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeDeletePasswordTokenResponse(response DeletePasswordTokenRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *DeletePasswordTokenNoContent:
w.WriteHeader(204)
span.SetStatus(codes.Ok, http.StatusText(204))
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeDeleteUserResponse(response DeleteUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *DeleteUserNoContent:
w.WriteHeader(204)
span.SetStatus(codes.Ok, http.StatusText(204))
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeListPasswordTokenResponse(response ListPasswordTokenRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListPasswordTokenOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeListUserResponse(response ListUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUserOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeListUserOwnerResponse(response ListUserOwnerRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUserOwnerOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeReadPasswordTokenResponse(response ReadPasswordTokenRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *PasswordTokenRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeReadPasswordTokenUserResponse(response ReadPasswordTokenUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *PasswordTokenUserRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UserRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeUpdatePasswordTokenResponse(response UpdatePasswordTokenRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *PasswordTokenUpdate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeUpdateUserResponse(response UpdateUserRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UserUpdate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}

489
ent/ogent/oas_router_gen.go
View file

@ -1,489 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"net/http"
"net/url"
"strings"
"github.com/ogen-go/ogen/uri"
)
// ServeHTTP serves http request as defined by OpenAPI v3 specification,
// calling handler that matches the path or returning not found error.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
elem := r.URL.Path
if rawPath := r.URL.RawPath; rawPath != "" {
if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
elem = normalized
}
}
if prefix := s.cfg.Prefix; len(prefix) > 0 {
if strings.HasPrefix(elem, prefix) {
// Cut prefix from the path.
elem = strings.TrimPrefix(elem, prefix)
} else {
// Prefix doesn't match.
s.notFound(w, r)
return
}
}
if len(elem) == 0 {
s.notFound(w, r)
return
}
args := [1]string{}
// Static code generated router with unwrapped path search.
switch {
default:
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
break
}
switch elem[0] {
case 'p': // Prefix: "password-tokens"
if l := len("password-tokens"); len(elem) >= l && elem[0:l] == "password-tokens" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch r.Method {
case "GET":
s.handleListPasswordTokenRequest([0]string{}, w, r)
case "POST":
s.handleCreatePasswordTokenRequest([0]string{}, w, r)
default:
s.notAllowed(w, r, "GET,POST")
}
return
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
switch r.Method {
case "DELETE":
s.handleDeletePasswordTokenRequest([1]string{
args[0],
}, w, r)
case "GET":
s.handleReadPasswordTokenRequest([1]string{
args[0],
}, w, r)
case "PATCH":
s.handleUpdatePasswordTokenRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "DELETE,GET,PATCH")
}
return
}
switch elem[0] {
case '/': // Prefix: "/user"
if l := len("/user"); len(elem) >= l && elem[0:l] == "/user" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleReadPasswordTokenUserRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
}
}
case 'u': // Prefix: "users"
if l := len("users"); len(elem) >= l && elem[0:l] == "users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch r.Method {
case "GET":
s.handleListUserRequest([0]string{}, w, r)
case "POST":
s.handleCreateUserRequest([0]string{}, w, r)
default:
s.notAllowed(w, r, "GET,POST")
}
return
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
switch r.Method {
case "DELETE":
s.handleDeleteUserRequest([1]string{
args[0],
}, w, r)
case "GET":
s.handleReadUserRequest([1]string{
args[0],
}, w, r)
case "PATCH":
s.handleUpdateUserRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "DELETE,GET,PATCH")
}
return
}
switch elem[0] {
case '/': // Prefix: "/owner"
if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleListUserOwnerRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
}
}
}
}
}
s.notFound(w, r)
}
// Route is route object.
type Route struct {
name string
operationID string
pathPattern string
count int
args [1]string
}
// Name returns ogen operation name.
//
// It is guaranteed to be unique and not empty.
func (r Route) Name() string {
return r.name
}
// OperationID returns OpenAPI operationId.
func (r Route) OperationID() string {
return r.operationID
}
// PathPattern returns OpenAPI path.
func (r Route) PathPattern() string {
return r.pathPattern
}
// Args returns parsed arguments.
func (r Route) Args() []string {
return r.args[:r.count]
}
// FindRoute finds Route for given method and path.
//
// Note: this method does not unescape path or handle reserved characters in path properly. Use FindPath instead.
func (s *Server) FindRoute(method, path string) (Route, bool) {
return s.FindPath(method, &url.URL{Path: path})
}
// FindPath finds Route for given method and URL.
func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
var (
elem = u.Path
args = r.args
)
if rawPath := u.RawPath; rawPath != "" {
if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
elem = normalized
}
defer func() {
for i, arg := range r.args[:r.count] {
if unescaped, err := url.PathUnescape(arg); err == nil {
r.args[i] = unescaped
}
}
}()
}
// Static code generated router with unwrapped path search.
switch {
default:
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
break
}
switch elem[0] {
case 'p': // Prefix: "password-tokens"
if l := len("password-tokens"); len(elem) >= l && elem[0:l] == "password-tokens" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
r.name = "ListPasswordToken"
r.operationID = "listPasswordToken"
r.pathPattern = "/password-tokens"
r.args = args
r.count = 0
return r, true
case "POST":
r.name = "CreatePasswordToken"
r.operationID = "createPasswordToken"
r.pathPattern = "/password-tokens"
r.args = args
r.count = 0
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
switch method {
case "DELETE":
r.name = "DeletePasswordToken"
r.operationID = "deletePasswordToken"
r.pathPattern = "/password-tokens/{id}"
r.args = args
r.count = 1
return r, true
case "GET":
r.name = "ReadPasswordToken"
r.operationID = "readPasswordToken"
r.pathPattern = "/password-tokens/{id}"
r.args = args
r.count = 1
return r, true
case "PATCH":
r.name = "UpdatePasswordToken"
r.operationID = "updatePasswordToken"
r.pathPattern = "/password-tokens/{id}"
r.args = args
r.count = 1
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/user"
if l := len("/user"); len(elem) >= l && elem[0:l] == "/user" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
// Leaf: ReadPasswordTokenUser
r.name = "ReadPasswordTokenUser"
r.operationID = "readPasswordTokenUser"
r.pathPattern = "/password-tokens/{id}/user"
r.args = args
r.count = 1
return r, true
default:
return
}
}
}
}
case 'u': // Prefix: "users"
if l := len("users"); len(elem) >= l && elem[0:l] == "users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
r.name = "ListUser"
r.operationID = "listUser"
r.pathPattern = "/users"
r.args = args
r.count = 0
return r, true
case "POST":
r.name = "CreateUser"
r.operationID = "createUser"
r.pathPattern = "/users"
r.args = args
r.count = 0
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
switch method {
case "DELETE":
r.name = "DeleteUser"
r.operationID = "deleteUser"
r.pathPattern = "/users/{id}"
r.args = args
r.count = 1
return r, true
case "GET":
r.name = "ReadUser"
r.operationID = "readUser"
r.pathPattern = "/users/{id}"
r.args = args
r.count = 1
return r, true
case "PATCH":
r.name = "UpdateUser"
r.operationID = "updateUser"
r.pathPattern = "/users/{id}"
r.args = args
r.count = 1
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/owner"
if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
// Leaf: ListUserOwner
r.name = "ListUserOwner"
r.operationID = "listUserOwner"
r.pathPattern = "/users/{id}/owner"
r.args = args
r.count = 1
return r, true
default:
return
}
}
}
}
}
}
}
return r, false
}

1047
ent/ogent/oas_schemas_gen.go
View file

File diff suppressed because it is too large Load diff

102
ent/ogent/oas_server_gen.go
View file

@ -1,102 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"context"
)
// Handler handles operations described by OpenAPI v3 specification.
type Handler interface {
// CreatePasswordToken implements createPasswordToken operation.
//
// Creates a new PasswordToken and persists it to storage.
//
// POST /password-tokens
CreatePasswordToken(ctx context.Context, req *CreatePasswordTokenReq) (CreatePasswordTokenRes, error)
// CreateUser implements createUser operation.
//
// Creates a new User and persists it to storage.
//
// POST /users
CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error)
// DeletePasswordToken implements deletePasswordToken operation.
//
// Deletes the PasswordToken with the requested ID.
//
// DELETE /password-tokens/{id}
DeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (DeletePasswordTokenRes, error)
// DeleteUser implements deleteUser operation.
//
// Deletes the User with the requested ID.
//
// DELETE /users/{id}
DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error)
// ListPasswordToken implements listPasswordToken operation.
//
// List PasswordTokens.
//
// GET /password-tokens
ListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (ListPasswordTokenRes, error)
// ListUser implements listUser operation.
//
// List Users.
//
// GET /users
ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error)
// ListUserOwner implements listUserOwner operation.
//
// List attached Owners.
//
// GET /users/{id}/owner
ListUserOwner(ctx context.Context, params ListUserOwnerParams) (ListUserOwnerRes, error)
// ReadPasswordToken implements readPasswordToken operation.
//
// Finds the PasswordToken with the requested ID and returns it.
//
// GET /password-tokens/{id}
ReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (ReadPasswordTokenRes, error)
// ReadPasswordTokenUser implements readPasswordTokenUser operation.
//
// Find the attached User of the PasswordToken with the given ID.
//
// GET /password-tokens/{id}/user
ReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (ReadPasswordTokenUserRes, error)
// ReadUser implements readUser operation.
//
// Finds the User with the requested ID and returns it.
//
// GET /users/{id}
ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error)
// UpdatePasswordToken implements updatePasswordToken operation.
//
// Updates a PasswordToken and persists changes to storage.
//
// PATCH /password-tokens/{id}
UpdatePasswordToken(ctx context.Context, req *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (UpdatePasswordTokenRes, error)
// UpdateUser implements updateUser operation.
//
// Updates a User and persists changes to storage.
//
// PATCH /users/{id}
UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error)
}
// Server implements http server based on OpenAPI v3 specification and
// calls Handler to handle requests.
type Server struct {
h Handler
baseServer
}
// NewServer creates new Server.
func NewServer(h Handler, opts ...ServerOption) (*Server, error) {
s, err := newServerConfig(opts...).baseServer()
if err != nil {
return nil, err
}
return &Server{
h: h,
baseServer: s,
}, nil
}

122
ent/ogent/oas_unimplemented_gen.go
View file

@ -1,122 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"context"
ht "github.com/ogen-go/ogen/http"
)
// UnimplementedHandler is no-op Handler which returns http.ErrNotImplemented.
type UnimplementedHandler struct{}
var _ Handler = UnimplementedHandler{}
// CreatePasswordToken implements createPasswordToken operation.
//
// Creates a new PasswordToken and persists it to storage.
//
// POST /password-tokens
func (UnimplementedHandler) CreatePasswordToken(ctx context.Context, req *CreatePasswordTokenReq) (r CreatePasswordTokenRes, _ error) {
return r, ht.ErrNotImplemented
}
// CreateUser implements createUser operation.
//
// Creates a new User and persists it to storage.
//
// POST /users
func (UnimplementedHandler) CreateUser(ctx context.Context, req *CreateUserReq) (r CreateUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeletePasswordToken implements deletePasswordToken operation.
//
// Deletes the PasswordToken with the requested ID.
//
// DELETE /password-tokens/{id}
func (UnimplementedHandler) DeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (r DeletePasswordTokenRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUser implements deleteUser operation.
//
// Deletes the User with the requested ID.
//
// DELETE /users/{id}
func (UnimplementedHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (r DeleteUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListPasswordToken implements listPasswordToken operation.
//
// List PasswordTokens.
//
// GET /password-tokens
func (UnimplementedHandler) ListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (r ListPasswordTokenRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUser implements listUser operation.
//
// List Users.
//
// GET /users
func (UnimplementedHandler) ListUser(ctx context.Context, params ListUserParams) (r ListUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUserOwner implements listUserOwner operation.
//
// List attached Owners.
//
// GET /users/{id}/owner
func (UnimplementedHandler) ListUserOwner(ctx context.Context, params ListUserOwnerParams) (r ListUserOwnerRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadPasswordToken implements readPasswordToken operation.
//
// Finds the PasswordToken with the requested ID and returns it.
//
// GET /password-tokens/{id}
func (UnimplementedHandler) ReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (r ReadPasswordTokenRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadPasswordTokenUser implements readPasswordTokenUser operation.
//
// Find the attached User of the PasswordToken with the given ID.
//
// GET /password-tokens/{id}/user
func (UnimplementedHandler) ReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (r ReadPasswordTokenUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUser implements readUser operation.
//
// Finds the User with the requested ID and returns it.
//
// GET /users/{id}
func (UnimplementedHandler) ReadUser(ctx context.Context, params ReadUserParams) (r ReadUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdatePasswordToken implements updatePasswordToken operation.
//
// Updates a PasswordToken and persists changes to storage.
//
// PATCH /password-tokens/{id}
func (UnimplementedHandler) UpdatePasswordToken(ctx context.Context, req *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (r UpdatePasswordTokenRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateUser implements updateUser operation.
//
// Updates a User and persists changes to storage.
//
// PATCH /users/{id}
func (UnimplementedHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (r UpdateUserRes, _ error) {
return r, ht.ErrNotImplemented
}

26
ent/ogent/oas_validators_gen.go
View file

@ -1,26 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"github.com/go-faster/errors"
)
func (s ListPasswordTokenOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s ListUserOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s ListUserOwnerOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}

264
ent/ogent/ogent.go
View file

@ -1,264 +0,0 @@
// Code generated by ent, DO NOT EDIT.
package ogent
import (
"context"
"github.com/go-faster/jx"
"github.com/mikestefanello/pagoda/ent"
"github.com/mikestefanello/pagoda/ent/passwordtoken"
"github.com/mikestefanello/pagoda/ent/user"
)
// OgentHandler implements the ogen generated Handler interface and uses Ent as data layer.
type OgentHandler struct {
client *ent.Client
}
// NewOgentHandler returns a new OgentHandler.
func NewOgentHandler(c *ent.Client) *OgentHandler { return &OgentHandler{c} }
// rawError renders err as json string.
func rawError(err error) jx.Raw {
var e jx.Encoder
e.Str(err.Error())
return e.Bytes()
}
// CreatePasswordToken handles POST /password-tokens requests.
func (h *OgentHandler) CreatePasswordToken(ctx context.Context, req *CreatePasswordTokenReq) (CreatePasswordTokenRes, error) {
b := h.client.PasswordToken.Create()
// Add all fields.
b.SetHash(req.Hash)
b.SetCreatedAt(req.CreatedAt)
// Add all edges.
b.SetUserID(req.User)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.PasswordToken.Query().Where(passwordtoken.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewPasswordTokenCreate(e), nil
}
// ReadPasswordToken handles GET /password-tokens/{id} requests.
func (h *OgentHandler) ReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (ReadPasswordTokenRes, error) {
q := h.client.PasswordToken.Query().Where(passwordtoken.IDEQ(params.ID))
e, err := q.Only(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
return NewPasswordTokenRead(e), nil
}
// UpdatePasswordToken handles PATCH /password-tokens/{id} requests.
func (h *OgentHandler) UpdatePasswordToken(ctx context.Context, req *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (UpdatePasswordTokenRes, error) {
b := h.client.PasswordToken.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Hash.Get(); ok {
b.SetHash(v)
}
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
// Add all edges.
if v, ok := req.User.Get(); ok {
b.SetUserID(v)
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.PasswordToken.Query().Where(passwordtoken.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewPasswordTokenUpdate(e), nil
}
// DeletePasswordToken handles DELETE /password-tokens/{id} requests.
func (h *OgentHandler) DeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (DeletePasswordTokenRes, error) {
err := h.client.PasswordToken.DeleteOneID(params.ID).Exec(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
return new(DeletePasswordTokenNoContent), nil
}
// ListPasswordToken handles GET /password-tokens requests.
func (h *OgentHandler) ListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (ListPasswordTokenRes, error) {
q := h.client.PasswordToken.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
r := NewPasswordTokenLists(es)
return (*ListPasswordTokenOKApplicationJSON)(&r), nil
}
// ReadPasswordTokenUser handles GET /password-tokens/{id}/user requests.
func (h *OgentHandler) ReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (ReadPasswordTokenUserRes, error) {
q := h.client.PasswordToken.Query().Where(passwordtoken.IDEQ(params.ID)).QueryUser()
e, err := q.Only(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
return NewPasswordTokenUserRead(e), nil
}
// CreateUser handles POST /users requests.
func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) {
b := h.client.User.Create()
// Add all fields.
b.SetName(req.Name)
b.SetEmail(req.Email)
b.SetPassword(req.Password)
b.SetVerified(req.Verified)
b.SetCreatedAt(req.CreatedAt)
// Add all edges.
b.AddOwnerIDs(req.Owner...)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.User.Query().Where(user.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUserCreate(e), nil
}
// ReadUser handles GET /users/{id} requests.
func (h *OgentHandler) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID))
e, err := q.Only(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
return NewUserRead(e), nil
}
// UpdateUser handles PATCH /users/{id} requests.
func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) {
b := h.client.User.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Name.Get(); ok {
b.SetName(v)
}
if v, ok := req.Email.Get(); ok {
b.SetEmail(v)
}
if v, ok := req.Password.Get(); ok {
b.SetPassword(v)
}
if v, ok := req.Verified.Get(); ok {
b.SetVerified(v)
}
// Add all edges.
if req.Owner != nil {
b.ClearOwner().AddOwnerIDs(req.Owner...)
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.User.Query().Where(user.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUserUpdate(e), nil
}
// DeleteUser handles DELETE /users/{id} requests.
func (h *OgentHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) {
err := h.client.User.DeleteOneID(params.ID).Exec(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
return new(DeleteUserNoContent), nil
}
// ListUser handles GET /users requests.
func (h *OgentHandler) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) {
q := h.client.User.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
r := NewUserLists(es)
return (*ListUserOKApplicationJSON)(&r), nil
}
// ListUserOwner handles GET /users/{id}/owner requests.
func (h *OgentHandler) ListUserOwner(ctx context.Context, params ListUserOwnerParams) (ListUserOwnerRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID)).QueryOwner()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
// Let the server handle the error.
return nil, err
}
r := NewUserOwnerLists(es)
return (*ListUserOwnerOKApplicationJSON)(&r), nil
}

300
ent/ogent/responses.go
View file

@ -1,300 +0,0 @@
// Code generated by ent, DO NOT EDIT.
package ogent
import "github.com/mikestefanello/pagoda/ent"
func NewPasswordTokenCreate(e *ent.PasswordToken) *PasswordTokenCreate {
if e == nil {
return nil
}
var ret PasswordTokenCreate
ret.ID = e.ID
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewPasswordTokenCreates(es []*ent.PasswordToken) []PasswordTokenCreate {
if len(es) == 0 {
return nil
}
r := make([]PasswordTokenCreate, len(es))
for i, e := range es {
r[i] = NewPasswordTokenCreate(e).Elem()
}
return r
}
func (pt *PasswordTokenCreate) Elem() PasswordTokenCreate {
if pt == nil {
return PasswordTokenCreate{}
}
return *pt
}
func NewPasswordTokenList(e *ent.PasswordToken) *PasswordTokenList {
if e == nil {
return nil
}
var ret PasswordTokenList
ret.ID = e.ID
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewPasswordTokenLists(es []*ent.PasswordToken) []PasswordTokenList {
if len(es) == 0 {
return nil
}
r := make([]PasswordTokenList, len(es))
for i, e := range es {
r[i] = NewPasswordTokenList(e).Elem()
}
return r
}
func (pt *PasswordTokenList) Elem() PasswordTokenList {
if pt == nil {
return PasswordTokenList{}
}
return *pt
}
func NewPasswordTokenRead(e *ent.PasswordToken) *PasswordTokenRead {
if e == nil {
return nil
}
var ret PasswordTokenRead
ret.ID = e.ID
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewPasswordTokenReads(es []*ent.PasswordToken) []PasswordTokenRead {
if len(es) == 0 {
return nil
}
r := make([]PasswordTokenRead, len(es))
for i, e := range es {
r[i] = NewPasswordTokenRead(e).Elem()
}
return r
}
func (pt *PasswordTokenRead) Elem() PasswordTokenRead {
if pt == nil {
return PasswordTokenRead{}
}
return *pt
}
func NewPasswordTokenUpdate(e *ent.PasswordToken) *PasswordTokenUpdate {
if e == nil {
return nil
}
var ret PasswordTokenUpdate
ret.ID = e.ID
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewPasswordTokenUpdates(es []*ent.PasswordToken) []PasswordTokenUpdate {
if len(es) == 0 {
return nil
}
r := make([]PasswordTokenUpdate, len(es))
for i, e := range es {
r[i] = NewPasswordTokenUpdate(e).Elem()
}
return r
}
func (pt *PasswordTokenUpdate) Elem() PasswordTokenUpdate {
if pt == nil {
return PasswordTokenUpdate{}
}
return *pt
}
func NewPasswordTokenUserRead(e *ent.User) *PasswordTokenUserRead {
if e == nil {
return nil
}
var ret PasswordTokenUserRead
ret.ID = e.ID
ret.Name = e.Name
ret.Email = e.Email
ret.Verified = e.Verified
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewPasswordTokenUserReads(es []*ent.User) []PasswordTokenUserRead {
if len(es) == 0 {
return nil
}
r := make([]PasswordTokenUserRead, len(es))
for i, e := range es {
r[i] = NewPasswordTokenUserRead(e).Elem()
}
return r
}
func (u *PasswordTokenUserRead) Elem() PasswordTokenUserRead {
if u == nil {
return PasswordTokenUserRead{}
}
return *u
}
func NewUserCreate(e *ent.User) *UserCreate {
if e == nil {
return nil
}
var ret UserCreate
ret.ID = e.ID
ret.Name = e.Name
ret.Email = e.Email
ret.Verified = e.Verified
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewUserCreates(es []*ent.User) []UserCreate {
if len(es) == 0 {
return nil
}
r := make([]UserCreate, len(es))
for i, e := range es {
r[i] = NewUserCreate(e).Elem()
}
return r
}
func (u *UserCreate) Elem() UserCreate {
if u == nil {
return UserCreate{}
}
return *u
}
func NewUserList(e *ent.User) *UserList {
if e == nil {
return nil
}
var ret UserList
ret.ID = e.ID
ret.Name = e.Name
ret.Email = e.Email
ret.Verified = e.Verified
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewUserLists(es []*ent.User) []UserList {
if len(es) == 0 {
return nil
}
r := make([]UserList, len(es))
for i, e := range es {
r[i] = NewUserList(e).Elem()
}
return r
}
func (u *UserList) Elem() UserList {
if u == nil {
return UserList{}
}
return *u
}
func NewUserRead(e *ent.User) *UserRead {
if e == nil {
return nil
}
var ret UserRead
ret.ID = e.ID
ret.Name = e.Name
ret.Email = e.Email
ret.Verified = e.Verified
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewUserReads(es []*ent.User) []UserRead {
if len(es) == 0 {
return nil
}
r := make([]UserRead, len(es))
for i, e := range es {
r[i] = NewUserRead(e).Elem()
}
return r
}
func (u *UserRead) Elem() UserRead {
if u == nil {
return UserRead{}
}
return *u
}
func NewUserUpdate(e *ent.User) *UserUpdate {
if e == nil {
return nil
}
var ret UserUpdate
ret.ID = e.ID
ret.Name = e.Name
ret.Email = e.Email
ret.Verified = e.Verified
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewUserUpdates(es []*ent.User) []UserUpdate {
if len(es) == 0 {
return nil
}
r := make([]UserUpdate, len(es))
for i, e := range es {
r[i] = NewUserUpdate(e).Elem()
}
return r
}
func (u *UserUpdate) Elem() UserUpdate {
if u == nil {
return UserUpdate{}
}
return *u
}
func NewUserOwnerList(e *ent.PasswordToken) *UserOwnerList {
if e == nil {
return nil
}
var ret UserOwnerList
ret.ID = e.ID
ret.CreatedAt = e.CreatedAt
return &ret
}
func NewUserOwnerLists(es []*ent.PasswordToken) []UserOwnerList {
if len(es) == 0 {
return nil
}
r := make([]UserOwnerList, len(es))
for i, e := range es {
r[i] = NewUserOwnerList(e).Elem()
}
return r
}
func (pt *UserOwnerList) Elem() UserOwnerList {
if pt == nil {
return UserOwnerList{}
}
return *pt
}

16
ent/ogent/time.go
View file

@ -1,16 +0,0 @@
package ogent
import (
"time"
)
type Datetime time.Time
func (d *Datetime) UnmarshalParam(param string) error {
t, err := time.Parse(`2006-01-02 15:04:05 MST`, param)
if err != nil {
return err
}
*d = Datetime(t)
return nil
}

1068
ent/openapi.json
View file

File diff suppressed because it is too large Load diff