F and G because we live in a :clown: world

Author: sideeffffect

SchedulerQuartz.scala

@@ -1,5 +1,6 @@
 package com.github.sideeffffect.quartz
 
+import cats.MonadThrow
 import cats.effect.std.Dispatcher
 import cats.effect.syntax.all._
 import cats.effect.{Async, MonadCancelThrow, Resource, Sync}
@@ -24,11 +25,11 @@ import scala.io.Source
 import scala.jdk.CollectionConverters._
 import scala.util.chaining._
 
-private class SchedulerQuartz[A: Encoder: Decoder, F[_]: Sync](
+private class SchedulerQuartz[A: Encoder: Decoder, F[_]: MonadThrow, G[_]: Sync](
     underlying: org.quartz.Scheduler,
     action: A => F[Unit],
     dispatcher: Dispatcher[F],
-) extends com.github.sideeffffect.quartz.Scheduler[A, F]
+) extends com.github.sideeffffect.quartz.Scheduler[A, G]
     with Job {
 
   def executeF(context: JobExecutionContext): F[Unit] = for {
@@ -38,14 +39,14 @@ private class SchedulerQuartz[A: Encoder: Decoder, F[_]: Sync](
 
   override def execute(context: JobExecutionContext): Unit = dispatcher.unsafeRunSync(executeF(context))
 
-  override def scheduleJob(name: String, group: String, jobData: A, cronExpression: String): F[Unit] = scheduleJob(
+  override def scheduleJob(name: String, group: String, jobData: A, cronExpression: String): G[Unit] = scheduleJob(
     name,
     group,
     jobData,
     _.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionFireAndProceed),
   ).void
 
-  override def scheduleJob(name: String, group: String, jobData: A, instant: Instant): F[Unit] = scheduleJob(
+  override def scheduleJob(name: String, group: String, jobData: A, instant: Instant): G[Unit] = scheduleJob(
     name,
     group,
     jobData,
@@ -58,10 +59,10 @@ private class SchedulerQuartz[A: Encoder: Decoder, F[_]: Sync](
       group: String,
       jobData: A,
       configure: TriggerBuilder[Trigger] => TriggerBuilder[? <: Trigger],
-  ): F[java.util.Date] = Sync[F].blocking {
+  ): G[java.util.Date] = Sync[G].blocking {
     val jobKey = JobKey.jobKey(name, group)
     val jobDetail = JobBuilder
-      .newJob(classOf[SchedulerQuartz[A, F]])
+      .newJob(classOf[SchedulerQuartz[A, F, G]])
       .withIdentity(jobKey)
       .usingJobData(jobDataMapKey, jobData.asJson.spaces2SortKeys)
       .requestRecovery(true)
@@ -78,11 +79,11 @@ private class SchedulerQuartz[A: Encoder: Decoder, F[_]: Sync](
     underlying.scheduleJob(jobDetail, trigger)
   }
 
-  override def checkExists(name: String, group: String): F[Boolean] = Sync[F].blocking {
+  override def checkExists(name: String, group: String): G[Boolean] = Sync[G].blocking {
     underlying.checkExists(JobKey.jobKey(name, group))
   }
 
-  override def deleteJob(name: String, group: String): F[Boolean] = Sync[F].blocking {
+  override def deleteJob(name: String, group: String): G[Boolean] = Sync[G].blocking {
     underlying.deleteJob(JobKey.jobKey(name, group))
   }
 }
@@ -142,11 +143,11 @@ object SchedulerQuartz {
     )
   """.query[Boolean].unique.transact(transactor)
 
-  def make[A: Encoder: Decoder, F[_]: Async, DS <: DataSource](
+  def make[A: Encoder: Decoder, DS <: DataSource, F[_]: Async, G[_]: Sync](
       transactor: Transactor.Aux[F, DS],
       dbInitScriptName: Option[String] = None,
       customQuartzConfig: Map[String, String] = Map(),
-  )(action: A => F[Unit]): Resource[F, com.github.sideeffffect.quartz.Scheduler[A, F]] = for {
+  )(action: A => F[Unit]): Resource[F, com.github.sideeffffect.quartz.Scheduler[A, G]] = for {
     dispatcher <- Dispatcher.parallel[F](await = true)
 
     quartzConfig0 = defaultQuartzConfig ++ customQuartzConfig
@@ -156,7 +157,7 @@ object SchedulerQuartz {
     dbIsInitialized <- isDbInitialized(transactor, quartzConfig(tablePrefixKey)).toResource
     _ <- Async[F].unlessA(dbIsInitialized)(dbInitScriptName.traverse(dbInit(transactor))).toResource
 
-    scheduler <- Resource[F, SchedulerQuartz[A, F]](Sync[F].blocking {
+    scheduler <- Resource[F, SchedulerQuartz[A, F, G]](Sync[F].blocking {
       DBConnectionManager
         .getInstance()
         .addConnectionProvider(
@@ -171,7 +172,7 @@ object SchedulerQuartz {
       val props = { val p = new Properties(); p.putAll(quartzConfig.asJava); p }
       val schedulerFactory = new StdSchedulerFactory(props)
       val scheduler = schedulerFactory.getScheduler()
-      val schedulerQuartz = new SchedulerQuartz[A, F](scheduler, action, dispatcher)
+      val schedulerQuartz = new SchedulerQuartz[A, F, G](scheduler, action, dispatcher)
       scheduler.setJobFactory((_: TriggerFiredBundle, _: org.quartz.Scheduler) => schedulerQuartz)
       scheduler.start()
       (