Merge pull request #3474 from chenharryhua/0.18

0.18
chenharryhua · Dec 7, 2024 · 8da7098 · 8da7098
2 parents 9bd9602 + 4e25323
commit 8da7098
Show file tree

Hide file tree

Showing 111 changed files with 545 additions and 622 deletions.
diff --git a/build.sbt b/build.sbt
@@ -207,9 +207,8 @@ lazy val common = (project in file("common"))
   .settings(name := "nj-common")
   .settings(
     libraryDependencies ++= List(
-      "org.apache.commons"               % "commons-lang3" % "3.17.0",
-      "io.dropwizard.metrics"            % "metrics-core"  % metricsV % Provided,
-      "org.typelevel" %% "log4cats-core" % log4catsV       % Provided
+      "org.apache.commons"    % "commons-lang3" % "3.17.0",
+      "io.dropwizard.metrics" % "metrics-core"  % metricsV % Provided
     ) ++ baseLib ++ testLib
   )
 

diff --git a/common/src/main/scala/com/github/chenharryhua/nanjin/common/NJLogLevel.scala b/common/src/main/scala/com/github/chenharryhua/nanjin/common/NJLogLevel.scala
diff --git a/common/src/test/scala/mtest/common/NJLogLevelTest.scala b/common/src/test/scala/mtest/common/NJLogLevelTest.scala
diff --git a/...enharryhua/nanjin/database/NJHikari.scala → ...enharryhua/nanjin/database/DBConfig.scala b/...enharryhua/nanjin/database/NJHikari.scala → ...enharryhua/nanjin/database/DBConfig.scala
@@ -12,26 +12,26 @@ import fs2.Stream
   * @param updateOps
   *   set operations apply to the initial config
   */
