Migrate to ZIO 2 (#529)

* Migrate to ZIO 2.x and zio-logging 2.x

Update ZIO 1.0.18 to 2.1.26, zio-logging 0.5.16 to 2.5.3, and switch
to zio-logging-slf4j2-bridge to match the slf4j 2.x API on the classpath.
Drop the unused zio-streams dependency.

- Replace the Logging environment service with ZIO 2 core logging; log
  context is applied via Main.withLogContext over ZIO.logAnnotate, and the
  console logger plus slf4j bridge are wired as a layer in Main.
- Port the case-app entry point from zio.App to ZIOAppDefault.
- Apply core API renames (effect/effectTotal, effectBlocking, foreach_,
  bracketAuto) and convert the Query reasoner from ZManaged to a scoped
  resource.
- Request a non-zero process exit explicitly on DOSDPError, since
  ZIOAppDefault no longer derives the exit code from a returned ExitCode.
- Update the test suite to zio-test 2.x (ZIOSpecDefault, test, assertZIO).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Preserve CLI failure exit codes

* Use ZIO type aliases

* Fix logging typo.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: balhoff

build.sbt

@@ -27,12 +27,12 @@ buildInfoKeys := Seq[BuildInfoKey](name, version, scalaVersion, sbtVersion, gitC
 
 buildInfoPackage := "org.monarchinitiative.dosdp.cli"
 
-val zioVersion = "1.0.18"
+val zioVersion = "2.1.26"
+val zioLoggingVersion = "2.5.3"
 
 libraryDependencies ++= {
     Seq(
       "dev.zio"                    %% "zio"                    % zioVersion,
-      "dev.zio"                    %% "zio-streams"            % zioVersion,
       "com.github.alexarchambault" %% "case-app"               % "2.0.6",
       "net.sourceforge.owlapi"     %  "owlapi-distribution"    % "4.5.29",
       "org.phenoscape"             %% "scowl"                  % "1.4.1",
@@ -55,8 +55,8 @@ libraryDependencies ++= {
       "org.apache.jena"            %  "apache-jena-libs"       % "4.10.0" exclude("org.slf4j", "slf4j-log4j12"),
       "com.github.tototoshi"       %% "scala-csv"              % "2.0.0",
       "commons-codec"              %  "commons-codec"          % "1.17.2",
-      "dev.zio"                    %% "zio-logging"            % "0.5.16",
-      "dev.zio"                    %% "zio-logging-slf4j-bridge" % "0.5.16",
+      "dev.zio"                    %% "zio-logging"            % zioLoggingVersion,
+      "dev.zio"                    %% "zio-logging-slf4j2-bridge" % zioLoggingVersion,
       "dev.zio"                    %% "zio-test"               % zioVersion % Test,
       "dev.zio"                    %% "zio-test-sbt"           % zioVersion % Test
     )

src/main/scala/org/monarchinitiative/dosdp/AnnotationCompiler.scala

@@ -3,8 +3,7 @@ package org.monarchinitiative.dosdp
 import org.monarchinitiative.dosdp.cli.DOSDPError
 import org.monarchinitiative.dosdp.cli.DOSDPError.logErrorFail
 import org.semanticweb.owlapi.model.OWLAnnotationProperty
-import zio._
-import zio.logging.Logging
+import zio.{Config => _, _}
 
 /**
  * Pattern-time normalization of annotations and permutations: resolves
@@ -18,7 +17,7 @@ import zio.logging.Logging
  */
 private[dosdp] object AnnotationCompiler {
 
-  def normalizeAnnotation(annotation: Annotations, checker: SafeOWLEntityChecker): ZIO[Logging, DOSDPError, NormalizedAnnotation] = annotation match {
+  def normalizeAnnotation(annotation: Annotations, checker: SafeOWLEntityChecker): IO[DOSDPError, NormalizedAnnotation] = annotation match {
     case PrintfAnnotation(anns, ap, text, vars, overrideColumn, multiClause, perms) =>
       for {
         prop <- checker.getOWLAnnotationProperty(ap).orElse(logErrorFail(s"No annotation property binding: $ap"))
@@ -38,7 +37,7 @@ private[dosdp] object AnnotationCompiler {
       } yield NormalizedIRIValueAnnotation(prop, varr, annotations.to(Set))
   }
 
-  def normalizeOBOAnnotation(annotation: OBOAnnotations, property: OWLAnnotationProperty, overrideColumn: Option[String], checker: SafeOWLEntityChecker): ZIO[Logging, DOSDPError, NormalizedAnnotation] =
+  def normalizeOBOAnnotation(annotation: OBOAnnotations, property: OWLAnnotationProperty, overrideColumn: Option[String], checker: SafeOWLEntityChecker): IO[DOSDPError, NormalizedAnnotation] =
     annotation match {
       case PrintfAnnotationOBO(anns, xrefs, text, vars, multiClause, perms) =>
         for {
@@ -53,14 +52,14 @@ private[dosdp] object AnnotationCompiler {
           xrefs.map(NormalizedListAnnotation(PrintfAnnotationOBO.Xref, _, Set.empty)).to(Set)))
     }
 
-  def normalizePermutation(permutation: Permutation, checker: SafeOWLEntityChecker): ZIO[Logging, DOSDPError, NormalizedPermutation] =
+  def normalizePermutation(permutation: Permutation, checker: SafeOWLEntityChecker): IO[DOSDPError, NormalizedPermutation] =
     for {
       props <- ZIO.foreach(permutation.annotationProperties)(apName =>
         checker.getOWLAnnotationProperty(apName).orElse(logErrorFail(s"No annotation property binding for permutation: $apName")))
     } yield NormalizedPermutation(permutation.`var`, props)
 
   /** Every variable named in a permutation spec must appear in the enclosing annotation's `vars` list. */
-  def validatePermutationVars(permutations: List[Permutation], vars: List[String]): ZIO[Logging, DOSDPError, Unit] = {
+  def validatePermutationVars(permutations: List[Permutation], vars: List[String]): IO[DOSDPError, Unit] = {
     val varSet = vars.toSet
     val invalidVars = permutations.map(_.`var`).filterNot(varSet.contains)
     if (invalidVars.isEmpty) ZIO.unit
@@ -72,7 +71,7 @@ private[dosdp] object AnnotationCompiler {
    * Names that fail to resolve are silently dropped here; `normalizePermutation` is the canonical
    * place where an unresolved reference becomes a validation error.
    */
-  def permutationAnnotationProperties(dosdp: DOSDP, checker: SafeOWLEntityChecker): URIO[Logging, Set[OWLAnnotationProperty]] = {
+  def permutationAnnotationProperties(dosdp: DOSDP, checker: SafeOWLEntityChecker): UIO[Set[OWLAnnotationProperty]] = {
     val names = collectPermutationPropertyNames(dosdp)
     ZIO.foreach(names.toList)(name => checker.getOWLAnnotationProperty(name).option)
       .map(_.flatten.toSet)

src/main/scala/org/monarchinitiative/dosdp/CompiledPattern.scala

@@ -6,8 +6,7 @@ import org.monarchinitiative.dosdp.AxiomType
 import org.semanticweb.owlapi.apibinding.OWLManager
 import org.semanticweb.owlapi.manchestersyntax.parser.{ManchesterOWLSyntaxClassExpressionParser, ManchesterOWLSyntaxInlineAxiomParser}
 import org.semanticweb.owlapi.model.{AxiomType => _, _}
-import zio._
-import zio.logging.Logging
+import zio.{Config => _, _}
 
 import scala.jdk.CollectionConverters._
 
@@ -197,7 +196,7 @@ private[dosdp] object PatternCompiler {
   private val PlaceholderLiteralPattern = """^\$(.+)$""".r
   private val VariableNamePattern = "^[A-Za-z0-9_]+$".r
 
-  def compile(dosdp: DOSDP, prefixes: PartialFunction[String, String]): ZIO[Logging, DOSDPError, CompiledPattern] = {
+  def compile(dosdp: DOSDP, prefixes: PartialFunction[String, String]): IO[DOSDPError, CompiledPattern] = {
     val checker = new DOSDPEntityChecker(dosdp, prefixes)
     val safeChecker = new SafeOWLEntityChecker(checker)
     val expressionParser = new ManchesterOWLSyntaxClassExpressionParser(factory, checker)
@@ -232,7 +231,7 @@ private[dosdp] object PatternCompiler {
       dataVarNames = dataVarNames)
   }
 
-  private def validateVariableNames(dosdp: DOSDP): ZIO[Logging, DOSDPError, Unit] = {
+  private def validateVariableNames(dosdp: DOSDP): IO[DOSDPError, Unit] = {
     val invalidNames = variableNames(dosdp)
       .filterNot(name => VariableNamePattern.pattern.matcher(name).matches)
       .toList.sorted
@@ -312,7 +311,7 @@ private[dosdp] object PatternCompiler {
     dataVarNames: Set[String],
     checker: SafeOWLEntityChecker,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, Option[CompiledClassExpression]] =
+  ): IO[DOSDPError, Option[CompiledClassExpression]] =
     ZIO.foreach(templateOpt) { template =>
       for {
         annotations <- ZIO.foreach(template.annotations.toList.flatten)(AnnotationCompiler.normalizeAnnotation(_, checker)).map(_.toSet)
@@ -326,7 +325,7 @@ private[dosdp] object PatternCompiler {
     dataVarNames: Set[String],
     annotations: Set[NormalizedAnnotation],
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, Option[CompiledClassExpression]] =
+  ): IO[DOSDPError, Option[CompiledClassExpression]] =
     (template.text, template.multi_clause) match {
       case (Some(_), _) =>
         parseClauseText(template.text, template.vars, template.multi_clause, dataVarNames, parser, template.shouldQuote, placeholderBindings)
@@ -347,7 +346,7 @@ private[dosdp] object PatternCompiler {
     quote: Boolean,
     annotations: Set[NormalizedAnnotation],
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, CompiledMultiClassExpression] =
+  ): IO[DOSDPError, CompiledMultiClassExpression] =
     for {
       clauses <- ZIO.foreach(mc.clauses.toList.flatten)(compilePrintfClause(_, dataVarNames, parser, quote, placeholderBindings))
       op      <- operatorFor(mc.sep, clauses.size)
@@ -359,7 +358,7 @@ private[dosdp] object PatternCompiler {
     parser: ManchesterOWLSyntaxClassExpressionParser,
     quote: Boolean,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, CompiledPrintfClause] =
+  ): IO[DOSDPError, CompiledPrintfClause] =
     for {
       main <- parseClauseText(Some(clause.text), clause.vars, None, dataVarNames, parser, quote, placeholderBindings)
       subs <- ZIO.foreach(clause.sub_clauses.toList.flatten)(compileSubExpression(_, dataVarNames, parser, quote, placeholderBindings))
@@ -371,7 +370,7 @@ private[dosdp] object PatternCompiler {
     parser: ManchesterOWLSyntaxClassExpressionParser,
     quote: Boolean,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, CompiledSubExpression] =
+  ): IO[DOSDPError, CompiledSubExpression] =
     for {
       clauses <- ZIO.foreach(mc.clauses.toList.flatten)(compilePrintfClause(_, dataVarNames, parser, quote, placeholderBindings))
       op      <- operatorFor(mc.sep, clauses.size)
@@ -387,7 +386,7 @@ private[dosdp] object PatternCompiler {
    * lone expression through). Omitting `sep` with two or more clauses is an
    * error.
    */
-  private def operatorFor(sep: Option[String], clauseCount: Int): ZIO[Logging, DOSDPError, LogicalOperator] =
+  private def operatorFor(sep: Option[String], clauseCount: Int): IO[DOSDPError, LogicalOperator] =
     sep match {
       case Some(" and ") => ZIO.succeed(LogicalOperator.And)
       case Some(" or ")  => ZIO.succeed(LogicalOperator.Or)
@@ -403,7 +402,7 @@ private[dosdp] object PatternCompiler {
     dataVarNames: Set[String],
     checker: SafeOWLEntityChecker,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, Option[CompiledAxiom]] =
+  ): IO[DOSDPError, Option[CompiledAxiom]] =
     ZIO.foreach(templateOpt.filter(_.text.isDefined)) { template =>
       for {
         _ <- ZIO.when(template.multi_clause.isDefined)(
@@ -420,7 +419,7 @@ private[dosdp] object PatternCompiler {
     dataVarNames: Set[String],
     checker: SafeOWLEntityChecker,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, Option[CompiledLogicalAxiom]] = {
+  ): IO[DOSDPError, Option[CompiledLogicalAxiom]] = {
     for {
       annotations <- ZIO.foreach(template.annotations.toList.flatten)(AnnotationCompiler.normalizeAnnotation(_, checker)).map(_.toSet)
       compiled <- template.axiom_type match {
@@ -450,12 +449,12 @@ private[dosdp] object PatternCompiler {
     parser: ManchesterOWLSyntaxClassExpressionParser,
     quote: Boolean,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, ParsedPiece[OWLClassExpression]] = {
+  ): IO[DOSDPError, ParsedPiece[OWLClassExpression]] = {
     val effective = withFallbackPlaceholders(referencedVars(vars, multi), placeholderBindings)
     val resolved = PrintfText.replaced(text, vars, multi, Some(effective), quote, dataVarNames)
     ZIO.fromOption(resolved).orElse(logErrorFail(s"Could not assemble Manchester template text for parsing"))
       .flatMap { rendered =>
-        ZIO.effect(parser.parse(rendered))
+        ZIO.attempt(parser.parse(rendered))
           .flatMapError(e => DOSDPError.logError(s"Failed to parse class expression: $rendered", e))
           .map(ce => describePiece(ce, vars))
       }
@@ -468,12 +467,12 @@ private[dosdp] object PatternCompiler {
     parser: ManchesterOWLSyntaxInlineAxiomParser,
     quote: Boolean,
     placeholderBindings: Map[String, Binding]
-  ): ZIO[Logging, DOSDPError, ParsedPiece[OWLAxiom]] = {
+  ): IO[DOSDPError, ParsedPiece[OWLAxiom]] = {
     val effective = withFallbackPlaceholders(vars.getOrElse(Nil), placeholderBindings)
     val resolved = PrintfText.replaced(text, vars, multi_clause = None, Some(effective), quote, dataVarNames)
     ZIO.fromOption(resolved).orElse(logErrorFail("Could not assemble Manchester axiom text for parsing"))
       .flatMap { rendered =>
-        ZIO.effect(parser.parse(rendered))
+        ZIO.attempt(parser.parse(rendered))
           .flatMapError(e => DOSDPError.logError(s"Failed to parse axiom: $rendered", e))
           .map(ax => describePiece(ax, vars))
       }
@@ -605,7 +604,7 @@ private[dosdp] object PatternCompiler {
     case _                           => ()
   }
 
-  private def compileOBOAnnotations(dosdp: DOSDP, checker: SafeOWLEntityChecker): ZIO[Logging, DOSDPError, Set[NormalizedAnnotation]] = {
+  private def compileOBOAnnotations(dosdp: DOSDP, checker: SafeOWLEntityChecker): IO[DOSDPError, Set[NormalizedAnnotation]] = {
     val fields: List[(Iterable[OBOAnnotations], OWLAnnotationProperty, Option[String])] = List(
       (dosdp.name,                                       Name,           Some(overrides(Name))),
       (dosdp.comment,                                    Comment,        Some(overrides(Comment))),
@@ -625,7 +624,7 @@ private[dosdp] object PatternCompiler {
     }.map(_.flatten.toSet)
   }
 
-  private def compileReadableIdentifierProperties(dosdp: DOSDP, checker: SafeOWLEntityChecker): ZIO[Logging, DOSDPError, List[OWLAnnotationProperty]] =
+  private def compileReadableIdentifierProperties(dosdp: DOSDP, checker: SafeOWLEntityChecker): IO[DOSDPError, List[OWLAnnotationProperty]] =
     ZIO.foreach(dosdp.readable_identifiers) { identifiers =>
       ZIO.foreach(identifiers)(name =>
         checker.getOWLAnnotationProperty(name)

src/main/scala/org/monarchinitiative/dosdp/DocsMarkdown.scala

@@ -5,8 +5,7 @@ import org.monarchinitiative.dosdp.cli.Docs.DocData
 import org.phenoscape.scowl._
 import org.semanticweb.owlapi.io.OWLObjectRenderer
 import org.semanticweb.owlapi.model.{IRI, OWLObject}
-import zio.ZIO
-import zio.logging.Logging
+import zio.{IO, ZIO}
 
 import scala.jdk.CollectionConverters._
 
@@ -20,7 +19,7 @@ import scala.jdk.CollectionConverters._
  */
 object DocsMarkdown {
 
-  def markdown(compiled: CompiledPattern, docData: DocData, renderer: OWLObjectRenderer, data: List[List[String]]): ZIO[Logging, DOSDPError, String] = {
+  def markdown(compiled: CompiledPattern, docData: DocData, renderer: OWLObjectRenderer, data: List[List[String]]): IO[DOSDPError, String] = {
     def r(obj: OWLObject): String = renderer.render(obj).replace("\n", " ")
 
     val dosdp = compiled.source

src/main/scala/org/monarchinitiative/dosdp/SPARQL.scala

@@ -9,16 +9,15 @@ import org.phenoscape.owlet.OwletManchesterSyntaxDataType.SerializableClassExpre
 import org.semanticweb.owlapi.apibinding.OWLManager
 import org.semanticweb.owlapi.model._
 import org.phenoscape.scowl._
-import zio._
-import zio.logging._
+import zio.{Config => _, _}
 
 import scala.jdk.CollectionConverters._
 
 object SPARQL {
 
   private val factory = OWLManager.getOWLDataFactory()
 
-  def queryFor(compiled: CompiledPattern, axioms: AxiomKind): ZIO[Logging, DOSDPError, String] = {
+  def queryFor(compiled: CompiledPattern, axioms: AxiomKind): IO[DOSDPError, String] = {
     // Logical axioms always materialize even on an annotation-only query: the
     // `OPTIONAL { ?var rdfs:label ... }` clauses are derived from their
     // variable set. Compute once and share with `selectFor` / `triplesFor` so
@@ -63,10 +62,10 @@ ORDER BY ?defined_class_label
 
   private val Thing = OWLManager.getOWLDataFactory.getOWLThing
 
-  def triplesFor(compiled: CompiledPattern, axioms: AxiomKind): ZIO[Logging, DOSDPError, Seq[String]] =
+  def triplesFor(compiled: CompiledPattern, axioms: AxiomKind): IO[DOSDPError, Seq[String]] =
     triplesFor(compiled, axioms, Expansion.placeholderAxioms(compiled, LogicalAxioms))
 
-  private def triplesFor(compiled: CompiledPattern, axioms: AxiomKind, logicalAxioms: Set[OWLAxiom]): ZIO[Logging, DOSDPError, Seq[String]] = {
+  private def triplesFor(compiled: CompiledPattern, axioms: AxiomKind, logicalAxioms: Set[OWLAxiom]): IO[DOSDPError, Seq[String]] = {
     val props = compiled.readableIdentifierProperties.to(Set)
     val (queryLogical, queryAnnotations) = Generate.axiomsOutputChoice(axioms)
     val annotationAxioms = if (queryAnnotations) Expansion.placeholderAxioms(compiled, AnnotationAxioms) else Set.empty[OWLAxiom]
@@ -94,13 +93,13 @@ ORDER BY ?defined_class_label
     } yield annotationTriples ++ axiomTriples ++ variableTriples ++ labelTriples
   }
 
-  def triplesForAxiom(axiom: OWLAxiom, readableIdentifierProperties: Set[OWLAnnotationProperty]): URIO[Logging, Seq[String]] = axiom match {
+  def triplesForAxiom(axiom: OWLAxiom, readableIdentifierProperties: Set[OWLAnnotationProperty]): UIO[Seq[String]] = axiom match {
     case subClassOf: OWLSubClassOfAxiom                   =>
       val (subClass, subClassTriples) = triplesForClassExpression(subClassOf.getSubClass)
       val (superClass, superClassTriples) = triplesForClassExpression(subClassOf.getSuperClass)
       ZIO.succeed(Seq(s"$subClass rdfs:subClassOf $superClass .") ++ subClassTriples ++ superClassTriples)
     case equivalentTo: OWLEquivalentClassesAxiom          =>
-      log.warn("More than two operands or missing named class in equivalent class axiom unexpected")
+      ZIO.logWarning("More than two operands or missing named class in equivalent class axiom unexpected")
         .when(!equivalentTo.containsNamedEquivalentClass || (equivalentTo.getClassExpressions.size > 2)) *>
         ZIO.succeed {
           (for {
@@ -113,7 +112,7 @@ ORDER BY ?defined_class_label
           }).toSeq.flatten
         }
     case disjointWith: OWLDisjointClassesAxiom            =>
-      log.warn("More than two operands or missing named class in disjointness axiom unexpected")
+      ZIO.logWarning("More than two operands or missing named class in disjointness axiom unexpected")
         .when(!disjointWith.getClassExpressions.asScala.forall(_.isAnonymous) || (disjointWith.getClassExpressions.size > 2)) *>
         ZIO.succeed {
           (for {

src/main/scala/org/monarchinitiative/dosdp/SafeOWLEntityChecker.scala

@@ -2,7 +2,7 @@ package org.monarchinitiative.dosdp
 
 import org.semanticweb.owlapi.expression.OWLEntityChecker
 import org.semanticweb.owlapi.model._
-import zio._
+import zio.{Config => _, _}
 
 class SafeOWLEntityChecker(checker: OWLEntityChecker) {