superglue 1.1.0 → 2.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4b39909974d5f15cf6353b2a5748e4e31878b3dee8622d8874cc18395bf684c
-  data.tar.gz: c375f0687470c2afb7de11fb1b566bd87e6a5e51d200faea291f42a7bb7b7b95
+  metadata.gz: ece4f5c86bd486f1c253c62fdbfff95056fb60bbcabc9e951d52945c17b9b1bc
+  data.tar.gz: 665759fb6ce210973e4c49838936161fa685c9e1361432a63745c30e4170c9ce
 SHA512:
-  metadata.gz: 4fa8626cc3b719c3df4f0c521e22a7bf7857bce6871c2b43bab714ab1ae019677bb8a854b257aa9a7181b928a399d518a6350f0b3aafcbe3237e3cd58ca4d8ea
-  data.tar.gz: 93798fbd725b53a4353415bc648fc7e8ffb0dffc046b10daa2a436398ea9c6d2e678a4ca0662d9e20ed001b1b5591830c81b982cfc7f6d9e6d69851e589c8ebb
+  metadata.gz: 9add30dbf5df13ce875abe6510e7ad4f3d9820333341821bbeb8620bfe96c3559168eeff4ea34512ac3210f29e46cf784529f2665720fa25bd24919299e8571c
+  data.tar.gz: 68755c19906211366a20bfc28d56bb68dc47404474071cbf071681cd30093c8315d8895f0be70136beef3c4017658139faf6d601818a0d3f259b1b3c9efdf6b9

data/app/channels/superglue/streams/broadcasts.rb

@@ -0,0 +1,129 @@
+module Superglue::Streams::Broadcasts
+  def broadcast_save_to(*streamables, **opts)
+    broadcast_action_to(*streamables, action: :save, **opts)
+  end
+
+  def broadcast_append_to(*streamables, **opts)
+    broadcast_action_to(*streamables, action: :append, **opts)
+  end
+
+  def broadcast_prepend_to(*streamables, **opts)
+    broadcast_action_to(*streamables, action: :prepend, **opts)
+  end
+
+  def broadcast_refresh_to(*streamables, **opts)
+    request_id = Superglue.current_request_id
+    content = JSON.generate({
+      type: "message",
+      action: "refresh",
+      requestId: request_id,
+      options: opts
+    })
+    broadcast_stream_to(*streamables, content: content)
+  end
+
+  def broadcast_action_to(*streamables, action:, fragment: nil, fragments: nil, save_as: nil, options: {}, **rendering)
+    locals = rendering[:locals] || {}
+    fragments = (fragment ? [fragment] : fragments)
+
+    fragments = fragments.map do |item|
+      convert_to_superglue_fragment_id(item)
+    end
+
+    if save_as
+      options[:saveAs] = convert_to_superglue_fragment_id(save_as)
+    end
+
+    locals[:broadcast_fragment_keys] = fragments
+    locals[:broadcast_action] = action
+    locals[:broadcast_options] = options
+    rendering[:locals] = locals
+
+    broadcast_stream_to(*streamables, content: render_broadcast_action(rendering))
+  end
+
+  def broadcast_save_later_to(*streamables, **opts)
+    broadcast_action_later_to(*streamables, action: :save, **opts)
+  end
+
+  def broadcast_append_later_to(*streamables, **opts)
+    broadcast_action_later_to(*streamables, action: :append, **opts)
+  end
+
+  def broadcast_prepend_later_to(*streamables, **opts)
+    broadcast_action_later_to(*streamables, action: :prepend, **opts)
+  end
+
+  def broadcast_refresh_later_to(*streamables, request_id: Superglue.current_request_id, **opts)
+    stream_name = stream_name_from(streamables)
+
+    refresh_debouncer_for(*streamables, request_id: request_id).debounce do
+      content = JSON.generate({
+        type: "message",
+        action: "refresh",
+        requestId: request_id,
+        options: opts
+      })
+
+      Superglue::Streams::BroadcastStreamJob.perform_later stream_name, content: content
+    end
+  end
+
+  def broadcast_action_later_to(*streamables, action:, fragment: nil, fragments: nil, save_as: nil, options: {}, **rendering)
+    streamables.flatten!
+    streamables.compact_blank!
+
+    return unless streamables.present?
+
+    fragments = (fragment ? [fragment] : fragments).map do |item|
+      convert_to_superglue_fragment_id(item)
+    end
+
+    if save_as
+      options[:saveAs] = convert_to_superglue_fragment_id(save_as)
+    end
+
+    Superglue::Streams::ActionBroadcastJob.perform_later \
+      stream_name_from(streamables), action: action, fragments: fragments, options: options, **rendering
+  end
+
+  def broadcast_stream_to(*streamables, content:)
+    streamables.flatten!
+    streamables.compact_blank!
+
+    return unless streamables.present?
+
+    ActionCable.server.broadcast stream_name_from(streamables), content
+  end
+
+  def refresh_debouncer_for(*streamables, request_id: nil) # :nodoc:
+    Superglue::ThreadDebouncer.for("superglue-refresh-debouncer-#{stream_name_from(streamables.including(request_id))}")
+  end
+
+  private
+
+  def convert_to_superglue_fragment_id(fragment)
+    fragment_array = Array.wrap(fragment)
+    if fragment_array.any? { |value| value.respond_to?(:to_key) }
+      ActionView::RecordIdentifier.dom_id(*fragment_array)
+    else
+      fragment
+    end
+  end
+
+  def render_format(format, **rendering)
+    rendering[:layout] = "superglue/layouts/stream_message"
+    ApplicationController.render(formats: [format], **rendering)
+  end
+
+  def render_broadcast_action(rendering)
+    json = rendering.delete(:json)
+
+    if json
+      rendering[:locals] ||= {}
+      rendering[:locals][:broadcast_json] = json
+    end
+
+    render_format(:json, **rendering)
+  end
+end

