Upgrade dependencies including scala to 3.7.3

api/app/actors/ScheduleTasksActor.scala

@@ -33,7 +33,7 @@ class ScheduleTasksActor @Inject()(
 
   private def scheduleOnce(taskType: TaskType): Unit = {
     context.system.scheduler.scheduleOnce(FiniteDuration(10, SECONDS)) {
-      UpsertTask(taskType)
+      self ! UpsertTask(taskType)
     }
   }
 
@@ -44,7 +44,7 @@ class ScheduleTasksActor @Inject()(
     Seq(
       schedule(ScheduleSyncGeneratorServices, FiniteDuration(1, HOURS)),
       schedule(CheckInvariants, FiniteDuration(12, HOURS)),
-      schedule(PurgeDeleted, FiniteDuration(1, HOURS))(FiniteDuration(5, SECONDS)),
+      schedule(PurgeDeleted, FiniteDuration(1, HOURS)),
     )
   }
 

api/app/actors/TaskDispatchActor.scala

@@ -20,7 +20,7 @@ class TaskDispatchActor @Inject() (
   private val actors = scala.collection.mutable.Map[TaskType, ActorRef]()
 
   private def schedule(message: Any, interval: FiniteDuration): Cancellable = {
-    context.system.scheduler.scheduleWithFixedDelay(FiniteDuration(1, SECONDS), interval, self, message)(ec)
+    context.system.scheduler.scheduleWithFixedDelay(FiniteDuration(1, SECONDS), interval, self, message)(using ec)
   }
 
   private val cancellables: Seq[Cancellable] = {

api/app/db/InternalApplicationsDao.scala

@@ -3,19 +3,16 @@ package db
 import cats.data.ValidatedNec
 import cats.implicits.*
 import db.generated.{ApplicationMoveForm, ApplicationMovesDao, ApplicationsDao}
-import io.apibuilder.api.v0.models.{AppSortBy, ApplicationForm, Error, MoveForm, SortOrder, User, Version, Visibility}
-import io.apibuilder.common.v0.models.{Audit, ReferenceGuid}
+import io.apibuilder.api.v0.models.{AppSortBy, ApplicationForm, Error, MoveForm, SortOrder, Version, Visibility}
 import io.apibuilder.task.v0.models.{EmailDataApplicationCreated, TaskType}
 import io.flow.postgresql.{OrderBy, Query}
 import lib.{UrlKey, Validation}
-import org.joda.time.DateTime
-import play.api.db.*
 import processor.EmailProcessorQueue
 import util.OptionalQueryFilter
 
 import java.sql.Connection
 import java.util.UUID
-import javax.inject.{Inject, Singleton}
+import javax.inject.Inject
 
 case class InternalApplication(db: generated.Application) {
   val guid: UUID = db.guid
@@ -230,7 +227,7 @@ class InternalApplicationsDao @Inject()(
   def findAllByGuids(authorization: Authorization, guids: Seq[UUID]): Seq[InternalApplication] = {
     findAll(authorization, guids = Some(guids), limit = None)
   }
-  
+
   def findAll(
     authorization: Authorization,
     orgKey: Option[String] = None,
@@ -289,14 +286,14 @@ class InternalApplicationsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(toOrderBy(sorting, ordering)),
-    ) { q =>
+    )( using (q: Query) => {
       authorization.applicationFilter(
         filters.foldLeft(q) { case (q, f) => f.filter(q) },
         "guid"
       )
       .equals("lower(name)", name.map(_.toLowerCase().trim))
       .equals("lower(key)", key.map(_.toLowerCase().trim))
-    }.map(InternalApplication(_))
+    }).map(InternalApplication(_))
   }
 
   private def toOrderBy(
@@ -332,4 +329,4 @@ class InternalApplicationsDao @Inject()(
     tasksDao.queueWithConnection(c, TaskType.IndexApplication, guid.toString)
   }
 
-}
+}

api/app/db/InternalAttributesDao.scala

@@ -5,6 +5,7 @@ import cats.data.ValidatedNec
 import cats.implicits.*
 import db.generated.AttributesDao
 import io.apibuilder.api.v0.models.{AttributeForm, User}
+import io.flow.postgresql.Query
 import lib.{UrlKey, Validation}
 
 import java.util.UUID
@@ -95,12 +96,12 @@ class InternalAttributesDao @Inject()(
       guids = guids,
       limit = limit,
       offset = offset
-    ) { q =>
+    )(using (q: Query) => {
       q.and(name.map { _ =>
         "lower(trim(attributes.name)) = lower(trim({name}))"
       }).bind("name", name)
       .and(isDeleted.map(Filters.isDeleted("attributes", _)))
-    }.map(InternalAttribute(_))
+    }).map(InternalAttribute(_))
   }
 
 }

