phlex-reactive 0.9.5 → 0.11.0

data/app/controllers/phlex/reactive/actions_controller.rb

@@ -85,7 +85,7 @@ module Phlex
         end
 
         event[:outcome] = :ok
-        stream = payload["m"] == "morph" ? component.to_stream_morph : component.to_stream_replace
+        stream = component.to_stream_replace(morph: payload["m"] == "morph")
         render turbo_stream: stream
       rescue Phlex::Reactive::InvalidToken => e
         event[:outcome] = :invalid_token
@@ -119,7 +119,7 @@ module Phlex
         payload = verified_payload
         component_class = resolve_component(payload["c"])
         event[:component] = component_class.name
-        action_def = component_class.reactive_action(reactive_action_name)
+        action_def = component_class.reactive_actions[reactive_action_name.to_sym]
 
         # default-deny
         unless action_def
@@ -189,7 +189,9 @@ module Phlex
         return unless callable
 
         message = callable.call(kind)
-        Phlex::Reactive::Response.flash_stream(:error, message, target: Phlex::Reactive.flash_target)
+        # flash_stream is a private Response builder (issue #182) — the endpoint's
+        # error path is an internal caller, so reach it via send.
+        Phlex::Reactive::Response.send(:flash_stream, :error, message, target: Phlex::Reactive.flash_target)
       rescue => e # rubocop:disable Style/RescueStandardError
         ::Rails.logger&.warn("[phlex-reactive] error_flash raised: #{e.message}") if defined?(::Rails) &&
                                                                                      ::Rails.respond_to?(:logger)
@@ -298,7 +300,7 @@ module Phlex
 
         streams = result.streams
 
-        # Partial update (Response.streams / reply.streams, issue #30): the action
+        # Partial update (reply.streams, issue #30): the action
         # re-rendered only PART of the component and opted out of the full-self
         # replace. Append a tiny token-only stream so the signed token still rolls
         # forward WITHOUT re-rendering (and clobbering) the live inputs. Skip it
@@ -320,7 +322,7 @@ module Phlex
         # for replace AND update of self (both re-render the root via
         # render_component, carrying the token), and still adds the fallback
         # replace when a hand-built `with(...)` stream omits it. Idempotent: a
-        # Response.replace(self)/update(self) already carries the token, so we
+        # reply.replace/update already carries the token, so we
         # don't double the self-render.
         #
         # GUARD 2 (issue #114): GLOBAL, un-scoped — "does ANY stream carry a
@@ -328,8 +330,21 @@ module Phlex
         # ground-truth flag (rx_carries_token?), a raw string from a substring
         # scan. Deliberately NOT rx_refreshes_token_for? (target-scoped): scoping
         # this guard would regress update/morph of self on an aliased id.
+        #
+        # A self-render reply (reply.replace/update/morph — subject_component
+        # set) whose streams somehow carry no token gets the full self-replace
+        # (defensive, unchanged). A companion-only reply.with (NO subject, NO
+        # token_component) that doesn't re-render the root gets a token-ONLY
+        # refresh instead — issue #180 automatic token refresh: reply.with and
+        # reply.streams converge, the author never picks a verb to keep the token
+        # fresh, and a live input is never clobbered by a forced replace.
         elsif result.render_self? && streams.none? { stream_carries_token?(it) }
-          streams = [component.to_stream_replace, *streams]
+          streams =
+            if result.subject_component
+              [component.to_stream_replace, *streams]
+            else
+              [*streams, component.to_stream_token]
+            end
         end
 
         append_deferred_streams(streams, result)
@@ -470,13 +485,31 @@ module Phlex
       # skipped — zero extra work on the production path.
       def coerce_params(action_def, component_class: nil, action_name: nil)
         dropped = Phlex::Reactive.verbose_errors ? [] : nil
-        raw = params.fetch(:params, {})
+        raw = unwrap_scope(params.fetch(:params, {}), component_class)
 
         coerced = action_def.schema.coerce(raw, dropped)
         log_dropped_params(dropped, action_def.params, component_class, action_name)
         coerced
       end
 
