Value Members

1.  def addPostFixToKey(string: String): (String) ⇒ String

   Add a post fix to an existing key

   Add a post fix to an existing key

   Definition Classes

   KeyConversionFunctions

2.  def addPrefixToKey(prefix: String): (String) ⇒ String

   Add a prefix to an existing key

   Add a prefix to an existing key

   Definition Classes

   KeyConversionFunctions

3.  implicit macro def autoTupleConversion[P <: Product, T]: TupleConversion[P, T]

   Definition Classes

   ImplicitTupleConversion

4.  def autoTupleConversion1[P, A](implicit ev: TupleConversion[P, (A)]): TupleConversion[P, A]

   Definition Classes

   ImplicitTupleConversion

5.  def camelToDelimiter(input: String, delimiter: String): String

   Convert camelCase to any delimited string.

   Convert camelCase to any delimited string. Example:

   camelToDelimiter("abcDef", "-") === abc-def

   Definition Classes

   KeyConversionFunctions

6.  final def configLayer[A](config: ConfigDescriptor[A])(implicit tag: Tag[A]): ZLayer[ConfigSource, ReadError[config.K], A]

   Convert a ConfigDescriptor to a Layer, which further requires a ConfigSource as input.

   Convert a ConfigDescriptor to a Layer, which further requires a ConfigSource as input. Note: Use configLayer_ instead of configLayer if ConfigSource information is already embedded in the descriptor.

   Example usage:

   final case class MyConfig(age: Int)
   
   val appConfigLayer  =
      ConfigSource.fromMap(Map("age" -> "20")).toLayer >>> configLayer(int("age").to[MyConfig])
   
   val app: ZIO[MyConfig with zio.console.Console,java.io.IOException, Unit] =
     getConfig[MyConfig].flatMap(Console.printLine)
   
   app.provideSomeLayer[Console](appConfigLayer)
   // ZIO[zio.console.Console, Exception, Unit]

   This can also be simplified to

   val appConfigLayer  =
    configLayer_(int("age").to[MyConfig] from  ConfigSource.fromMap(Map("age" -> "20")))
   
   app.provideSomeLayer[Console](appConfigLayer)

   The preference depends on how you want to design the entry point to managing config of your app.

   Definition Classes

   ConfigModule

7.  final def configLayer_[A](config: ConfigDescriptor[A])(implicit tag: Tag[A]): ZLayer[Any, ReadError[config.K], A]

   Convert a ConfigDescriptor to a Layer.

   Convert a ConfigDescriptor to a Layer.

   Example usage:

   final case class MyConfig(age: Int, name: String)
   
   object MyConfig {
     val config =
       (int("age") zip string("name")).to[MyConfig] from ConfigSource.fromMap(Map("age" -> "20", "name" -> "afsal"))
   }
   
   val app: ZIO[Has[MyConfig] with zio.console.Console, java.io.IOException, Unit] =
     getConfig[MyConfig].flatMap(putStrLn)
   
   val io: ZIO[zio.console.Console, Exception, Unit] =
     app.provideSomeLayer[Console](configLayer_(MyConfig.config))
   
   println(zio.Runtime.default.unsafeRun(io))

   Definition Classes

   ConfigModule

8.  final def generateDocs[A](config: ConfigDescriptor[A]): ConfigDocs

   Generate documentation based on the ConfigDescriptor, where a ConfigDescriptor is a structure representing the logic to fetch the application config from various sources.

   Generate documentation based on the ConfigDescriptor, where a ConfigDescriptor is a structure representing the logic to fetch the application config from various sources.

   Once we generate the docs, this can be converted to a light weight Table structure which is much more easier to be converted to markdown or json formats.

   Example :

   val configDescriptor: ConfigDescriptor[MyAppConfig] = ???
   
   generatedDocs(configDescriptor).toTable.toGithubFlavouredMarkdown

   Definition Classes

   ConfigDocsModule

9.  def generateReport[A](config: ConfigDescriptor[A], value: A): Either[String, ConfigDocs]

   Generate a report based on the ConfigDescriptor and an A, where a ConfigDescriptor represents the logic to fetch the application config from various sources, and A represents the actual config value that was retrieved.

   Generate a report based on the ConfigDescriptor and an A, where a ConfigDescriptor represents the logic to fetch the application config from various sources, and A represents the actual config value that was retrieved.

   Definition Classes

   ConfigDocsModule