api/app/db/InternalChangesDao.scala

@@ -1,7 +1,5 @@
 package db
 
-import anorm.JodaParameterMetaData.*
-import anorm.*
 import db.generated.{ChangeForm, ChangesDao}
 import io.apibuilder.api.v0.models.*
 import io.flow.postgresql.{OrderBy, Query}
@@ -157,7 +155,7 @@ class InternalChangesDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("-changed_at, type, -description")),
-    ) { q =>
+    )(using (q: Query) => {
       authorization.applicationFilter(
           filters.foldLeft(q) { case (q, f) => f.filter(q) },
           "application_guid"
@@ -170,6 +168,6 @@ class InternalChangesDao @Inject()(
             "lower(description) = lower(trim({description}))"
           }
         ).bind("description", description)
-    }.map(InternalChange(_))
+    }).map(InternalChange(_))
   }
-}
+}

api/app/db/InternalEmailVerificationConfirmationsDao.scala

@@ -47,10 +47,9 @@ class InternalEmailVerificationConfirmationsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("created_at"))
-    ) { q =>
+    )( using (q: Query) => {
       q.and(isDeleted.map(Filters.isDeleted("email_verification_confirmations", _)))
-    }.map(InternalEmailVerificationConfirmation(_))
+    }).map(InternalEmailVerificationConfirmation(_))
   }
 
 }
-

api/app/db/InternalEmailVerificationsDao.scala

@@ -1,16 +1,14 @@
 package db
 
 import db.generated.EmailVerificationsDao
-import io.apibuilder.api.v0.models.User
 import io.apibuilder.task.v0.models.EmailDataEmailVerificationCreated
 import io.flow.postgresql.{OrderBy, Query}
 import lib.TokenGenerator
 import org.joda.time.DateTime
-import play.api.db.*
 import processor.EmailProcessorQueue
 
 import java.util.UUID
-import javax.inject.{Inject, Singleton}
+import javax.inject.Inject
 
 case class InternalEmailVerification(db: generated.EmailVerification) {
   val guid: UUID = db.guid
@@ -80,11 +78,11 @@ class InternalEmailVerificationsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("created_at"))
-    ) { q =>
+    )( using (q: Query) => {
       q.equals("lower(email)", email.map(_.toLowerCase))
         .and(isExpired.map(Filters.isExpired("email_verifications", _)))
         .and(isDeleted.map(Filters.isDeleted("email_verifications", _)))
-    }.map(InternalEmailVerification(_))
+    }).map(InternalEmailVerification(_))
   }
 
 }

api/app/db/InternalMembershipRequestsDao.scala

@@ -147,10 +147,10 @@ class InternalMembershipRequestsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("created_at")),
-    ) { q =>
+    )( using (q: Query) => {
         filters.foldLeft(q) { case (q, f) => f.filter(q) }
         .and(isDeleted.map(Filters.isDeleted("membership_requests", _)))
         .equals("role", role.map(_.toString))
-    }.map(InternalMembershipRequest(_))
+    }).map(InternalMembershipRequest(_))
   }
 }

api/app/db/InternalMembershipsDao.scala

@@ -49,7 +49,7 @@ class InternalMembershipsDao @Inject()(
     }
   }
 
