From 196d34cc1f2603f33b83893f7e2a6dc5130e65cf Mon Sep 17 00:00:00 2001 From: mikestefanello <552328+mikestefanello@users.noreply.github.com> Date: Tue, 1 Apr 2025 10:20:14 -0400 Subject: [PATCH] Added ogent for entity code gen. --- ent/entc.go | 29 + ent/generate.go | 3 +- ent/ogent/oas_cfg_gen.go | 277 +++ ent/ogent/oas_client_gen.go | 1116 ++++++++++ ent/ogent/oas_handlers_gen.go | 1288 +++++++++++ ent/ogent/oas_interfaces_gen.go | 50 + ent/ogent/oas_json_gen.go | 2834 ++++++++++++++++++++++++ ent/ogent/oas_middleware_gen.go | 10 + ent/ogent/oas_parameters_gen.go | 947 ++++++++ ent/ogent/oas_request_decoders_gen.go | 268 +++ ent/ogent/oas_request_encoders_gen.go | 68 + ent/ogent/oas_response_decoders_gen.go | 2053 +++++++++++++++++ ent/ogent/oas_response_encoders_gen.go | 780 +++++++ ent/ogent/oas_router_gen.go | 489 ++++ ent/ogent/oas_schemas_gen.go | 1047 +++++++++ ent/ogent/oas_server_gen.go | 102 + ent/ogent/oas_unimplemented_gen.go | 122 + ent/ogent/oas_validators_gen.go | 26 + ent/ogent/ogent.go | 445 ++++ ent/ogent/responses.go | 300 +++ ent/ogent/time.go | 16 + ent/openapi.json | 1068 +++++++++ ent/runtime/runtime.go | 4 +- go.mod | 21 +- go.sum | 47 + pkg/handlers/admin.go | 9 + pkg/ui/components/head.go | 9 +- pkg/ui/layouts/admin.go | 1 + pkg/ui/pages/entity.go | 28 +- 29 files changed, 13445 insertions(+), 12 deletions(-) create mode 100644 ent/entc.go create mode 100644 ent/ogent/oas_cfg_gen.go create mode 100644 ent/ogent/oas_client_gen.go create mode 100644 ent/ogent/oas_handlers_gen.go create mode 100644 ent/ogent/oas_interfaces_gen.go create mode 100644 ent/ogent/oas_json_gen.go create mode 100644 ent/ogent/oas_middleware_gen.go create mode 100644 ent/ogent/oas_parameters_gen.go create mode 100644 ent/ogent/oas_request_decoders_gen.go create mode 100644 ent/ogent/oas_request_encoders_gen.go create mode 100644 ent/ogent/oas_response_decoders_gen.go create mode 100644 ent/ogent/oas_response_encoders_gen.go create mode 100644 ent/ogent/oas_router_gen.go create mode 100644 ent/ogent/oas_schemas_gen.go create mode 100644 ent/ogent/oas_server_gen.go create mode 100644 ent/ogent/oas_unimplemented_gen.go create mode 100644 ent/ogent/oas_validators_gen.go create mode 100644 ent/ogent/ogent.go create mode 100644 ent/ogent/responses.go create mode 100644 ent/ogent/time.go create mode 100644 ent/openapi.json diff --git a/ent/entc.go b/ent/entc.go new file mode 100644 index 0000000..66899ae --- /dev/null +++ b/ent/entc.go @@ -0,0 +1,29 @@ +//go: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" +) + +func main() { + spec := new(ogen.Spec) + oas, err := entoas.NewExtension(entoas.Spec(spec)) + if err != nil { + log.Fatalf("creating entoas extension: %v", err) + } + ogent, err := ogent.NewExtension(spec) + 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) + } +} diff --git a/ent/generate.go b/ent/generate.go index 8d3fdfd..971f235 100644 --- a/ent/generate.go +++ b/ent/generate.go @@ -1,3 +1,4 @@ package ent -//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate ./schema +//go:generate go run -mod=mod entc.go +//go:generate sed -i -e "s/json:\"/form:\"/g" ogent/oas_schemas_gen.go diff --git a/ent/ogent/oas_cfg_gen.go b/ent/ogent/oas_cfg_gen.go new file mode 100644 index 0000000..db14e1c --- /dev/null +++ b/ent/ogent/oas_cfg_gen.go @@ -0,0 +1,277 @@ +// 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 + } + }) +} diff --git a/ent/ogent/oas_client_gen.go b/ent/ogent/oas_client_gen.go new file mode 100644 index 0000000..407574a --- /dev/null +++ b/ent/ogent/oas_client_gen.go @@ -0,0 +1,1116 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "context" + "net/url" + "time" + + "github.com/go-faster/errors" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/trace" + + "github.com/ogen-go/ogen/conv" + ht "github.com/ogen-go/ogen/http" + "github.com/ogen-go/ogen/otelogen" + "github.com/ogen-go/ogen/uri" +) + +// Client implements OAS client. +type Client struct { + serverURL *url.URL + baseClient +} + +var _ Handler = struct { + *Client +}{} + +// NewClient initializes new Client defined by OAS. +func NewClient(serverURL string, opts ...ClientOption) (*Client, error) { + u, err := url.Parse(serverURL) + if err != nil { + return nil, err + } + c, err := newClientConfig(opts...).baseClient() + if err != nil { + return nil, err + } + return &Client{ + serverURL: u, + baseClient: c, + }, nil +} + +type serverURLKey struct{} + +// WithServerURL sets context key to override server URL. +func WithServerURL(ctx context.Context, u *url.URL) context.Context { + return context.WithValue(ctx, serverURLKey{}, u) +} + +func (c *Client) requestURL(ctx context.Context) *url.URL { + u, ok := ctx.Value(serverURLKey{}).(*url.URL) + if !ok { + return c.serverURL + } + return u +} + +// CreatePasswordToken invokes createPasswordToken operation. +// +// Creates a new PasswordToken and persists it to storage. +// +// POST /password-tokens +func (c *Client) CreatePasswordToken(ctx context.Context, request *CreatePasswordTokenReq) (CreatePasswordTokenRes, error) { + res, err := c.sendCreatePasswordToken(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreatePasswordToken(ctx context.Context, request *CreatePasswordTokenReq) (res CreatePasswordTokenRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createPasswordToken"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "CreatePasswordToken", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreatePasswordTokenRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeCreatePasswordTokenResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// CreateUser invokes createUser operation. +// +// Creates a new User and persists it to storage. +// +// POST /users +func (c *Client) CreateUser(ctx context.Context, request *CreateUserReq) (CreateUserRes, error) { + res, err := c.sendCreateUser(ctx, request) + _ = res + return res, err +} + +func (c *Client) sendCreateUser(ctx context.Context, request *CreateUserReq) (res CreateUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "CreateUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeCreateUserRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeCreateUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeletePasswordToken invokes deletePasswordToken operation. +// +// Deletes the PasswordToken with the requested ID. +// +// DELETE /password-tokens/{id} +func (c *Client) DeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (DeletePasswordTokenRes, error) { + res, err := c.sendDeletePasswordToken(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (res DeletePasswordTokenRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deletePasswordToken"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "DeletePasswordToken", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "DELETE", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeDeletePasswordTokenResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// DeleteUser invokes deleteUser operation. +// +// Deletes the User with the requested ID. +// +// DELETE /users/{id} +func (c *Client) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) { + res, err := c.sendDeleteUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendDeleteUser(ctx context.Context, params DeleteUserParams) (res DeleteUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "DeleteUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "DELETE", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeDeleteUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListPasswordToken invokes listPasswordToken operation. +// +// List PasswordTokens. +// +// GET /password-tokens +func (c *Client) ListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (ListPasswordTokenRes, error) { + res, err := c.sendListPasswordToken(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (res ListPasswordTokenRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listPasswordToken"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ListPasswordToken", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "page" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Page.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "itemsPerPage" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ItemsPerPage.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeListPasswordTokenResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListUser invokes listUser operation. +// +// List Users. +// +// GET /users +func (c *Client) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) { + res, err := c.sendListUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListUser(ctx context.Context, params ListUserParams) (res ListUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ListUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "page" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Page.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "itemsPerPage" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ItemsPerPage.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeListUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ListUserOwner invokes listUserOwner operation. +// +// List attached Owners. +// +// GET /users/{id}/owner +func (c *Client) ListUserOwner(ctx context.Context, params ListUserOwnerParams) (ListUserOwnerRes, error) { + res, err := c.sendListUserOwner(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendListUserOwner(ctx context.Context, params ListUserOwnerParams) (res ListUserOwnerRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserOwner"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ListUserOwner", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + u.Path += "/owner" + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "page" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "page", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Page.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "itemsPerPage" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "itemsPerPage", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.ItemsPerPage.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeListUserOwnerResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadPasswordToken invokes readPasswordToken operation. +// +// Finds the PasswordToken with the requested ID and returns it. +// +// GET /password-tokens/{id} +func (c *Client) ReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (ReadPasswordTokenRes, error) { + res, err := c.sendReadPasswordToken(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (res ReadPasswordTokenRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readPasswordToken"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ReadPasswordToken", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeReadPasswordTokenResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadPasswordTokenUser invokes readPasswordTokenUser operation. +// +// Find the attached User of the PasswordToken with the given ID. +// +// GET /password-tokens/{id}/user +func (c *Client) ReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (ReadPasswordTokenUserRes, error) { + res, err := c.sendReadPasswordTokenUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (res ReadPasswordTokenUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readPasswordTokenUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ReadPasswordTokenUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + u.Path += "/user" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeReadPasswordTokenUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// ReadUser invokes readUser operation. +// +// Finds the User with the requested ID and returns it. +// +// GET /users/{id} +func (c *Client) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) { + res, err := c.sendReadUser(ctx, params) + _ = res + return res, err +} + +func (c *Client) sendReadUser(ctx context.Context, params ReadUserParams) (res ReadUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "ReadUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeReadUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdatePasswordToken invokes updatePasswordToken operation. +// +// Updates a PasswordToken and persists changes to storage. +// +// PATCH /password-tokens/{id} +func (c *Client) UpdatePasswordToken(ctx context.Context, request *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (UpdatePasswordTokenRes, error) { + res, err := c.sendUpdatePasswordToken(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdatePasswordToken(ctx context.Context, request *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (res UpdatePasswordTokenRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updatePasswordToken"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "UpdatePasswordToken", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/password-tokens/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PATCH", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdatePasswordTokenRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeUpdatePasswordTokenResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// UpdateUser invokes updateUser operation. +// +// Updates a User and persists changes to storage. +// +// PATCH /users/{id} +func (c *Client) UpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) { + res, err := c.sendUpdateUser(ctx, request, params) + _ = res + return res, err +} + +func (c *Client) sendUpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (res UpdateUserRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateUser"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "UpdateUser", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + u.Path += "/users/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.IntToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + u.Path += e.Result() + } + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "PATCH", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeUpdateUserRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeUpdateUserResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} diff --git a/ent/ogent/oas_handlers_gen.go b/ent/ogent/oas_handlers_gen.go new file mode 100644 index 0000000..44775b6 --- /dev/null +++ b/ent/ogent/oas_handlers_gen.go @@ -0,0 +1,1288 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "context" + "net/http" + "time" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + "go.opentelemetry.io/otel/trace" + + "github.com/ogen-go/ogen/middleware" + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/otelogen" +) + +// handleCreatePasswordTokenRequest handles createPasswordToken operation. +// +// Creates a new PasswordToken and persists it to storage. +// +// POST /password-tokens +func (s *Server) handleCreatePasswordTokenRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createPasswordToken"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/password-tokens"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreatePasswordToken", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "CreatePasswordToken", + ID: "createPasswordToken", + } + ) + request, close, err := s.decodeCreatePasswordTokenRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response CreatePasswordTokenRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreatePasswordToken", + OperationID: "createPasswordToken", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreatePasswordTokenReq + Params = struct{} + Response = CreatePasswordTokenRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.CreatePasswordToken(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreatePasswordToken(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeCreatePasswordTokenResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleCreateUserRequest handles createUser operation. +// +// Creates a new User and persists it to storage. +// +// POST /users +func (s *Server) handleCreateUserRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("createUser"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/users"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "CreateUser", + ID: "createUser", + } + ) + request, close, err := s.decodeCreateUserRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response CreateUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "CreateUser", + OperationID: "createUser", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = *CreateUserReq + Params = struct{} + Response = CreateUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.CreateUser(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.CreateUser(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeCreateUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleDeletePasswordTokenRequest handles deletePasswordToken operation. +// +// Deletes the PasswordToken with the requested ID. +// +// DELETE /password-tokens/{id} +func (s *Server) handleDeletePasswordTokenRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deletePasswordToken"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/password-tokens/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeletePasswordToken", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "DeletePasswordToken", + ID: "deletePasswordToken", + } + ) + params, err := decodeDeletePasswordTokenParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response DeletePasswordTokenRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeletePasswordToken", + OperationID: "deletePasswordToken", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeletePasswordTokenParams + Response = DeletePasswordTokenRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeletePasswordTokenParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeletePasswordToken(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeletePasswordToken(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDeletePasswordTokenResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleDeleteUserRequest handles deleteUser operation. +// +// Deletes the User with the requested ID. +// +// DELETE /users/{id} +func (s *Server) handleDeleteUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("deleteUser"), + semconv.HTTPMethodKey.String("DELETE"), + semconv.HTTPRouteKey.String("/users/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "DeleteUser", + ID: "deleteUser", + } + ) + params, err := decodeDeleteUserParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response DeleteUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "DeleteUser", + OperationID: "deleteUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = DeleteUserParams + Response = DeleteUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackDeleteUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.DeleteUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.DeleteUser(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeDeleteUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListPasswordTokenRequest handles listPasswordToken operation. +// +// List PasswordTokens. +// +// GET /password-tokens +func (s *Server) handleListPasswordTokenRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listPasswordToken"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/password-tokens"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListPasswordToken", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ListPasswordToken", + ID: "listPasswordToken", + } + ) + params, err := decodeListPasswordTokenParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ListPasswordTokenRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListPasswordToken", + OperationID: "listPasswordToken", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListPasswordTokenParams + Response = ListPasswordTokenRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListPasswordTokenParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListPasswordToken(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListPasswordToken(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListPasswordTokenResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListUserRequest handles listUser operation. +// +// List Users. +// +// GET /users +func (s *Server) handleListUserRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUser"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ListUser", + ID: "listUser", + } + ) + params, err := decodeListUserParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ListUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListUser", + OperationID: "listUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListUserParams + Response = ListUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListUser(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleListUserOwnerRequest handles listUserOwner operation. +// +// List attached Owners. +// +// GET /users/{id}/owner +func (s *Server) handleListUserOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("listUserOwner"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users/{id}/owner"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserOwner", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ListUserOwner", + ID: "listUserOwner", + } + ) + params, err := decodeListUserOwnerParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ListUserOwnerRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ListUserOwner", + OperationID: "listUserOwner", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + { + Name: "page", + In: "query", + }: params.Page, + { + Name: "itemsPerPage", + In: "query", + }: params.ItemsPerPage, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ListUserOwnerParams + Response = ListUserOwnerRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackListUserOwnerParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ListUserOwner(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ListUserOwner(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeListUserOwnerResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadPasswordTokenRequest handles readPasswordToken operation. +// +// Finds the PasswordToken with the requested ID and returns it. +// +// GET /password-tokens/{id} +func (s *Server) handleReadPasswordTokenRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readPasswordToken"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/password-tokens/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadPasswordToken", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ReadPasswordToken", + ID: "readPasswordToken", + } + ) + params, err := decodeReadPasswordTokenParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ReadPasswordTokenRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadPasswordToken", + OperationID: "readPasswordToken", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadPasswordTokenParams + Response = ReadPasswordTokenRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadPasswordTokenParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadPasswordToken(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadPasswordToken(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadPasswordTokenResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadPasswordTokenUserRequest handles readPasswordTokenUser operation. +// +// Find the attached User of the PasswordToken with the given ID. +// +// GET /password-tokens/{id}/user +func (s *Server) handleReadPasswordTokenUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readPasswordTokenUser"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/password-tokens/{id}/user"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadPasswordTokenUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ReadPasswordTokenUser", + ID: "readPasswordTokenUser", + } + ) + params, err := decodeReadPasswordTokenUserParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ReadPasswordTokenUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadPasswordTokenUser", + OperationID: "readPasswordTokenUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadPasswordTokenUserParams + Response = ReadPasswordTokenUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadPasswordTokenUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadPasswordTokenUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadPasswordTokenUser(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadPasswordTokenUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleReadUserRequest handles readUser operation. +// +// Finds the User with the requested ID and returns it. +// +// GET /users/{id} +func (s *Server) handleReadUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("readUser"), + semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/users/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "ReadUser", + ID: "readUser", + } + ) + params, err := decodeReadUserParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var response ReadUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "ReadUser", + OperationID: "readUser", + Body: nil, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ReadUserParams + Response = ReadUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackReadUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.ReadUser(ctx, params) + return response, err + }, + ) + } else { + response, err = s.h.ReadUser(ctx, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeReadUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleUpdatePasswordTokenRequest handles updatePasswordToken operation. +// +// Updates a PasswordToken and persists changes to storage. +// +// PATCH /password-tokens/{id} +func (s *Server) handleUpdatePasswordTokenRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updatePasswordToken"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/password-tokens/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdatePasswordToken", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "UpdatePasswordToken", + ID: "updatePasswordToken", + } + ) + params, err := decodeUpdatePasswordTokenParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + request, close, err := s.decodeUpdatePasswordTokenRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response UpdatePasswordTokenRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdatePasswordToken", + OperationID: "updatePasswordToken", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdatePasswordTokenReq + Params = UpdatePasswordTokenParams + Response = UpdatePasswordTokenRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdatePasswordTokenParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdatePasswordToken(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdatePasswordToken(ctx, request, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUpdatePasswordTokenResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// handleUpdateUserRequest handles updateUser operation. +// +// Updates a User and persists changes to storage. +// +// PATCH /users/{id} +func (s *Server) handleUpdateUserRequest(args [1]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("updateUser"), + semconv.HTTPMethodKey.String("PATCH"), + semconv.HTTPRouteKey.String("/users/{id}"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateUser", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "UpdateUser", + ID: "updateUser", + } + ) + params, err := decodeUpdateUserParams(args, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + request, close, err := s.decodeUpdateUserRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response UpdateUserRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "UpdateUser", + OperationID: "updateUser", + Body: request, + Params: middleware.Parameters{ + { + Name: "id", + In: "path", + }: params.ID, + }, + Raw: r, + } + + type ( + Request = *UpdateUserReq + Params = UpdateUserParams + Response = UpdateUserRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackUpdateUserParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.UpdateUser(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.UpdateUser(ctx, request, params) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeUpdateUserResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} diff --git a/ent/ogent/oas_interfaces_gen.go b/ent/ogent/oas_interfaces_gen.go new file mode 100644 index 0000000..8502c4a --- /dev/null +++ b/ent/ogent/oas_interfaces_gen.go @@ -0,0 +1,50 @@ +// 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() +} diff --git a/ent/ogent/oas_json_gen.go b/ent/ogent/oas_json_gen.go new file mode 100644 index 0000000..ea98890 --- /dev/null +++ b/ent/ogent/oas_json_gen.go @@ -0,0 +1,2834 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "math/bits" + "strconv" + "time" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + + "github.com/ogen-go/ogen/json" + "github.com/ogen-go/ogen/validate" +) + +// Encode implements json.Marshaler. +func (s *CreatePasswordTokenReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreatePasswordTokenReq) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("hash") + e.Str(s.Hash) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } + { + + e.FieldStart("user") + e.Int(s.User) + } +} + +var jsonFieldsNameOfCreatePasswordTokenReq = [3]string{ + 0: "hash", + 1: "created_at", + 2: "user", +} + +// Decode decodes CreatePasswordTokenReq from json. +func (s *CreatePasswordTokenReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreatePasswordTokenReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "hash": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Hash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"hash\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "user": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.User = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"user\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreatePasswordTokenReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreatePasswordTokenReq) { + name = jsonFieldsNameOfCreatePasswordTokenReq[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreatePasswordTokenReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreatePasswordTokenReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CreateUserReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CreateUserReq) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("password") + e.Str(s.Password) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } + { + if s.Owner != nil { + e.FieldStart("owner") + e.ArrStart() + for _, elem := range s.Owner { + e.Int(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfCreateUserReq = [6]string{ + 0: "name", + 1: "email", + 2: "password", + 3: "verified", + 4: "created_at", + 5: "owner", +} + +// Decode decodes CreateUserReq from json. +func (s *CreateUserReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CreateUserReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "name": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "password": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Password = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"password\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "owner": + if err := func() error { + s.Owner = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + s.Owner = append(s.Owner, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"owner\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CreateUserReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfCreateUserReq) { + name = jsonFieldsNameOfCreateUserReq[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *CreateUserReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CreateUserReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListPasswordTokenOKApplicationJSON as json. +func (s ListPasswordTokenOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []PasswordTokenList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListPasswordTokenOKApplicationJSON from json. +func (s *ListPasswordTokenOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListPasswordTokenOKApplicationJSON to nil") + } + var unwrapped []PasswordTokenList + if err := func() error { + unwrapped = make([]PasswordTokenList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem PasswordTokenList + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ListPasswordTokenOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListPasswordTokenOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListPasswordTokenOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListUserOKApplicationJSON as json. +func (s ListUserOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []UserList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListUserOKApplicationJSON from json. +func (s *ListUserOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListUserOKApplicationJSON to nil") + } + var unwrapped []UserList + if err := func() error { + unwrapped = make([]UserList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem UserList + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ListUserOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListUserOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListUserOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ListUserOwnerOKApplicationJSON as json. +func (s ListUserOwnerOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := []UserOwnerList(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() +} + +// Decode decodes ListUserOwnerOKApplicationJSON from json. +func (s *ListUserOwnerOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ListUserOwnerOKApplicationJSON to nil") + } + var unwrapped []UserOwnerList + if err := func() error { + unwrapped = make([]UserOwnerList, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem UserOwnerList + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ListUserOwnerOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ListUserOwnerOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ListUserOwnerOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes bool as json. +func (o OptBool) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Bool(bool(o.Value)) +} + +// Decode decodes bool from json. +func (o *OptBool) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptBool to nil") + } + o.Set = true + v, err := d.Bool() + if err != nil { + return err + } + o.Value = bool(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptBool) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptBool) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes time.Time as json. +func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { + if !o.Set { + return + } + format(e, o.Value) +} + +// Decode decodes time.Time from json. +func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { + if o == nil { + return errors.New("invalid: unable to decode OptDateTime to nil") + } + o.Set = true + v, err := format(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDateTime) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e, json.EncodeDateTime) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDateTime) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d, json.DecodeDateTime) +} + +// Encode encodes int as json. +func (o OptInt) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Int(int(o.Value)) +} + +// Decode decodes int from json. +func (o *OptInt) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptInt to nil") + } + o.Set = true + v, err := d.Int() + if err != nil { + return err + } + o.Value = int(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptInt) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptInt) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes string as json. +func (o OptString) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Str(string(o.Value)) +} + +// Decode decodes string from json. +func (o *OptString) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptString to nil") + } + o.Set = true + v, err := d.Str() + if err != nil { + return err + } + o.Value = string(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptString) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptString) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PasswordTokenCreate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PasswordTokenCreate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfPasswordTokenCreate = [2]string{ + 0: "id", + 1: "created_at", +} + +// Decode decodes PasswordTokenCreate from json. +func (s *PasswordTokenCreate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PasswordTokenCreate to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PasswordTokenCreate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfPasswordTokenCreate) { + name = jsonFieldsNameOfPasswordTokenCreate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PasswordTokenCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PasswordTokenCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PasswordTokenList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PasswordTokenList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfPasswordTokenList = [2]string{ + 0: "id", + 1: "created_at", +} + +// Decode decodes PasswordTokenList from json. +func (s *PasswordTokenList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PasswordTokenList to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PasswordTokenList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfPasswordTokenList) { + name = jsonFieldsNameOfPasswordTokenList[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PasswordTokenList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PasswordTokenList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PasswordTokenRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PasswordTokenRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfPasswordTokenRead = [2]string{ + 0: "id", + 1: "created_at", +} + +// Decode decodes PasswordTokenRead from json. +func (s *PasswordTokenRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PasswordTokenRead to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PasswordTokenRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfPasswordTokenRead) { + name = jsonFieldsNameOfPasswordTokenRead[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PasswordTokenRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PasswordTokenRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PasswordTokenUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PasswordTokenUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfPasswordTokenUpdate = [2]string{ + 0: "id", + 1: "created_at", +} + +// Decode decodes PasswordTokenUpdate from json. +func (s *PasswordTokenUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PasswordTokenUpdate to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PasswordTokenUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfPasswordTokenUpdate) { + name = jsonFieldsNameOfPasswordTokenUpdate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PasswordTokenUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PasswordTokenUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PasswordTokenUserRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PasswordTokenUserRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfPasswordTokenUserRead = [5]string{ + 0: "id", + 1: "name", + 2: "email", + 3: "verified", + 4: "created_at", +} + +// Decode decodes PasswordTokenUserRead from json. +func (s *PasswordTokenUserRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PasswordTokenUserRead to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PasswordTokenUserRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfPasswordTokenUserRead) { + name = jsonFieldsNameOfPasswordTokenUserRead[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PasswordTokenUserRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PasswordTokenUserRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *R400) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *R400) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("code") + e.Int(s.Code) + } + { + + e.FieldStart("status") + e.Str(s.Status) + } + { + + if len(s.Errors) != 0 { + e.FieldStart("errors") + e.Raw(s.Errors) + } + } +} + +var jsonFieldsNameOfR400 = [3]string{ + 0: "code", + 1: "status", + 2: "errors", +} + +// Decode decodes R400 from json. +func (s *R400) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode R400 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Code = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code\"") + } + case "status": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "errors": + if err := func() error { + v, err := d.RawAppend(nil) + s.Errors = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"errors\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode R400") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfR400) { + name = jsonFieldsNameOfR400[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *R400) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R400) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *R404) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *R404) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("code") + e.Int(s.Code) + } + { + + e.FieldStart("status") + e.Str(s.Status) + } + { + + if len(s.Errors) != 0 { + e.FieldStart("errors") + e.Raw(s.Errors) + } + } +} + +var jsonFieldsNameOfR404 = [3]string{ + 0: "code", + 1: "status", + 2: "errors", +} + +// Decode decodes R404 from json. +func (s *R404) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode R404 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Code = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code\"") + } + case "status": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "errors": + if err := func() error { + v, err := d.RawAppend(nil) + s.Errors = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"errors\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode R404") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfR404) { + name = jsonFieldsNameOfR404[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *R404) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R404) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *R409) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *R409) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("code") + e.Int(s.Code) + } + { + + e.FieldStart("status") + e.Str(s.Status) + } + { + + if len(s.Errors) != 0 { + e.FieldStart("errors") + e.Raw(s.Errors) + } + } +} + +var jsonFieldsNameOfR409 = [3]string{ + 0: "code", + 1: "status", + 2: "errors", +} + +// Decode decodes R409 from json. +func (s *R409) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode R409 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Code = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code\"") + } + case "status": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "errors": + if err := func() error { + v, err := d.RawAppend(nil) + s.Errors = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"errors\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode R409") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfR409) { + name = jsonFieldsNameOfR409[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *R409) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R409) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *R500) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *R500) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("code") + e.Int(s.Code) + } + { + + e.FieldStart("status") + e.Str(s.Status) + } + { + + if len(s.Errors) != 0 { + e.FieldStart("errors") + e.Raw(s.Errors) + } + } +} + +var jsonFieldsNameOfR500 = [3]string{ + 0: "code", + 1: "status", + 2: "errors", +} + +// Decode decodes R500 from json. +func (s *R500) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode R500 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.Code = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code\"") + } + case "status": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Status = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "errors": + if err := func() error { + v, err := d.RawAppend(nil) + s.Errors = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"errors\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode R500") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfR500) { + name = jsonFieldsNameOfR500[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *R500) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *R500) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdatePasswordTokenReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdatePasswordTokenReq) encodeFields(e *jx.Encoder) { + { + if s.Hash.Set { + e.FieldStart("hash") + s.Hash.Encode(e) + } + } + { + if s.CreatedAt.Set { + e.FieldStart("created_at") + s.CreatedAt.Encode(e, json.EncodeDateTime) + } + } + { + if s.User.Set { + e.FieldStart("user") + s.User.Encode(e) + } + } +} + +var jsonFieldsNameOfUpdatePasswordTokenReq = [3]string{ + 0: "hash", + 1: "created_at", + 2: "user", +} + +// Decode decodes UpdatePasswordTokenReq from json. +func (s *UpdatePasswordTokenReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdatePasswordTokenReq to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "hash": + if err := func() error { + s.Hash.Reset() + if err := s.Hash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"hash\"") + } + case "created_at": + if err := func() error { + s.CreatedAt.Reset() + if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "user": + if err := func() error { + s.User.Reset() + if err := s.User.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"user\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdatePasswordTokenReq") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdatePasswordTokenReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdatePasswordTokenReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UpdateUserReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UpdateUserReq) encodeFields(e *jx.Encoder) { + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } + { + if s.Email.Set { + e.FieldStart("email") + s.Email.Encode(e) + } + } + { + if s.Password.Set { + e.FieldStart("password") + s.Password.Encode(e) + } + } + { + if s.Verified.Set { + e.FieldStart("verified") + s.Verified.Encode(e) + } + } + { + if s.Owner != nil { + e.FieldStart("owner") + e.ArrStart() + for _, elem := range s.Owner { + e.Int(elem) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfUpdateUserReq = [5]string{ + 0: "name", + 1: "email", + 2: "password", + 3: "verified", + 4: "owner", +} + +// Decode decodes UpdateUserReq from json. +func (s *UpdateUserReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UpdateUserReq to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + if err := func() error { + s.Email.Reset() + if err := s.Email.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "password": + if err := func() error { + s.Password.Reset() + if err := s.Password.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"password\"") + } + case "verified": + if err := func() error { + s.Verified.Reset() + if err := s.Verified.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "owner": + if err := func() error { + s.Owner = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + s.Owner = append(s.Owner, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"owner\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UpdateUserReq") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UpdateUserReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UpdateUserReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserCreate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserCreate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfUserCreate = [5]string{ + 0: "id", + 1: "name", + 2: "email", + 3: "verified", + 4: "created_at", +} + +// Decode decodes UserCreate from json. +func (s *UserCreate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserCreate to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserCreate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserCreate) { + name = jsonFieldsNameOfUserCreate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserCreate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserCreate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfUserList = [5]string{ + 0: "id", + 1: "name", + 2: "email", + 3: "verified", + 4: "created_at", +} + +// Decode decodes UserList from json. +func (s *UserList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserList to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserList) { + name = jsonFieldsNameOfUserList[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserOwnerList) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserOwnerList) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfUserOwnerList = [2]string{ + 0: "id", + 1: "created_at", +} + +// Decode decodes UserOwnerList from json. +func (s *UserOwnerList) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserOwnerList to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserOwnerList") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000011, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserOwnerList) { + name = jsonFieldsNameOfUserOwnerList[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserOwnerList) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserOwnerList) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserRead) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserRead) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfUserRead = [5]string{ + 0: "id", + 1: "name", + 2: "email", + 3: "verified", + 4: "created_at", +} + +// Decode decodes UserRead from json. +func (s *UserRead) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserRead to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserRead") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserRead) { + name = jsonFieldsNameOfUserRead[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserRead) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserRead) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *UserUpdate) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *UserUpdate) encodeFields(e *jx.Encoder) { + { + + e.FieldStart("id") + e.Int(s.ID) + } + { + + e.FieldStart("name") + e.Str(s.Name) + } + { + + e.FieldStart("email") + e.Str(s.Email) + } + { + + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + + e.FieldStart("created_at") + json.EncodeDateTime(e, s.CreatedAt) + } +} + +var jsonFieldsNameOfUserUpdate = [5]string{ + 0: "id", + 1: "name", + 2: "email", + 3: "verified", + 4: "created_at", +} + +// Decode decodes UserUpdate from json. +func (s *UserUpdate) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode UserUpdate to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "id": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int() + s.ID = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "email": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Email = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"email\"") + } + case "verified": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "created_at": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := json.DecodeDateTime(d) + s.CreatedAt = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UserUpdate") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011111, + } { + if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { + // Mask only required fields and check equality to mask using XOR. + // + // If XOR result is not zero, result is not equal to expected, so some fields are missed. + // Bits of fields which would be set are actually bits of missed fields. + missed := bits.OnesCount8(result) + for bitN := 0; bitN < missed; bitN++ { + bitIdx := bits.TrailingZeros8(result) + fieldIdx := i*8 + bitIdx + var name string + if fieldIdx < len(jsonFieldsNameOfUserUpdate) { + name = jsonFieldsNameOfUserUpdate[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) + } + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *UserUpdate) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UserUpdate) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} diff --git a/ent/ogent/oas_middleware_gen.go b/ent/ogent/oas_middleware_gen.go new file mode 100644 index 0000000..3a7593f --- /dev/null +++ b/ent/ogent/oas_middleware_gen.go @@ -0,0 +1,10 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "github.com/ogen-go/ogen/middleware" +) + +// Middleware is middleware type. +type Middleware = middleware.Middleware diff --git a/ent/ogent/oas_parameters_gen.go b/ent/ogent/oas_parameters_gen.go new file mode 100644 index 0000000..d946076 --- /dev/null +++ b/ent/ogent/oas_parameters_gen.go @@ -0,0 +1,947 @@ +// 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 +} diff --git a/ent/ogent/oas_request_decoders_gen.go b/ent/ogent/oas_request_decoders_gen.go new file mode 100644 index 0000000..e9a4cfb --- /dev/null +++ b/ent/ogent/oas_request_decoders_gen.go @@ -0,0 +1,268 @@ +// 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) + } +} diff --git a/ent/ogent/oas_request_encoders_gen.go b/ent/ogent/oas_request_encoders_gen.go new file mode 100644 index 0000000..cd7da3f --- /dev/null +++ b/ent/ogent/oas_request_encoders_gen.go @@ -0,0 +1,68 @@ +// 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 +} diff --git a/ent/ogent/oas_response_decoders_gen.go b/ent/ogent/oas_response_decoders_gen.go new file mode 100644 index 0000000..5ca71c8 --- /dev/null +++ b/ent/ogent/oas_response_decoders_gen.go @@ -0,0 +1,2053 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "io" + "mime" + "net/http" + + "github.com/go-faster/errors" + "github.com/go-faster/jx" + + "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/validate" +) + +func decodeCreatePasswordTokenResponse(resp *http.Response) (res CreatePasswordTokenRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response PasswordTokenCreate + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeCreateUserResponse(resp *http.Response) (res CreateUserRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response UserCreate + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeDeletePasswordTokenResponse(resp *http.Response) (res DeletePasswordTokenRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeletePasswordTokenNoContent{}, nil + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeDeleteUserResponse(resp *http.Response) (res DeleteUserRes, err error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &DeleteUserNoContent{}, nil + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeListPasswordTokenResponse(resp *http.Response) (res ListPasswordTokenRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListPasswordTokenOKApplicationJSON + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeListUserResponse(resp *http.Response) (res ListUserRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListUserOKApplicationJSON + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeListUserOwnerResponse(resp *http.Response) (res ListUserOwnerRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response ListUserOwnerOKApplicationJSON + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeReadPasswordTokenResponse(resp *http.Response) (res ReadPasswordTokenRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response PasswordTokenRead + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeReadPasswordTokenUserResponse(resp *http.Response) (res ReadPasswordTokenUserRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response PasswordTokenUserRead + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeReadUserResponse(resp *http.Response) (res ReadUserRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response UserRead + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeUpdatePasswordTokenResponse(resp *http.Response) (res UpdatePasswordTokenRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response PasswordTokenUpdate + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeUpdateUserResponse(resp *http.Response) (res UpdateUserRes, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response UserUpdate + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 400: + // Code 400. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R400 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 404: + // Code 404. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R404 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 409: + // Code 409. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R409 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + case 500: + // Code 500. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response R500 + if err := func() error { + if err := response.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 res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} diff --git a/ent/ogent/oas_response_encoders_gen.go b/ent/ogent/oas_response_encoders_gen.go new file mode 100644 index 0000000..408f86b --- /dev/null +++ b/ent/ogent/oas_response_encoders_gen.go @@ -0,0 +1,780 @@ +// 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) + } +} diff --git a/ent/ogent/oas_router_gen.go b/ent/ogent/oas_router_gen.go new file mode 100644 index 0000000..cdec43e --- /dev/null +++ b/ent/ogent/oas_router_gen.go @@ -0,0 +1,489 @@ +// 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 +} diff --git a/ent/ogent/oas_schemas_gen.go b/ent/ogent/oas_schemas_gen.go new file mode 100644 index 0000000..8c4ce53 --- /dev/null +++ b/ent/ogent/oas_schemas_gen.go @@ -0,0 +1,1047 @@ +// Code generated by ogen, DO NOT EDIT. + +package ogent + +import ( + "time" + + "github.com/go-faster/jx" +) + +type CreatePasswordTokenReq struct { + Hash string `form:"hash"` + CreatedAt time.Time `form:"created_at"` + User int `form:"user"` +} + +// GetHash returns the value of Hash. +func (s *CreatePasswordTokenReq) GetHash() string { + return s.Hash +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CreatePasswordTokenReq) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// GetUser returns the value of User. +func (s *CreatePasswordTokenReq) GetUser() int { + return s.User +} + +// SetHash sets the value of Hash. +func (s *CreatePasswordTokenReq) SetHash(val string) { + s.Hash = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CreatePasswordTokenReq) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// SetUser sets the value of User. +func (s *CreatePasswordTokenReq) SetUser(val int) { + s.User = val +} + +type CreateUserReq struct { + Name string `form:"name"` + Email string `form:"email"` + Password string `form:"password"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` + Owner []int `form:"owner"` +} + +// GetName returns the value of Name. +func (s *CreateUserReq) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *CreateUserReq) GetEmail() string { + return s.Email +} + +// GetPassword returns the value of Password. +func (s *CreateUserReq) GetPassword() string { + return s.Password +} + +// GetVerified returns the value of Verified. +func (s *CreateUserReq) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *CreateUserReq) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// GetOwner returns the value of Owner. +func (s *CreateUserReq) GetOwner() []int { + return s.Owner +} + +// SetName sets the value of Name. +func (s *CreateUserReq) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *CreateUserReq) SetEmail(val string) { + s.Email = val +} + +// SetPassword sets the value of Password. +func (s *CreateUserReq) SetPassword(val string) { + s.Password = val +} + +// SetVerified sets the value of Verified. +func (s *CreateUserReq) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *CreateUserReq) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// SetOwner sets the value of Owner. +func (s *CreateUserReq) SetOwner(val []int) { + s.Owner = val +} + +// DeletePasswordTokenNoContent is response for DeletePasswordToken operation. +type DeletePasswordTokenNoContent struct{} + +func (*DeletePasswordTokenNoContent) deletePasswordTokenRes() {} + +// DeleteUserNoContent is response for DeleteUser operation. +type DeleteUserNoContent struct{} + +func (*DeleteUserNoContent) deleteUserRes() {} + +type ListPasswordTokenOKApplicationJSON []PasswordTokenList + +func (*ListPasswordTokenOKApplicationJSON) listPasswordTokenRes() {} + +type ListUserOKApplicationJSON []UserList + +func (*ListUserOKApplicationJSON) listUserRes() {} + +type ListUserOwnerOKApplicationJSON []UserOwnerList + +func (*ListUserOwnerOKApplicationJSON) listUserOwnerRes() {} + +// NewOptBool returns new OptBool with value set to v. +func NewOptBool(v bool) OptBool { + return OptBool{ + Value: v, + Set: true, + } +} + +// OptBool is optional bool. +type OptBool struct { + Value bool + Set bool +} + +// IsSet returns true if OptBool was set. +func (o OptBool) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptBool) Reset() { + var v bool + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptBool) SetTo(v bool) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptBool) Get() (v bool, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptBool) Or(d bool) bool { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDateTime returns new OptDateTime with value set to v. +func NewOptDateTime(v time.Time) OptDateTime { + return OptDateTime{ + Value: v, + Set: true, + } +} + +// OptDateTime is optional time.Time. +type OptDateTime struct { + Value time.Time + Set bool +} + +// IsSet returns true if OptDateTime was set. +func (o OptDateTime) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDateTime) Reset() { + var v time.Time + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDateTime) SetTo(v time.Time) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDateTime) Get() (v time.Time, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptDateTime) Or(d time.Time) time.Time { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptInt returns new OptInt with value set to v. +func NewOptInt(v int) OptInt { + return OptInt{ + Value: v, + Set: true, + } +} + +// OptInt is optional int. +type OptInt struct { + Value int + Set bool +} + +// IsSet returns true if OptInt was set. +func (o OptInt) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptInt) Reset() { + var v int + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptInt) SetTo(v int) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptInt) Get() (v int, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptInt) Or(d int) int { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptString returns new OptString with value set to v. +func NewOptString(v string) OptString { + return OptString{ + Value: v, + Set: true, + } +} + +// OptString is optional string. +type OptString struct { + Value string + Set bool +} + +// IsSet returns true if OptString was set. +func (o OptString) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptString) Reset() { + var v string + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptString) SetTo(v string) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptString) Get() (v string, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptString) Or(d string) string { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// Ref: #/components/schemas/PasswordTokenCreate +type PasswordTokenCreate struct { + ID int `form:"id"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *PasswordTokenCreate) GetID() int { + return s.ID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *PasswordTokenCreate) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *PasswordTokenCreate) SetID(val int) { + s.ID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *PasswordTokenCreate) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*PasswordTokenCreate) createPasswordTokenRes() {} + +// Ref: #/components/schemas/PasswordTokenList +type PasswordTokenList struct { + ID int `form:"id"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *PasswordTokenList) GetID() int { + return s.ID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *PasswordTokenList) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *PasswordTokenList) SetID(val int) { + s.ID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *PasswordTokenList) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/PasswordTokenRead +type PasswordTokenRead struct { + ID int `form:"id"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *PasswordTokenRead) GetID() int { + return s.ID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *PasswordTokenRead) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *PasswordTokenRead) SetID(val int) { + s.ID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *PasswordTokenRead) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*PasswordTokenRead) readPasswordTokenRes() {} + +// Ref: #/components/schemas/PasswordTokenUpdate +type PasswordTokenUpdate struct { + ID int `form:"id"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *PasswordTokenUpdate) GetID() int { + return s.ID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *PasswordTokenUpdate) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *PasswordTokenUpdate) SetID(val int) { + s.ID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *PasswordTokenUpdate) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*PasswordTokenUpdate) updatePasswordTokenRes() {} + +// Ref: #/components/schemas/PasswordToken_UserRead +type PasswordTokenUserRead struct { + ID int `form:"id"` + Name string `form:"name"` + Email string `form:"email"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *PasswordTokenUserRead) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *PasswordTokenUserRead) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *PasswordTokenUserRead) GetEmail() string { + return s.Email +} + +// GetVerified returns the value of Verified. +func (s *PasswordTokenUserRead) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *PasswordTokenUserRead) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *PasswordTokenUserRead) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *PasswordTokenUserRead) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *PasswordTokenUserRead) SetEmail(val string) { + s.Email = val +} + +// SetVerified sets the value of Verified. +func (s *PasswordTokenUserRead) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *PasswordTokenUserRead) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*PasswordTokenUserRead) readPasswordTokenUserRes() {} + +type R400 struct { + Code int `form:"code"` + Status string `form:"status"` + Errors jx.Raw `form:"errors"` +} + +// GetCode returns the value of Code. +func (s *R400) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R400) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R400) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R400) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R400) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R400) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R400) createPasswordTokenRes() {} +func (*R400) createUserRes() {} +func (*R400) deletePasswordTokenRes() {} +func (*R400) deleteUserRes() {} +func (*R400) listPasswordTokenRes() {} +func (*R400) listUserOwnerRes() {} +func (*R400) listUserRes() {} +func (*R400) readPasswordTokenRes() {} +func (*R400) readPasswordTokenUserRes() {} +func (*R400) readUserRes() {} +func (*R400) updatePasswordTokenRes() {} +func (*R400) updateUserRes() {} + +type R404 struct { + Code int `form:"code"` + Status string `form:"status"` + Errors jx.Raw `form:"errors"` +} + +// GetCode returns the value of Code. +func (s *R404) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R404) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R404) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R404) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R404) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R404) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R404) deletePasswordTokenRes() {} +func (*R404) deleteUserRes() {} +func (*R404) listPasswordTokenRes() {} +func (*R404) listUserOwnerRes() {} +func (*R404) listUserRes() {} +func (*R404) readPasswordTokenRes() {} +func (*R404) readPasswordTokenUserRes() {} +func (*R404) readUserRes() {} +func (*R404) updatePasswordTokenRes() {} +func (*R404) updateUserRes() {} + +type R409 struct { + Code int `form:"code"` + Status string `form:"status"` + Errors jx.Raw `form:"errors"` +} + +// GetCode returns the value of Code. +func (s *R409) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R409) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R409) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R409) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R409) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R409) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R409) createPasswordTokenRes() {} +func (*R409) createUserRes() {} +func (*R409) deletePasswordTokenRes() {} +func (*R409) deleteUserRes() {} +func (*R409) listPasswordTokenRes() {} +func (*R409) listUserOwnerRes() {} +func (*R409) listUserRes() {} +func (*R409) readPasswordTokenRes() {} +func (*R409) readPasswordTokenUserRes() {} +func (*R409) readUserRes() {} +func (*R409) updatePasswordTokenRes() {} +func (*R409) updateUserRes() {} + +type R500 struct { + Code int `form:"code"` + Status string `form:"status"` + Errors jx.Raw `form:"errors"` +} + +// GetCode returns the value of Code. +func (s *R500) GetCode() int { + return s.Code +} + +// GetStatus returns the value of Status. +func (s *R500) GetStatus() string { + return s.Status +} + +// GetErrors returns the value of Errors. +func (s *R500) GetErrors() jx.Raw { + return s.Errors +} + +// SetCode sets the value of Code. +func (s *R500) SetCode(val int) { + s.Code = val +} + +// SetStatus sets the value of Status. +func (s *R500) SetStatus(val string) { + s.Status = val +} + +// SetErrors sets the value of Errors. +func (s *R500) SetErrors(val jx.Raw) { + s.Errors = val +} + +func (*R500) createPasswordTokenRes() {} +func (*R500) createUserRes() {} +func (*R500) deletePasswordTokenRes() {} +func (*R500) deleteUserRes() {} +func (*R500) listPasswordTokenRes() {} +func (*R500) listUserOwnerRes() {} +func (*R500) listUserRes() {} +func (*R500) readPasswordTokenRes() {} +func (*R500) readPasswordTokenUserRes() {} +func (*R500) readUserRes() {} +func (*R500) updatePasswordTokenRes() {} +func (*R500) updateUserRes() {} + +type UpdatePasswordTokenReq struct { + Hash OptString `form:"hash"` + CreatedAt OptDateTime `form:"created_at"` + User OptInt `form:"user"` +} + +// GetHash returns the value of Hash. +func (s *UpdatePasswordTokenReq) GetHash() OptString { + return s.Hash +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UpdatePasswordTokenReq) GetCreatedAt() OptDateTime { + return s.CreatedAt +} + +// GetUser returns the value of User. +func (s *UpdatePasswordTokenReq) GetUser() OptInt { + return s.User +} + +// SetHash sets the value of Hash. +func (s *UpdatePasswordTokenReq) SetHash(val OptString) { + s.Hash = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UpdatePasswordTokenReq) SetCreatedAt(val OptDateTime) { + s.CreatedAt = val +} + +// SetUser sets the value of User. +func (s *UpdatePasswordTokenReq) SetUser(val OptInt) { + s.User = val +} + +type UpdateUserReq struct { + Name OptString `form:"name"` + Email OptString `form:"email"` + Password OptString `form:"password"` + Verified OptBool `form:"verified"` + Owner []int `form:"owner"` +} + +// GetName returns the value of Name. +func (s *UpdateUserReq) GetName() OptString { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *UpdateUserReq) GetEmail() OptString { + return s.Email +} + +// GetPassword returns the value of Password. +func (s *UpdateUserReq) GetPassword() OptString { + return s.Password +} + +// GetVerified returns the value of Verified. +func (s *UpdateUserReq) GetVerified() OptBool { + return s.Verified +} + +// GetOwner returns the value of Owner. +func (s *UpdateUserReq) GetOwner() []int { + return s.Owner +} + +// SetName sets the value of Name. +func (s *UpdateUserReq) SetName(val OptString) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *UpdateUserReq) SetEmail(val OptString) { + s.Email = val +} + +// SetPassword sets the value of Password. +func (s *UpdateUserReq) SetPassword(val OptString) { + s.Password = val +} + +// SetVerified sets the value of Verified. +func (s *UpdateUserReq) SetVerified(val OptBool) { + s.Verified = val +} + +// SetOwner sets the value of Owner. +func (s *UpdateUserReq) SetOwner(val []int) { + s.Owner = val +} + +// Ref: #/components/schemas/UserCreate +type UserCreate struct { + ID int `form:"id"` + Name string `form:"name"` + Email string `form:"email"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserCreate) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *UserCreate) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *UserCreate) GetEmail() string { + return s.Email +} + +// GetVerified returns the value of Verified. +func (s *UserCreate) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserCreate) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserCreate) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *UserCreate) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *UserCreate) SetEmail(val string) { + s.Email = val +} + +// SetVerified sets the value of Verified. +func (s *UserCreate) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserCreate) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*UserCreate) createUserRes() {} + +// Ref: #/components/schemas/UserList +type UserList struct { + ID int `form:"id"` + Name string `form:"name"` + Email string `form:"email"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserList) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *UserList) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *UserList) GetEmail() string { + return s.Email +} + +// GetVerified returns the value of Verified. +func (s *UserList) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserList) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserList) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *UserList) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *UserList) SetEmail(val string) { + s.Email = val +} + +// SetVerified sets the value of Verified. +func (s *UserList) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserList) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/User_OwnerList +type UserOwnerList struct { + ID int `form:"id"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserOwnerList) GetID() int { + return s.ID +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserOwnerList) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserOwnerList) SetID(val int) { + s.ID = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserOwnerList) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +// Ref: #/components/schemas/UserRead +type UserRead struct { + ID int `form:"id"` + Name string `form:"name"` + Email string `form:"email"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserRead) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *UserRead) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *UserRead) GetEmail() string { + return s.Email +} + +// GetVerified returns the value of Verified. +func (s *UserRead) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserRead) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserRead) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *UserRead) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *UserRead) SetEmail(val string) { + s.Email = val +} + +// SetVerified sets the value of Verified. +func (s *UserRead) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserRead) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*UserRead) readUserRes() {} + +// Ref: #/components/schemas/UserUpdate +type UserUpdate struct { + ID int `form:"id"` + Name string `form:"name"` + Email string `form:"email"` + Verified bool `form:"verified"` + CreatedAt time.Time `form:"created_at"` +} + +// GetID returns the value of ID. +func (s *UserUpdate) GetID() int { + return s.ID +} + +// GetName returns the value of Name. +func (s *UserUpdate) GetName() string { + return s.Name +} + +// GetEmail returns the value of Email. +func (s *UserUpdate) GetEmail() string { + return s.Email +} + +// GetVerified returns the value of Verified. +func (s *UserUpdate) GetVerified() bool { + return s.Verified +} + +// GetCreatedAt returns the value of CreatedAt. +func (s *UserUpdate) GetCreatedAt() time.Time { + return s.CreatedAt +} + +// SetID sets the value of ID. +func (s *UserUpdate) SetID(val int) { + s.ID = val +} + +// SetName sets the value of Name. +func (s *UserUpdate) SetName(val string) { + s.Name = val +} + +// SetEmail sets the value of Email. +func (s *UserUpdate) SetEmail(val string) { + s.Email = val +} + +// SetVerified sets the value of Verified. +func (s *UserUpdate) SetVerified(val bool) { + s.Verified = val +} + +// SetCreatedAt sets the value of CreatedAt. +func (s *UserUpdate) SetCreatedAt(val time.Time) { + s.CreatedAt = val +} + +func (*UserUpdate) updateUserRes() {} diff --git a/ent/ogent/oas_server_gen.go b/ent/ogent/oas_server_gen.go new file mode 100644 index 0000000..8d8178f --- /dev/null +++ b/ent/ogent/oas_server_gen.go @@ -0,0 +1,102 @@ +// 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 +} diff --git a/ent/ogent/oas_unimplemented_gen.go b/ent/ogent/oas_unimplemented_gen.go new file mode 100644 index 0000000..20d526d --- /dev/null +++ b/ent/ogent/oas_unimplemented_gen.go @@ -0,0 +1,122 @@ +// 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 +} diff --git a/ent/ogent/oas_validators_gen.go b/ent/ogent/oas_validators_gen.go new file mode 100644 index 0000000..5cf2044 --- /dev/null +++ b/ent/ogent/oas_validators_gen.go @@ -0,0 +1,26 @@ +// 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 +} diff --git a/ent/ogent/ogent.go b/ent/ogent/ogent.go new file mode 100644 index 0000000..379e59b --- /dev/null +++ b/ent/ogent/ogent.go @@ -0,0 +1,445 @@ +// Code generated by ent, DO NOT EDIT. + +package ogent + +import ( + "context" + "net/http" + + "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 { + switch { + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsConstraintError(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // 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 { + switch { + case ent.IsNotFound(err): + return &R404{ + Code: http.StatusNotFound, + Status: http.StatusText(http.StatusNotFound), + Errors: rawError(err), + }, nil + case ent.IsNotSingular(err): + return &R409{ + Code: http.StatusConflict, + Status: http.StatusText(http.StatusConflict), + Errors: rawError(err), + }, nil + default: + // Let the server handle the error. + return nil, err + } + } + r := NewUserOwnerLists(es) + return (*ListUserOwnerOKApplicationJSON)(&r), nil +} diff --git a/ent/ogent/responses.go b/ent/ogent/responses.go new file mode 100644 index 0000000..b57eb76 --- /dev/null +++ b/ent/ogent/responses.go @@ -0,0 +1,300 @@ +// 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 +} diff --git a/ent/ogent/time.go b/ent/ogent/time.go new file mode 100644 index 0000000..56a44aa --- /dev/null +++ b/ent/ogent/time.go @@ -0,0 +1,16 @@ +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 +} diff --git a/ent/openapi.json b/ent/openapi.json new file mode 100644 index 0000000..cb1df3a --- /dev/null +++ b/ent/openapi.json @@ -0,0 +1,1068 @@ +{ + "openapi": "3.0.3", + "info": { + "title": "Ent Schema API", + "description": "This is an auto generated API description made out of an Ent schema definition", + "version": "0.1.0" + }, + "paths": { + "/password-tokens": { + "get": { + "tags": [ + "PasswordToken" + ], + "summary": "List PasswordTokens", + "description": "List PasswordTokens.", + "operationId": "listPasswordToken", + "parameters": [ + { + "name": "page", + "in": "query", + "description": "what page to render", + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "itemsPerPage", + "in": "query", + "description": "item count to render per page", + "schema": { + "type": "integer", + "maximum": 255, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result PasswordToken list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/PasswordTokenList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "PasswordToken" + ], + "summary": "Create a new PasswordToken", + "description": "Creates a new PasswordToken and persists it to storage.", + "operationId": "createPasswordToken", + "requestBody": { + "description": "PasswordToken to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "user": { + "type": "integer" + } + }, + "required": [ + "hash", + "created_at", + "user" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "PasswordToken created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PasswordTokenCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/password-tokens/{id}": { + "get": { + "tags": [ + "PasswordToken" + ], + "summary": "Find a PasswordToken by ID", + "description": "Finds the PasswordToken with the requested ID and returns it.", + "operationId": "readPasswordToken", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the PasswordToken", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "PasswordToken with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PasswordTokenRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "PasswordToken" + ], + "summary": "Deletes a PasswordToken by ID", + "description": "Deletes the PasswordToken with the requested ID.", + "operationId": "deletePasswordToken", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the PasswordToken", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "PasswordToken with requested ID was deleted" + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "patch": { + "tags": [ + "PasswordToken" + ], + "summary": "Updates a PasswordToken", + "description": "Updates a PasswordToken and persists changes to storage.", + "operationId": "updatePasswordToken", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the PasswordToken", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "PasswordToken properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "hash": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "user": { + "type": "integer" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "PasswordToken updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PasswordTokenUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/password-tokens/{id}/user": { + "get": { + "tags": [ + "PasswordToken" + ], + "summary": "Find the attached User", + "description": "Find the attached User of the PasswordToken with the given ID", + "operationId": "readPasswordTokenUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the PasswordToken", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "User attached to PasswordToken with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/PasswordToken_UserRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/users": { + "get": { + "tags": [ + "User" + ], + "summary": "List Users", + "description": "List Users.", + "operationId": "listUser", + "parameters": [ + { + "name": "page", + "in": "query", + "description": "what page to render", + "schema": { + "type": "integer", + "minimum": 1 + } + }, + { + "name": "itemsPerPage", + "in": "query", + "description": "item count to render per page", + "schema": { + "type": "integer", + "maximum": 255, + "minimum": 1 + } + } + ], + "responses": { + "200": { + "description": "result User list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/UserList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "post": { + "tags": [ + "User" + ], + "summary": "Create a new User", + "description": "Creates a new User and persists it to storage.", + "operationId": "createUser", + "requestBody": { + "description": "User to create", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "password": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "type": "array", + "items": { + "type": "integer" + } + } + }, + "required": [ + "name", + "email", + "password", + "verified", + "created_at" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "User created", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserCreate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/users/{id}": { + "get": { + "tags": [ + "User" + ], + "summary": "Find a User by ID", + "description": "Finds the User with the requested ID and returns it.", + "operationId": "readUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "User with requested ID was found", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserRead" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "delete": { + "tags": [ + "User" + ], + "summary": "Deletes a User by ID", + "description": "Deletes the User with the requested ID.", + "operationId": "deleteUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "responses": { + "204": { + "description": "User with requested ID was deleted" + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + }, + "patch": { + "tags": [ + "User" + ], + "summary": "Updates a User", + "description": "Updates a User and persists changes to storage.", + "operationId": "updateUser", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + } + ], + "requestBody": { + "description": "User properties to update", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "password": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "owner": { + "type": "array", + "items": { + "type": "integer" + } + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "User updated", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/UserUpdate" + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + }, + "/users/{id}/owner": { + "get": { + "tags": [ + "User" + ], + "summary": "List attached Owners", + "description": "List attached Owners.", + "operationId": "listUserOwner", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "ID of the User", + "required": true, + "schema": { + "type": "integer" + } + }, + { + "name": "page", + "in": "query", + "description": "what page to render", + "schema": { + "type": "integer" + } + }, + { + "name": "itemsPerPage", + "in": "query", + "description": "item count to render per page", + "schema": { + "type": "integer" + } + } + ], + "responses": { + "200": { + "description": "result Users list", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "$ref": "#/components/schemas/User_OwnerList" + } + } + } + } + }, + "400": { + "$ref": "#/components/responses/400" + }, + "404": { + "$ref": "#/components/responses/404" + }, + "409": { + "$ref": "#/components/responses/409" + }, + "500": { + "$ref": "#/components/responses/500" + } + } + } + } + }, + "components": { + "schemas": { + "PasswordToken": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "hash": { + "type": "string" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "user": { + "$ref": "#/components/schemas/User" + } + }, + "required": [ + "id", + "hash", + "created_at", + "user" + ] + }, + "PasswordTokenCreate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "created_at" + ] + }, + "PasswordTokenList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "created_at" + ] + }, + "PasswordTokenRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "created_at" + ] + }, + "PasswordTokenUpdate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "created_at" + ] + }, + "PasswordToken_UserRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "name", + "email", + "verified", + "created_at" + ] + }, + "User": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "password": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + }, + "owner": { + "type": "array", + "items": { + "$ref": "#/components/schemas/PasswordToken" + } + } + }, + "required": [ + "id", + "name", + "email", + "password", + "verified", + "created_at" + ] + }, + "UserCreate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "name", + "email", + "verified", + "created_at" + ] + }, + "UserList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "name", + "email", + "verified", + "created_at" + ] + }, + "UserRead": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "name", + "email", + "verified", + "created_at" + ] + }, + "UserUpdate": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "verified": { + "type": "boolean" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "name", + "email", + "verified", + "created_at" + ] + }, + "User_OwnerList": { + "type": "object", + "properties": { + "id": { + "type": "integer" + }, + "created_at": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "id", + "created_at" + ] + } + }, + "responses": { + "400": { + "description": "invalid input, data invalid", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "code": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "errors": {} + }, + "required": [ + "code", + "status" + ] + } + } + } + }, + "403": { + "description": "insufficient permissions", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "code": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "errors": {} + }, + "required": [ + "code", + "status" + ] + } + } + } + }, + "404": { + "description": "resource not found", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "code": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "errors": {} + }, + "required": [ + "code", + "status" + ] + } + } + } + }, + "409": { + "description": "conflicting resources", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "code": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "errors": {} + }, + "required": [ + "code", + "status" + ] + } + } + } + }, + "500": { + "description": "unexpected error", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "code": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "errors": {} + }, + "required": [ + "code", + "status" + ] + } + } + } + } + } + } +} \ No newline at end of file diff --git a/ent/runtime/runtime.go b/ent/runtime/runtime.go index a7b15cb..e75c555 100644 --- a/ent/runtime/runtime.go +++ b/ent/runtime/runtime.go @@ -51,6 +51,6 @@ func init() { } const ( - Version = "v0.14.2" // Version of ent codegen. - Sum = "h1:ywld/j2Rx4EmnIKs8eZ29cbFA1zpB+DA9TLL5l3rlq0=" // Sum of ent codegen. + Version = "v0.14.3" // Version of ent codegen. + Sum = "h1:wokAV/kIlH9TeklJWGGS7AYJdVckr0DloWjIcO9iIIQ=" // Sum of ent codegen. ) diff --git a/go.mod b/go.mod index 3b703a3..d9b0d66 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,8 @@ go 1.24.0 require ( entgo.io/ent v0.14.3 github.com/PuerkitoBio/goquery v1.10.2 + github.com/go-faster/errors v0.6.1 + github.com/go-faster/jx v0.42.0-alpha.1 github.com/go-playground/validator/v10 v10.25.0 github.com/golang-jwt/jwt v3.2.2+incompatible github.com/gorilla/context v1.1.2 @@ -13,24 +15,37 @@ require ( github.com/mattn/go-sqlite3 v1.14.24 github.com/maypok86/otter v1.2.4 github.com/mikestefanello/backlite v0.3.0 + github.com/ogen-go/ogen v0.59.0 github.com/spf13/afero v1.14.0 github.com/spf13/viper v1.20.0 github.com/stretchr/testify v1.10.0 + go.opentelemetry.io/otel v1.13.0 + go.opentelemetry.io/otel/metric v0.36.0 + go.opentelemetry.io/otel/trace v1.13.0 + go.uber.org/multierr v1.11.0 golang.org/x/crypto v0.36.0 maragu.dev/gomponents v1.1.0 ) require ( ariga.io/atlas v0.31.1-0.20250212144724-069be8033e83 // indirect + ariga.io/ogent v0.0.0-20230621041143-ed3e5d4da458 // indirect + entgo.io/contrib v0.6.0 // indirect github.com/agext/levenshtein v1.2.3 // indirect github.com/andybalholm/cascadia v1.3.3 // indirect github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect github.com/bmatcuk/doublestar v1.3.4 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dlclark/regexp2 v1.8.0 // indirect github.com/dolthub/maphash v0.1.0 // indirect + github.com/fatih/color v1.14.1 // indirect github.com/fsnotify/fsnotify v1.8.0 // indirect github.com/gabriel-vasile/mimetype v1.4.8 // indirect github.com/gammazero/deque v0.2.1 // indirect + github.com/ghodss/yaml v1.0.0 // indirect + github.com/go-faster/yamlx v0.4.1 // indirect + github.com/go-logr/logr v1.2.3 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/go-openapi/inflect v0.21.0 // indirect github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect @@ -48,6 +63,7 @@ require ( github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rogpeppe/go-internal v1.10.0 // indirect github.com/sagikazarmark/locafero v0.7.0 // indirect + github.com/segmentio/asm v1.2.0 // indirect github.com/sourcegraph/conc v0.3.0 // indirect github.com/spf13/cast v1.7.1 // indirect github.com/spf13/pflag v1.0.6 // indirect @@ -56,7 +72,9 @@ require ( github.com/valyala/fasttemplate v1.2.2 // indirect github.com/zclconf/go-cty v1.14.4 // indirect github.com/zclconf/go-cty-yaml v1.1.0 // indirect - go.uber.org/multierr v1.11.0 // indirect + go.uber.org/atomic v1.10.0 // indirect + go.uber.org/zap v1.24.0 // indirect + golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect golang.org/x/mod v0.23.0 // indirect golang.org/x/net v0.37.0 // indirect golang.org/x/sync v0.12.0 // indirect @@ -65,5 +83,6 @@ require ( golang.org/x/time v0.8.0 // indirect golang.org/x/tools v0.30.0 // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 7bbf619..5035114 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,9 @@ ariga.io/atlas v0.31.1-0.20250212144724-069be8033e83 h1:nX4HXncwIdvQ8/8sIUIf1nyCkK8qdBaHQ7EtzPpuiGE= ariga.io/atlas v0.31.1-0.20250212144724-069be8033e83/go.mod h1:Oe1xWPuu5q9LzyrWfbZmEZxFYeu4BHTyzfjeW2aZp/w= +ariga.io/ogent v0.0.0-20230621041143-ed3e5d4da458 h1:FShFeMszKX8VcySiTRgshmj98jQWMv2GjQgMJcHJJi4= +ariga.io/ogent v0.0.0-20230621041143-ed3e5d4da458/go.mod h1:95vCbvAYAW6NsWUrSL23k2SQykuf/yjellmwV1X+svI= +entgo.io/contrib v0.6.0 h1:xfo4TbJE7sJZWx7BV7YrpSz7IPFvS8MzL3fnfzZjKvQ= +entgo.io/contrib v0.6.0/go.mod h1:3qWIseJ/9Wx2Hu5zVh15FDzv7d/UvKNcYKdViywWCQg= entgo.io/ent v0.14.3 h1:wokAV/kIlH9TeklJWGGS7AYJdVckr0DloWjIcO9iIIQ= entgo.io/ent v0.14.3/go.mod h1:aDPE/OziPEu8+OWbzy4UlvWmD2/kbRuWfK2A40hcxJM= github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60= @@ -12,12 +16,18 @@ github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kk github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA= github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY= github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= +github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= +github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQrS0= github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dlclark/regexp2 v1.8.0 h1:rJD5HeGIT/2b5CDk63FVCwZA3qgYElfg+oQK7uH5pfE= +github.com/dlclark/regexp2 v1.8.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= github.com/dolthub/maphash v0.1.0 h1:bsQ7JsF4FkkWyrP3oCnFJgrCUAFbFf3kOl4L/QxPDyQ= github.com/dolthub/maphash v0.1.0/go.mod h1:gkg4Ch4CdCDu5h6PMriVLawB7koZ+5ijb9puGMV50a4= +github.com/fatih/color v1.14.1 h1:qfhVLaG5s+nCROl1zJsZRxFeYrHLqWroPOQ8BWiNb4w= +github.com/fatih/color v1.14.1/go.mod h1:2oHN61fhTpgcxD3TSWCgKDiH1+x4OiDVVGH8WlgGZGg= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/8M= @@ -26,6 +36,19 @@ github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3G github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8= github.com/gammazero/deque v0.2.1 h1:qSdsbG6pgp6nL7A0+K/B7s12mcCY/5l5SIUpMOl+dC0= github.com/gammazero/deque v0.2.1/go.mod h1:LFroj8x4cMYCukHJDbxFCkT+r9AndaJnFMuZDV34tuU= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= +github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/jx v0.42.0-alpha.1 h1:KRu+ofEoozOsq2qpjwIp2R08vw9w2VqfbV4wtybQZ9U= +github.com/go-faster/jx v0.42.0-alpha.1/go.mod h1:fTSMeBYBKUmGFJaA6EkF658Rrco40FHenmq9fOBpYuM= +github.com/go-faster/yamlx v0.4.1 h1:00RQkZopoLDF1SgBDJVHuN6epTOK7T0TkN427vbvEBk= +github.com/go-faster/yamlx v0.4.1/go.mod h1:QXr/i3Z00jRhskgyWkoGsEdseebd/ZbZEpGS6DJv8oo= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= +github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-openapi/inflect v0.21.0 h1:FoBjBTQEcbg2cJUWX6uwL9OyIW8eqc9k4KhN4lfbeYk= github.com/go-openapi/inflect v0.21.0/go.mod h1:INezMuUu7SJQc2AyR3WO0DqqYUJSj8Kb4hBd7WtjlAw= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= @@ -82,14 +105,20 @@ github.com/mikestefanello/backlite v0.3.0 h1:C6hYoXoIJ7RyRfapZJdW95V3ao/g3tW8dWZ github.com/mikestefanello/backlite v0.3.0/go.mod h1:oTT4WWGP2EDfgCfjA3PODuIz4YfA/QROEAh4o6+SlsI= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/ogen-go/ogen v0.59.0 h1:9aSSZ1KCLJIcRyjkO7IHrG0vAI6l1BO877LwTbMcX+k= +github.com/ogen-go/ogen v0.59.0/go.mod h1:0MHLcWEbxwdvR+R9E05paQSRh/2vHtVSJgKqmwYyW8M= github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M= github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= github.com/sagikazarmark/locafero v0.7.0 h1:5MqpDsTGNDhY8sGp0Aowyf0qKsPrhewaLSsFaodPcyo= github.com/sagikazarmark/locafero v0.7.0/go.mod h1:2za3Cg5rMaTMoG/2Ulr9AwtFaIppKXTRYnozin4aB5k= +github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys= +github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= github.com/spf13/afero v1.14.0 h1:9tH6MapGnn/j0eb0yIXiLjERO8RB6xIVZRDCX7PtqWA= @@ -100,6 +129,8 @@ github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.20.0 h1:zrxIyR3RQIOsarIrgL8+sAvALXul9jeEPa06Y0Ph6vY= github.com/spf13/viper v1.20.0/go.mod h1:P9Mdzt1zoHIG8m2eZQinpiBjo6kCmZSKBClNNqjJvu4= +github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU= +github.com/stoewer/go-strcase v1.2.0/go.mod h1:IBiWB2sKIp3wVVQ3Y035++gc+knqhUQag1KpM8ahLw8= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= @@ -115,8 +146,20 @@ github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b h1:FosyBZYxY3 github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b/go.mod h1:ZRKQfBXbGkpdV6QMzT3rU1kSTAnfu1dO8dPKjYprgj8= github.com/zclconf/go-cty-yaml v1.1.0 h1:nP+jp0qPHv2IhUVqmQSzjvqAWcObN0KBkUl2rWBdig0= github.com/zclconf/go-cty-yaml v1.1.0/go.mod h1:9YLUH4g7lOhVWqUbctnVlZ5KLpg7JAprQNgxSZ1Gyxs= +go.opentelemetry.io/otel v1.13.0 h1:1ZAKnNQKwBBxFtww/GwxNUyTf0AxkZzrukO8MeXqe4Y= +go.opentelemetry.io/otel v1.13.0/go.mod h1:FH3RtdZCzRkJYFTCsAKDy9l/XYjMdNv6QrkFFB8DvVg= +go.opentelemetry.io/otel/metric v0.36.0 h1:t0lgGI+L68QWt3QtOIlqM9gXoxqxWLhZ3R/e5oOAY0Q= +go.opentelemetry.io/otel/metric v0.36.0/go.mod h1:wKVw57sd2HdSZAzyfOM9gTqqE8v7CbqWsYL6AyrH9qk= +go.opentelemetry.io/otel/trace v1.13.0 h1:CBgRZ6ntv+Amuj1jDsMhZtlAPT6gbyIRdaIzFhfBSdY= +go.opentelemetry.io/otel/trace v1.13.0/go.mod h1:muCvmmO9KKpvuXSf3KKAXXB2ygNYHQ+ZfI5X08d3tds= +go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= +go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= +go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= +go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= @@ -125,6 +168,8 @@ golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= @@ -201,6 +246,8 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= maragu.dev/gomponents v1.1.0 h1:iCybZZChHr1eSlvkWp/JP3CrZGzctLudQ/JI3sBcO4U= diff --git a/pkg/handlers/admin.go b/pkg/handlers/admin.go index e5ba8f2..80446da 100644 --- a/pkg/handlers/admin.go +++ b/pkg/handlers/admin.go @@ -13,6 +13,7 @@ import ( "entgo.io/ent/entc/load" "github.com/labstack/echo/v4" "github.com/mikestefanello/pagoda/ent" + "github.com/mikestefanello/pagoda/ent/ogent" "github.com/mikestefanello/pagoda/ent/passwordtoken" "github.com/mikestefanello/pagoda/ent/user" "github.com/mikestefanello/pagoda/pkg/msg" @@ -29,6 +30,7 @@ const entityIDContextKey = "admin:entity_id" type Admin struct { orm *ent.Client graph *gen.Graph + ogent *ogent.OgentHandler } func init() { @@ -38,6 +40,7 @@ func init() { func (h *Admin) Init(c *services.Container) error { h.graph = c.Graph h.orm = c.ORM + h.ogent = ogent.NewOgentHandler(h.orm) return nil } @@ -116,6 +119,12 @@ func (h *Admin) EntityAdd(p AdminEntityPlugin) echo.HandlerFunc { func (h *Admin) EntityAddSubmit(p AdminEntityPlugin) echo.HandlerFunc { return func(ctx echo.Context) error { + var v ogent.CreatePasswordTokenReq // TODO type + err := ctx.Bind(&v) + if err != nil { + return fail(err, fmt.Sprintf("failed to bind create password token request body")) + } + fmt.Printf("%+v", v) return h.EntityAdd(p)(ctx) } } diff --git a/pkg/ui/components/head.go b/pkg/ui/components/head.go index b767a0b..0ce6701 100644 --- a/pkg/ui/components/head.go +++ b/pkg/ui/components/head.go @@ -10,6 +10,13 @@ import ( ) func JS(r *ui.Request) Node { + return Group{ + Script(Src("https://unpkg.com/htmx.org@2.0.0/dist/htmx.min.js")), + Script(Src("https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js"), Defer()), + } +} + +func HtmxListeners(r *ui.Request) Node { const htmxErr = ` document.body.addEventListener('htmx:beforeSwap', function(evt) { if (evt.detail.xhr.status >= 400){ @@ -28,8 +35,6 @@ func JS(r *ui.Request) Node { ` return Group{ - Script(Src("https://unpkg.com/htmx.org@2.0.0/dist/htmx.min.js")), - Script(Src("https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js"), Defer()), Script(Raw(htmxErr)), Iff(len(r.CSRF) > 0, func() Node { return Script(Raw(fmt.Sprintf(htmxCSRF, r.CSRF))) diff --git a/pkg/ui/layouts/admin.go b/pkg/ui/layouts/admin.go index fe18623..3ece961 100644 --- a/pkg/ui/layouts/admin.go +++ b/pkg/ui/layouts/admin.go @@ -36,6 +36,7 @@ func Admin(r *ui.Request, content Node) Node { ), ), ), + HtmxListeners(r), ), ) } diff --git a/pkg/ui/pages/entity.go b/pkg/ui/pages/entity.go index 7c15358..7362263 100644 --- a/pkg/ui/pages/entity.go +++ b/pkg/ui/pages/entity.go @@ -3,6 +3,9 @@ package pages import ( "fmt" "net/http" + "strings" + "time" + "unicode" "entgo.io/ent/entc/load" "entgo.io/ent/schema/field" @@ -40,19 +43,29 @@ func AdminEntityAdd(ctx echo.Context, schema *load.Schema) error { nodes := make(Group, 0) + label := func(name string) string { + if len(name) == 0 { + return name + } + text := []rune(strings.ReplaceAll(name, "_", " ")) + text[0] = unicode.ToUpper(text[0]) + return string(text) + } + for _, f := range schema.Fields { switch f.Info.Type { case field.TypeString: nodes = append(nodes, InputField(InputFieldParams{ Name: f.Name, InputType: "text", - Label: f.Name, + Label: label(f.Name), })) case field.TypeTime: nodes = append(nodes, InputField(InputFieldParams{ Name: f.Name, - InputType: "datetime", - Label: f.Name, + InputType: "text", + Label: label(f.Name), + Help: fmt.Sprintf("Use the following format: %s", time.Now().Format(time.RFC3339)), })) case field.TypeBool: nodes = append(nodes, P(Textf("%s not supported", f.Name))) @@ -68,16 +81,19 @@ func AdminEntityAdd(ctx echo.Context, schema *load.Schema) error { nodes = append(nodes, InputField(InputFieldParams{ Name: e.Name, InputType: "number", - Label: e.Name, + Label: label(e.Name), })) } nodes = append(nodes, ControlGroup( FormButton("is-primary", "Submit"), - ButtonLink("/", "is-secondary", "Cancel"), + ButtonLink("/", "is-secondary", "Cancel"), // todo ), CSRF(r)) - return r.Render(layouts.Admin, Form(Method(http.MethodPost), nodes)) + return r.Render(layouts.Admin, Form( + Method(http.MethodPost), + nodes, + )) } type AdminEntityListParams struct {