10.  final def getConfig[A](implicit tag: Tag[A]): ZIO[A, Nothing, A]

    Example usage:

    Example usage:

    A helper method allowing you to forget passing configs as arguments to all over the place in your app. Whereever, you need to access the config, simply call getConfig[MyConfig].flatMap(config => ???).

    PS: if you are familiar with Kleisli, this is similar to using Kleisi[IO, Config, A], except for the fact that it is Has[Config] instead of Config allowing you to mixin with other dependencies keeping your Monad the same

    import zio.console._
    
    final case class MyConfig(username: String, port: Int)
    
    val app: ZIO[Has[MyConfig] with Console, java.io.IOException, Unit] =
      for {
         config <- getConfig[MyConfig]
         _      <- putStrLn(config.toString)
      } yield ()
    
    val configDesc =
      (string("USERNAME") zip int("PORT")).to[MyConfig] from ConfigSource.fromMap(Map())
    
    val main: ZIO[zio.console.Console, Exception, Unit] =
      app.provideSomeLayer[Console](configLayer_(configDesc))

    Definition Classes

    ConfigModule

11.  final def read[A](configuration: ConfigDescriptor[A]): IO[ReadError[config.K], A]

    Definition Classes

    ReadModule

12.  final def requiredZipAndOrFields[A](config: ConfigDescriptor[A]): Int

    Definition Classes

    ReadModule

13.  def sizeOfZipAndOrErrors(error: ReadError[config.K]): Int

    Definition Classes

    ReadModule

14.  val toKebabCase: (String) ⇒ String

    Convert a camelCase key to kebab-case val s = abcDef toKebabCase(s) === abc-def

    Convert a camelCase key to kebab-case val s = abcDef toKebabCase(s) === abc-def

    Definition Classes

    KeyConversionFunctions

15.  val toSnakeCase: (String) ⇒ String

    Convert a camelCase key to snake_case

    Convert a camelCase key to snake_case

    Definition Classes

    KeyConversionFunctions

16.  final def write[A](config: ConfigDescriptor[A], a: A): Either[String, PropertyTree[config.K, config.V]]

    Definition Classes

    WriteModule

17.  object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

18.  object Table extends Serializable

    Definition Classes

    ConfigDocsModule

19.  object ConfigSource

    Definition Classes

    ConfigSourceModule

20.  object ConfigDescriptor extends ConfigDescriptorFunctions

    Definition Classes

    ConfigStringModule

21.  object ZConfig

    Use functions in this Config object when you need to retrieve your instance of config in terms of zio.Layer.

    Use functions in this Config object when you need to retrieve your instance of config in terms of zio.Layer.

    For example:

    final case class MyConfig(dburl: String, port: Int)
    
    val myConfigDesc: ConfigDescriptor[MyConfig]             = (string("dburl") zip int("port")).to[MyConfig]
    val myConfig: Layer[ReadError[String], Config[MyConfig]] = Config.fromSystemEnv(myConfigDesc)

    By using Config.fromSystemEnv(myConfigDesc), it internally extends your description which is myConfigDesc to include the ConfigSource. In the above example, it is the ConfigSource corresponding to sys.env. It then calls zio.config.read with this new description that includes the source information.

    Extending an existing config description to include a ConfigSource is as simple as

    myConfigDesc from configSource

    Also, note that Config[MyConfig] in the above example is a simple type alias to Has[MyConfig].

    If you want to retrieve your config as scala.Either instead of zio.Layer, then you will have to extend your description to include the information on ConfigSource manually.

    For example:

    import zio.config._, ConfigDescriptor._
    final case class MyConfig(dburl: String, port: Int)
    
    val myConfig: ConfigDescriptor[MyConfig]         = (string("dburl") zip int("port")).to[MyConfig]
    val constantSource: ConfigSource                 = ConfigSource.fromMap(Map("dburl" -> "xyz", "port" -> "8080"))
    val result: Either[ReadError[String], MyConfig]  = read(myConfig from constantSource)

    Note: With the above approach, we got a simple scala.Either instead of retrieving them in terms of ZIO. Instead of the above approach, if we use Config.fromMap(constantMap, myConfig), then we will get a Layer[ReadError[String], MyConfig]

    The above approach is especially useful when we have a custom ConfigSource. For instance, we can form a custom ConfigSource by composing a few existing ConfigSources.

    For example:

    import zio.config._, ConfigDescriptor._
    
    final case class MyConfig(dburl: String, port: Int)
    
    val myConfig: ConfigDescriptor[MyConfig]     = (string("dburl") zip int("port")).to[MyConfig]
    val sysEnvSource: UIO[MyConfig]              = ConfigSource.fromSystemEnv
    val constantSource: ConfigSource             = ConfigSource.fromMap(Map("dburl" -> "xyz", "port" -> "8080"))
    val result: IO[ReadError[String], MyConfig]  = configSource.flatMap(source => read(myConfig from sysEnvSource.orElse(constantSource))

    In the above example, the results returned an UIO because of the existence of ConfigSource corresponding to sys.env.

    Definition Classes

    ConfigStringModule

22.  object InvariantZip extends InvariantZipLowPriority0
23.  object PropertyTree
24.  object PropertyTreePath extends Serializable

    Annotations

    @silent( "Unused import" )

25.  object PropertyType extends PropertyTypePlatformSpecific
26.  object ReadError extends Serializable
27.  object TupleConversion