8998019047

Committed 08 May 2024 07:31AM UTC coverage: 47.171% (-0.7%) from 47.829%

Build # 8998019047

Build Type

Committed by

Commit Message

chore: pr cleanup

Pull Request Pull Request #1021: feat: oidc4vc credential configuration and metadata endpoints [WIP]

Run Details

2 of 253 new or added lines in 12 files covered. (0.79%)

186 existing lines in 51 files now uncovered.

7388 of 15662 relevant lines covered (47.17%)

0.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/cloud-agent/service/server/src/main/scala/org/hyperledger/identus/oidc4vc/http/IssuerMetadata.scala

package org.hyperledger.identus.oidc4vc.http

import org.hyperledger.identus.pollux.core.model.oidc4vc as pollux
import sttp.tapir.Schema
import sttp.tapir.Schema.annotations.encodedName
import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}

import java.net.URL
import scala.language.implicitConversions

case class IssuerMetadata(
    credential_issuer: String,
    authorization_servers: Option[Seq[String]],
    credential_endpoint: String,
    credential_configurations_supported: Map[String, SupportedCredentialConfiguration]
)

object IssuerMetadata {
  given schema: Schema[IssuerMetadata] = Schema.derived
  given encoder: JsonEncoder[IssuerMetadata] = DeriveJsonEncoder.gen
  given decoder: JsonDecoder[IssuerMetadata] = DeriveJsonDecoder.gen

  def fromIssuer(
      agentBaseUrl: URL,
      issuer: pollux.CredentialIssuer,
      credentialConfigurations: Seq[pollux.CredentialConfiguration]
  ): IssuerMetadata = {
    val credentialIssuerBaseUrl = agentBaseUrl.toURI().resolve(s"oidc4vc/issuers/${issuer.id}").toString
    IssuerMetadata(
      credential_issuer = credentialIssuerBaseUrl,
      authorization_servers = Some(Seq(issuer.authorizationServer.toString())),
      credential_endpoint = s"$credentialIssuerBaseUrl/credentials",
      credential_configurations_supported =
        credentialConfigurations.map(cc => (cc.configurationId, cc: SupportedCredentialConfiguration)).toMap
    )
  }
}

final case class SupportedCredentialConfiguration(
    format: CredentialFormat,
    scope: String,
    credential_definition: CredentialDefinition,
    cryptographic_binding_methods_supported: Seq[String] = Seq("did:prism"),
    credential_signing_alg_values_supported: Seq[String] = Seq("ES256K"),
    proof_types_supported: SupportProofType =
      SupportProofType(jwt = ProofTypeConfiguration(proof_signing_alg_values_supported = Seq("ES256K")))
)

object SupportedCredentialConfiguration {
  given schema: Schema[SupportedCredentialConfiguration] = Schema.derived
  given encoder: JsonEncoder[SupportedCredentialConfiguration] = DeriveJsonEncoder.gen
  given decoder: JsonDecoder[SupportedCredentialConfiguration] = DeriveJsonDecoder.gen

  given Conversion[pollux.CredentialConfiguration, SupportedCredentialConfiguration] = cc =>
    SupportedCredentialConfiguration(
      format = cc.format,
      scope = cc.scope,
      credential_definition = CredentialDefinition(
        `@context` = Some(Seq("https://www.w3.org/2018/credentials/v1")),
        `type` = Seq("VerifiableCredential"),
        credentialSubject = None
      )
    )
}

final case class SupportProofType(jwt: ProofTypeConfiguration)

object SupportProofType {
  given schema: Schema[SupportProofType] = Schema.derived
  given encoder: JsonEncoder[SupportProofType] = DeriveJsonEncoder.gen
  given decoder: JsonDecoder[SupportProofType] = DeriveJsonDecoder.gen
}

final case class ProofTypeConfiguration(proof_signing_alg_values_supported: Seq[String])

object ProofTypeConfiguration {
  given schema: Schema[ProofTypeConfiguration] = Schema.derived
  given encoder: JsonEncoder[ProofTypeConfiguration] = DeriveJsonEncoder.gen
  given decoder: JsonDecoder[ProofTypeConfiguration] = DeriveJsonDecoder.gen
}