+      # Issue #184: a scoped component's fields POST bracketed (todo[title]), which
+      # Rails expands to { "todo" => { "title" => … } } before the action runs. Peel
+      # exactly ONE scope level so the FLAT schema { title: :string } matches (the
+      # #67 bracket-drop footgun). Only when the component declares reactive_scope
+      # AND the raw params carry that single key mapping to a Hash — otherwise the
+      # raw params pass through untouched (unscoped components + nested_attributes
+      # shapes are unaffected).
+      def unwrap_scope(raw, component_class)
+        scope = component_class.reactive_scope if component_class.respond_to?(:reactive_scope)
+        return raw unless scope
+
+        # At the endpoint `raw` is ActionController::Parameters, so `raw[scope]` is
+        # too — NOT a Hash. Accept either shape (both answer to the schema's
+        # coerce): unwrap only when the scope key maps to a nested params/hash.
+        nested = raw[scope.to_s]
+        nested.is_a?(Hash) || nested.is_a?(ActionController::Parameters) ? nested : raw
+      end
+
       # ---- verbose_errors dropped-param logging --------------------------
       # ParamSchema collects the dropped entries; the controller formats the ONE
       # warn line (with the #16/#21 shape hints). Everything below runs ONLY when
@@ -564,7 +597,7 @@ module Phlex
             diagnostic: :unknown_class
           )
         end
