pgbus 0.6.5 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d43bc708b048e8b81cae4c4954686fcd0f227fd8bc2498c599ab231f262ef607
-  data.tar.gz: 465eba8207a366a8f639f110e8131d064b46267161ffbf969b86aa470de56bfa
+  metadata.gz: e747f3644d06463ea9cd87dc79fbe19e1787ba7d4e9df0ba7512f729b6189224
+  data.tar.gz: 1b2f8a1eb8f2c10c32fa3f2c0eab5a59b2de1382e07537ee349d958393061d96
 SHA512:
-  metadata.gz: cbc395ea4f504b5295b7a90c50981aef8cce7b7a060a8488db2b8a3a73d9d08ae8a571a067626e1e269a501e87790f230231018d527096ebba89a6a743a390ac
-  data.tar.gz: 12ff4342c5fb3b1b30c328c7f373dcfcfd2db72d87d4a079e0538ba6857ca89b952078a6150ae495b560815bb637f396768397ccb250b98371096e146cb37b23
+  metadata.gz: b60516dfce1ba05b77afd21ab8e6ad3d227a2dde4edefc662221217533e22d1fa810f5056cc0f7d4470dbc220a7ae920408b785b088f8155c6a0bcb802283243
+  data.tar.gz: b386c96b0b493a00b196926fc014797e807538a6039fd772a4b0bafefd2b019d9a4f2f25136b264c03aa6a88a1533899e156341e57b81afdda0c9bf88de6a477

data/app/{javascript → assets/javascripts}/pgbus/stream_source_element.js

@@ -35,7 +35,8 @@
 //     automatically based on the last id: we observed. The native
 //     client is more battle-tested for reconnection backoff.
 
-import { connectStreamSource, disconnectStreamSource } from "@hotwired/turbo"
+import { Turbo } from "@hotwired/turbo-rails"
+const { connectStreamSource, disconnectStreamSource } = Turbo
 
 class PgbusStreamSourceElement extends HTMLElement {
   static get observedAttributes() {
@@ -51,6 +52,7 @@ class PgbusStreamSourceElement extends HTMLElement {
   }
 
   connectedCallback() {
+    this.closed = false
     connectStreamSource(this)
     const sinceId = this.getAttribute("since-id")
     this.lastEventId = sinceId && sinceId !== "" ? sinceId : null
@@ -106,7 +108,11 @@ class PgbusStreamSourceElement extends HTMLElement {
 
       while (!this.closed) {
         const { value, done } = await reader.read()
-        if (done) break
+        if (done) {
+          this.removeAttribute("connected")
+          this.switchToEventSource()
+          return
+        }
 
         buffer += decoder.decode(value, { stream: true })
         const events = buffer.split("\n\n")
@@ -131,7 +137,7 @@ class PgbusStreamSourceElement extends HTMLElement {
   switchToEventSource() {
     if (this.closed) return
 
-    const url = this.buildUrl({ includeSince: false })
+    const url = this.buildUrl({ includeSince: true })
     this.eventSource = new EventSource(url, { withCredentials: true })
 
     this.eventSource.addEventListener("open", () => {

data/app/helpers/pgbus/streams_helper.rb

@@ -46,7 +46,11 @@ module Pgbus
         "channel" => "Turbo::StreamsChannel"
       }.merge(html_attributes.transform_keys(&:to_s))
 
-      render_tag("pgbus-stream-source", attributes)
+      element = render_tag("pgbus-stream-source", attributes)
+      script = pgbus_stream_source_script_tag
+      return element unless script
+
+      safe_concat(script, element)
     end
 
     private
@@ -118,6 +122,34 @@ module Pgbus
       cache[stream_name] ||= Pgbus.stream(stream_name).current_msg_id
     end
 
+    # Emits a <script type="module"> tag that imports the custom element
+    # definition exactly once per request. Without this, <pgbus-stream-source>
+    # is an inert unknown element — no SSE connection opens. Uses a
+    # thread-local flag cleared by the WatermarkCacheMiddleware.
+    def pgbus_stream_source_script_tag
+      cache = Thread.current[:pgbus_streams_watermark_cache] ||= {}
+      return nil if cache[:script_emitted]
+
+      cache[:script_emitted] = true
+      script = '<script type="module">import "pgbus/stream_source_element"</script>'
+      script.respond_to?(:html_safe) ? script.html_safe : script
+    end
+
+    # Concatenates two HTML-safe strings without losing the safety flag.
+    # ActiveSupport::SafeBuffer#+ preserves safety when both operands
+    # are safe. Plain string interpolation ("#{a}#{b}") creates a new
+    # String, dropping html_safe — which causes Phlex and safe_join to
+    # HTML-escape the output.
+    def safe_concat(*parts)
+      if defined?(ActiveSupport::SafeBuffer)
+        buf = ActiveSupport::SafeBuffer.new
+        parts.each { |p| buf.safe_concat(p) }
+        buf
+      else
+        parts.join
+      end
+    end
+
     def render_tag(name, attributes)
       attr_string = attributes.map { |k, v| %(#{k}="#{CGI.escape_html(v.to_s)}") }.join(" ")
       html = "<#{name} #{attr_string}></#{name}>"

data/lib/pgbus/engine.rb

@@ -66,6 +66,29 @@ module Pgbus
       app.middleware.use Pgbus::Streams::WatermarkCacheMiddleware if Pgbus.configuration.streams_enabled
     end
 
+    # Make stream_source_element.js available to the host app's asset
+    # pipeline (Propshaft or Sprockets) so it can be included via
+    # `javascript_include_tag "pgbus/stream_source_element"` or pinned
+    # in importmap. When importmap-rails is loaded, auto-pin it so
+    # host apps get it without manual configuration.
+    initializer "pgbus.streams.assets" do |app|
+      if Pgbus.configuration.streams_enabled && app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[pgbus/stream_source_element.js]
+      end
+    end
+
+    initializer "pgbus.streams.importmap" do
+      if Pgbus.configuration.streams_enabled && defined?(::Importmap::Map)
+        ActiveSupport.on_load(:after_initialize) do
+          next unless Rails.application.respond_to?(:importmap)
+
+          Rails.application.importmap.pin(
+            "pgbus/stream_source_element", to: "pgbus/stream_source_element.js"
+          )
+        end
+      end
+    end
+
     # Install the Turbo::StreamsChannel patch after turbo-rails has been
     # loaded. The patch redirects broadcast_stream_to through Pgbus.stream
     # instead of ActionCable. When turbo-rails is not loaded, this is a
@@ -84,6 +107,15 @@ module Pgbus
           # `_` keeps RuboCop's Lint/Void from deleting the line.
           _autoload_trigger = Pgbus::Streams::TurboBroadcastable
           Pgbus::Streams.install_turbo_broadcastable_patch!
+
+          # Subscribe-side patch: override turbo_stream_from to render
+          # <pgbus-stream-source> (SSE) instead of <turbo-cable-stream-source>
+          # (ActionCable). Without this, third-party gems like
+          # hotwire-livereload that call turbo_stream_from in their views
+          # subscribe via ActionCable while the broadcast (patched above)
+          # goes through PGMQ — the message never arrives.
+          _autoload_trigger_override = Pgbus::Streams::TurboStreamOverride
+          Pgbus::Streams.install_turbo_stream_override!
         end
       end
     end

data/lib/pgbus/streams/turbo_stream_override.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Streams
+    # Runtime patch that redirects `turbo_stream_from` (the view helper)
+    # through `pgbus_stream_from` when pgbus streams are enabled. This is
+    # the subscribe-side counterpart to `TurboBroadcastable` (which patches
+    # the publish-side `broadcast_stream_to`).
+    #
+    # Without this patch, third-party gems like hotwire-livereload call
+    # `turbo_stream_from "hotwire-livereload"` in their views, which
+    # renders a `<turbo-cable-stream-source>` element connected to
+    # ActionCable. Meanwhile, the `TurboBroadcastable` patch routes the
+    # broadcast through PGMQ/SSE. Publisher and subscriber end up on
+    # different transports — the message never arrives.
+    #
+    # After this patch, `turbo_stream_from` renders a `<pgbus-stream-source>`
+    # element instead, so both sides use PGMQ/SSE. When `streams_enabled`
+    # is false, the original turbo-rails behavior is preserved via `super`.
+    #
+    # The `include Pgbus::StreamsHelper` is required because some callers
+    # invoke `turbo_stream_from` from a Rack middleware context (e.g.
+    # hotwire-livereload's Middleware uses `ActionController::Base.helpers`)
+    # where `Turbo::StreamsHelper` is available but `Pgbus::StreamsHelper`
+    # is not — the engine's `isolate_namespace` scopes helpers to its own
+    # views. Including it here ensures `pgbus_stream_from` is always
+    # reachable on the receiver.
+    module TurboStreamOverride
+      include Pgbus::StreamsHelper
+
+      def turbo_stream_from(*streamables, **attributes)
+        if Pgbus.configuration.streams_enabled
+          pgbus_stream_from(*streamables, **attributes)
+        else
+          super
+        end
+      end
+    end
+
+    # Apply the patch to Turbo::StreamsHelper. Idempotent: prepending the
+    # same module twice is a no-op. Called from Pgbus::Engine's initializer
+    # when both turbo-rails and pgbus streams are enabled.
+    def self.install_turbo_stream_override!
+      return unless defined?(::Turbo::StreamsHelper)
+      return if ::Turbo::StreamsHelper.ancestors.include?(TurboStreamOverride)
+
+      ::Turbo::StreamsHelper.prepend(TurboStreamOverride)
+    end
+  end
+end

data/lib/pgbus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgbus
-  VERSION = "0.6.5"
+  VERSION = "0.6.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.6.7
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -121,6 +121,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/assets/javascripts/pgbus/stream_source_element.js
 - app/controllers/pgbus/api/insights_controller.rb
 - app/controllers/pgbus/api/metrics_controller.rb
 - app/controllers/pgbus/api/stats_controller.rb
@@ -145,7 +146,6 @@ files:
 - app/frontend/pgbus/vendor/turbo.js
 - app/helpers/pgbus/application_helper.rb
 - app/helpers/pgbus/streams_helper.rb
-- app/javascript/pgbus/stream_source_element.js
 - app/models/pgbus/application_record.rb
 - app/models/pgbus/batch_entry.rb
 - app/models/pgbus/blocked_execution.rb
@@ -297,6 +297,7 @@ files:
 - lib/pgbus/streams/presence.rb
 - lib/pgbus/streams/signed_name.rb
 - lib/pgbus/streams/turbo_broadcastable.rb
+- lib/pgbus/streams/turbo_stream_override.rb
 - lib/pgbus/streams/watermark_cache_middleware.rb
 - lib/pgbus/uniqueness.rb
 - lib/pgbus/version.rb