1	package org.hyperledger.identus.oidc4vc.http
2
3	import org.hyperledger.identus.pollux.core.model.oidc4vc as pollux
4	import sttp.tapir.Schema
5	import sttp.tapir.Schema.annotations.encodedName
6	import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
7
8	import java.net.URL
9	import scala.language.implicitConversions
10
11	case class IssuerMetadata(
12	credential_issuer: String,
13	authorization_servers: Option[Seq[String]],
14	credential_endpoint: String,
15	credential_configurations_supported: Map[String, SupportedCredentialConfiguration]
16	)
17
18	object IssuerMetadata {
19	given schema: Schema[IssuerMetadata] = Schema.derived	×
20	given encoder: JsonEncoder[IssuerMetadata] = DeriveJsonEncoder.gen	×
21	given decoder: JsonDecoder[IssuerMetadata] = DeriveJsonDecoder.gen	×
22
23	def fromIssuer(	×
24	agentBaseUrl: URL,
25	issuer: pollux.CredentialIssuer,
26	credentialConfigurations: Seq[pollux.CredentialConfiguration]
27	): IssuerMetadata = {
28	val credentialIssuerBaseUrl = agentBaseUrl.toURI().resolve(s"oidc4vc/issuers/${issuer.id}").toString	×
29	IssuerMetadata(
30	credential_issuer = credentialIssuerBaseUrl,
31	authorization_servers = Some(Seq(issuer.authorizationServer.toString())),	×
32	credential_endpoint = s"$credentialIssuerBaseUrl/credentials",	×
33	credential_configurations_supported =
NEW 34	credentialConfigurations.map(cc => (cc.configurationId, cc: SupportedCredentialConfiguration)).toMap	×
35	)
36	}
37	}
38
39	final case class SupportedCredentialConfiguration(
40	format: CredentialFormat,
41	scope: String,
42	credential_definition: CredentialDefinition,
NEW 43	cryptographic_binding_methods_supported: Seq[String] = Seq("did:prism"),	×
NEW 44	credential_signing_alg_values_supported: Seq[String] = Seq("ES256K"),	×
45	proof_types_supported: SupportProofType =
NEW 46	SupportProofType(jwt = ProofTypeConfiguration(proof_signing_alg_values_supported = Seq("ES256K")))	×
47	)
48
49	object SupportedCredentialConfiguration {
NEW 50	given schema: Schema[SupportedCredentialConfiguration] = Schema.derived	×
NEW 51	given encoder: JsonEncoder[SupportedCredentialConfiguration] = DeriveJsonEncoder.gen	×
NEW 52	given decoder: JsonDecoder[SupportedCredentialConfiguration] = DeriveJsonDecoder.gen	×
53
54	given Conversion[pollux.CredentialConfiguration, SupportedCredentialConfiguration] = cc =>
NEW 55	SupportedCredentialConfiguration(	×
NEW 56	format = cc.format,	×
NEW 57	scope = cc.scope,	×
58	credential_definition = CredentialDefinition(
NEW 59	`@context` = Some(Seq("https://www.w3.org/2018/credentials/v1")),	×
NEW 60	`type` = Seq("VerifiableCredential"),	×
61	credentialSubject = None
62	)
63	)
64	}
65
66	final case class SupportProofType(jwt: ProofTypeConfiguration)
67
68	object SupportProofType {
NEW 69	given schema: Schema[SupportProofType] = Schema.derived	×
NEW 70	given encoder: JsonEncoder[SupportProofType] = DeriveJsonEncoder.gen	×
NEW 71	given decoder: JsonDecoder[SupportProofType] = DeriveJsonDecoder.gen	×
72	}
73
74	final case class ProofTypeConfiguration(proof_signing_alg_values_supported: Seq[String])
75
76	object ProofTypeConfiguration {
NEW 77	given schema: Schema[ProofTypeConfiguration] = Schema.derived	×
NEW 78	given encoder: JsonEncoder[ProofTypeConfiguration] = DeriveJsonEncoder.gen	×
NEW 79	given decoder: JsonDecoder[ProofTypeConfiguration] = DeriveJsonDecoder.gen	×
80	}

hyperledger / identus-cloud-agent / 8998019047

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous