WIP: Improve all public APIs by dropping (using Context)

besom-cfg/k8s/src/main/scala/ConfiguredContainerArgs.scala

@@ -130,7 +130,7 @@ object ConfiguredContainerArgs:
 
       case Right(()) =>
         val envExpr = '{
-          val envOutput                 = ${ env }.asOptionOutput()(using ${ context })
+          val envOutput                 = ${ env }.asOptionOutput()
           val conf                      = ${ configuration }
           val configurationAsEnvVarArgs = conf.foldedToEnvVarArgs(using $context)
           envOutput.zip(configurationAsEnvVarArgs).map {

core/src/main/scala/besom/internal/BesomModule.scala

@@ -1,6 +1,6 @@
 package besom.internal
 
-import besom.internal.logging.{LocalBesomLogger => logger, BesomLogger}
+import besom.internal.logging.{BesomMDC, LocalBesomLogger => logger, BesomLogger}
 import besom.util.printer
 
 /** An abstract effect Besom module, which can be implemented for different effect types.
@@ -40,6 +40,8 @@ trait EffectBesomModule extends BesomSyntax:
     *   the program to run
     */
   def run(program: Context ?=> Stack): Unit =
+    given emptyMDC: BesomMDC[_] = BesomMDC.empty
+
     val everything: Result[Unit] = Result.scoped {
       for
         _              <- BesomLogger.setupLogger()

core/src/main/scala/besom/internal/BesomSyntax.scala

@@ -103,8 +103,8 @@ trait BesomSyntax:
 
           val componentContext = ComponentContext(ctx, urnRes, componentBase)
           val componentOutput =
-            try Output(Result.pure(f(using componentContext)(using componentBase)))
-            catch case e: Exception => Output(Result.fail(e))
+            try Output.pure(f(using componentContext)(using componentBase))
+            catch case e: Exception => Output.fail(e)
 
           val componentResult = componentOutput.getValueOrFail {
             s"Component resource $name of type $typ did not return a value. This should not happen."
@@ -120,22 +120,22 @@ trait BesomSyntax:
   end component
 
   extension [A <: ProviderResource](pr: A)
-    def provider(using Context): Output[Option[ProviderResource]] = Output {
+    def provider(using Context): Output[Option[ProviderResource]] = Output.ofResult {
       Context().resources.getStateFor(pr).map(_.custom.provider)
     }
 
   extension [A <: CustomResource](cr: A)
-    def provider(using Context): Output[Option[ProviderResource]] = Output {
+    def provider(using Context): Output[Option[ProviderResource]] = Output.ofResult {
       Context().resources.getStateFor(cr).map(_.provider)
     }
 
   extension [A <: ComponentResource](cmpr: A)
-    def providers(using Context): Output[Map[String, ProviderResource]] = Output {
+    def providers(using Context): Output[Map[String, ProviderResource]] = Output.ofResult {
       Context().resources.getStateFor(cmpr).map(_.providers)
     }
 
   extension [A <: RemoteComponentResource](cb: A)
-    def providers(using Context): Output[Map[String, ProviderResource]] = Output {
+    def providers(using Context): Output[Map[String, ProviderResource]] = Output.ofResult {
       Context().resources.getStateFor(cb).map(_.providers)
     }
 
@@ -160,7 +160,7 @@ trait BesomSyntax:
       * an [[IllegalArgumentException]].
       */
     def toNonEmptyOutput(using Context): Output[NonEmptyString] =
-      NonEmptyString(s).fold(Output.fail(IllegalArgumentException(s"String $s was empty!")))(Output.apply(_))
+      NonEmptyString(s).fold(Output.fail(IllegalArgumentException(s"String $s was empty!")))(Output.pure(_))
 
   extension (os: Output[String])
     /** Converts an [[Output]] of [[String]] to an [[Output]] of [[NonEmptyString]] which will be failed if the string is empty.

core/src/main/scala/besom/internal/Config.scala

@@ -43,10 +43,10 @@ class Config private (
     * @return
     *   the configuration value of the requested type
     */
-  private def getRawValue(key: NonEmptyString)(using ctx: Context): Output[Option[String]] =
+  private def getRawValue(key: NonEmptyString): Output[Option[String]] =
     if configSecretKeys.contains(key)
     then Output.secret(tryGet(key))
-    else Output(tryGet(key))
+    else Output.pure(tryGet(key))
 
   private def readConfigValue[A: ConfigValueReader](
     key: NonEmptyString,
@@ -99,7 +99,7 @@ class Config private (
       .orElse(environment.collectFirst {
         case env if sys.env.contains(env) => sys.env(env)
       })
-    val value = if isSecret then Output.secret(rawValue) else Output(rawValue)
+    val value = if isSecret then Output.secret(rawValue) else Output.pure(rawValue)
     readConfigValue(key, value).map(_.orElse(default))
 
   /** Loads an optional configuration or secret value by its key, or returns [[None]] if it doesn't exist. If the configuration value is a
@@ -132,7 +132,7 @@ class Config private (
     def secretOption = if configSecretKeys.contains(key) then "[--secret]" else ""
     get[A](key).flatMap { valueOpt =>
       valueOpt match
-        case Some(value) => Output(value)
+        case Some(value) => Output.pure(value)
         case None =>
           Output.fail {
             ConfigError(
@@ -555,4 +555,4 @@ trait ConfigFactory:
     */
   def apply(namespace: NonEmptyString)(using Context): Output[Config] =
     val projectConfig = Context().config
-    Output(Config.forNamespace(namespace, projectConfig.configMap, projectConfig.configSecretKeys))
+    Output.ofResult(Config.forNamespace(namespace, projectConfig.configMap, projectConfig.configSecretKeys))

core/src/main/scala/besom/internal/Context.scala

@@ -129,7 +129,7 @@ class ContextImpl(
   override private[besom] def pulumiStack: NonEmptyString                = runInfo.stack
 
   override private[besom] def getParentURN: Result[URN] =
-    stackPromise.get.flatMap(_.urn.getData).map(_.getValue).flatMap {
+    stackPromise.get.flatMap(_.urn.getData(using this)).map(_.getValue).flatMap {
       case Some(urn) => Result.pure(urn)
       case None      => Result.fail(Exception("Stack urn is not available. This should not happen."))
     }

core/src/main/scala/besom/internal/Input.scala

@@ -15,63 +15,61 @@ object Input:
 
   given simpleInputOps: {} with
     extension [A](input: Input[A])
-      private[Input] def wrappedAsOutput(isSecret: Boolean = false)(using ctx: Context): Output[A] =
+      private[Input] def wrappedAsOutput(isSecret: Boolean = false): Output[A] =
         input match
           case output: Output[_] => output.asInstanceOf[Output[A]]
-          case a: A @unchecked   => if isSecret then Output.secret(a) else Output(a)
+          case a: A @unchecked   => if isSecret then Output.secret(a) else Output.pure(a)
 
     extension [A](input: Input[A])
-      def asOutput(isSecret: Boolean = false)(using ctx: Context): Output[A] =
+      def asOutput(isSecret: Boolean = false): Output[A] =
         input.wrappedAsOutput(isSecret)
 
     extension [A](input: Input.Optional[A])
-      private[Input] def wrappedAsOptionOutput(isSecret: Boolean = false)(using ctx: Context): Output[Option[A]] =
+      private[Input] def wrappedAsOptionOutput(isSecret: Boolean = false): Output[Option[A]] =
         val output = input match
           case output: Output[_]                  => output.asInstanceOf[Output[A | Option[A]]]
-          case maybeA: (A | Option[A]) @unchecked => if isSecret then Output.secret(maybeA) else Output(maybeA)
+          case maybeA: (A | Option[A]) @unchecked => if isSecret then Output.secret(maybeA) else Output.pure(maybeA)
         output.map(_.asOption)
 
-      def asOptionOutput(isSecret: Boolean = false)(using ctx: Context): Output[Option[A]] =
+      def asOptionOutput(isSecret: Boolean = false): Output[Option[A]] =
         input.wrappedAsOptionOutput(isSecret)
 
   given mapInputOps: {} with
-    private def inputMapToMapOutput[A](inputMap: Map[String, Input[A]], isSecret: Boolean)(using ctx: Context): Output[Map[String, A]] =
+    private def inputMapToMapOutput[A](inputMap: Map[String, Input[A]], isSecret: Boolean): Output[Map[String, A]] =
       val outputMap = inputMap.view.mapValues(_.asOutput(isSecret)).toMap
       Output.traverseMap(outputMap)
 
     extension [A](input: Input[Map[String, Input[A]]])
-      def asOutput(isSecret: Boolean = false)(using ctx: Context): Output[Map[String, A]] =
+      def asOutput(isSecret: Boolean = false): Output[Map[String, A]] =
         input.wrappedAsOutput(isSecret).flatMap(inputMapToMapOutput(_, isSecret = isSecret))
 
     extension [A](input: Input.Optional[Map[String, Input[A]]])
-      def asOptionOutput(isSecret: Boolean = false)(using ctx: Context): Output[Option[Map[String, A]]] =
+      def asOptionOutput(isSecret: Boolean = false): Output[Option[Map[String, A]]] =
         input.wrappedAsOptionOutput(isSecret).flatMap {
           case Some(map) => inputMapToMapOutput(map, isSecret = isSecret).map(Option(_))
-          case None      => Output(None)
+          case None      => Output.pure(None)
         }
 
   given iterableInputOps: {} with
-    private def inputIterableToIterableOutput[A](inputIterable: Iterable[Input[A]], isSecret: Boolean)(using
-      ctx: Context
-    ): Output[Iterable[A]] =
+    private def inputIterableToIterableOutput[A](inputIterable: Iterable[Input[A]], isSecret: Boolean): Output[Iterable[A]] =
       val outputIterable = inputIterable.map(simpleInputOps.asOutput(_)(isSecret = isSecret))
       Output.sequence(outputIterable)
 
     extension [A](input: Input.OneOrIterable[A])
-      def asManyOutput(isSecret: Boolean = false)(using ctx: Context): Output[Iterable[A]] =
+      def asManyOutput(isSecret: Boolean = false): Output[Iterable[A]] =
         input.wrappedAsOutput(isSecret).flatMap {
           case iterable: Iterable[Input[A]] @unchecked => inputIterableToIterableOutput(iterable, isSecret = isSecret)
-          case a: A @unchecked                         => Output(Iterable(a))
+          case a: A @unchecked                         => Output.pure(Iterable(a))
         }
 
     extension [A](input: Input[Iterable[Input[A]]])
-      def asOutput(isSecret: Boolean = false)(using ctx: Context): Output[Iterable[A]] =
+      def asOutput(isSecret: Boolean = false): Output[Iterable[A]] =
         input.wrappedAsOutput(isSecret).flatMap(inputIterableToIterableOutput(_, isSecret = isSecret))
 
     extension [A](input: Input.Optional[Iterable[Input[A]]])
-      def asOptionOutput(isSecret: Boolean = false)(using ctx: Context): Output[Option[Iterable[A]]] =
+      def asOptionOutput(isSecret: Boolean = false): Output[Option[Iterable[A]]] =
         input.wrappedAsOptionOutput(isSecret).flatMap {
           case Some(map) => inputIterableToIterableOutput(map, isSecret = isSecret).map(Option(_))
-          case None      => Output(None)
+          case None      => Output.pure(None)
         }
 end Input