-sealed abstract class NJHikari(cfg: HikariConfig, updateOps: List[HikariConfig => Unit]) {
+sealed abstract class DBConfig(cfg: HikariConfig, updateOps: List[HikariConfig => Unit]) {
 
-  final def set(f: HikariConfig => Unit): NJHikari =
-    new NJHikari(cfg, f :: updateOps) {}
+  final def set(f: HikariConfig => Unit): DBConfig =
+    new DBConfig(cfg, f :: updateOps) {}
 
   final lazy val hikariConfig: HikariConfig = {
     updateOps.reverse.foreach(_(cfg))
     cfg.validate()
     cfg
   }
 
-  final def transactorResource[F[_]: Async]: Resource[F, HikariTransactor[F]] =
+  final def transactorR[F[_]: Async]: Resource[F, HikariTransactor[F]] =
     HikariTransactor.fromHikariConfig[F](hikariConfig)
 
-  final def transactorStream[F[_]: Async]: Stream[F, HikariTransactor[F]] =
-    Stream.resource(transactorResource)
+  final def transactorS[F[_]: Async]: Stream[F, HikariTransactor[F]] =
+    Stream.resource(transactorR)
 }
 
-object NJHikari {
-  def apply(db: Postgres): NJHikari = {
+object DBConfig {
+  def apply(db: Postgres): DBConfig = {
     val initConfig: HikariConfig = {
       val cfg = new HikariConfig
       cfg.setDriverClassName("org.postgresql.Driver")
@@ -40,10 +40,10 @@ object NJHikari {
       cfg.setPassword(db.password.value)
       cfg
     }
-    new NJHikari(initConfig, Nil) {}
+    new DBConfig(initConfig, Nil) {}
   }
 
-  def apply(db: Redshift): NJHikari = {
+  def apply(db: Redshift): DBConfig = {
     val initConfig: HikariConfig = {
       val cfg = new HikariConfig
       cfg.setDriverClassName("com.amazon.redshift.jdbc42.Driver")
@@ -54,10 +54,10 @@ object NJHikari {
       cfg.addDataSourceProperty("sslfactory", "com.amazon.redshift.ssl.NonValidatingFactory")
       cfg
     }
-    new NJHikari(initConfig, Nil) {}
+    new DBConfig(initConfig, Nil) {}
   }
 
-  def apply(db: SqlServer): NJHikari = {
+  def apply(db: SqlServer): DBConfig = {
     val initConfig: HikariConfig = {
       val cfg = new HikariConfig
       cfg.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver")
@@ -66,6 +66,6 @@ object NJHikari {
       cfg.setPassword(db.password.value)
       cfg
     }
-    new NJHikari(initConfig, Nil) {}
+    new DBConfig(initConfig, Nil) {}
   }
 }
diff --git a/database/src/test/scala/mtest/database/DoobieMetaTest.scala b/database/src/test/scala/mtest/database/DoobieMetaTest.scala
@@ -4,7 +4,7 @@ import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import cats.implicits.catsSyntaxApplicativeId
 import com.github.chenharryhua.nanjin.common.database.*
-import com.github.chenharryhua.nanjin.database.NJHikari
+import com.github.chenharryhua.nanjin.database.DBConfig
 import doobie.ConnectionIO
 import fs2.Stream
 import org.scalatest.funsuite.AnyFunSuite
@@ -24,7 +24,7 @@ class DoobieMetaTest extends AnyFunSuite with FunSuiteDiscipline with Configurat
   test("setter") {
     val username = Username("postgres")
     val password = Password("postgres")
-    val nj = NJHikari(postgres)
+    val nj = DBConfig(postgres)
       .set(_.setUsername("superceded by last update"))
       .set(_.setUsername(username.value))
       .set(_.setPassword(password.value))
@@ -33,7 +33,7 @@ class DoobieMetaTest extends AnyFunSuite with FunSuiteDiscipline with Configurat
     assert(nj.hikariConfig.getMaximumPoolSize == 10)
 
     val stream: Stream[IO, Int] = for {
-      tnx <- nj.transactorStream[IO]
+      tnx <- nj.transactorS[IO]
       n <- Stream.eval(tnx.trans.apply(42.pure[ConnectionIO]))
     } yield n
 

diff --git a/...hua/nanjin/datetime/NJDateTimeRange.scala → ...ryhua/nanjin/datetime/DateTimeRange.scala b/...hua/nanjin/datetime/NJDateTimeRange.scala → ...ryhua/nanjin/datetime/DateTimeRange.scala
@@ -13,9 +13,9 @@ import java.time.*
 import scala.concurrent.duration.FiniteDuration
 
 // lazy range
-@Lenses final case class NJDateTimeRange(
-  private val start: Option[NJDateTimeRange.TimeTypes],
-  private val end: Option[NJDateTimeRange.TimeTypes],
+@Lenses final case class DateTimeRange(
+  private val start: Option[DateTimeRange.TimeTypes],
+  private val end: Option[DateTimeRange.TimeTypes],
   zoneId: ZoneId) {
 
   private object calcDateTime extends Poly1 {
@@ -50,12 +50,12 @@ import scala.concurrent.duration.FiniteDuration
 
   def dayStrings: List[String] = days.map(d => NJTimestamp(d, zoneId).`Year=yyyy/Month=mm/Day=dd`(zoneId))
 
-  def subranges(interval: FiniteDuration): List[NJDateTimeRange] =
+  def subranges(interval: FiniteDuration): List[DateTimeRange] =
     (startTimestamp, endTimestamp).traverseN { (s, e) =>
       s.milliseconds
         .until(e.milliseconds, interval.toMillis)
         .toList
-        .map(a => NJDateTimeRange(zoneId).withStartTime(a).withEndTime(a + interval.toMillis))
+        .map(a => DateTimeRange(zoneId).withStartTime(a).withEndTime(a + interval.toMillis))
     }.flatten
 
   def period: Option[Period] =
@@ -64,64 +64,64 @@ import scala.concurrent.duration.FiniteDuration
   def javaDuration: Option[java.time.Duration] =
     (zonedStartTime, zonedEndTime).mapN((s, e) => java.time.Duration.between(s, e))
 
-  def withZoneId(zoneId: ZoneId): NJDateTimeRange =
-    NJDateTimeRange.zoneId.replace(zoneId)(this)
+  def withZoneId(zoneId: ZoneId): DateTimeRange =
+    DateTimeRange.zoneId.replace(zoneId)(this)
 
-  def withZoneId(zoneId: String): NJDateTimeRange =
-    NJDateTimeRange.zoneId.replace(ZoneId.of(zoneId))(this)
+  def withZoneId(zoneId: String): DateTimeRange =
+    DateTimeRange.zoneId.replace(ZoneId.of(zoneId))(this)
 
   implicit private def coproductPrism[A](implicit
-    evInject: Inject[NJDateTimeRange.TimeTypes, A],
-    evSelector: Selector[NJDateTimeRange.TimeTypes, A]): Prism[NJDateTimeRange.TimeTypes, A] =
-    Prism[NJDateTimeRange.TimeTypes, A](evSelector.apply)(evInject.apply)
+    evInject: Inject[DateTimeRange.TimeTypes, A],
+    evSelector: Selector[DateTimeRange.TimeTypes, A]): Prism[DateTimeRange.TimeTypes, A] =
+    Prism[DateTimeRange.TimeTypes, A](evSelector.apply)(evInject.apply)
 
-  private def setStart[A](a: A)(implicit prism: Prism[NJDateTimeRange.TimeTypes, A]): NJDateTimeRange =
-    NJDateTimeRange.start.replace(Some(prism.reverseGet(a)))(this)
+  private def setStart[A](a: A)(implicit prism: Prism[DateTimeRange.TimeTypes, A]): DateTimeRange =
+    DateTimeRange.start.replace(Some(prism.reverseGet(a)))(this)
 
-  private def setEnd[A](a: A)(implicit prism: Prism[NJDateTimeRange.TimeTypes, A]): NJDateTimeRange =
-    NJDateTimeRange.end.replace(Some(prism.reverseGet(a)))(this)
+  private def setEnd[A](a: A)(implicit prism: Prism[DateTimeRange.TimeTypes, A]): DateTimeRange =
+    DateTimeRange.end.replace(Some(prism.reverseGet(a)))(this)
 
   // start
-  def withStartTime(ts: LocalTime): NJDateTimeRange      = setStart(toLocalDateTime(ts))
-  def withStartTime(ts: LocalDate): NJDateTimeRange      = setStart(toLocalDateTime(ts))
-  def withStartTime(ts: LocalDateTime): NJDateTimeRange  = setStart(ts)
-  def withStartTime(ts: OffsetDateTime): NJDateTimeRange = setStart(NJTimestamp(ts))
-  def withStartTime(ts: ZonedDateTime): NJDateTimeRange  = setStart(NJTimestamp(ts))
-  def withStartTime(ts: Instant): NJDateTimeRange        = setStart(NJTimestamp(ts))
-  def withStartTime(ts: Long): NJDateTimeRange           = setStart(NJTimestamp(ts))
-  def withStartTime(ts: Timestamp): NJDateTimeRange      = setStart(NJTimestamp(ts))
-  def withStartTime(ts: String): NJDateTimeRange         = setStart(ts)
+  def withStartTime(ts: LocalTime): DateTimeRange      = setStart(toLocalDateTime(ts))
+  def withStartTime(ts: LocalDate): DateTimeRange      = setStart(toLocalDateTime(ts))
+  def withStartTime(ts: LocalDateTime): DateTimeRange  = setStart(ts)
+  def withStartTime(ts: OffsetDateTime): DateTimeRange = setStart(NJTimestamp(ts))
+  def withStartTime(ts: ZonedDateTime): DateTimeRange  = setStart(NJTimestamp(ts))
+  def withStartTime(ts: Instant): DateTimeRange        = setStart(NJTimestamp(ts))
+  def withStartTime(ts: Long): DateTimeRange           = setStart(NJTimestamp(ts))
+  def withStartTime(ts: Timestamp): DateTimeRange      = setStart(NJTimestamp(ts))
+  def withStartTime(ts: String): DateTimeRange         = setStart(ts)
 
   // end
-  def withEndTime(ts: LocalTime): NJDateTimeRange      = setEnd(toLocalDateTime(ts))
-  def withEndTime(ts: LocalDate): NJDateTimeRange      = setEnd(toLocalDateTime(ts))
-  def withEndTime(ts: LocalDateTime): NJDateTimeRange  = setEnd(ts)
-  def withEndTime(ts: OffsetDateTime): NJDateTimeRange = setEnd(NJTimestamp(ts))
-  def withEndTime(ts: ZonedDateTime): NJDateTimeRange  = setEnd(NJTimestamp(ts))
-  def withEndTime(ts: Instant): NJDateTimeRange        = setEnd(NJTimestamp(ts))
-  def withEndTime(ts: Long): NJDateTimeRange           = setEnd(NJTimestamp(ts))
-  def withEndTime(ts: Timestamp): NJDateTimeRange      = setEnd(NJTimestamp(ts))
-  def withEndTime(ts: String): NJDateTimeRange         = setEnd(ts)
-
-  def withNSeconds(seconds: Long): NJDateTimeRange = {
+  def withEndTime(ts: LocalTime): DateTimeRange      = setEnd(toLocalDateTime(ts))
+  def withEndTime(ts: LocalDate): DateTimeRange      = setEnd(toLocalDateTime(ts))
+  def withEndTime(ts: LocalDateTime): DateTimeRange  = setEnd(ts)
+  def withEndTime(ts: OffsetDateTime): DateTimeRange = setEnd(NJTimestamp(ts))
+  def withEndTime(ts: ZonedDateTime): DateTimeRange  = setEnd(NJTimestamp(ts))
+  def withEndTime(ts: Instant): DateTimeRange        = setEnd(NJTimestamp(ts))
+  def withEndTime(ts: Long): DateTimeRange           = setEnd(NJTimestamp(ts))
+  def withEndTime(ts: Timestamp): DateTimeRange      = setEnd(NJTimestamp(ts))
+  def withEndTime(ts: String): DateTimeRange         = setEnd(ts)
+
+  def withNSeconds(seconds: Long): DateTimeRange = {
     val now = LocalDateTime.now
     withStartTime(now.minusSeconds(seconds)).withEndTime(now)
   }
 
-  def withTimeRange(start: String, end: String): NJDateTimeRange =
+  def withTimeRange(start: String, end: String): DateTimeRange =
     withStartTime(start).withEndTime(end)
 
-  def withOneDay(ts: LocalDate): NJDateTimeRange =
+  def withOneDay(ts: LocalDate): DateTimeRange =
     withStartTime(ts).withEndTime(ts.plusDays(1))
 
-  def withOneDay(ts: String): NJDateTimeRange =
+  def withOneDay(ts: String): DateTimeRange =
     DateTimeParser.localDateParser.parse(ts).map(withOneDay) match {
       case Left(ex)   => throw ex.parseException(ts)
       case Right(day) => day
     }
 
-  def withToday: NJDateTimeRange     = withOneDay(LocalDate.now)
-  def withYesterday: NJDateTimeRange = withOneDay(LocalDate.now.minusDays(1))
+  def withToday: DateTimeRange     = withOneDay(LocalDate.now)
+  def withYesterday: DateTimeRange = withOneDay(LocalDate.now.minusDays(1))
 
   def isInBetween(ts: Long): Boolean =
     (startTimestamp, endTimestamp) match {
@@ -136,16 +136,16 @@ import scala.concurrent.duration.FiniteDuration
     duration.map(DurationFormatter.defaultFormatter.format).getOrElse("infinite")
 }
 
-object NJDateTimeRange {
+object DateTimeRange {
 
   final type TimeTypes =
     NJTimestamp :+:
       LocalDateTime :+:
       String :+: // date-time in string, like "03:12"
       CNil
 
-  implicit final val partialOrderNJDateTimeRange: PartialOrder[NJDateTimeRange] & Show[NJDateTimeRange] =
-    new PartialOrder[NJDateTimeRange] with Show[NJDateTimeRange] {
+  implicit final val partialOrderNJDateTimeRange: PartialOrder[DateTimeRange] & Show[DateTimeRange] =
+    new PartialOrder[DateTimeRange] with Show[DateTimeRange] {
 
       private def lessStart(a: Option[NJTimestamp], b: Option[NJTimestamp]): Boolean =
         (a, b) match {
@@ -161,7 +161,7 @@ object NJDateTimeRange {
           case (Some(x), Some(y)) => x > y
         }
 
-      override def partialCompare(x: NJDateTimeRange, y: NJDateTimeRange): Double =
+      override def partialCompare(x: DateTimeRange, y: DateTimeRange): Double =
         (x, y) match {
           case (a, b) if a.endTimestamp === b.endTimestamp && a.startTimestamp === b.startTimestamp =>
             0.0
@@ -174,10 +174,10 @@ object NJDateTimeRange {
           case _ => Double.NaN
         }
 
-      override def show(x: NJDateTimeRange): String = x.toString
+      override def show(x: DateTimeRange): String = x.toString
 
     }
 
-  def apply(zoneId: ZoneId): NJDateTimeRange = NJDateTimeRange(None, None, zoneId)
+  def apply(zoneId: ZoneId): DateTimeRange = DateTimeRange(None, None, zoneId)
 
 }
diff --git a/...arryhua/nanjin/datetime/NJLocalTime.scala → ...yhua/nanjin/datetime/LocalTimeRange.scala b/...arryhua/nanjin/datetime/NJLocalTime.scala → ...yhua/nanjin/datetime/LocalTimeRange.scala
@@ -1,21 +1,10 @@
 package com.github.chenharryhua.nanjin.datetime
 
-import java.time.{Duration as JavaDuration, Instant, LocalTime, ZoneId, ZonedDateTime}
+import java.time.{Instant, LocalTime, ZoneId, ZonedDateTime}
 import scala.concurrent.duration.{Duration, FiniteDuration}
-import scala.jdk.DurationConverters.{JavaDurationOps, ScalaDurationOps}
+import scala.jdk.DurationConverters.ScalaDurationOps
 
-final case class NJLocalTime(value: LocalTime) {
-
-  def distance(other: LocalTime): FiniteDuration = {
-    val dur = JavaDuration.between(value, other)
-    val res = if (dur.isNegative) {
-      dur.plusHours(24)
-    } else dur
-    res.toScala
-  }
-}
-
-final case class NJLocalTimeRange(start: LocalTime, duration: FiniteDuration, zoneId: ZoneId) {
+final case class LocalTimeRange(start: LocalTime, duration: FiniteDuration, zoneId: ZoneId) {
 
   // start time inclusive, end time exclusive
   def inBetween(instant: Instant): Boolean =