6380885733

Committed 02 Oct 2023 01:37PM UTC coverage: 29.098% (+0.2%) from 28.908%

Build Type

push

Committed by

Commit Message

refactor: update zio-http to 3.0.0-RC2 and tapir to 1.6.4, remove legacy tapir (#729)

Signed-off-by: Shota Jolbordi <shota.jolbordi@iohk.io>
Signed-off-by: Milos Backonja <milos.backonja@iohk.io>
Signed-off-by: Anton Baliasnikov <anton.baliasnikov@iohk.io>
Signed-off-by: Pat Losoponkul <pat.losoponkul@iohk.io>
Signed-off-by: Benjamin Voiturier <benjamin.voiturier@iohk.io>
Signed-off-by: shotexa <shota.jolbordi@iohk.io>
Co-authored-by: Milos Backonja <35807060+milosbackonja@users.noreply.github.com>
Co-authored-by: atala-dev <atala.dev@iohk.io>
Co-authored-by: patlo-iog <pat.losoponkul@iohk.io>
Co-authored-by: Yurii Shynbuiev - IOHK <yurii.shynbuiev@iohk.io>
Co-authored-by: bvoiturier <benjamin.voiturier@iohk.io>

Run Details

35 of 35 new or added lines in 4 files covered. (100.0%)

3511 of 12066 relevant lines covered (29.1%)

0.29 hits per line

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

40.54

/pollux/lib/sql-doobie/src/main/scala/io/iohk/atala/pollux/sql/model/db/VerificationPolicy.scala

package io.iohk.atala.pollux.sql.model.db

import io.getquill.*
import io.getquill.doobie.DoobieContext
import io.iohk.atala.shared.models.WalletId
import java.util.UUID

import java.time.OffsetDateTime

case class VerificationPolicy(
    id: UUID,
    nonce: Int,
    name: String,
    description: String,
    createdAt: OffsetDateTime,
    updatedAt: OffsetDateTime,
    walletId: WalletId
)

case class VerificationPolicyConstraint(
    fk_id: UUID,
    index: Int,
    `type`: String,
    schemaId: String,
    trustedIssuers: Seq[String]
)

object VerificationPolicySql extends DoobieContext.Postgres(SnakeCase) {
  import io.iohk.atala.pollux.sql.repository.VerificationPolicyExtensions._

  def insert(verificationPolicy: VerificationPolicy) = {
    run(quote(query[VerificationPolicy].insertValue(lift(verificationPolicy)).returning(vp => vp)))
  }

  def insertConstraints(constraints: Seq[VerificationPolicyConstraint]) = {
    run(
      quote(liftQuery(constraints).foreach(c => query[VerificationPolicyConstraint].insertValue(c).returning(c => c)))
    )
  }

  def dropConstraintsByVerificationPolicyId(fk_id: UUID) = {
    run(quote(query[VerificationPolicyConstraint].filter(_.fk_id == lift(fk_id)).delete))
  }

  def getById(id: UUID) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
      )
    ).map(_.headOption)

  def getHashById(id: UUID) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
          .map(_.nonce)
      )
    ).map(_.headOption)

  def exists(id: UUID) =
    run(quote(query[VerificationPolicy].filter(_.id == lift(id)).isEmpty))

  def exists(id: UUID, hash: Int) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(id))
          .filter(_.nonce == lift(hash))
          .isEmpty
      )
    )

  def getVerificationPolicyConstrains(fk_ids: Seq[UUID]) =
    run(
      quote(
        query[VerificationPolicyConstraint].filter(vpc => liftQuery(fk_ids).contains(vpc.fk_id))
      )
    )

  def update(verificationPolicy: VerificationPolicy, nonce: Int) =
    run(
      quote(
        query[VerificationPolicy]
          .filter(_.id == lift(verificationPolicy.id))
          .filter(_.nonce == lift(nonce))
          .update(
            _.nonce -> lift(verificationPolicy.nonce),
            _.description -> lift(verificationPolicy.description),
            _.name -> lift(verificationPolicy.name),
            _.updatedAt -> lift(verificationPolicy.updatedAt)
          )
          .returning(vp => vp)
      )
    )

  def delete(id: UUID) =
    run(
      quote(query[VerificationPolicy])
        .filter(_.id == lift(id))
        .delete
        .returning(vp => vp)
    )

  def delete(id: UUID, hash: Int) =
    run(
      quote(query[VerificationPolicy])
        .filter(_.id == lift(id))
        .filter(_.nonce == lift(hash))
        .delete
        .returning(vp => vp)
    )

  def deleteAll() = run(quote(query[VerificationPolicy].delete))

  def deleteConstraints(fk_id: UUID) =
    run(quote(query[VerificationPolicyConstraint]).filter(_.fk_id == lift(fk_id)).delete)

  def count() = run(quote(query[VerificationPolicy].size))

  def countOfConstraints() = run(quote(query[VerificationPolicyConstraint]).size)

  def countFiltered(nameOpt: Option[String]) =
    run(
      quote(query[VerificationPolicy]).dynamic
        .filterOpt(nameOpt)((vp, name) => quote(vp.name.like(name)))
        .size
    )

  def filteredVerificationPolicies(nameOpt: Option[String], offsetOpt: Option[Int], limitOpt: Option[Int]) = run {

    quote(query[VerificationPolicy]).dynamic
      .filterOpt(nameOpt)((vcs, name) => quote(vcs.name.like(name)))
      .sortBy(_.id)
      .dropOpt(offsetOpt)
      .take(limitOpt.getOrElse(1000))
  }
}