data/app/channels/superglue/streams/stream_name.rb

@@ -0,0 +1,25 @@
+module Superglue::Streams::StreamName
+  def verified_stream_name(signed_stream_name)
+    Superglue.signed_stream_verifier.verified signed_stream_name
+  end
+
+  def signed_stream_name(streamables)
+    Superglue.signed_stream_verifier.generate stream_name_from(streamables)
+  end
+
+  module ClassMethods
+    def verified_stream_name_from_params
+      self.class.verified_stream_name(params[:signed_stream_name])
+    end
+  end
+
+  private
+
+  def stream_name_from(streamables)
+    if streamables.is_a?(Array)
+      streamables.map { |streamable| stream_name_from(streamable) }.join(":")
+    else
+      streamables.then { |streamable| streamable.try(:to_gid_param) || streamable.to_param }
+    end
+  end
+end

data/app/channels/superglue/streams_channel.rb

@@ -0,0 +1,13 @@
+class Superglue::StreamsChannel < ActionCable::Channel::Base
+  extend Superglue::Streams::StreamName
+  extend Superglue::Streams::Broadcasts
+  include Superglue::Streams::StreamName::ClassMethods
+
+  def subscribed
+    if stream_name = verified_stream_name_from_params
+      stream_from stream_name
+    else
+      reject
+    end
+  end
+end

data/app/controllers/concerns/superglue/request_id_tracking.rb

@@ -0,0 +1,13 @@
+module Superglue::RequestIdTracking
+  extend ActiveSupport::Concern
+
+  included do
+    around_action :superglue_tracking_request_id
+  end
+
+  private
+
+  def superglue_tracking_request_id(&block)
+    Superglue.with_request_id(request.headers["X-Superglue-Request-Id"], &block)
+  end
+end

data/app/helpers/superglue/streams_helper.rb

