ory-am/hydra

Method Persister.VerifyAndInvalidateConsentRequest has 5 return statements (exceeds 4 allowed).

Open

func (p *Persister) VerifyAndInvalidateConsentRequest(ctx context.Context, verifier string) (_ *flow.AcceptOAuth2ConsentRequest, err error) {
    ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.VerifyAndInvalidateConsentRequest")
    defer otelx.End(span, &err)

    f, err := flowctx.Decode[flow.Flow](ctx, p.r.FlowCipher(), verifier, flowctx.AsConsentVerifier)

Function checkStatus has 5 return statements (exceeds 4 allowed).

Open

func checkStatus(t *testing.T, testID string) (string, status) {
    res, err := httpClient.Get(urlx.AppendPaths(server, "/api/info", testID).String())
    require.NoError(t, err)
    defer res.Body.Close()
    body, err := io.ReadAll(res.Body)

Method Handler.introspectOAuth2Token has 5 return statements (exceeds 4 allowed).

Open

func (h *Handler) introspectOAuth2Token(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    ctx := r.Context()
    session := NewSessionWithCustomClaims(ctx, h.c, "")

    if r.Method != "POST" {

Method Handler.performOidcFrontOrBackChannelLogout has 5 return statements (exceeds 4 allowed).

Open

func (h *Handler) performOidcFrontOrBackChannelLogout(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    ctx := r.Context()

    handled, err := h.r.ConsentStrategy().HandleOpenIDConnectLogout(ctx, w, r)
    if errors.Is(err, consent.ErrAbortOAuth2Request) {

Function BenchmarkAuthCode has 5 return statements (exceeds 4 allowed).

Open

func BenchmarkAuthCode(b *testing.B) {
    flag.Parse()

    ctx := context.Background()

Method NullDuration.UnmarshalJSON has 5 return statements (exceeds 4 allowed).

Open

func (ns *NullDuration) UnmarshalJSON(data []byte) error {
    if ns == nil {
        return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
    }

Method OAuth2RequestSQL.toRequest has 5 return statements (exceeds 4 allowed).

Open

func (r *OAuth2RequestSQL) toRequest(ctx context.Context, session fosite.Session, p *Persister) (_ *fosite.Request, err error) {
    ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.toRequest")
    defer otelx.End(span, &err)

    sess := r.Session

Method Duration.UnmarshalJSON has 5 return statements (exceeds 4 allowed).

Open

func (ns *Duration) UnmarshalJSON(data []byte) error {
    if ns == nil {
        return errors.New("json.RawMessage: UnmarshalJSON on nil pointer")
    }

Function claimsFromVCResponse has 5 return statements (exceeds 4 allowed).

Open

func claimsFromVCResponse(t *testing.T, reg driver.Registry, vc *hydraoauth2.VerifiableCredentialResponse) (*jwt.Token, *hydraoauth2.VerifableCredentialClaims) {
    ctx := context.Background()
    token, err := jwt.ParseWithClaims(vc.Credential, new(hydraoauth2.VerifableCredentialClaims), func(token *jwt.Token) (interface{}, error) {
        kid, found := token.Header["kid"]
        if !found {

Method Session.UnmarshalJSON has 5 return statements (exceeds 4 allowed).

Open

func (s *Session) UnmarshalJSON(original []byte) (err error) {
    transformed := original
    originalParsed := gjson.ParseBytes(original)

    for oldKey, newKey := range keyRewrites {

Method Persister.GetAccessTokenSession has 5 return statements (exceeds 4 allowed).

Open

func (p *Persister) GetAccessTokenSession(ctx context.Context, signature string, session fosite.Session) (request fosite.Requester, err error) {
    ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.GetAccessTokenSession")
    defer otelx.End(span, &err)

    r := OAuth2RequestSQL{Table: sqlTableAccess}

Method SQLDataRows.ToJWK has 5 return statements (exceeds 4 allowed).

Open

func (d SQLDataRows) ToJWK(ctx context.Context, r interface {
    KeyCipher() *aead.AESGCM
}) (keys *jose.JSONWebKeySet, err error) {
    if len(d) == 0 {
        return nil, errors.Wrap(x.ErrNotFound, "")

Method Persister.deleteSessionByRequestID has 5 return statements (exceeds 4 allowed).

Open

func (p *Persister) deleteSessionByRequestID(ctx context.Context, id string, table tableName) (err error) {
    ctx, span := p.r.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.deleteSessionByRequestID")
    defer otelx.End(span, &err)

    err = p.QueryWithNetwork(ctx).

Method Handler.oauth2TokenExchange has 5 return statements (exceeds 4 allowed).

Open

func (h *Handler) oauth2TokenExchange(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    session := NewSessionWithCustomClaims(ctx, h.c, "")

    accessRequest, err := h.r.OAuth2Provider().NewAccessRequest(ctx, r, session)

Function OnlyPublicSDKKeys has 5 return statements (exceeds 4 allowed).

Open

func OnlyPublicSDKKeys(in []hydra.JsonWebKey) (out []hydra.JsonWebKey, _ error) {
    var interim []jose.JSONWebKey
    var b bytes.Buffer

    if err := json.NewEncoder(&b).Encode(&in); err != nil {

Function executeHookAndUpdateSession has 5 return statements (exceeds 4 allowed).

Open

func executeHookAndUpdateSession(ctx context.Context, reg x.HTTPClientProvider, hookConfig *config.HookConfig, reqBodyBytes []byte, session *Session) error {
    req, err := retryablehttp.NewRequestWithContext(ctx, http.MethodPost, hookConfig.URL, bytes.NewReader(reqBodyBytes))
    if err != nil {
        return errorsx.WithStack(
            fosite.ErrServerError.

Identical blocks of code found in 2 locations. Consider refactoring.

Open

            checkAndAcceptLoginHandler(t, adminClient, subject, func(t *testing.T, res *hydra.OAuth2LoginRequest, err error) hydra.AcceptOAuth2LoginRequest {
                require.NoError(t, err)
                assert.False(t, res.Skip) // Skip should always be false here because prompt has login
                return hydra.AcceptOAuth2LoginRequest{Remember: pointerx.Bool(true)}
            }),

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

                checkAndAcceptLoginHandler(t, adminClient, subject, func(t *testing.T, res *hydra.OAuth2LoginRequest, err error) hydra.AcceptOAuth2LoginRequest {
                    require.NoError(t, err)
                    assert.False(t, res.Skip) // Skip should always be false here
                    return hydra.AcceptOAuth2LoginRequest{
                        Remember: pointerx.Bool(true),

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                    {
                        name:      "proof=invalid type",
                        proofType: "invalid",
                        proof: func() string {
                            // Create mismatching public and private keys.

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

                    {
                        name:   "proof=invalid format",
                        format: "invalid_format",
                        proof: func() string {
                            // Create mismatching public and private keys.

• Read up
  Read up