1	package io.iohk.atala.pollux.sql.model.db
2
3	import io.getquill.*
4	import io.getquill.doobie.DoobieContext
5	import io.iohk.atala.shared.models.WalletId
6	import java.util.UUID
7
8	import java.time.OffsetDateTime
9
10	case class VerificationPolicy(
11	id: UUID,
12	nonce: Int,
13	name: String,
14	description: String,
15	createdAt: OffsetDateTime,
16	updatedAt: OffsetDateTime,
17	walletId: WalletId
18	)
19
20	case class VerificationPolicyConstraint(
21	fk_id: UUID,
22	index: Int,
23	`type`: String,
24	schemaId: String,
25	trustedIssuers: Seq[String]
26	)
27
28	object VerificationPolicySql extends DoobieContext.Postgres(SnakeCase) {
29	import io.iohk.atala.pollux.sql.repository.VerificationPolicyExtensions._
30		1✔
31	def insert(verificationPolicy: VerificationPolicy) = {	1✔
32	run(quote(query[VerificationPolicy].insertValue(lift(verificationPolicy)).returning(vp => vp)))
33	}
34		1✔
35	def insertConstraints(constraints: Seq[VerificationPolicyConstraint]) = {	1✔
36	run(	1✔
37	quote(liftQuery(constraints).foreach(c => query[VerificationPolicyConstraint].insertValue(c).returning(c => c)))
38	)
39	}
40		1✔
41	def dropConstraintsByVerificationPolicyId(fk_id: UUID) = {	×
42	run(quote(query[VerificationPolicyConstraint].filter(_.fk_id == lift(fk_id)).delete))
43	}
44		1✔
45	def getById(id: UUID) =	×
46	run(
47	quote(
48	query[VerificationPolicy]
49	.filter(_.id == lift(id))
50	)	1✔
51	).map(_.headOption)
52		×
53	def getHashById(id: UUID) =	×
54	run(
55	quote(
56	query[VerificationPolicy]
57	.filter(_.id == lift(id))
58	.map(_.nonce)
59	)	×
60	).map(_.headOption)
61		×
62	def exists(id: UUID) =	×
63	run(quote(query[VerificationPolicy].filter(_.id == lift(id)).isEmpty))
64		×
65	def exists(id: UUID, hash: Int) =	×
66	run(
67	quote(
68	query[VerificationPolicy]
69	.filter(_.id == lift(id))
70	.filter(_.nonce == lift(hash))
71	.isEmpty
72	)
73	)
74		1✔
75	def getVerificationPolicyConstrains(fk_ids: Seq[UUID]) =	1✔
76	run(
77	quote(
78	query[VerificationPolicyConstraint].filter(vpc => liftQuery(fk_ids).contains(vpc.fk_id))
79	)
80	)
81		1✔
82	def update(verificationPolicy: VerificationPolicy, nonce: Int) =	1✔
83	run(
84	quote(
85	query[VerificationPolicy]
86	.filter(_.id == lift(verificationPolicy.id))
87	.filter(_.nonce == lift(nonce))
88	.update(
89	_.nonce -> lift(verificationPolicy.nonce),
90	_.description -> lift(verificationPolicy.description),
91	_.name -> lift(verificationPolicy.name),
92	_.updatedAt -> lift(verificationPolicy.updatedAt)
93	)
94	.returning(vp => vp)
95	)
96	)
97		1✔
98	def delete(id: UUID) =	×
99	run(
100	quote(query[VerificationPolicy])
101	.filter(_.id == lift(id))
102	.delete
103	.returning(vp => vp)
104	)
105		×
106	def delete(id: UUID, hash: Int) =	×
107	run(
108	quote(query[VerificationPolicy])
109	.filter(_.id == lift(id))
110	.filter(_.nonce == lift(hash))
111	.delete
112	.returning(vp => vp)
113	)
114		1✔
115	def deleteAll() = run(quote(query[VerificationPolicy].delete))
116		×
117	def deleteConstraints(fk_id: UUID) =	×
118	run(quote(query[VerificationPolicyConstraint]).filter(_.fk_id == lift(fk_id)).delete)
119		1✔
120	def count() = run(quote(query[VerificationPolicy].size))
121		×
122	def countOfConstraints() = run(quote(query[VerificationPolicyConstraint]).size)
123		×
124	def countFiltered(nameOpt: Option[String]) =	×
125	run(	×
126	quote(query[VerificationPolicy]).dynamic
127	.filterOpt(nameOpt)((vp, name) => quote(vp.name.like(name)))	×
128	.size
129	)
130		×
131	def filteredVerificationPolicies(nameOpt: Option[String], offsetOpt: Option[Int], limitOpt: Option[Int]) = run {
132		×
133	quote(query[VerificationPolicy]).dynamic
134	.filterOpt(nameOpt)((vcs, name) => quote(vcs.name.like(name)))
135	.sortBy(_.id)
136	.dropOpt(offsetOpt)	×
137	.take(limitOpt.getOrElse(1000))
138	}
139	}

input-output-hk / atala-prism-building-blocks / 6380885733

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