-  private[db] def create(implicit c: java.sql.Connection, createdBy: UUID, org: OrganizationReference, user: UserReference, role: MembershipRole): InternalMembership = {
+  private[db] def create(c: java.sql.Connection, createdBy: UUID, org: OrganizationReference, user: UserReference, role: MembershipRole): InternalMembership = {
     val guid = dao.insert(c, createdBy, generated.MembershipForm(
       userGuid = user.guid,
       organizationGuid = org.guid,
@@ -179,11 +179,11 @@ class InternalMembershipsDao @Inject()(
       userGuid = userGuid,
       limit = limit,
       offset = offset,
-    ) { q =>
+    )( using (q: Query) => {
       filters.foldLeft(q) { case (q, f) => f.filter(q) }
         .equals("memberships.role", role.map(_.toString))
         .optionalIn("memberships.role", roles.map(_.map(_.toString)))
         .and(isDeleted.map(Filters.isDeleted("memberships", _)))
-    }.map(InternalMembership(_))
+    }).map(InternalMembership(_))
   }
 }

api/app/db/InternalOrganizationAttributeValuesDao.scala

@@ -103,7 +103,7 @@ class InternalOrganizationAttributeValuesDao @Inject()(
   private def findByOrganizationGuidAndAttributeGuid(organizationGuid: UUID, attributeGuid: UUID): Option[InternalOrganizationAttributeValue] = {
     findAll(organizationGuid = Some(organizationGuid), attributeGuid = Some(attributeGuid), limit = Some(1)).headOption
   }
-  
+
   def findAll(
     guid: Option[UUID] = None,
     organizationGuid: Option[UUID] = None,
@@ -133,9 +133,9 @@ class InternalOrganizationAttributeValuesDao @Inject()(
       attributeGuid = attributeGuid,
       limit = limit,
       offset = offset,
-    ) { q =>
+    )( using (q: Query) => {
       filters.foldLeft(q) { case (q, f) => f.filter(q) }
         .and(isDeleted.map(Filters.isDeleted("organization_attribute_values", _)))
-    }.map(InternalOrganizationAttributeValue(_))
+    }).map(InternalOrganizationAttributeValue(_))
   }
 }

api/app/db/InternalOrganizationDomainsDao.scala

@@ -1,9 +1,7 @@
 package db
 
 import db.generated.OrganizationDomainsDao
-import io.apibuilder.api.v0.models.Domain
 import io.flow.postgresql.{OrderBy, Query}
-import play.api.db.*
 
 import java.util.UUID
 import javax.inject.Inject
@@ -18,12 +16,12 @@ class InternalOrganizationDomainsDao @Inject()(
 ) {
 
   def create(createdBy: InternalUser, org: InternalOrganization, domainName: String): InternalOrganizationDomain = {
-    dao.db.withConnection { implicit c =>
+    dao.db.withConnection { c =>
       create(c, createdBy, org.guid, domainName)
     }
   }
 
-  private[db] def create(implicit c: java.sql.Connection, createdBy: InternalUser, orgGuid: UUID, domainName: String): InternalOrganizationDomain = {
+  private[db] def create(c: java.sql.Connection, createdBy: InternalUser, orgGuid: UUID, domainName: String): InternalOrganizationDomain = {
     val guid = dao.insert(c, createdBy.guid, generated.OrganizationDomainForm(
       organizationGuid = orgGuid,
       domain = domainName.trim
@@ -57,9 +55,9 @@ class InternalOrganizationDomainsDao @Inject()(
       domain = domain.map(_.trim.toLowerCase()),
       limit = limit,
       orderBy = orderBy,
-    ) { q =>
+    )( using (q: Query) => {
       q.and(isDeleted.map(Filters.isDeleted("organization_domains", _)))
-    }.map(InternalOrganizationDomain(_))
+    }).map(InternalOrganizationDomain(_))
   }
-  
+
 }

api/app/db/InternalOrganizationsDao.scala

@@ -1,7 +1,8 @@
 package db
 
-import io.apibuilder.api.v0.models._
+import io.apibuilder.api.v0.models.*
 import io.apibuilder.common.v0.models.MembershipRole
+import io.flow.postgresql.Query
 import lib.{Misc, UrlKey, Validation}
 import org.joda.time.DateTime
 import play.api.inject.Injector
@@ -158,7 +159,7 @@ class InternalOrganizationsDao @Inject()(
     }
   }
 
-  private def create(implicit c: java.sql.Connection, user: InternalUser, form: OrganizationForm): InternalOrganization = {
+  private def create(c: java.sql.Connection, user: InternalUser, form: OrganizationForm): InternalOrganization = {
     val errors = validate(form)
     assert(errors.isEmpty, errors.map(_.message).mkString("\n"))
 
@@ -213,7 +214,7 @@ class InternalOrganizationsDao @Inject()(
       guids = guids,
       limit = limit,
       offset = offset,
-    ) { q =>
+    )( using (q: Query) => {
       authorization.organizationFilter(q, "organizations.guid")
       .equals("key", key)
       .equals("lower(name)", name.map(_.toLowerCase().trim))
@@ -237,6 +238,6 @@ class InternalOrganizationsDao @Inject()(
       }).bind("deleted_at_before", deletedAtBefore)
       .and(isDeleted.map(Filters.isDeleted("organizations", _)))
       .orderBy("lower(name), created_at")
-    }.map(InternalOrganization(_))
+    }).map(InternalOrganization(_))
   }
 }

