ghostdogpr

//> using dep com.github.ghostdogpr::caliban-quick:2.5.0

// 1. Defining the schema

enum Origin {
  case EARTH, MARS, BELT
}

case class Character(name: String, nicknames: List[String], origin: Origin)

ghostdogpr

//> using dep com.github.ghostdogpr::caliban:2.2.0

import caliban._
import caliban.schema._

case class Queries(books: List[Book]) derives Schema.SemiAuto
case class Book(id: Int, name: String) derives Schema.SemiAuto

val api = graphQL(RootResolver(Queries(Nil)))

ghostdogpr

import scala.deriving.Mirror
import scala.compiletime._

trait Schema[T]

object Schema {
  implicit val stringSchema: Schema[String] = new Schema[String] {}
  implicit def listSchema[A](implicit ev: Schema[A]): Schema[List[A]] = new Schema[List[A]] {}
  implicit def mapSchema[A, B](implicit evA: Schema[A], evB: Schema[B]): Schema[Map[A, B]] =
    new Schema[Map[A, B]] {}

ghostdogpr

package caliban

import caliban.GraphQL._
import zio.ZIO
import zio.console.putStrLn
import zio.zquery._

object Test2 extends zio.App {

  case class User(firstName: UQuery[String], lastName: UQuery[String], age: UQuery[Int])

ghostdogpr

package caliban

import caliban.GraphQL._
import zio.console.putStrLn
import zio.ZIO
import zio.zquery._

object Test extends zio.App {

  case class User(firstName: UQuery[String], lastName: UQuery[String], age: UQuery[Int])

ghostdogpr

import scala.deriving._
import scala.quoted._
import scala.quoted.matching._
import scala.compiletime._

trait Show[T] {
  def show(x: T): String
}
object Show {

ghostdogpr

// Step 1:
// Code generation creates helpers from a GraphQL schema
// Character.* and Queries.* here are auto-generated

// Step 2:
// Build your own queries combining those helpers
val character =
  (Character.name ~
    Character.nicknames ~
    Character.origin).mapN(CharacterView)

ghostdogpr

import magnolia.{ CaseClass, Magnolia, SealedTrait }
import mercator.Monadic
import zio.random.Random
import zio.test.{ Gen, Sized }

object Generators {

  implicit val genUnit: Typeclass[Unit]     = Gen.unit
  implicit val genBool: Typeclass[Boolean]  = Gen.boolean
  implicit val genString: Typeclass[String] = Gen.small(Gen.stringN(_)(Gen.alphaNumericChar))

ghostdogpr

import language.experimental.macros
import language.implicitConversions
import magnolia._

trait MyTypeclass[T] {
  def f(t: T): String
}

object MyTypeclass {
  type Typeclass[T] = MyTypeclass[T]

ghostdogpr

def listen(actorSystem: ActorSystem, topic: String): Task[Queue[String]] =
  for {
    queue      <- Queue.bounded[String](1000)
    rts        <- Task.runtime[Any]
    _          <- Task(actorSystem.actorOf(Props(new SubscriberActor(topic, rts, queue))))
  } yield queue
  
case class MessageEnvelope(msg: String)
  
class SubscriberActor(topic: String, rts: Runtime[Any], queue: Queue[String]) extends Actor {