-        unless klass.respond_to?(:reactive_action?) && klass.include?(Phlex::Reactive::Component)
+        unless klass.respond_to?(:reactive_actions) && klass.include?(Phlex::Reactive::Component)
           raise Phlex::Reactive::InvalidToken.new(
             "#{name} resolved but does not include Phlex::Reactive::Component",
             diagnostic: :not_reactive_class

data/app/javascript/phlex/reactive/confirm_predicate.js

@@ -0,0 +1,52 @@
+// The client-side confirm-predicate registry — the multi-field escape hatch for
+// conditional confirmation (issue #179).
+//
+// confirm: { when: { total: 0 }, message: } handles the single-field 80% case
+// declaratively (the reactive_show conditions language), with NO JS. But some
+// soft-validation is multi-field — "warn if the end date precedes the start",
+// "warn if two related totals disagree" — which a single field=value condition
+// can't express. This registry is the seam for that logic: name a pure function
+// with `confirm: { predicate: "name", message: }` (Ruby) and register it here.
+//
+// The seam mirrors compute.js (setComputeReducer) and confirm.js: a settable
+// registry with a lookup the controller calls. Register once at boot:
+//
+//   import { setConfirmPredicate } from "phlex/reactive/confirm_predicate"
+//   setConfirmPredicate("end_before_start", ({ starts_at, ends_at }) =>
+//     ends_at !== "" && ends_at < starts_at)
+//
+// The predicate's signature is (fields) => boolean:
+//
+//   fields — a plain object of { name: value } over the trigger root's collected
+//            controls (the SAME snapshot reactive_compute reads — #collectFields).
+//            Values are the raw control values (strings; a checkbox is a boolean).
+//
+// It returns truthy to WARN (the confirm dialog fires with the declared message)
+// or falsy to PROCEED with no dialog. The predicate is soft-validation UX, NOT
+// authorization: a user can bypass it (devtools, an unregistered name) and the
+// action still hits the endpoint's real authorize/default-deny — never let a
+// predicate stand in for a server-side check.
+//
+// A missing predicate (name never registered) makes the gate a NO-OP: the
+// controller proceeds WITHOUT a dialog and warns, exactly like compute.js's
+// unknown-reducer posture — a stale/typo'd name must not break the page or
+// (worse) block a legitimate action behind a dialog that can never resolve.
+
+const predicates = new Map()
+
+// Register (or replace) the predicate for `key`. `fn` is
+// (fields: Record<string, unknown>) => boolean — truthy warns, falsy proceeds.
+export function setConfirmPredicate(key, fn) {
+  predicates.set(key, fn)
+}
+
+// Look up a registered predicate; undefined when none — the controller then
+// proceeds without a dialog (and warns) rather than throwing or blocking.
+export function confirmPredicate(key) {
+  return predicates.get(key)
+}
+
+// Test seam: clear the registry so a predicate registered in one test can't leak.
+export function __resetConfirmPredicateRegistryForTest() {
+  predicates.clear()
+}

data/app/javascript/phlex/reactive/confirm_predicate.min.js

@@ -0,0 +1,4 @@
+var j=new Map;function u(b,q){j.set(b,q)}function v(b){return j.get(b)}function w(){j.clear()}export{u as setConfirmPredicate,v as confirmPredicate,w as __resetConfirmPredicateRegistryForTest};
+
+//# debugId=2F392605F11792F264756E2164756E21
+//# sourceMappingURL=confirm_predicate.min.js.map

data/app/javascript/phlex/reactive/confirm_predicate.min.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["confirm_predicate.js"],
+  "sourcesContent": [
+    "// The client-side confirm-predicate registry — the multi-field escape hatch for\n// conditional confirmation (issue #179).\n//\n// confirm: { when: { total: 0 }, message: } handles the single-field 80% case\n// declaratively (the reactive_show conditions language), with NO JS. But some\n// soft-validation is multi-field — \"warn if the end date precedes the start\",\n// \"warn if two related totals disagree\" — which a single field=value condition\n// can't express. This registry is the seam for that logic: name a pure function\n// with `confirm: { predicate: \"name\", message: }` (Ruby) and register it here.\n//\n// The seam mirrors compute.js (setComputeReducer) and confirm.js: a settable\n// registry with a lookup the controller calls. Register once at boot:\n//\n//   import { setConfirmPredicate } from \"phlex/reactive/confirm_predicate\"\n//   setConfirmPredicate(\"end_before_start\", ({ starts_at, ends_at }) =>\n//     ends_at !== \"\" && ends_at < starts_at)\n//\n// The predicate's signature is (fields) => boolean:\n//\n//   fields — a plain object of { name: value } over the trigger root's collected\n//            controls (the SAME snapshot reactive_compute reads — #collectFields).\n//            Values are the raw control values (strings; a checkbox is a boolean).\n//\n// It returns truthy to WARN (the confirm dialog fires with the declared message)\n// or falsy to PROCEED with no dialog. The predicate is soft-validation UX, NOT\n// authorization: a user can bypass it (devtools, an unregistered name) and the\n// action still hits the endpoint's real authorize/default-deny — never let a\n// predicate stand in for a server-side check.\n//\n// A missing predicate (name never registered) makes the gate a NO-OP: the\n// controller proceeds WITHOUT a dialog and warns, exactly like compute.js's\n// unknown-reducer posture — a stale/typo'd name must not break the page or\n// (worse) block a legitimate action behind a dialog that can never resolve.\n\nconst predicates = new Map()\n\n// Register (or replace) the predicate for `key`. `fn` is\n// (fields: Record<string, unknown>) => boolean — truthy warns, falsy proceeds.\nexport function setConfirmPredicate(key, fn) {\n  predicates.set(key, fn)\n}\n\n// Look up a registered predicate; undefined when none — the controller then\n// proceeds without a dialog (and warns) rather than throwing or blocking.\nexport function confirmPredicate(key) {\n  return predicates.get(key)\n}\n\n// Test seam: clear the registry so a predicate registered in one test can't leak.\nexport function __resetConfirmPredicateRegistryForTest() {\n  predicates.clear()\n}\n"
+  ],
+  "mappings": "AAkCA,IAAM,EAAa,IAAI,IAIhB,SAAS,CAAmB,CAAC,EAAK,EAAI,CAC3C,EAAW,IAAI,EAAK,CAAE,EAKjB,SAAS,CAAgB,CAAC,EAAK,CACpC,OAAO,EAAW,IAAI,CAAG,EAIpB,SAAS,CAAsC,EAAG,CACvD,EAAW,MAAM",
+  "debugId": "2F392605F11792F264756E2164756E21",
+  "names": []
+}