@@ -0,0 +1,70 @@
+module Superglue::StreamsHelper
+  def stream_from_props(*streamables, **attributes)
+    raise ArgumentError, "streamables can't be blank" unless streamables.any?(&:present?)
+    attributes[:channel] = attributes[:channel]&.to_s || "Superglue::StreamsChannel"
+    attributes[:signed_stream_name] = Superglue::StreamsChannel.signed_stream_name(streamables)
+
+    attributes
+  end
+
+  def fragment_id(value)
+    if value.respond_to?(:to_key)
+      ActionView::RecordIdentifier.dom_id(value)
+    elsif value.respond_to?(:broadcast_fragment_default)
+      value.broadcast_fragment_default
+    else
+      value.to_s
+    end
+  end
+
+  def broadcast_prepend_props(model: nil, fragment: nil, save_as: nil, options: {}, **rendering)
+    if save_as
+      options[:saveAs] ||= fragment_id(save_as)
+    end
+
+    broadcast_action_props(action: "prepend", model:, fragment:, options:, **rendering)
+  end
+
+  def broadcast_append_props(model: nil, fragment: nil, save_as: nil, options: {}, **rendering)
+    if save_as
+      options[:saveAs] ||= fragment_id(save_as)
+    end
+
+    broadcast_action_props(action: "append", model:, fragment:, options:, **rendering)
+  end
+
+  def broadcast_save_props(model: nil, partial: nil, fragment: nil, options: {}, **rendering)
+    if model && !fragment
+      fragment = fragment_id(model)
+    end
+
+    broadcast_action_props(action: "save", model:, fragment:, options:, **rendering)
+  end
+
+  def broadcast_action_props(action:, partial: nil, model: nil, fragment: nil, options: {}, **rendering)
+    if model
+      fragment = model.broadcast_fragment_default if !fragment
+
+      if model.respond_to?(:to_partial_path)
+        rendering[:locals] = (rendering[:locals] || {}).reverse_merge(model.model_name.element.to_sym => model).compact
+        partial ||= model.to_partial_path
+      end
+    end
+
+    fragment = fragment_id(fragment)
+
+    if !partial
+      raise StandardError, "A partial is needed to render a stream"
+    end
+
+    json = instance_variable_get(:@__json)
+
+    json.child! do
+      json.fragmentIds [fragment]
+      json.handler action
+      json.options(options)
+      json.data(partial: [partial, rendering]) do
+      end
+    end
+  end
+end

data/app/jobs/superglue/streams/action_broadcast_job.rb

@@ -0,0 +1,7 @@
+class Superglue::Streams::ActionBroadcastJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+
+  def perform(stream, action:, fragments:, options: {}, **rendering)
+    Superglue::StreamsChannel.broadcast_action_to stream, action: action, fragments: fragments, options: options, **rendering
+  end
+end

data/app/jobs/superglue/streams/broadcast_stream_job.rb

@@ -0,0 +1,7 @@
+class Superglue::Streams::BroadcastStreamJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+
+  def perform(stream, content:)
+    Superglue::StreamsChannel.broadcast_stream_to(stream, content: content)
+  end
+end

data/app/models/concerns/superglue/broadcastable.rb