api/app/db/InternalOriginalsDao.scala

@@ -2,6 +2,7 @@ package db
 
 import db.generated.OriginalsDao
 import io.apibuilder.api.v0.models.{Original, OriginalType}
+import io.flow.postgresql.Query
 
 import java.util.UUID
 import javax.inject.Inject
@@ -16,7 +17,7 @@ case class InternalOriginal(db: generated.Original) {
 class InternalOriginalsDao @Inject()(dao: OriginalsDao) {
 
   def create(
-    implicit c: java.sql.Connection,
+    c: java.sql.Connection,
     user: InternalUser,
     versionGuid: UUID,
     original: Original
@@ -29,7 +30,7 @@ class InternalOriginalsDao @Inject()(dao: OriginalsDao) {
   }
 
   def softDeleteByVersionGuid(
-    implicit c: java.sql.Connection,
+    c: java.sql.Connection,
     user: InternalUser,
     versionGuid: UUID
   ): Unit = {
@@ -40,7 +41,7 @@ class InternalOriginalsDao @Inject()(dao: OriginalsDao) {
     dao.findAll(
       versionGuids = Some(versionGuids),
       limit = None,
-    ) { q => q.isNull("deleted_at") }.map(InternalOriginal(_))
+    )( using (q: Query) => { q.isNull("deleted_at") }).map(InternalOriginal(_))
   }
 
   def findByVersionGuid(guid: UUID): Option[InternalOriginal] = {

api/app/db/InternalPasswordResetsDao.scala

@@ -95,10 +95,10 @@ class InternalPasswordResetsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("created_at"))
-    ) { q =>
+    )( using (q: Query) => {
       q.and(isDeleted.map(Filters.isDeleted("password_resets", _)))
         .and(isExpired.map(Filters.isExpired("password_resets", _)))
-    }.map(InternalPasswordReset(_))
+    }).map(InternalPasswordReset(_))
   }
 
 }

api/app/db/InternalSubscriptionsDao.scala

@@ -41,10 +41,10 @@ class InternalSubscriptionsDao @Inject()(
   private def validateOrg(key: String): ValidatedNec[Error, Organization] = {
     organizationsDao.findAll(
       limit = Some(1),
-    ) { q =>
+    )( using (q: Query) => {
         q.equals("key", key)
           .isNull("deleted_at")
-      }
+      })
       .headOption
       .toValidNec(Validation.singleError("Organization not found"))
   }
@@ -68,7 +68,7 @@ class InternalSubscriptionsDao @Inject()(
       case Some(_) => Validation.singleError("User is already subscribed to this publication for this organization").invalidNec
     }
   }
-  
+
   private def validate(form: SubscriptionForm): ValidatedNec[Error, ValidatedSubscriptionForm] = {
     (
       validateOrg(form.organizationKey).andThen { org =>
@@ -142,14 +142,14 @@ class InternalSubscriptionsDao @Inject()(
       limit = limit,
       offset = offset,
       orderBy = Some(OrderBy("created_at"))
-    ) { q =>
+    )( using (q: Query) => {
       authorization.subscriptionFilter(
         filters.foldLeft(q) { case (q, f) => f.filter(q) },
         "subscriptions"
       )
       .and(isDeleted.map(Filters.isDeleted("subscriptions", _)))
       .equals("publication", publication.map(_.toString))
-    }.map(InternalSubscription(_))
+    }).map(InternalSubscription(_))
   }
 
 }