5424029372

Committed 30 Jun 2023 02:31PM UTC coverage: 27.432% (+0.2%) from 27.199%

Build Type

Committed by

Commit Message

Remove leftover usage of nowarn

Pull Request Pull Request #577: chore: update to scala 3.3.0, remove unused imports.

Run Details

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

2476 of 9026 relevant lines covered (27.43%)

0.27 hits per line

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

47.37

/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.InsertMeta

import java.util.UUID
import io.getquill.*
import io.getquill.doobie.DoobieContext

import java.time.OffsetDateTime

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

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) = {
    inline given InsertMeta[VerificationPolicy] = insertMeta(exclude = _.id, _.createdAt, _.updatedAt)
    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) =
    // TODO, compiler marks this import as unused, since it is new to scala 3 it can be broken for givens or this given is indeed unused
    inline given UpdateMeta[VerificationPolicy] = updateMeta(exclude = _.id)
    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.InsertMeta
4
5	import java.util.UUID
6	import io.getquill.*
7	import io.getquill.doobie.DoobieContext
8
9	import java.time.OffsetDateTime
10
11	case class VerificationPolicy(
12	id: UUID,
13	nonce: Int,
14	name: String,
15	description: String,
16	createdAt: OffsetDateTime,
17	updatedAt: OffsetDateTime
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) = {
32	inline given InsertMeta[VerificationPolicy] = insertMeta(exclude = _.id, _.createdAt, _.updatedAt)	×
33	run(quote(query[VerificationPolicy].insertValue(lift(verificationPolicy)).returning(vp => vp)))
34	}
35		1✔
36	def insertConstraints(constraints: Seq[VerificationPolicyConstraint]) = {	1✔
37	run(	1✔
38	quote(liftQuery(constraints).foreach(c => query[VerificationPolicyConstraint].insertValue(c).returning(c => c)))
39	)
40	}
41		1✔
42	def dropConstraintsByVerificationPolicyId(fk_id: UUID) = {	1✔
43	run(quote(query[VerificationPolicyConstraint].filter(_.fk_id == lift(fk_id)).delete))
44	}
45		1✔
46	def getById(id: UUID) =	×
47	run(
48	quote(
49	query[VerificationPolicy]
50	.filter(_.id == lift(id))
51	)	1✔
52	).map(_.headOption)
53		×
54	def getHashById(id: UUID) =	×
55	run(
56	quote(
57	query[VerificationPolicy]
58	.filter(_.id == lift(id))
59	.map(_.nonce)
60	)	×
61	).map(_.headOption)
62		×
63	def exists(id: UUID) =	×
64	run(quote(query[VerificationPolicy].filter(_.id == lift(id)).isEmpty))
65		×
66	def exists(id: UUID, hash: Int) =	×
67	run(
68	quote(
69	query[VerificationPolicy]
70	.filter(_.id == lift(id))
71	.filter(_.nonce == lift(hash))
72	.isEmpty
73	)
74	)
75		1✔
76	def getVerificationPolicyConstrains(fk_ids: Seq[UUID]) =	1✔
77	run(
78	quote(
79	query[VerificationPolicyConstraint].filter(vpc => liftQuery(fk_ids).contains(vpc.fk_id))
80	)
81	)
82		1✔
83	def update(verificationPolicy: VerificationPolicy, nonce: Int) =
84	// TODO, compiler marks this import as unused, since it is new to scala 3 it can be broken for givens or this given is indeed unused
85	inline given UpdateMeta[VerificationPolicy] = updateMeta(exclude = _.id)	1✔
86	run(
87	quote(
88	query[VerificationPolicy]
89	.filter(_.id == lift(verificationPolicy.id))
90	.filter(_.nonce == lift(nonce))
91	.update(
92	_.nonce -> lift(verificationPolicy.nonce),
93	_.description -> lift(verificationPolicy.description),
94	_.name -> lift(verificationPolicy.name),
95	_.updatedAt -> lift(verificationPolicy.updatedAt)
96	)
97	.returning(vp => vp)
98	)
99	)
100		1✔
101	def delete(id: UUID) =	1✔
102	run(
103	quote(query[VerificationPolicy])
104	.filter(_.id == lift(id))
105	.delete
106	.returning(vp => vp)
107	)
108		×
109	def delete(id: UUID, hash: Int) =	×
110	run(
111	quote(query[VerificationPolicy])
112	.filter(_.id == lift(id))
113	.filter(_.nonce == lift(hash))
114	.delete
115	.returning(vp => vp)
116	)
117		1✔
118	def deleteAll() = run(quote(query[VerificationPolicy].delete))
119		×
120	def deleteConstraints(fk_id: UUID) =	×
121	run(quote(query[VerificationPolicyConstraint]).filter(_.fk_id == lift(fk_id)).delete)
122		1✔
123	def count() = run(quote(query[VerificationPolicy].size))
124		×
125	def countOfConstraints() = run(quote(query[VerificationPolicyConstraint]).size)
126		×
127	def countFiltered(nameOpt: Option[String]) =	×
128	run(	×
129	quote(query[VerificationPolicy]).dynamic
130	.filterOpt(nameOpt)((vp, name) => quote(vp.name.like(name)))	×
131	.size
132	)
133		1✔
134	def filteredVerificationPolicies(nameOpt: Option[String], offsetOpt: Option[Int], limitOpt: Option[Int]) = run {
135		×
136	quote(query[VerificationPolicy]).dynamic
137	.filterOpt(nameOpt)((vcs, name) => quote(vcs.name.like(name)))
138	.sortBy(_.id)
139	.dropOpt(offsetOpt)	×
140	.take(limitOpt.getOrElse(1000))
141	}
142	}	1✔

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

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