@@ -0,0 +1,151 @@
+module Superglue::Broadcastable
+  extend ActiveSupport::Concern
+
+  included do
+    thread_mattr_accessor :suppressed_superglue_broadcasts, instance_accessor: false
+    delegate :suppressed_superglue_broadcasts?, to: "self.class"
+  end
+
+  module ClassMethods
+    def broadcasts_to(stream, inserts_by: :append, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+      after_create_commit -> { broadcast_action_later_to(stream.try(:call, self) || send(stream), action: inserts_by, fragment: fragment.try(:call, self) || fragment, save_as: save_as&.try(:call, self), **rendering) }
+      after_update_commit -> { broadcast_save_later_to(stream.try(:call, self) || send(stream), **rendering) }
+    end
+
+    def broadcasts(stream = model_name.plural, inserts_by: :append, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+      after_create_commit -> { broadcast_action_later_to(stream, action: inserts_by, fragment: fragment.try(:call, self) || fragment, save_as: save_as&.try(:call, self), **rendering) }
+      after_update_commit -> { broadcast_save_later(**rendering) }
+    end
+
+    def broadcasts_refreshes_to(stream)
+      after_commit -> { broadcast_refresh_later_to(stream.try(:call, self) || send(stream)) }
+    end
+
+    def broadcasts_refreshes(stream = model_name.plural)
+      after_create_commit -> { broadcast_refresh_later_to(stream) }
+      after_update_commit -> { broadcast_refresh_later }
+      after_destroy_commit -> { broadcast_refresh }
+    end
+
+    def broadcast_fragment_default
+      model_name.plural
+    end
+
+    def suppressing_superglue_broadcasts(&block)
+      original, self.suppressed_superglue_broadcasts = suppressed_superglue_broadcasts, true
+      yield
+    ensure
+      self.suppressed_superglue_broadcasts = original
+    end
+
+    def suppressed_superglue_broadcasts?
+      suppressed_superglue_broadcasts
+    end
+  end
+
+  # add fragment?
+  def broadcast_save_to(*streamables, **rendering)
+    Superglue::StreamsChannel.broadcast_save_to(*streamables, **extract_options_and_add_fragment(rendering, fragment: self)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_save(**rendering)
+    broadcast_save_to self, **rendering
+  end
+
+  # todo save_as: true
+  def broadcast_append_to(*streamables, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    Superglue::StreamsChannel.broadcast_append_to(*streamables, save_as: save_as, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_append(fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    broadcast_append_to self, fragment: fragment, save_as: save_as, **rendering
+  end
+
+  def broadcast_prepend_to(*streamables, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    Superglue::StreamsChannel.broadcast_prepend_to(*streamables, save_as: save_as, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_prepend(fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    broadcast_prepend_to self, fragment: fragment, save_as: save_as, **rendering
+  end
+
+  def broadcast_refresh_to(*streamables)
+    Superglue::StreamsChannel.broadcast_refresh_to(*streamables) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_refresh
+    broadcast_refresh_to self
+  end
+
+  # todo rename options to js_options
+  def broadcast_action_to(*streamables, action:, fragment: broadcast_fragment_default, options: {}, **rendering)
+    Superglue::StreamsChannel.broadcast_action_to(*streamables, action: action, options: options, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_action(action, fragment: broadcast_fragment_default, options: {}, **rest)
+    broadcast_action_to self, action: action, fragment: fragment, options: options, **rest
+  end
+
+  def broadcast_save_later_to(*streamables, **rendering)
+    Superglue::StreamsChannel.broadcast_save_later_to(*streamables, **extract_options_and_add_fragment(rendering, fragment: self)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_save_later(**rendering)
+    broadcast_save_later_to self, **rendering
+  end
+
+  def broadcast_append_later_to(*streamables, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    Superglue::StreamsChannel.broadcast_append_later_to(*streamables, save_as: save_as, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_append_later(fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    broadcast_append_later_to self, fragment: fragment, save_as: save_as, **rendering
+  end
+
+  def broadcast_prepend_later_to(*streamables, fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    Superglue::StreamsChannel.broadcast_prepend_later_to(*streamables, save_as: save_as, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_prepend_later(fragment: broadcast_fragment_default, save_as: nil, **rendering)
+    broadcast_prepend_later_to self, fragment: fragment, save_as: save_as, **rendering
+  end
+
+  def broadcast_refresh_later_to(*streamables)
+    Superglue::StreamsChannel.broadcast_refresh_later_to(*streamables, request_id: Superglue.current_request_id) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_refresh_later
+    broadcast_refresh_later_to self
+  end
+
+  def broadcast_action_later_to(*streamables, action:, fragment: broadcast_fragment_default, options: {}, **rendering)
+    Superglue::StreamsChannel.broadcast_action_later_to(*streamables, action: action, options: options, **extract_options_and_add_fragment(rendering, fragment: fragment)) unless suppressed_superglue_broadcasts?
+  end
+
+  def broadcast_action_later(action:, fragment: broadcast_fragment_default, options: {}, **rendering)
+    broadcast_action_later_to self, action: action, fragment: fragment, options: options, **rendering
+  end
+
+  def broadcast_fragment_default
+    self.class.broadcast_fragment_default
+  end
+  
+  private
+
+  def extract_options_and_add_fragment(rendering = {}, fragment: broadcast_fragment_default)
+    broadcast_rendering_with_defaults(rendering).tap do |options|
+      options[:fragment] = fragment if !options.key?(:fragment) && !options.key?(:fragments)
+    end
+  end
+
+  def broadcast_rendering_with_defaults(options)
+    options.tap do |o|
+      # Add the current instance into the locals with the element name (which is the un-namespaced name)
+      # as the key. This parallels how the ActionView::ObjectRenderer would create a local variable.
+      o[:locals] = (o[:locals] || {}).reverse_merge(model_name.element.to_sym => self).compact
+
+      # if none of these options are passed in, it will set a partial from #to_partial_path
+      o[:partial] ||= to_partial_path
+    end
+  end
+end

data/app/models/superglue/debouncer.rb

@@ -0,0 +1,25 @@
+class Superglue::Debouncer
+  attr_reader :delay, :scheduled_task
+
+  DEFAULT_DELAY = 0.5
+
+  def initialize(delay: DEFAULT_DELAY)
+    @delay = delay
+    @scheduled_task = nil
+  end
+
+  def debounce(&block)
+    scheduled_task&.cancel unless scheduled_task&.complete?
+    @scheduled_task = Concurrent::ScheduledTask.execute(delay, &block)
+  end
+
+  def wait
+    scheduled_task&.wait(wait_timeout)
+  end
+
+  private
+
+  def wait_timeout
+    delay + 1
+  end
+end

data/app/models/superglue/thread_debouncer.rb

@@ -0,0 +1,27 @@
+class Superglue::ThreadDebouncer
+  delegate :wait, to: :debouncer
+
+  def self.for(key, delay: Superglue::Debouncer::DEFAULT_DELAY)
+    Thread.current[key] ||= new(key, Thread.current, delay: delay)
+  end
+
+  private_class_method :new
+
+  def initialize(key, thread, delay:)
+    @key = key
+    @debouncer = Superglue::Debouncer.new(delay: delay)
+    @thread = thread
+  end
+
+  def debounce
+    debouncer.debounce do
+      yield.tap do
+        thread[key] = nil
+      end
+    end
+  end
+
+  private
+
+  attr_reader :key, :debouncer, :thread
+end

data/app/views/superglue/layouts/_stream_message.json.props

@@ -0,0 +1,15 @@
+json.disable_deferments!
+ 
+if local_assigns[:broadcast_json]
+  json.data broadcast_json
+else
+  json.data do
+    yield
+  end
+end
+
+json.fragments json.fragments!
+json.action "handleStreamMessage"
+json.handler broadcast_action
+json.fragmentIds broadcast_fragment_keys
+json.options broadcast_options

data/app/views/superglue/layouts/stream.json.props

@@ -0,0 +1,10 @@
+json.disable_deferments!
+
+json.data do
+  yield
+end
+
+json.fragments json.fragments!
+json.action "handleStreamResponse"
+
+json.flash flash.to_h

data/lib/generators/superglue/install/install_generator.rb

@@ -30,6 +30,9 @@ module Superglue
         say "Copying application.json.props"
         copy_file "#{__dir__}/templates/application.json.props", "app/views/layouts/application.json.props"
 
+        say "Copying stream.json.props"
+        copy_file "#{__dir__}/templates/stream.json.props", "app/views/layouts/stream.json.props"
+
         say "Adding required member methods to ApplicationRecord"
         add_member_methods
 
@@ -37,7 +40,7 @@ module Superglue
         insert_jsx_rendering_defaults
 
         say "Installing Superglue and friends"
-        run "yarn add react react-dom @reduxjs/toolkit react-redux @thoughtbot/superglue"
+        run "yarn add react react-dom @reduxjs/toolkit react-redux @thoughtbot/superglue@2.0.0-alpha.1"
 
         if use_typescript
           run "yarn add -D @types/react-dom @types/react @types/node @thoughtbot/candy_wrapper"

data/lib/generators/superglue/install/templates/stream.json.props

@@ -0,0 +1,15 @@
+json.disable_deferments!
+
+json.data do
+  json.array! do
+    yield json
+  end
+end
+json.fragments json.fragments!
+json.assets [ asset_path('application.js') ]
+
+if protect_against_forgery?
+  json.csrfToken form_authenticity_token
+end
+
+json.action "handleStreamResponse"

data/lib/generators/superglue/install/templates/ts/page_to_page_mapping.ts

@@ -1,4 +1,4 @@
-// import your page component #todo fix output of new lines
+// import your page component
 // e.g import PostsEdit from '../views/posts/edit'
 
 // Mapping between your props template to Component, you must add to this
@@ -28,7 +28,6 @@
 // }
 // ```
 //
-const pageIdentifierToPageComponent = {
-};
+const pageIdentifierToPageComponent = {};
 
-export { pageIdentifierToPageComponent }
+export { pageIdentifierToPageComponent };

data/lib/superglue/engine.rb

@@ -0,0 +1,55 @@
+module Superglue
+  module Controller
+    include Helpers
+
+    def self.included(base)
+      base.include ::Superglue::Rendering
+      return unless base.respond_to?(:helper_method)
+
+      base.helper_method :param_to_dig_path
+      base.helper_method :render_props
+    end
+  end
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Superglue
+    config.eager_load_namespaces << Superglue
+    config.superglue = ActiveSupport::OrderedOptions.new
+    config.superglue.auto_include = true
+    config.autoload_once_paths = %W[
+      #{root}/app/channels
+      #{root}/app/controllers
+      #{root}/app/controllers/concerns
+      #{root}/app/helpers
+      #{root}/app/models
+      #{root}/app/models/concerns
+      #{root}/app/jobs
+    ]
+
+    initializer :superglue do |app|
+      ActiveSupport.on_load(:action_controller) do
+        next if self != ActionController::Base
+
+        include Controller
+        include Superglue::RequestIdTracking
+
+        prepend_view_path(
+          Superglue::Resolver.new(Rails.root.join("app/views"))
+        )
+      end
+    end
+
+    initializer "superglue.helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        helper Superglue::StreamsHelper
+      end
+    end
+
+    initializer "superglue.signed_stream_verifier_key" do
+      config.after_initialize do
+        Superglue.signed_stream_verifier_key = config.superglue.signed_stream_verifier_key ||
+          Rails.application.key_generator.generate_key("superglue/signed_stream_verifier_key")
+      end
+    end
+  end
+end

data/lib/superglue.rb

@@ -1,46 +1,38 @@
-require "superglue/helpers"
-require "superglue/redirection"
-require "superglue/rendering"
-require "superglue/resolver"
-require "props_template"
-require "form_props"
+require 'superglue/helpers'
+require 'superglue/rendering'
+require 'superglue/resolver'
+require 'superglue/engine'
+require 'props_template'
+require 'form_props'
 
 module Superglue
-  module Controller
-    include Redirection
-    include Helpers
+  extend ActiveSupport::Autoload
 
-    def self.included(base)
-      base.include ::Superglue::Rendering
-      if base.respond_to?(:helper_method)
-        base.helper_method :param_to_dig_path
-        base.helper_method :render_props
-      end
-    end
-  end
+  mattr_accessor :draw_routes, default: true
 
-  class Engine < ::Rails::Engine
-    config.superglue = ActiveSupport::OrderedOptions.new
-    config.superglue.auto_include = true
+  thread_mattr_accessor :current_request_id
 
-    generators do |app|
-      Rails::Generators.configure! app.config.generators
-      Rails::Generators.hidden_namespaces.uniq!
-      require "generators/rails/scaffold_controller_generator"
-    end
+  class << self
+    attr_writer :signed_stream_verifier_key
 
-    initializer :superglue do |app|
-      ActiveSupport.on_load(:action_controller) do
-        next if self != ActionController::Base
+    def signed_stream_verifier
+      @signed_stream_verifier ||= ActiveSupport::MessageVerifier.new(
+        signed_stream_verifier_key,
+        digest: 'SHA256',
+        serializer: JSON
+      )
+    end
 
-        if app.config.superglue.auto_include
-          include Controller
+    def signed_stream_verifier_key
+      @signed_stream_verifier_key or raise ArgumentError, 'Superglue requires a signed_stream_verifier_key'
+    end
 
-          prepend_view_path(
-            Superglue::Resolver.new(Rails.root.join("app/views"))
-          )
-        end
-      end
+    def with_request_id(request_id)
+      old_request_id = current_request_id
+      self.current_request_id = request_id
+      yield
+    ensure
+      self.current_request_id = old_request_id
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: superglue
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0.alpha.1
 platform: ruby
 authors:
 - Johny Ho
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-18 00:00:00.000000000 Z
+date: 2025-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.37'
+        version: 1.0.0.alpha
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.37'
+        version: 1.0.0.alpha
 - !ruby/object:Gem::Dependency
   name: form_props
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +65,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- app/channels/superglue/streams/broadcasts.rb
+- app/channels/superglue/streams/stream_name.rb
+- app/channels/superglue/streams_channel.rb
+- app/controllers/concerns/superglue/request_id_tracking.rb
+- app/helpers/superglue/streams_helper.rb
+- app/jobs/superglue/streams/action_broadcast_job.rb
+- app/jobs/superglue/streams/broadcast_stream_job.rb
+- app/models/concerns/superglue/broadcastable.rb
+- app/models/superglue/debouncer.rb
+- app/models/superglue/thread_debouncer.rb
+- app/views/superglue/layouts/_stream_message.json.props
+- app/views/superglue/layouts/stream.json.props
 - lib/generators/superglue/install/install_generator.rb
 - lib/generators/superglue/install/templates/application.json.props
 - lib/generators/superglue/install/templates/erb/superglue.html.erb
@@ -78,6 +90,7 @@ files:
 - lib/generators/superglue/install/templates/js/layout.jsx
 - lib/generators/superglue/install/templates/js/page_to_page_mapping.js
 - lib/generators/superglue/install/templates/js/store.js
+- lib/generators/superglue/install/templates/stream.json.props
 - lib/generators/superglue/install/templates/ts/application.tsx
 - lib/generators/superglue/install/templates/ts/application_visit.ts
 - lib/generators/superglue/install/templates/ts/components.ts
@@ -104,8 +117,8 @@ files:
 - lib/generators/superglue/view_collection/templates/ts/show.tsx
 - lib/generators/superglue/view_collection/view_collection_generator.rb
 - lib/superglue.rb
+- lib/superglue/engine.rb
 - lib/superglue/helpers.rb
-- lib/superglue/redirection.rb
 - lib/superglue/rendering.rb
 - lib/superglue/resolver.rb
 homepage: https://github.com/thoughtbot/superglue_rails/

data/lib/superglue/redirection.rb

@@ -1,29 +0,0 @@
-module Superglue
-  module Redirection
-    def _compute_redirect_to_location(request, options)
-      computed_location = URI.parse(super)
-      next_param = Rack::Utils
-        .parse_nested_query(computed_location.query)
-
-      if request.params[:__] == "0"
-        computed_location.query = next_param.merge({__: "0"}).to_query
-      end
-
-      computed_location.to_s
-    end
-
-    def redirect_back_with_props_at(opts)
-      if request.referrer && params[:props_at]
-        referrer_url = URI.parse(request.referrer)
-        referrer_url.query = Rack::Utils
-          .parse_nested_query(referrer_url.query)
-          .merge({props_at: params[:props_at]})
-          .to_query
-
-        redirect_to referrer_url.to_s, opts
-      else
-        redirect_back(opts)
-      end
-    end
-  end
-end