Datastar extension methods for Endpoint (#3736) (#3745)

Author: 987Nabil

.github/workflows/pr-automation.yml

@@ -1,7 +1,7 @@
 name: PR Automation
 
 on:
-  pull_request:
+  pull_request_target:
     types: [opened, synchronize, reopened, edited]
   schedule:
     # Run daily at 00:00 UTC to check for stale PRs

zio-http-datastar-sdk/src/main/scala/zio/http/datastar/Attributes.scala

@@ -6,6 +6,7 @@ import scala.language.implicitConversions
 
 import zio.schema._
 
+import zio.http.template2.Dom.AttributeValue
 import zio.http.template2._
 
 trait Attributes {
@@ -165,14 +166,14 @@ trait Attributes {
    * [[https://data-star.dev/reference/attributes#data-preserve-attr]]
    */
   final def dataPreserveAttr(attribute: Dom.Attribute, attributes: Dom.Attribute*): Dom.Attribute =
-    Dom.attr(s"$prefix-preserve-attr", (attribute +: attributes).map(_.name).mkString(" "))
+    Dom.attr(s"$prefix-preserve-attr", AttributeValue.StringValue((attribute +: attributes).map(_.name).mkString(" ")))
 
   /**
    * data-preserve-attr – Preserve attributes during morphing. Doc:
    * [[https://data-star.dev/reference/attributes#data-preserve-attr]]
    */
   final def dataPreserveAttr(attribute: String, attributes: String*): Dom.Attribute =
-    Dom.attr(s"$prefix-preserve-attr", (attribute +: attributes).mkString(" "))
+    Dom.attr(s"$prefix-preserve-attr", AttributeValue.StringValue((attribute +: attributes).mkString(" ")))
 
   /**
    * data-ref – Assign a local reference. Doc:
@@ -237,7 +238,7 @@ object Attributes {
 
     final case class Single(prefix: String, className: String, caseModifier: CaseModifier = defaultCaseModifier)
         extends DataClass {
-      assert(className.nonEmpty, "Class name cannot be empty")
+      assert(!className.isBlank, "Class name cannot be empty")
       private[datastar] val full = s"$prefix-class-$className${caseModifier.suffix(defaultCaseModifier)}"
 
       def :=(signal: Signal[_]): CompleteAttribute = Dom.attr(full) := signal.ref

zio-http-datastar-sdk/src/main/scala/zio/http/datastar/DatastarEvent.scala

@@ -4,6 +4,7 @@ import zio._
 
 import zio.http.ServerSentEvent
 import zio.http.datastar.ServerSentEventGenerator.DefaultRetryDelay
+import zio.http.template2.Dom.AttributeValue
 import zio.http.template2._
 
 sealed trait DatastarEvent {
@@ -15,13 +16,17 @@ sealed trait DatastarEvent {
 object DatastarEvent {
 
   final case class PatchElements(
-    elements: Iterable[Dom],
+    elements: Dom,
     selector: Option[CssSelector] = None,
     mode: ElementPatchMode = ElementPatchMode.Outer,
     useViewTransition: Boolean = false,
     eventId: Option[String] = None,
     retryDuration: Duration = 1000.millis,
   ) extends DatastarEvent {
+    assert(
+      mode != ElementPatchMode.Remove || (selector.nonEmpty && elements.isEmpty),
+      "When using mode 'remove', 'selector' must be defined and 'elements' must be empty",
+    )
     override val eventType: EventType                       = EventType.PatchElements
     override def toServerSentEvent: ServerSentEvent[String] = {
       val sb = new StringBuilder()
@@ -36,13 +41,7 @@ object DatastarEvent {
         sb.append("useViewTransition true\n")
       }
 
-      elements.foreach { d =>
-        val rendered = d.render
-        if (rendered.contains('\n'))
-          rendered.split('\n').foreach(line => sb.append("elements ").append(line).append('\n'))
-        else
-          sb.append("elements ").append(rendered).append('\n')
-      }
+      sb.append("elements ").append(elements.renderMinified).append('\n')
 
       val retry = if (retryDuration != DefaultRetryDelay) Some(retryDuration) else None
       ServerSentEvent(sb.toString(), Some(eventType.render), eventId, retry)
@@ -159,8 +158,10 @@ object DatastarEvent {
     script0: Dom.Element.Script,
     options: ExecuteScriptOptions,
   ): ExecuteScript = {
-    val removeAttr      = if (options.autoRemove) Dom.attr("data-effect", "el.remove") else Dom.empty
-    val scriptWithAttrs = script0(removeAttr)(options.attributes.map(a => Dom.attr(a._1, a._2)))
+    val removeAttr      =
+      if (options.autoRemove) Dom.attr("data-effect", AttributeValue.StringValue("el.remove")) else Dom.empty
+    val scriptWithAttrs =
+      script0(removeAttr)(options.attributes.map(a => Dom.attr(a._1, AttributeValue.StringValue(a._2))))
 
     ExecuteScript(
       script = scriptWithAttrs,
@@ -200,7 +201,7 @@ object DatastarEvent {
     patchElements(elements, PatchElementOptions.default)
 
   def patchElements(elements: String, options: PatchElementOptions): PatchElements =
-    patchElements(elements.split('\n').map(Dom.raw).toList, options)
+    patchElements(Dom.raw(elements), options)
 
   def patchElements(elements: String, selector: Option[CssSelector]): PatchElements =
     patchElements(elements, PatchElementOptions(selector = selector))
@@ -239,10 +240,17 @@ object DatastarEvent {
     patchElements(elements, PatchElementOptions(selector, mode, useViewTransition, eventId, retryDuration))
 
   def patchElements(element: Dom): PatchElements =
-    patchElements(List(element), PatchElementOptions.default)
+    patchElements(element, PatchElementOptions.default)
 
   def patchElements(element: Dom, options: PatchElementOptions): PatchElements =
-    patchElements(List(element), options)
+    patchElements(
+      element,
+      options.selector,
+      options.mode,
+      options.useViewTransition,
+      options.eventId,
+      options.retryDuration,
+    )
 
   def patchElements(element: Dom, selector: Option[CssSelector]): PatchElements =
     patchElements(element, PatchElementOptions(selector = selector))
@@ -275,63 +283,13 @@ object DatastarEvent {
     eventId: Option[String],
     retryDuration: Duration,
   ): PatchElements =
-    patchElements(element, PatchElementOptions(selector, mode, useViewTransition, eventId, retryDuration))
-
-  def patchElements(elements: Iterable[Dom]): PatchElements =
-    patchElements(elements, PatchElementOptions.default)
-
-  def patchElements(elements: Iterable[Dom], options: PatchElementOptions): PatchElements = {
-    PatchElements(
-      elements = elements,
-      selector = options.selector,
-      mode = options.mode,
-      useViewTransition = options.useViewTransition,
-      eventId = options.eventId,
-      retryDuration = options.retryDuration,
-    )
-  }
-
-  def patchElements(elements: Iterable[Dom], selector: Option[CssSelector]): PatchElements =
-    patchElements(elements, PatchElementOptions(selector = selector))
-
-  def patchElements(elements: Iterable[Dom], selector: Option[CssSelector], mode: ElementPatchMode): PatchElements =
-    patchElements(elements, PatchElementOptions(selector = selector, mode = mode))
-
-  def patchElements(
-    elements: Iterable[Dom],
-    selector: Option[CssSelector],
-    mode: ElementPatchMode,
-    useViewTransition: Boolean,
-  ): PatchElements =
-    patchElements(
-      elements,
-      PatchElementOptions(selector = selector, mode = mode, useViewTransition = useViewTransition),
-    )
-
-  def patchElements(
-    elements: Iterable[Dom],
-    selector: Option[CssSelector],
-    mode: ElementPatchMode,
-    useViewTransition: Boolean,
-    eventId: Option[String],
-  ): PatchElements =
-    patchElements(elements, PatchElementOptions(selector, mode, useViewTransition, eventId))
-
-  def patchElements(
-    elements: Iterable[Dom],
-    selector: Option[CssSelector],
-    mode: ElementPatchMode,
-    useViewTransition: Boolean,
-    eventId: Option[String],
-    retryDuration: Duration,
-  ): PatchElements =
-    patchElements(elements, PatchElementOptions(selector, mode, useViewTransition, eventId, retryDuration))
+    PatchElements(element, selector, mode, useViewTransition, eventId, retryDuration)
 
   def patchSignals(signal: String): PatchSignals =
-    patchSignals(Iterable(signal), PatchSignalOptions.default)
+    patchSignals(List(signal), PatchSignalOptions.default)
 
   def patchSignals(signal: String, options: PatchSignalOptions): PatchSignals =
-    patchSignals(Iterable(signal), options)
+    patchSignals(List(signal), options)
 
   def patchSignals(signal: String, onlyIfMissing: Boolean): PatchSignals =
     patchSignals(signal, PatchSignalOptions(onlyIfMissing = onlyIfMissing))

zio-http-datastar-sdk/src/main/scala/zio/http/datastar/DatastarPackageBase.scala

@@ -7,7 +7,8 @@ import zio._
 import zio.stream.ZStream
 
 import zio.http._
-import zio.http.codec.HttpCodec
+import zio.http.codec.{Doc, HttpCodec, HttpContentCodec}
+import zio.http.endpoint.{AuthType, Endpoint}
 import zio.http.template2._
 
 trait DatastarPackageBase extends Attributes {
@@ -32,6 +33,64 @@ trait DatastarPackageBase extends Attributes {
       HttpCodec.header(Header.CacheControl).const(Header.CacheControl.NoCache) ++
       HttpCodec.header(Header.Connection).const(Header.Connection.KeepAlive)
 
+  val datastarEventCodec =
+    HttpCodec.content[Dom] ++
+      HttpCodec
+        .header(Header.ContentType)
+        .const(Header.ContentType(MediaType.text.`html`)) ++
+      HttpCodec.header(Header.CacheControl).const(Header.CacheControl.NoCache) ++
+      HttpCodec.headerAs[CssSelector]("datastar-selector").optional ++
+      HttpCodec.headerAs[ElementPatchMode]("datastar-mode").optional ++
+      HttpCodec.headerAs[Boolean]("datastar-use-view-transition").optional
+
+  implicit class EndpointExtensions(endpoint: Endpoint.type) {
+    def datastarEvents[Input](
+      route: RoutePattern[Input],
+    ): Endpoint[Input, Input, ZNothing, ZStream[Any, Nothing, DatastarEvent], AuthType.None.type] =
+      Endpoint(
+        route,
+        route.toHttpCodec,
+        datastarCodec.transformOrFailLeft(_ => Left("Not implemented"))(_.map(_.toServerSentEvent)),
+        HttpCodec.unused,
+        HttpContentCodec.responseErrorCodec,
+        Doc.empty,
+        AuthType.None,
+      )
+
+    def datastarEvent[Input](
+      route: RoutePattern[Input],
+    ): Endpoint[Input, Input, ZNothing, DatastarEvent.PatchElements, AuthType.None.type] =
+      Endpoint(
+        route,
+        route.toHttpCodec,
+        datastarEventCodec.transformOrFailLeft[DatastarEvent.PatchElements](_ => Left("Not implemented"))(event =>
+          (
+            event.elements,
+            event.selector,
+            if (event.mode == ElementPatchMode.Outer) None else Some(event.mode),
+            if (event.useViewTransition) Some(true) else None,
+          ),
+        ),
+        HttpCodec.unused,
+        HttpContentCodec.responseErrorCodec,
+        Doc.empty,
+        AuthType.None,
+      )
+
+    def datastar[Input](
+      route: RoutePattern[Input],
+    ): Endpoint[Input, Input, ZNothing, ZStream[Any, Nothing, ServerSentEvent[String]], AuthType.None.type] =
+      Endpoint(
+        route,
+        route.toHttpCodec,
+        datastarCodec,
+        HttpCodec.unused,
+        HttpContentCodec.responseErrorCodec,
+        Doc.empty,
+        AuthType.None,
+      )
+  }
+
   implicit def signalUpdateToModifier[A](signalUpdate: SignalUpdate[A]): Modifier =
     dataSignals(signalUpdate.signal)(signalUpdate.signal.schema) := signalUpdate.toExpression