#{generate_children(iur["children"], opts)}
@@ -247,6 +259,7 @@ defmodule AshUI.Rendering.LiveUIAdapter do
defp generate_heex(%{"type" => "column"} = iur, opts) do
spacing = Map.get(iur["props"] || %{}, "spacing", 8)
+
"""
#{generate_children(iur["children"], opts)}
@@ -270,6 +283,7 @@ defmodule AshUI.Rendering.LiveUIAdapter do
variant = Map.get(iur["props"] || %{}, "variant", "primary")
click_event = "#{event_prefix}:click"
+
"""
"""
@@ -322,6 +336,7 @@ defmodule AshUI.Rendering.LiveUIAdapter do
defp generate_children(nil, _opts), do: ""
defp generate_children([], _opts), do: ""
+
defp generate_children(children, opts) when is_list(children) do
Enum.map_join(children, &generate_heex(&1, opts))
end
@@ -361,12 +376,13 @@ defmodule AshUI.Rendering.LiveUIAdapter do
Enum.reduce(bindings, events, fn binding, acc ->
type = Map.get(binding, "type")
- event_type = case type do
- "event" -> "action"
- "bidirectional" -> "update"
- "collection" -> "stream"
- _ -> "change"
- end
+ event_type =
+ case type do
+ "event" -> "action"
+ "bidirectional" -> "update"
+ "collection" -> "stream"
+ _ -> "change"
+ end
[%{event: "#{event_prefix}:#{event_type}", target: binding["target"]} | acc]
end)
@@ -385,6 +401,7 @@ defmodule AshUI.Rendering.LiveUIAdapter do
defp extract_default_value(source) when is_map(source) do
Map.get(source, "default", nil)
end
+
defp extract_default_value(_), do: nil
defp extract_static_elements(iur) do
@@ -395,13 +412,14 @@ defmodule AshUI.Rendering.LiveUIAdapter do
defp extract_static(children, acc) when is_list(children) do
Enum.reduce(children, acc, fn child, acc2 ->
if child["type"] in ["text", "divider", "spacer"] and
- not has_signals(child) do
+ not has_signals(child) do
[child["id"] | acc2]
else
extract_static(child["children"] || [], acc2)
end
end)
end
+
defp extract_static(_, acc), do: acc
defp has_signals(child) do
@@ -417,4 +435,34 @@ defmodule AshUI.Rendering.LiveUIAdapter do
|> Enum.filter(fn binding -> Map.get(binding, "type") == "collection" end)
|> Enum.map(fn binding -> Map.get(binding, "target") end)
end
+
+ defp emit_render_telemetry(result, started_at, metadata) do
+ duration = System.monotonic_time() - started_at
+
+ case result do
+ {:ok, _rendered} = success ->
+ Telemetry.emit(
+ :render,
+ :complete,
+ %{count: 1, duration: duration},
+ Map.put(metadata, :status, :ok)
+ )
+
+ success
+
+ {:error, reason} = error ->
+ error_metadata = Map.merge(metadata, %{status: :error, error: inspect(reason)})
+ Telemetry.emit(:render, :error, %{count: 1, duration: duration}, error_metadata)
+ error
+ end
+ end
+
+ defp render_metadata(canonical_iur, renderer) do
+ %{
+ renderer: renderer,
+ resource_id: Map.get(canonical_iur, "id"),
+ resource_type: :screen,
+ screen_id: Map.get(canonical_iur, "id")
+ }
+ end
end
diff --git a/lib/ash_ui/rendering/web_ui_adapter.ex b/lib/ash_ui/rendering/web_ui_adapter.ex
index ee196642..5c2bef7f 100644
--- a/lib/ash_ui/rendering/web_ui_adapter.ex
+++ b/lib/ash_ui/rendering/web_ui_adapter.ex
@@ -20,6 +20,7 @@ defmodule AshUI.Rendering.WebUIAdapter do
alias AshUI.Rendering.IURAdapter
alias AshUI.Compilation.IUR
+ alias AshUI.Telemetry
@doc """
Renders a canonical IUR to static HTML string.
@@ -42,11 +43,18 @@ defmodule AshUI.Rendering.WebUIAdapter do
"""
@spec render(map(), keyword()) :: {:ok, String.t()} | {:error, term()}
def render(canonical_iur, opts \\ []) when is_map(canonical_iur) do
- if Code.ensure_loaded?(WebUI.Renderer) do
- call_web_ui_renderer(canonical_iur, opts)
- else
- render_fallback(canonical_iur, opts)
- end
+ started_at = System.monotonic_time()
+ metadata = render_metadata(canonical_iur, :web_ui)
+ Telemetry.emit(:render, :start, %{count: 1}, metadata)
+
+ result =
+ if Code.ensure_loaded?(WebUI.Renderer) do
+ call_web_ui_renderer(canonical_iur, opts)
+ else
+ render_fallback(canonical_iur, opts)
+ end
+
+ emit_render_telemetry(result, started_at, metadata)
end
@doc """
@@ -277,21 +285,28 @@ defmodule AshUI.Rendering.WebUIAdapter do
end
defp generate_asset_tags(asset_config) do
- css_tags = Enum.map_join(asset_config.css_files, fn file ->
- fingerprint = if asset_config.fingerprinted, do: "?v=#{:erlang.phash2(:os.system_time())}", else: ""
- "
"
- end)
+ css_tags =
+ Enum.map_join(asset_config.css_files, fn file ->
+ fingerprint =
+ if asset_config.fingerprinted, do: "?v=#{:erlang.phash2(:os.system_time())}", else: ""
- js_tags = Enum.map_join(asset_config.js_files, fn file ->
- fingerprint = if asset_config.fingerprinted, do: "?v=#{:erlang.phash2(:os.system_time())}", else: ""
- ""
- end)
+ "
"
+ end)
+
+ js_tags =
+ Enum.map_join(asset_config.js_files, fn file ->
+ fingerprint =
+ if asset_config.fingerprinted, do: "?v=#{:erlang.phash2(:os.system_time())}", else: ""
+
+ ""
+ end)
css_tags <> js_tags
end
defp generate_children(nil), do: ""
defp generate_children([]), do: ""
+
defp generate_children(children) when is_list(children) do
Enum.map_join(children, &generate_html(&1, []))
end
@@ -319,9 +334,9 @@ defmodule AshUI.Rendering.WebUIAdapter do
description = get_default_description(iur)
%{
- "title": name,
- "type": "website",
- "description": description
+ title: name,
+ type: "website",
+ description: description
}
end
@@ -329,8 +344,8 @@ defmodule AshUI.Rendering.WebUIAdapter do
name = Map.get(iur, "name", "")
%{
- "card": "summary",
- "title": name
+ card: "summary",
+ title: name
}
end
@@ -353,6 +368,7 @@ defmodule AshUI.Rendering.WebUIAdapter do
# Extract default value or initial data
Map.get(source, "default", nil)
end
+
defp extract_port_value(_), do: nil
defp encode_ports_json(ports) do
@@ -366,5 +382,35 @@ defmodule AshUI.Rendering.WebUIAdapter do
|> wrap_in_object()
end
+ defp emit_render_telemetry(result, started_at, metadata) do
+ duration = System.monotonic_time() - started_at
+
+ case result do
+ {:ok, _rendered} = success ->
+ Telemetry.emit(
+ :render,
+ :complete,
+ %{count: 1, duration: duration},
+ Map.put(metadata, :status, :ok)
+ )
+
+ success
+
+ {:error, reason} = error ->
+ error_metadata = Map.merge(metadata, %{status: :error, error: inspect(reason)})
+ Telemetry.emit(:render, :error, %{count: 1, duration: duration}, error_metadata)
+ error
+ end
+ end
+
+ defp render_metadata(canonical_iur, renderer) do
+ %{
+ renderer: renderer,
+ resource_id: Map.get(canonical_iur, "id"),
+ resource_type: :screen,
+ screen_id: Map.get(canonical_iur, "id")
+ }
+ end
+
defp wrap_in_object(str), do: "{#{str}}"
end
diff --git a/lib/ash_ui/repo.ex b/lib/ash_ui/repo.ex
index 86aeeddf..03b5d4ce 100644
--- a/lib/ash_ui/repo.ex
+++ b/lib/ash_ui/repo.ex
@@ -9,10 +9,21 @@ defmodule AshUI.Repo do
"""
use AshPostgres.Repo,
- otp_app: :ash_ui
+ otp_app: :ash_ui,
+ warn_on_missing_ash_functions?: false
+ @doc """
+ Returns the PostgreSQL extensions expected by the Ash UI repo.
+ """
def installed_extensions do
# Add any Postgres extensions you need here
["uuid-ossp", "pg_trgm"]
end
+
+ @doc """
+ Returns the minimum supported PostgreSQL version for this repo.
+ """
+ def min_pg_version do
+ %Version{major: 16, minor: 0, patch: 0}
+ end
end
diff --git a/lib/ash_ui/resources/binding.ex b/lib/ash_ui/resources/binding.ex
index aafd1705..2bde6f76 100644
--- a/lib/ash_ui/resources/binding.ex
+++ b/lib/ash_ui/resources/binding.ex
@@ -4,33 +4,56 @@ defmodule AshUI.Resources.Binding do
Bindings connect UI elements to Ash resource data.
"""
+
use Ash.Resource,
domain: AshUI.Domain,
data_layer: AshPostgres.DataLayer
+ postgres do
+ table "ui_bindings"
+ repo AshUI.Repo
+ end
+
attributes do
uuid_primary_key :id
- attribute :source, :string, allow_nil?: false
+ attribute :source, :map, allow_nil?: false, default: %{}
attribute :target, :string, allow_nil?: false
attribute :binding_type, :atom, constraints: [one_of: [:value, :list, :action]]
attribute :transform, :map, default: %{}
- attribute :element_id, :uuid
- attribute :screen_id, :uuid
attribute :metadata, :map, default: %{}
+ attribute :active, :boolean, default: true
+ attribute :version, :integer, default: 1
create_timestamp :inserted_at
update_timestamp :updated_at
end
relationships do
- belongs_to :element, AshUI.Resources.Element
- belongs_to :screen, AshUI.Resources.Screen
+ belongs_to :element, AshUI.Resources.Element do
+ attribute_type :uuid
+ allow_nil? true
+ end
+
+ belongs_to :screen, AshUI.Resources.Screen do
+ attribute_type :uuid
+ allow_nil? true
+ end
end
actions do
- defaults [:create, :update, :destroy]
+ defaults [:read, :destroy]
+
+ create :create do
+ primary? true
+ accept [:source, :target, :binding_type, :transform, :element_id, :screen_id, :metadata, :active, :version]
+ end
+
+ update :update do
+ primary? true
+ accept [:source, :target, :binding_type, :transform, :element_id, :screen_id, :metadata, :active]
+ change increment(:version)
+ end
read :read_with_filter do
- argument :filter, :map, default: %{}
filter expr(active == true)
end
end
diff --git a/lib/ash_ui/resources/element.ex b/lib/ash_ui/resources/element.ex
index e595a447..db10dfc5 100644
--- a/lib/ash_ui/resources/element.ex
+++ b/lib/ash_ui/resources/element.ex
@@ -4,30 +4,53 @@ defmodule AshUI.Resources.Element do
Elements are atomic UI components (widgets) like buttons, inputs, text, etc.
"""
+
use Ash.Resource,
domain: AshUI.Domain,
data_layer: AshPostgres.DataLayer
+ postgres do
+ table "ui_elements"
+ repo AshUI.Repo
+ end
+
attributes do
uuid_primary_key :id
attribute :type, :atom, allow_nil?: false
attribute :props, :map, default: %{}
attribute :variants, {:array, :atom}, default: []
attribute :position, :integer, default: 0
- attribute :screen_id, :uuid
attribute :metadata, :map, default: %{}
+ attribute :active, :boolean, default: true
attribute :version, :integer, default: 1
create_timestamp :inserted_at
update_timestamp :updated_at
end
relationships do
- belongs_to :screen, AshUI.Resources.Screen
- has_many :bindings, AshUI.Resources.Binding
+ belongs_to :screen, AshUI.Resources.Screen do
+ attribute_type :uuid
+ allow_nil? true
+ end
+
+ has_many :bindings, AshUI.Resources.Binding do
+ destination_attribute :element_id
+ end
end
actions do
- defaults [:read, :create, :update, :destroy]
+ defaults [:read, :destroy]
+
+ create :create do
+ primary? true
+ accept [:type, :props, :variants, :position, :screen_id, :metadata, :active, :version]
+ end
+
+ update :update do
+ primary? true
+ accept [:type, :props, :variants, :position, :screen_id, :metadata, :active]
+ change increment(:version)
+ end
end
# Note: Policy DSL requires Ash.Policy.Authorizer extension
diff --git a/lib/ash_ui/resources/screen.ex b/lib/ash_ui/resources/screen.ex
index e5f3c50a..e13e1347 100644
--- a/lib/ash_ui/resources/screen.ex
+++ b/lib/ash_ui/resources/screen.ex
@@ -2,10 +2,16 @@ defmodule AshUI.Resources.Screen do
@moduledoc """
Ash Resource for storing unified-ui screen definitions.
"""
+
use Ash.Resource,
domain: AshUI.Domain,
data_layer: AshPostgres.DataLayer
+ postgres do
+ table "ui_screens"
+ repo AshUI.Repo
+ end
+
attributes do
uuid_primary_key :id
attribute :name, :string, allow_nil?: false
@@ -13,18 +19,44 @@ defmodule AshUI.Resources.Screen do
attribute :layout, :atom, default: :default
attribute :route, :string
attribute :metadata, :map, default: %{}
+ attribute :active, :boolean, default: true
attribute :version, :integer, default: 1
create_timestamp :inserted_at
update_timestamp :updated_at
end
+ identities do
+ identity :unique_name, [:name]
+ end
+
relationships do
- has_many :elements, AshUI.Resources.Element
- has_many :bindings, AshUI.Resources.Binding
+ has_many :elements, AshUI.Resources.Element do
+ destination_attribute :screen_id
+ end
+
+ has_many :bindings, AshUI.Resources.Binding do
+ destination_attribute :screen_id
+ end
end
actions do
- defaults [:read, :create, :update, :destroy]
+ defaults [:read]
+
+ create :create do
+ primary? true
+ accept [:name, :unified_dsl, :layout, :route, :metadata, :active, :version]
+ end
+
+ update :update do
+ primary? true
+ accept [:name, :unified_dsl, :layout, :route, :metadata, :active]
+ change increment(:version)
+ end
+
+ destroy :destroy do
+ primary? true
+ change cascade_destroy(:elements)
+ end
end
# Note: Policy DSL requires Ash.Policy.Authorizer extension
diff --git a/lib/ash_ui/runtime/action_binding.ex b/lib/ash_ui/runtime/action_binding.ex
index 542b82b5..d4bd4b80 100644
--- a/lib/ash_ui/runtime/action_binding.ex
+++ b/lib/ash_ui/runtime/action_binding.ex
@@ -46,11 +46,11 @@ defmodule AshUI.Runtime.ActionBinding do
@spec execute_action(Binding.t() | map(), map(), context(), keyword()) ::
{:ok, action_result()} | {:error, term()}
def execute_action(binding, event_data, context, opts \\ []) do
- source = binding.source || %{}
+ source = Map.get(binding, :source) || Map.get(binding, "source") || %{}
resource = Map.get(source, "resource")
action_name = Map.get(source, "action")
- with {:ok, _} <- check_authorization(binding, context),
+ with {:ok, :authorized} <- check_authorization(binding, context),
{:ok, params} <- prepare_params(binding, event_data, context),
{:ok, result} <- call_ash_action(resource, action_name, params, context, opts) do
{:ok,
@@ -132,14 +132,14 @@ defmodule AshUI.Runtime.ActionBinding do
# Check authorization before executing action
defp check_authorization(binding, context) do
- resource = get_in(binding, [:source, "resource"])
- action = get_in(binding, [:source, "action"])
+ _resource = get_in(binding, [:source, "resource"])
+ _action = get_in(binding, [:source, "action"])
user_id = Map.get(context, :user_id)
# In production, this would call Ash.can?/3
# For now, allow if user_id is present
if user_id do
- :ok
+ {:ok, :authorized}
else
{:error, :unauthorized}
end
@@ -203,14 +203,18 @@ defmodule AshUI.Runtime.ActionBinding do
# Handle successful action
defp handle_action_success(socket, binding, result) do
target = binding.target || Map.get(binding, "target")
+ ash_ui = Map.get(socket.assigns, :ash_ui, %{})
+ actions = Map.get(ash_ui, :actions, %{})
+ action_state = Map.get(actions, target, %{})
- # Store result in assigns
- updated_socket =
- put_in(socket.assigns, [:ash_ui, :actions, target, "result"], result)
+ updated_actions =
+ actions
+ |> Map.put(target, Map.put(action_state, "result", result))
+ |> Map.update!(target, &Map.put(&1, "error", nil))
- # Clear any previous errors
+ # Store result in assigns
updated_socket =
- put_in(updated_socket.assigns, [:ash_ui, :actions, target, "error"], nil)
+ %{socket | assigns: Map.put(socket.assigns, :ash_ui, Map.put(ash_ui, :actions, updated_actions))}
# Show success message if configured
updated_socket =
@@ -226,14 +230,18 @@ defmodule AshUI.Runtime.ActionBinding do
# Handle action error
defp handle_action_error(socket, binding) do
target = binding.target || Map.get(binding, "target")
+ ash_ui = Map.get(socket.assigns, :ash_ui, %{})
+ actions = Map.get(ash_ui, :actions, %{})
+ action_state = Map.get(actions, target, %{})
+ updated_actions = Map.put(actions, target, Map.put(action_state, "error", "Action failed"))
# Store error in assigns
updated_socket =
- put_in(socket.assigns, [:ash_ui, :actions, target, "error"], "Action failed")
+ %{socket | assigns: Map.put(socket.assigns, :ash_ui, Map.put(ash_ui, :actions, updated_actions))}
# Show error message
error_message = get_in(binding, [:metadata, "error_message"]) || "Action failed"
- updated_socket = put_flash(socket, :error, error_message)
+ updated_socket = put_flash(updated_socket, :error, error_message)
{:noreply, updated_socket}
end
diff --git a/lib/ash_ui/runtime/bidirectional_binding.ex b/lib/ash_ui/runtime/bidirectional_binding.ex
index 28a5c63b..aa82767e 100644
--- a/lib/ash_ui/runtime/bidirectional_binding.ex
+++ b/lib/ash_ui/runtime/bidirectional_binding.ex
@@ -8,6 +8,7 @@ defmodule AshUI.Runtime.BidirectionalBinding do
alias AshUI.Runtime.BindingEvaluator
alias AshUI.Resources.Binding
+ alias AshUI.Telemetry
@type socket :: map()
@type context :: %{
@@ -30,7 +31,8 @@ defmodule AshUI.Runtime.BidirectionalBinding do
* `{:ok, socket}` - Updated socket with binding value
* `{:error, reason}` - Read failed
"""
- @spec read_binding(Binding.t() | map(), socket(), context()) :: {:ok, socket()} | {:error, term()}
+ @spec read_binding(Binding.t() | map(), socket(), context()) ::
+ {:ok, socket()} | {:error, term()}
def read_binding(binding, socket, context) do
with {:ok, value} <- BindingEvaluator.evaluate(binding, context) do
updated_socket = put_binding_value(socket, binding, value)
@@ -56,16 +58,21 @@ defmodule AshUI.Runtime.BidirectionalBinding do
@spec write_binding(Binding.t() | map(), term(), socket(), context()) ::
{:ok, socket(), map()} | {:error, term(), socket()}
def write_binding(binding, new_value, socket, context) do
- with :ok <- validate_input(binding, new_value),
- {:ok, sanitized} <- sanitize_input(binding, new_value),
- {:ok, result} <- update_resource(binding, sanitized, context) do
- updated_socket = put_binding_value(socket, binding, sanitized)
- {:ok, updated_socket, result}
- else
- {:error, reason} ->
- error_socket = put_binding_error(socket, binding, reason)
- {:error, reason, error_socket}
- end
+ started_at = System.monotonic_time()
+
+ result =
+ with :ok <- validate_input(binding, new_value),
+ {:ok, sanitized} <- sanitize_input(binding, new_value),
+ {:ok, result} <- update_resource(binding, sanitized, context) do
+ updated_socket = put_binding_value(socket, binding, sanitized)
+ {:ok, updated_socket, result}
+ else
+ {:error, reason} ->
+ error_socket = put_binding_error(socket, binding, reason)
+ {:error, reason, error_socket}
+ end
+
+ emit_binding_update_telemetry(binding, context, started_at, result)
end
@doc """
@@ -216,7 +223,7 @@ defmodule AshUI.Runtime.BidirectionalBinding do
# Update Ash resource with new value
defp update_resource(binding, value, context) do
- source = binding.source || %{}
+ source = Map.get(binding, :source) || Map.get(binding, "source") || %{}
resource = Map.get(source, "resource")
field = Map.get(source, "field")
id = get_resource_id(source, context)
@@ -236,21 +243,43 @@ defmodule AshUI.Runtime.BidirectionalBinding do
# Helper functions for socket management
defp put_binding_value(socket, binding, value) do
- target = binding.target || Map.get(binding, "target")
- put_in(socket.assigns, [:ash_ui, :bindings, target], %{
- "value" => value,
- "updated_at" => System.system_time(:millisecond)
- })
+ target = Map.get(binding, :target) || Map.get(binding, "target")
+ ash_ui = Map.get(socket.assigns, :ash_ui, %{})
+ bindings = Map.get(ash_ui, :bindings, %{})
+
+ updated_bindings =
+ Map.put(bindings, target, %{
+ "value" => value,
+ "updated_at" => System.system_time(:millisecond)
+ })
+
+ %{
+ socket
+ | assigns: Map.put(socket.assigns, :ash_ui, Map.put(ash_ui, :bindings, updated_bindings))
+ }
end
defp get_binding_value(socket, binding) do
- target = binding.target || Map.get(binding, "target")
- get_in(socket.assigns, [:ash_ui, :bindings, target, "value"])
+ target = Map.get(binding, :target) || Map.get(binding, "target")
+
+ socket.assigns
+ |> Map.get(:ash_ui, %{})
+ |> Map.get(:bindings, %{})
+ |> Map.get(target, %{})
+ |> Map.get("value")
end
defp put_binding_error(socket, binding, error) do
- target = binding.target || Map.get(binding, "target")
- put_in(socket.assigns, [:ash_ui, :bindings, target, "error"], error)
+ target = Map.get(binding, :target) || Map.get(binding, "target")
+ ash_ui = Map.get(socket.assigns, :ash_ui, %{})
+ bindings = Map.get(ash_ui, :bindings, %{})
+ binding_state = Map.get(bindings, target, %{})
+ updated_bindings = Map.put(bindings, target, Map.put(binding_state, "error", error))
+
+ %{
+ socket
+ | assigns: Map.put(socket.assigns, :ash_ui, Map.put(ash_ui, :bindings, updated_bindings))
+ }
end
defp get_binding_id(%Binding{id: id}), do: id
@@ -259,4 +288,37 @@ defmodule AshUI.Runtime.BidirectionalBinding do
defp subscription_id(binding) do
"#{get_binding_id(binding)}_#{System.system_time(:millisecond)}"
end
+
+ defp emit_binding_update_telemetry(binding, context, started_at, result) do
+ duration = System.monotonic_time() - started_at
+
+ metadata = %{
+ binding_id: get_binding_id(binding),
+ binding_type: Map.get(binding, :binding_type) || Map.get(binding, "binding_type"),
+ target: Map.get(binding, :target) || Map.get(binding, "target"),
+ resource_id: get_binding_id(binding),
+ resource_type: :binding,
+ screen_id: Map.get(binding, :screen_id) || Map.get(binding, "screen_id"),
+ user_id: Map.get(context, :user_id)
+ }
+
+ case result do
+ {:ok, updated_socket, update_result} = success ->
+ Telemetry.emit(
+ :binding,
+ :update,
+ %{count: 1, duration: duration},
+ Map.put(metadata, :status, :ok)
+ )
+
+ {:ok, updated_socket, update_result}
+
+ {:error, reason, error_socket} = error ->
+ error_metadata = Map.merge(metadata, %{status: :error, error: inspect(reason)})
+
+ Telemetry.emit(:binding, :update, %{count: 1, duration: duration}, error_metadata)
+ Telemetry.emit(:binding, :error, %{count: 1, duration: duration}, error_metadata)
+ {:error, reason, error_socket}
+ end
+ end
end
diff --git a/lib/ash_ui/runtime/binding_evaluator.ex b/lib/ash_ui/runtime/binding_evaluator.ex
index 335584bf..c710a6e8 100644
--- a/lib/ash_ui/runtime/binding_evaluator.ex
+++ b/lib/ash_ui/runtime/binding_evaluator.ex
@@ -7,6 +7,7 @@ defmodule AshUI.Runtime.BindingEvaluator do
"""
alias AshUI.Resources.Binding
+ alias AshUI.Telemetry
@type context :: %{
user_id: String.t() | nil,
@@ -42,21 +43,30 @@ defmodule AshUI.Runtime.BindingEvaluator do
def evaluate(%Binding{} = binding, context, opts) do
source_map = binding.source || %{}
+ transform = binding.transform || %{}
+ started_at = System.monotonic_time()
- with {:ok, value} <- resolve_source(source_map, context, opts),
- {:ok, transformed} <- apply_transformations(value, binding.transform, context) do
- {:ok, transformed}
- end
+ result =
+ with {:ok, value} <- resolve_source(source_map, context, opts),
+ {:ok, transformed} <- apply_transformations(value, transform, context) do
+ {:ok, transformed}
+ end
+
+ emit_binding_telemetry(binding, context, started_at, :evaluate, result)
end
def evaluate(binding, context, opts) when is_map(binding) do
source = Map.get(binding, :source) || Map.get(binding, "source", %{})
transform = Map.get(binding, :transform) || Map.get(binding, "transform", %{})
+ started_at = System.monotonic_time()
- with {:ok, value} <- resolve_source(source, context, opts),
- {:ok, transformed} <- apply_transformations(value, transform, context) do
- {:ok, transformed}
- end
+ result =
+ with {:ok, value} <- resolve_source(source, context, opts),
+ {:ok, transformed} <- apply_transformations(value, transform, context) do
+ {:ok, transformed}
+ end
+
+ emit_binding_telemetry(binding, context, started_at, :evaluate, result)
end
# Resolve source path to actual value
@@ -243,7 +253,9 @@ defmodule AshUI.Runtime.BindingEvaluator do
## Returns
* Map of binding_id to result
"""
- @spec evaluate_batch([Binding.t() | map()], context(), keyword()) :: %{String.t() => evaluation_result()}
+ @spec evaluate_batch([Binding.t() | map()], context(), keyword()) :: %{
+ String.t() => evaluation_result()
+ }
def evaluate_batch(bindings, context, opts \\ []) do
Enum.reduce(bindings, %{}, fn binding, acc ->
id = get_binding_id(binding)
@@ -254,4 +266,37 @@ defmodule AshUI.Runtime.BindingEvaluator do
defp get_binding_id(%Binding{id: id}), do: id
defp get_binding_id(binding), do: Map.get(binding, :id) || Map.get(binding, "id")
+
+ defp emit_binding_telemetry(binding, context, started_at, event, result) do
+ duration = System.monotonic_time() - started_at
+
+ metadata = %{
+ binding_id: get_binding_id(binding),
+ binding_type: Map.get(binding, :binding_type) || Map.get(binding, "binding_type"),
+ target: Map.get(binding, :target) || Map.get(binding, "target"),
+ resource_id: get_binding_id(binding),
+ resource_type: :binding,
+ screen_id: Map.get(binding, :screen_id) || Map.get(binding, "screen_id"),
+ user_id: Map.get(context, :user_id)
+ }
+
+ case result do
+ {:ok, _value} = success ->
+ Telemetry.emit(
+ :binding,
+ event,
+ %{count: 1, duration: duration},
+ Map.put(metadata, :status, :ok)
+ )
+
+ success
+
+ {:error, reason} = error ->
+ error_metadata = Map.merge(metadata, %{status: :error, error: inspect(reason)})
+
+ Telemetry.emit(:binding, event, %{count: 1, duration: duration}, error_metadata)
+ Telemetry.emit(:binding, :error, %{count: 1, duration: duration}, error_metadata)
+ error
+ end
+ end
end
diff --git a/lib/ash_ui/telemetry.ex b/lib/ash_ui/telemetry.ex
new file mode 100644
index 00000000..26e2bb07
--- /dev/null
+++ b/lib/ash_ui/telemetry.ex
@@ -0,0 +1,425 @@
+defmodule AshUI.Telemetry do
+ @moduledoc """
+ Central telemetry helpers and default metrics handlers for Ash UI.
+
+ This module defines the canonical event catalog for Phase 8 observability,
+ emits normalized telemetry payloads, and keeps lightweight in-memory metrics
+ that local dashboards and tests can query.
+ """
+
+ use GenServer
+
+ @metrics_table :ash_ui_telemetry_metrics
+ @default_handler_id "ash-ui-default-telemetry"
+ @sensitive_keys [
+ :email,
+ "email",
+ :name,
+ "name",
+ :password,
+ "password",
+ :token,
+ "token",
+ :secret,
+ "secret"
+ ]
+
+ @common_metadata [
+ :resource_id,
+ :resource_type,
+ :screen_id,
+ :session_id,
+ :user_id,
+ :status,
+ :error,
+ :trace_id,
+ :span_id,
+ :parent_span_id
+ ]
+
+ @event_definitions [
+ %{
+ event_name: [:ash_ui, :screen, :mount],
+ description: "Screen mount completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata
+ },
+ %{
+ event_name: [:ash_ui, :screen, :unmount],
+ description: "Screen unmount completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata
+ },
+ %{
+ event_name: [:ash_ui, :screen, :update],
+ description: "Screen update observed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata
+ },
+ %{
+ event_name: [:ash_ui, :screen, :mount_error],
+ description: "Screen mount failed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata
+ },
+ %{
+ event_name: [:ash_ui, :screen, :auth_failure],
+ description: "Screen authorization failed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata
+ },
+ %{
+ event_name: [:ash_ui, :binding, :evaluate],
+ description: "Binding evaluation completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:binding_id, :binding_type, :target]
+ },
+ %{
+ event_name: [:ash_ui, :binding, :update],
+ description: "Binding update completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:binding_id, :binding_type, :target]
+ },
+ %{
+ event_name: [:ash_ui, :binding, :error],
+ description: "Binding operation failed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:binding_id, :binding_type, :target]
+ },
+ %{
+ event_name: [:ash_ui, :compilation, :compile_start],
+ description: "Compilation started",
+ measurements: [:count, :system_time],
+ metadata: @common_metadata ++ [:cache]
+ },
+ %{
+ event_name: [:ash_ui, :compilation, :compile_end],
+ description: "Compilation completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:cache]
+ },
+ %{
+ event_name: [:ash_ui, :compilation, :compile_error],
+ description: "Compilation failed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:cache]
+ },
+ %{
+ event_name: [:ash_ui, :render, :start],
+ description: "Rendering started",
+ measurements: [:count, :system_time],
+ metadata: @common_metadata ++ [:renderer]
+ },
+ %{
+ event_name: [:ash_ui, :render, :complete],
+ description: "Rendering completed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:renderer]
+ },
+ %{
+ event_name: [:ash_ui, :render, :error],
+ description: "Rendering failed",
+ measurements: [:count, :duration, :system_time],
+ metadata: @common_metadata ++ [:renderer]
+ },
+ %{
+ event_name: [:ash_ui, :authorization, :auth_check],
+ description: "Authorization check performed",
+ measurements: [:count, :system_time],
+ metadata: @common_metadata ++ [:action]
+ },
+ %{
+ event_name: [:ash_ui, :authorization, :auth_success],
+ description: "Authorization check succeeded",
+ measurements: [:count, :system_time],
+ metadata: @common_metadata ++ [:action]
+ },
+ %{
+ event_name: [:ash_ui, :authorization, :auth_fail],
+ description: "Authorization check failed",
+ measurements: [:count, :system_time],
+ metadata: @common_metadata ++ [:action]
+ }
+ ]
+
+ @type event_definition :: %{
+ event_name: [atom()],
+ description: String.t(),
+ measurements: [atom()],
+ metadata: [atom()]
+ }
+
+ @doc """
+ Starts the telemetry process and installs the default handler set.
+ """
+ def start_link(opts \\ []) do
+ GenServer.start_link(__MODULE__, %{}, Keyword.put_new(opts, :name, __MODULE__))
+ end
+
+ @impl true
+ @doc false
+ def init(state) do
+ ensure_metrics_table()
+ attach_default_handlers()
+ {:ok, state}
+ end
+
+ @doc """
+ Returns the canonical Ash UI event catalog.
+ """
+ @spec events() :: [event_definition()]
+ def events, do: @event_definitions
+
+ @doc """
+ Attaches the default telemetry handlers that populate the in-memory metrics table.
+ """
+ @spec attach_default_handlers() :: :ok
+ def attach_default_handlers do
+ ensure_metrics_table()
+ event_names = Enum.map(@event_definitions, & &1.event_name)
+
+ case :telemetry.attach_many(@default_handler_id, event_names, &__MODULE__.handle_event/4, %{}) do
+ :ok -> :ok
+ {:error, :already_exists} -> :ok
+ end
+ end
+
+ @doc """
+ Detaches the default telemetry handlers if they are attached.
+ """
+ @spec detach_default_handlers() :: :ok
+ def detach_default_handlers do
+ :telemetry.detach(@default_handler_id)
+ :ok
+ rescue
+ _ -> :ok
+ end
+
+ @doc """
+ Clears the accumulated in-memory telemetry counters.
+ """
+ @spec reset_metrics() :: :ok
+ def reset_metrics do
+ ensure_metrics_table()
+ :ets.delete_all_objects(@metrics_table)
+ :ok
+ end
+
+ @doc """
+ Returns a snapshot of aggregated telemetry counters and dashboard-friendly metrics.
+ """
+ @spec snapshot() :: map()
+ def snapshot do
+ ensure_metrics_table()
+ rows = Map.new(:ets.tab2list(@metrics_table))
+
+ %{
+ events:
+ Enum.map(@event_definitions, fn definition ->
+ key = event_key(definition.event_name)
+
+ Map.merge(definition, %{
+ count: counter(rows, {:count, key}),
+ total_duration: counter(rows, {:duration, key}),
+ ok_count: counter(rows, {:status, key, :ok}),
+ error_count: counter(rows, {:status, key, :error})
+ })
+ end),
+ dashboards: %{
+ screen_performance: screen_performance_snapshot(rows),
+ error_rate: error_rate_snapshot(rows),
+ authorization_failures: authorization_failure_snapshot(rows),
+ renderer_usage: renderer_usage_snapshot(rows)
+ }
+ }
+ end
+
+ @doc """
+ Emits a canonical Ash UI telemetry event for the given category and event name.
+ """
+ @spec emit(atom(), atom(), map(), map(), keyword()) :: :ok
+ def emit(category, event, measurements \\ %{}, metadata \\ %{}, opts \\ []) do
+ execute([:ash_ui, category, event], measurements, metadata, opts)
+ end
+
+ @doc """
+ Executes a telemetry event after normalizing measurements and metadata.
+ """
+ @spec execute([atom()], map(), map(), keyword()) :: :ok
+ def execute(event_name, measurements \\ %{}, metadata \\ %{}, opts \\ [])
+ when is_list(event_name) do
+ normalized_measurements = normalize_measurements(measurements)
+ normalized_metadata = normalize_metadata(event_name, metadata)
+
+ :telemetry.execute(event_name, normalized_measurements, normalized_metadata)
+
+ Enum.each(Keyword.get(opts, :legacy_event_names, []), fn legacy_event_name ->
+ :telemetry.execute(legacy_event_name, normalized_measurements, normalized_metadata)
+ end)
+
+ :ok
+ end
+
+ @doc """
+ Default telemetry handler used to accumulate counts, durations, and status metrics.
+ """
+ @spec handle_event([atom()], map(), map(), map()) :: :ok
+ def handle_event(event_name, measurements, metadata, _config) do
+ ensure_metrics_table()
+ key = event_key(event_name)
+
+ increment_counter({:count, key}, measurement_value(measurements, :count, 1))
+ increment_counter({:duration, key}, measurement_value(measurements, :duration, 0))
+
+ status = Map.get(metadata, :status, infer_status(event_name, metadata))
+ increment_counter({:status, key, status}, 1)
+
+ case Map.get(metadata, :renderer) do
+ nil -> :ok
+ renderer -> increment_counter({:renderer, renderer}, 1)
+ end
+
+ if status == :error or not is_nil(Map.get(metadata, :error)) do
+ increment_counter({:errors, :total}, 1)
+ end
+
+ :ok
+ end
+
+ defp screen_performance_snapshot(rows) do
+ mount_count = event_metric(rows, [:ash_ui, :screen, :mount], :count)
+ mount_duration = event_metric(rows, [:ash_ui, :screen, :mount], :duration)
+ compile_count = event_metric(rows, [:ash_ui, :compilation, :compile_end], :count)
+ compile_duration = event_metric(rows, [:ash_ui, :compilation, :compile_end], :duration)
+ render_count = event_metric(rows, [:ash_ui, :render, :complete], :count)
+ render_duration = event_metric(rows, [:ash_ui, :render, :complete], :duration)
+
+ %{
+ mount_count: mount_count,
+ average_mount_duration: average_duration(mount_duration, mount_count),
+ compile_count: compile_count,
+ average_compile_duration: average_duration(compile_duration, compile_count),
+ render_count: render_count,
+ average_render_duration: average_duration(render_duration, render_count)
+ }
+ end
+
+ defp error_rate_snapshot(rows) do
+ total_events =
+ @event_definitions
+ |> Enum.map(&counter(rows, {:count, event_key(&1.event_name)}))
+ |> Enum.sum()
+
+ total_errors = counter(rows, {:errors, :total})
+
+ %{
+ total_events: total_events,
+ total_errors: total_errors,
+ error_rate: ratio(total_errors, total_events)
+ }
+ end
+
+ defp authorization_failure_snapshot(rows) do
+ %{
+ authorization_failures: event_metric(rows, [:ash_ui, :authorization, :auth_fail], :count),
+ screen_auth_failures: event_metric(rows, [:ash_ui, :screen, :auth_failure], :count)
+ }
+ end
+
+ defp renderer_usage_snapshot(rows) do
+ %{
+ live_ui: counter(rows, {:renderer, :live_ui}),
+ web_ui: counter(rows, {:renderer, :web_ui}),
+ desktop_ui: counter(rows, {:renderer, :desktop_ui}),
+ fallback: counter(rows, {:renderer, :fallback})
+ }
+ end
+
+ defp event_metric(rows, event_name, metric) do
+ counter(rows, {metric, event_key(event_name)})
+ end
+
+ defp average_duration(_duration, 0), do: 0.0
+ defp average_duration(duration, count), do: duration / count
+
+ defp ratio(_numerator, 0), do: 0.0
+ defp ratio(numerator, denominator), do: numerator / denominator
+
+ defp counter(rows, key), do: Map.get(rows, key, 0)
+
+ defp increment_counter(_key, amount) when not is_integer(amount), do: :ok
+ defp increment_counter(_key, amount) when amount < 0, do: :ok
+
+ defp increment_counter(key, amount) do
+ :ets.update_counter(@metrics_table, key, {2, amount}, {key, 0})
+ :ok
+ end
+
+ defp measurement_value(measurements, key, default) do
+ case Map.get(measurements, key, default) do
+ value when is_integer(value) -> value
+ value when is_float(value) -> round(value)
+ _ -> default
+ end
+ end
+
+ defp normalize_measurements(measurements) do
+ measurements =
+ case measurements do
+ value when is_map(value) -> value
+ value when is_list(value) -> Map.new(value)
+ _ -> %{}
+ end
+
+ measurements
+ |> Enum.filter(fn {_key, value} -> is_integer(value) or is_float(value) end)
+ |> Map.new()
+ |> Map.put_new(:count, 1)
+ |> Map.put_new(:system_time, System.system_time(:native))
+ end
+
+ defp normalize_metadata(event_name, metadata) do
+ metadata =
+ case metadata do
+ value when is_map(value) -> value
+ value when is_list(value) -> Map.new(value)
+ _ -> %{}
+ end
+
+ metadata
+ |> redact_sensitive_data()
+ |> Map.put_new(:status, infer_status(event_name, metadata))
+ end
+
+ defp redact_sensitive_data(metadata) do
+ Enum.reduce(@sensitive_keys, metadata, &Map.delete(&2, &1))
+ end
+
+ defp infer_status(event_name, metadata) do
+ cond do
+ Map.has_key?(metadata, :status) -> Map.get(metadata, :status)
+ Map.has_key?(metadata, :error) -> :error
+ List.last(event_name) in [:error, :mount_error, :auth_failure, :auth_fail] -> :error
+ true -> :ok
+ end
+ end
+
+ defp event_key(event_name) do
+ event_name
+ |> Enum.map(&to_string/1)
+ |> Enum.join(".")
+ end
+
+ defp ensure_metrics_table do
+ case :ets.whereis(@metrics_table) do
+ :undefined ->
+ :ets.new(@metrics_table, [:named_table, :public, :set, read_concurrency: true])
+ :ok
+
+ _table ->
+ :ok
+ end
+ rescue
+ ArgumentError -> :ok
+ end
+end
diff --git a/priv/monitoring/dashboards/README.md b/priv/monitoring/dashboards/README.md
new file mode 100644
index 00000000..55574763
--- /dev/null
+++ b/priv/monitoring/dashboards/README.md
@@ -0,0 +1,5 @@
+This directory contains portable dashboard definitions for Ash UI telemetry.
+
+Each JSON file describes a dashboard in terms of Ash UI event names, measurements,
+and recommended aggregations so teams can map them into Grafana, LiveDashboard,
+or another metrics backend.
diff --git a/priv/monitoring/dashboards/authorization_failures.json b/priv/monitoring/dashboards/authorization_failures.json
new file mode 100644
index 00000000..83378586
--- /dev/null
+++ b/priv/monitoring/dashboards/authorization_failures.json
@@ -0,0 +1,18 @@
+{
+ "title": "Ash UI Authorization Failures",
+ "version": 1,
+ "panels": [
+ {
+ "title": "Authorization Failures",
+ "event_name": "ash_ui.authorization.auth_fail",
+ "measurement": "count",
+ "aggregation": "sum"
+ },
+ {
+ "title": "Screen Auth Failures",
+ "event_name": "ash_ui.screen.auth_failure",
+ "measurement": "count",
+ "aggregation": "sum"
+ }
+ ]
+}
diff --git a/priv/monitoring/dashboards/error_rate.json b/priv/monitoring/dashboards/error_rate.json
new file mode 100644
index 00000000..21f842e5
--- /dev/null
+++ b/priv/monitoring/dashboards/error_rate.json
@@ -0,0 +1,24 @@
+{
+ "title": "Ash UI Error Rate",
+ "version": 1,
+ "panels": [
+ {
+ "title": "Total Errors",
+ "event_name": "ash_ui.error.*",
+ "measurement": "count",
+ "aggregation": "sum"
+ },
+ {
+ "title": "Compilation Errors",
+ "event_name": "ash_ui.compilation.compile_error",
+ "measurement": "count",
+ "aggregation": "sum"
+ },
+ {
+ "title": "Render Errors",
+ "event_name": "ash_ui.render.error",
+ "measurement": "count",
+ "aggregation": "sum"
+ }
+ ]
+}
diff --git a/priv/monitoring/dashboards/renderer_usage.json b/priv/monitoring/dashboards/renderer_usage.json
new file mode 100644
index 00000000..c5176132
--- /dev/null
+++ b/priv/monitoring/dashboards/renderer_usage.json
@@ -0,0 +1,33 @@
+{
+ "title": "Ash UI Renderer Usage",
+ "version": 1,
+ "panels": [
+ {
+ "title": "Live UI Renders",
+ "event_name": "ash_ui.render.complete",
+ "measurement": "count",
+ "aggregation": "sum",
+ "filter": {
+ "renderer": "live_ui"
+ }
+ },
+ {
+ "title": "Web UI Renders",
+ "event_name": "ash_ui.render.complete",
+ "measurement": "count",
+ "aggregation": "sum",
+ "filter": {
+ "renderer": "web_ui"
+ }
+ },
+ {
+ "title": "Desktop UI Renders",
+ "event_name": "ash_ui.render.complete",
+ "measurement": "count",
+ "aggregation": "sum",
+ "filter": {
+ "renderer": "desktop_ui"
+ }
+ }
+ ]
+}
diff --git a/priv/monitoring/dashboards/screen_performance.json b/priv/monitoring/dashboards/screen_performance.json
new file mode 100644
index 00000000..0a64c034
--- /dev/null
+++ b/priv/monitoring/dashboards/screen_performance.json
@@ -0,0 +1,24 @@
+{
+ "title": "Ash UI Screen Performance",
+ "version": 1,
+ "panels": [
+ {
+ "title": "Screen Mount Duration",
+ "event_name": "ash_ui.screen.mount",
+ "measurement": "duration",
+ "aggregation": "avg"
+ },
+ {
+ "title": "Compilation Duration",
+ "event_name": "ash_ui.compilation.compile_end",
+ "measurement": "duration",
+ "aggregation": "p95"
+ },
+ {
+ "title": "Render Duration",
+ "event_name": "ash_ui.render.complete",
+ "measurement": "duration",
+ "aggregation": "avg"
+ }
+ ]
+}
diff --git a/priv/repo/migrations/20260319000001_create_ui_screens.exs b/priv/repo/migrations/20260319000001_create_ui_screens.exs
index 11c1e103..1fe76a3c 100644
--- a/priv/repo/migrations/20260319000001_create_ui_screens.exs
+++ b/priv/repo/migrations/20260319000001_create_ui_screens.exs
@@ -9,7 +9,7 @@ defmodule Repo.Migrations.CreateUiScreens do
add :layout, :string, default: "default"
add :route, :string
add :metadata, :map, default: "{}"
- add :version, :integer, default:1, null: false
+ add :version, :integer, default: 1, null: false
add :inserted_at, :utc_datetime_usec
add :updated_at, :utc_datetime_usec
diff --git a/priv/repo/migrations/20260319000002_create_ui_elements.exs b/priv/repo/migrations/20260319000002_create_ui_elements.exs
index a99de8ba..41a6a9fd 100644
--- a/priv/repo/migrations/20260319000002_create_ui_elements.exs
+++ b/priv/repo/migrations/20260319000002_create_ui_elements.exs
@@ -8,7 +8,7 @@ defmodule Repo.Migrations.CreateUiElements do
add :props, :map, default: "{}"
add :variants, {:array, :string}, default: []
add :position, :integer, default: 0
- add :screen_id, :uuid
+ add :screen_id, references(:ui_screens, type: :uuid, on_delete: :delete_all)
add :metadata, :map, default: "{}"
add :inserted_at, :utc_datetime_usec
add :updated_at, :utc_datetime_usec
diff --git a/priv/repo/migrations/20260319000003_create_ui_bindings.exs b/priv/repo/migrations/20260319000003_create_ui_bindings.exs
index d1712392..ae83af51 100644
--- a/priv/repo/migrations/20260319000003_create_ui_bindings.exs
+++ b/priv/repo/migrations/20260319000003_create_ui_bindings.exs
@@ -8,8 +8,8 @@ defmodule AshUi.Repo.Migrations.CreateUiBindings do
add :target, :string
add :binding_type, :string, default: "value"
add :transform, :map, default: "{}"
- add :element_id, :uuid, references(:ui_elements, type: :uuid, on_delete: :delete_all)
- add :screen_id, :uuid, references(:ui_screens, type: :uuid, on_delete: :delete_all)
+ add :element_id, references(:ui_elements, type: :uuid, on_delete: :delete_all)
+ add :screen_id, references(:ui_screens, type: :uuid, on_delete: :delete_all)
add :metadata, :map, default: "{}"
add :version, :integer, default: 1
timestamps(type: :utc_datetime)
diff --git a/priv/repo/migrations/20260320110000_add_screen_fk_to_ui_elements.exs b/priv/repo/migrations/20260320110000_add_screen_fk_to_ui_elements.exs
new file mode 100644
index 00000000..8fb61721
--- /dev/null
+++ b/priv/repo/migrations/20260320110000_add_screen_fk_to_ui_elements.exs
@@ -0,0 +1,30 @@
+defmodule Repo.Migrations.AddScreenFkToUiElements do
+ use Ecto.Migration
+
+ def up do
+ execute("""
+ DO $$
+ BEGIN
+ IF NOT EXISTS (
+ SELECT 1
+ FROM pg_constraint
+ WHERE conname = 'ui_elements_screen_id_fkey'
+ ) THEN
+ ALTER TABLE ui_elements
+ ADD CONSTRAINT ui_elements_screen_id_fkey
+ FOREIGN KEY (screen_id)
+ REFERENCES ui_screens(id)
+ ON DELETE CASCADE;
+ END IF;
+ END
+ $$
+ """)
+ end
+
+ def down do
+ execute("""
+ ALTER TABLE ui_elements
+ DROP CONSTRAINT IF EXISTS ui_elements_screen_id_fkey
+ """)
+ end
+end
diff --git a/release/KNOWN_ISSUES.md b/release/KNOWN_ISSUES.md
new file mode 100644
index 00000000..461aa5d0
--- /dev/null
+++ b/release/KNOWN_ISSUES.md
@@ -0,0 +1,14 @@
+# Known Issues
+
+## Critical
+
+- None
+
+## High
+
+- External renderer packages are still optional, so some environments rely on fallback adapter behavior.
+- Code-doc governance still reports missing docs on some existing modules and must be cleared before a real release cut.
+
+## Watchlist
+
+- Release validation depends on full conformance and coverage runs, which may take longer than focused developer workflows.
diff --git a/release/README.md b/release/README.md
new file mode 100644
index 00000000..0a6ca0b9
--- /dev/null
+++ b/release/README.md
@@ -0,0 +1,24 @@
+# Release Assets
+
+This directory contains the operational files used for Phase 8 release readiness.
+
+## Contents
+
+- `RELEASE_CHECKLIST.md`: release criteria and cut procedure
+- `ROLLBACK_PLAN.md`: rollback triggers and execution steps
+- `KNOWN_ISSUES.md`: current release blocker inventory
+- `templates/rollback-communication.md`: communication template for rollback or pause
+
+## Validation Scripts
+
+- `./scripts/validate_release_readiness.sh`
+- `./scripts/generate_changelog.sh`
+- `./scripts/test_rollback_procedure.sh`
+
+## Typical Sequence
+
+1. update the version in `mix.exs`
+2. run `./scripts/validate_release_readiness.sh`
+3. generate release notes with `./scripts/generate_changelog.sh vX.Y.Z`
+4. review `release/KNOWN_ISSUES.md`
+5. use `.github/workflows/release.yml` for dry run or release execution
diff --git a/release/RELEASE_CHECKLIST.md b/release/RELEASE_CHECKLIST.md
new file mode 100644
index 00000000..16bc19b5
--- /dev/null
+++ b/release/RELEASE_CHECKLIST.md
@@ -0,0 +1,85 @@
+# Release Checklist
+
+Use this checklist before cutting an Ash UI release.
+
+## Release Criteria
+
+- [ ] All conformance tests pass via `./scripts/run_conformance.sh`
+- [ ] All governance workflows pass:
+ - `ci.yml`
+ - `conformance.yml`
+ - `specs-governance.yml`
+ - `guides-governance.yml`
+ - `rfc-governance.yml`
+ - `release.yml` dry run
+- [ ] Code coverage meets or exceeds the release threshold of `70%`
+- [ ] `release/KNOWN_ISSUES.md` lists no critical bugs
+- [ ] Root README, guides, and release assets are current
+- [ ] Telemetry dashboards are available and recent signals look healthy
+
+## Release Inputs
+
+- current version from `mix.exs`
+- generated changelog draft from `./scripts/generate_changelog.sh`
+- current branch and commit SHA
+- release dry-run result from `.github/workflows/release.yml`
+
+## Cut Procedure
+
+### 1. Update version numbers
+
+- update `version` in `mix.exs`
+- review any version references in guides, examples, and release notes
+
+### 2. Validate readiness
+
+Run:
+
+```bash
+./scripts/validate_release_readiness.sh
+```
+
+For full release gating in CI, the release workflow runs the script with heavy checks enabled:
+
+- conformance
+- coverage threshold
+- rollback validation
+
+### 3. Generate changelog draft
+
+Run:
+
+```bash
+./scripts/generate_changelog.sh vX.Y.Z
+```
+
+Review the generated draft and merge the important items into `CHANGELOG.md`.
+
+### 4. Dry-run the release workflow
+
+Use `.github/workflows/release.yml` with:
+
+- `dry_run=true`
+- empty `tag_name`
+
+The dry run should complete without failures before any tag is created.
+
+### 5. Create and publish the tag
+
+Use the release workflow with:
+
+- `dry_run=false`
+- `tag_name=vX.Y.Z`
+
+The workflow creates the git tag if needed and creates the GitHub release entry.
+
+### 6. Publish to Hex if enabled
+
+If `HEX_API_KEY` is configured in GitHub Actions secrets, the workflow will publish to Hex automatically after the GitHub release step.
+
+## Sign-Off
+
+- [ ] Engineering sign-off
+- [ ] Docs sign-off
+- [ ] Observability sign-off
+- [ ] Rollback owner assigned
diff --git a/release/ROLLBACK_PLAN.md b/release/ROLLBACK_PLAN.md
new file mode 100644
index 00000000..43049fad
--- /dev/null
+++ b/release/ROLLBACK_PLAN.md
@@ -0,0 +1,44 @@
+# Rollback Plan
+
+This document defines when and how to roll back an Ash UI release candidate.
+
+## Rollback Criteria
+
+Initiate rollback when any of the following are true after release:
+
+- repeated screen mount failures appear in telemetry
+- authorization failures spike unexpectedly for known-good paths
+- renderer output is broken across a supported integration path
+- the published package cannot be installed or compiled cleanly
+- critical regressions are confirmed with no safe hotfix available immediately
+
+## Rollback Steps
+
+1. Pause rollout and stop promoting the new version.
+2. Confirm the affected version, commit SHA, and distribution channel.
+3. Notify stakeholders using `release/templates/rollback-communication.md`.
+4. Revert consumers to the previous known-good version or tag.
+5. If a GitHub release was published, mark it as superseded in the release notes.
+6. If Hex publication already happened:
+ - prefer shipping a corrective patch release when unpublish is not appropriate
+ - only unpublish if it is permitted and operationally safe
+7. Capture the triggering signals in `release/KNOWN_ISSUES.md`.
+8. Open follow-up work for the root cause and the safe re-release path.
+
+## Rollback Owner Checklist
+
+- [ ] previous known-good version identified
+- [ ] consumer rollback instructions ready
+- [ ] communication sent
+- [ ] telemetry stabilized after rollback
+- [ ] follow-up issue or patch plan created
+
+## Validation
+
+Run:
+
+```bash
+./scripts/test_rollback_procedure.sh
+```
+
+This validates that the rollback artifacts and required sections are present.
diff --git a/release/templates/rollback-communication.md b/release/templates/rollback-communication.md
new file mode 100644
index 00000000..8ea60205
--- /dev/null
+++ b/release/templates/rollback-communication.md
@@ -0,0 +1,19 @@
+# Rollback Notice
+
+- Affected release: `
`
+- Trigger time (UTC): ``
+- Rollback owner: ``
+- Triggering signal: ``
+- Customer impact: ``
+- Immediate action: ``
+- Next update ETA: ``
+
+## Summary
+
+We are rolling back the Ash UI release identified above due to the triggering signal listed in this notice. Consumers should remain on the previous known-good version until follow-up guidance is published.
+
+## Next Steps
+
+1. confirm rollback completion
+2. verify telemetry has stabilized
+3. publish follow-up guidance or corrective release plan
diff --git a/rfcs/README.md b/rfcs/README.md
index 34f7f546..7d4bdbe0 100644
--- a/rfcs/README.md
+++ b/rfcs/README.md
@@ -73,6 +73,7 @@ See [templates/rfc-template.md](templates/rfc-template.md) for the RFC template.
| RFC | Title | Status | Phase |
|---|---|---|---|
| RFC-0001 | Ash UI Governance System | Active | 1 |
+| RFC-0002 | Ash UI as unified-ui Integration Layer | Draft | 1 |
## Related Documentation
diff --git a/scripts/generate_changelog.sh b/scripts/generate_changelog.sh
new file mode 100755
index 00000000..80f33cb2
--- /dev/null
+++ b/scripts/generate_changelog.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+cd "$ROOT"
+
+VERSION="${1:-}"
+OUTPUT_FILE="${2:-}"
+
+if [[ -z "$VERSION" ]]; then
+ echo "usage: $0 [output-file]"
+ exit 1
+fi
+
+if [[ -z "$OUTPUT_FILE" ]]; then
+ OUTPUT_FILE="reports/release/changelog-${VERSION}.md"
+fi
+
+mkdir -p "$(dirname "$OUTPUT_FILE")"
+
+DATE="$(date -u +%F)"
+PREVIOUS_TAG="$(git tag --list 'v*' --sort=-creatordate | grep -Fxv "$VERSION" | head -n1 || true)"
+
+if [[ -n "$PREVIOUS_TAG" ]]; then
+ RANGE="${PREVIOUS_TAG}..HEAD"
+ RANGE_LABEL="${PREVIOUS_TAG}..HEAD"
+else
+ RANGE="HEAD"
+ RANGE_LABEL="initial-history"
+fi
+
+COMMITS="$(git log --no-merges --pretty='- %h %s' "$RANGE")"
+if [[ -z "$COMMITS" ]]; then
+ COMMITS="- No commits found"
+fi
+
+cat > "$OUTPUT_FILE" < "$REPORT_DIR/report.md" <> "$REPORT_DIR/report.md"
+ done <<<"$CONFORMANCE_TEST_FILES"
+else
+ echo "- None" >> "$REPORT_DIR/report.md"
+fi
+
+cat > "$REPORT_DIR/report.json" <&1 | tee "$REPORT_DIR/test-output.txt"
+TEST_STATUS=${PIPESTATUS[0]}
+set -e
+
+if [[ "$TEST_STATUS" -eq 0 ]]; then
+ export CONFORMANCE_STATUS="passed"
+else
+ export CONFORMANCE_STATUS="failed"
+fi
+
+./scripts/generate_conformance_report.sh "$REPORT_DIR"
+
+exit "$TEST_STATUS"
diff --git a/scripts/test_rollback_procedure.sh b/scripts/test_rollback_procedure.sh
new file mode 100755
index 00000000..b95a4ef2
--- /dev/null
+++ b/scripts/test_rollback_procedure.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+cd "$ROOT"
+
+REPORT_DIR="${ROLLBACK_REPORT_DIR:-reports/release}"
+mkdir -p "$REPORT_DIR"
+
+failures=0
+
+fail() {
+ echo "FAIL: $1"
+ failures=1
+}
+
+required_files=(
+ "release/ROLLBACK_PLAN.md"
+ "release/templates/rollback-communication.md"
+ "release/KNOWN_ISSUES.md"
+)
+
+echo "Checking rollback files..."
+for file in "${required_files[@]}"; do
+ if [[ ! -f "$file" ]]; then
+ fail "missing rollback artifact: $file"
+ fi
+done
+
+echo "Checking rollback plan structure..."
+required_sections=(
+ '^## Rollback Criteria$'
+ '^## Rollback Steps$'
+ '^## Rollback Owner Checklist$'
+ '^## Validation$'
+)
+
+for section in "${required_sections[@]}"; do
+ if ! rg -q "$section" release/ROLLBACK_PLAN.md; then
+ fail "rollback plan missing section: $section"
+ fi
+done
+
+echo "Checking rollback communication template..."
+template_markers=(
+ ''
+ ''
+ ''
+ ''
+ ''
+ ''
+ ''
+)
+
+for marker in "${template_markers[@]}"; do
+ if ! rg -q "$marker" release/templates/rollback-communication.md; then
+ fail "rollback communication template missing marker: $marker"
+ fi
+done
+
+GENERATED_AT="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+cat > "$REPORT_DIR/rollback-test.md" <&1 | tee "$REPORT_DIR/coverage.txt"
+ coverage_status=${PIPESTATUS[0]}
+ set -e
+
+ if [[ "$coverage_status" -ne 0 ]]; then
+ fail "coverage check failed for threshold ${threshold}%"
+ fi
+else
+ note "coverage run skipped (set RELEASE_RUN_COVERAGE=true to enforce)"
+fi
+
+echo "Testing rollback procedure..."
+./scripts/test_rollback_procedure.sh || fail "rollback procedure validation failed"
+
+GENERATED_AT="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+cat > "$REPORT_DIR/release-readiness.md" <> "$REPORT_DIR/release-readiness.md"
+else
+ for item in "${notes[@]}"; do
+ echo "- $item" >> "$REPORT_DIR/release-readiness.md"
+ done
+fi
+
+if [[ "$failures" -ne 0 ]]; then
+ echo "Release readiness validation failed."
+ exit 1
+fi
+
+echo "Release readiness validation passed."
diff --git a/scripts/validate_rfc_governance.sh b/scripts/validate_rfc_governance.sh
index 22e48c3b..f6f481e5 100755
--- a/scripts/validate_rfc_governance.sh
+++ b/scripts/validate_rfc_governance.sh
@@ -5,6 +5,7 @@ ROOT="${RFC_GOVERNANCE_ROOT:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)
cd "$ROOT"
failures=0
+VALID_STATUSES='Draft|Review|Discussion|Accepted|Rejected|Implementation|Implemented|Active|Deprecated'
fail() {
echo "FAIL: $1"
@@ -29,6 +30,23 @@ for file in "${required_files[@]}"; do
fi
done
+echo "Checking RFC index and README stay in sync..."
+while IFS= read -r rfc_id; do
+ [[ -z "$rfc_id" ]] && continue
+
+ if ! rg -q "$rfc_id" rfcs/index.md; then
+ fail "RFC missing from rfcs/index.md: $rfc_id"
+ fi
+
+ if ! rg -q "$rfc_id" rfcs/README.md; then
+ fail "RFC missing from rfcs/README.md: $rfc_id"
+ fi
+done < <(
+ find rfcs -maxdepth 1 -type f -name 'RFC-*.md' -exec basename {} .md \; |
+ sed -E 's/^(RFC-[0-9]+).*/\1/' |
+ sort -u
+)
+
echo "Checking RFC template has required sections..."
if [[ -f "rfcs/templates/rfc-template.md" ]]; then
required_sections=(
@@ -54,18 +72,49 @@ for rfc in rfcs/RFC-*.md; do
rfc_name="$(basename "$rfc")"
echo " Found: $rfc_name"
- # Check for required fields
- if ! rg -q '\*\*Status\*\*:' "$rfc"; then
- fail "RFC missing Status field: $rfc_name"
+ required_fields=(
+ '\*\*Status\*\*:'
+ '\*\*Phase\*\*:'
+ '\*\*Authors\*\*:'
+ '\*\*Created\*\*:'
+ '\*\*Modified\*\*:'
+ )
+
+ for field in "${required_fields[@]}"; do
+ if ! rg -q "$field" "$rfc"; then
+ fail "RFC missing required metadata field ($field): $rfc_name"
+ fi
+ done
+
+ required_sections=(
+ '^## Summary$'
+ '^## Motivation$'
+ '^## Proposed Design$'
+ '^## Governance Mapping$'
+ '^## Spec Creation Plan$'
+ '^## Alternatives$'
+ '^## Implementation Plan$'
+ '^## References$'
+ )
+
+ for section in "${required_sections[@]}"; do
+ if ! rg -q "$section" "$rfc"; then
+ fail "RFC missing required section ($section): $rfc_name"
+ fi
+ done
+
+ if ! rg -q "\\*\\*Status\\*\\*: (${VALID_STATUSES})" "$rfc"; then
+ fail "RFC has invalid status value: $rfc_name"
fi
- if ! rg -q '## Summary' "$rfc"; then
- fail "RFC missing Summary section: $rfc_name"
+ if ! rg -q '\*\*Created\*\*: [0-9]{4}-[0-9]{2}-[0-9]{2}' "$rfc"; then
+ fail "RFC missing valid Created date: $rfc_name"
fi
- if ! rg -q '## Governance Mapping' "$rfc"; then
- fail "RFC missing Governance Mapping section: $rfc_name"
+ if ! rg -q '\*\*Modified\*\*: [0-9]{4}-[0-9]{2}-[0-9]{2}' "$rfc"; then
+ fail "RFC missing valid Modified date: $rfc_name"
fi
+
fi
done
@@ -73,5 +122,10 @@ if [[ "$RFC_COUNT" -eq 0 ]]; then
echo " No RFC files found (except template)"
fi
+if [[ "$failures" -ne 0 ]]; then
+ echo "RFC governance validation failed."
+ exit 1
+fi
+
echo "RFC governance validation passed."
exit 0
diff --git a/scripts/validate_specs_governance.sh b/scripts/validate_specs_governance.sh
index d26647a9..1b1cd431 100755
--- a/scripts/validate_specs_governance.sh
+++ b/scripts/validate_specs_governance.sh
@@ -24,8 +24,8 @@ if [[ ! -f "$SCENARIO_CATALOG" ]]; then
exit 1
fi
-# Ash UI uses SCN (Scenario) entries, not AC entries
-KNOWN_SCENARIOS="$(rg -o 'SCN-[0-9]+' "$SCENARIO_CATALOG" | sort -u || true)"
+KNOWN_REQS="$(rg --no-filename -o 'REQ-[A-Z]+-[0-9A-Z]+' specs rfcs guides 2>/dev/null | sort -u || true)"
+KNOWN_SCENARIOS="$(rg --no-filename -o 'SCN-[0-9A-Z]+' "$SCENARIO_CATALOG" | sort -u || true)"
echo "Checking required contract files exist..."
required_contracts=(
@@ -54,6 +54,16 @@ for contract in specs/contracts/*.md; do
if ! rg -q 'REQ-[A-Z]+-[0-9]+' "$contract"; then
fail "contract may be missing REQ entries: $contract"
fi
+
+ if [[ "$contract" != "specs/contracts/control_plane_ownership_matrix.md" ]]; then
+ if ! rg -q '^## Traceability$' "$contract"; then
+ fail "contract missing Traceability section: $contract"
+ fi
+
+ if ! rg -q '^## Conformance$' "$contract"; then
+ fail "contract missing Conformance section: $contract"
+ fi
+ fi
done
echo "Checking topology.md..."
@@ -61,5 +71,33 @@ if [[ ! -f "specs/topology.md" ]]; then
fail "missing topology.md"
fi
-echo "Governance validation passed."
+echo "Checking planning files..."
+for phase in specs/planning/phase-0{1,2,3,4,5,6,7,8}-*.md; do
+ if [[ ! -f "$phase" ]]; then
+ fail "missing planning phase file: $phase"
+ fi
+done
+
+echo "Checking matrix REQ references..."
+while IFS= read -r req; do
+ [[ -z "$req" ]] && continue
+ if ! grep -Fxq "$req" <<<"$KNOWN_REQS"; then
+ fail "matrix references unknown requirement: $req"
+ fi
+done < <(rg --no-filename -o 'REQ-[A-Z]+-[0-9A-Z]+' "$MATRIX" | sort -u || true)
+
+echo "Checking matrix SCN references..."
+while IFS= read -r scn; do
+ [[ -z "$scn" ]] && continue
+ if ! grep -Fxq "$scn" <<<"$KNOWN_SCENARIOS"; then
+ fail "matrix references unknown scenario: $scn"
+ fi
+done < <(rg --no-filename -o 'SCN-[0-9A-Z]+' "$MATRIX" | sort -u || true)
+
+if [[ "$failures" -ne 0 ]]; then
+ echo "Specs governance validation failed."
+ exit 1
+fi
+
+echo "Specs governance validation passed."
exit 0
diff --git a/specs/conformance/spec_conformance_matrix.md b/specs/conformance/spec_conformance_matrix.md
index 77b0362c..26a5de4d 100644
--- a/specs/conformance/spec_conformance_matrix.md
+++ b/specs/conformance/spec_conformance_matrix.md
@@ -83,6 +83,7 @@ The matrix provides complete traceability from:
| REQ-RENDER-001 | Renderer Contract | rendering/registry.md | - |
| REQ-RENDER-002 | LiveView Rendering | rendering/liveview.md | SCN-061 |
| REQ-RENDER-003 | Static HTML Rendering | rendering/static.md | SCN-062 |
+| REQ-RENDER-003B | Desktop Rendering | rendering/desktop.md | - |
| REQ-RENDER-004 | Component Rendering | rendering/component.md | SCN-063 |
| REQ-RENDER-005 | Data Binding Rendering | rendering/binding.md | SCN-064 |
| REQ-RENDER-006 | Error Handling | rendering/errors.md | SCN-066 |
diff --git a/specs/planning/phase-08-governance-gates-and-release-readiness.md b/specs/planning/phase-08-governance-gates-and-release-readiness.md
index 998e411d..20aa4113 100644
--- a/specs/planning/phase-08-governance-gates-and-release-readiness.md
+++ b/specs/planning/phase-08-governance-gates-and-release-readiness.md
@@ -14,191 +14,191 @@ Back to index: [README](./README.md)
- CI enforces governance rules automatically
- Release requires all acceptance criteria to pass
-[ ] 8 Phase 8 - Governance Gates and Release Readiness
+[X] 8 Phase 8 - Governance Gates and Release Readiness
Finalize CI gates, conformance tests, and rollout readiness checks for production deployment.
- [ ] 8.1 Section - CI/CD Pipeline Setup
+[X] 8.1 Section - CI/CD Pipeline Setup
Implement automated governance gates in CI pipeline.
- [ ] 8.1.1 Task - Create specs validation workflow
+ [X] 8.1.1 Task - Create specs validation workflow
Add GitHub Actions workflow for specs validation.
- [ ] 8.1.1.1 Subtask - Create `.github/workflows/specs-governance.yml`
- [ ] 8.1.1.2 Subtask - Run `scripts/validate_specs_governance.sh`
- [ ] 8.1.1.3 Subtask - Check on push to main and PRs
- [ ] 8.1.1.4 Subtask - Fail build if validation fails
+ [X] 8.1.1.1 Subtask - Create `.github/workflows/specs-governance.yml`
+ [X] 8.1.1.2 Subtask - Run `scripts/validate_specs_governance.sh`
+ [X] 8.1.1.3 Subtask - Check on push to main and PRs
+ [X] 8.1.1.4 Subtask - Fail build if validation fails
- [ ] 8.1.2 Task - Create RFC validation workflow
+ [X] 8.1.2 Task - Create RFC validation workflow
Add GitHub Actions workflow for RFC validation.
- [ ] 8.1.2.1 Subtask - Create `.github/workflows/rfc-governance.yml`
- [ ] 8.1.2.2 Subtask - Run `scripts/validate_rfc_governance.sh`
- [ ] 8.1.2.3 Subtask - Check RFC metadata completeness
- [ ] 8.1.2.4 Subtask - Verify RFC traceability links
+ [X] 8.1.2.1 Subtask - Create `.github/workflows/rfc-governance.yml`
+ [X] 8.1.2.2 Subtask - Run `scripts/validate_rfc_governance.sh`
+ [X] 8.1.2.3 Subtask - Check RFC metadata completeness
+ [X] 8.1.2.4 Subtask - Verify RFC traceability links
- [ ] 8.1.3 Task - Create guides validation workflow
+ [X] 8.1.3 Task - Create guides validation workflow
Add GitHub Actions workflow for guides validation.
- [ ] 8.1.3.1 Subtask - Create `.github/workflows/guides-governance.yml`
- [ ] 8.1.3.2 Subtask - Run `scripts/validate_guides_governance.sh`
- [ ] 8.1.3.3 Subtask - Check guide metadata completeness
- [ ] 8.1.3.4 Subtask - Verify guide diagram requirements
+ [X] 8.1.3.1 Subtask - Create `.github/workflows/guides-governance.yml`
+ [X] 8.1.3.2 Subtask - Run `scripts/validate_guides_governance.sh`
+ [X] 8.1.3.3 Subtask - Check guide metadata completeness
+ [X] 8.1.3.4 Subtask - Verify guide diagram requirements
- [ ] 8.1.4 Task - Create conformance test workflow
+ [X] 8.1.4 Task - Create conformance test workflow
Add GitHub Actions workflow for conformance testing.
- [ ] 8.1.4.1 Subtask - Create `.github/workflows/conformance.yml`
- [ ] 8.1.4.2 Subtask - Run all conformance scenarios
- [ ] 8.1.4.3 Subtask - Generate conformance report
- [ ] 8.1.4.4 Subtask - Upload report as artifact
+ [X] 8.1.4.1 Subtask - Create `.github/workflows/conformance.yml`
+ [X] 8.1.4.2 Subtask - Run all conformance scenarios
+ [X] 8.1.4.3 Subtask - Generate conformance report
+ [X] 8.1.4.4 Subtask - Upload report as artifact
- [ ] 8.2 Section - Conformance Test Implementation
+ [X] 8.2 Section - Conformance Test Implementation
Implement automated conformance tests for all requirements.
- [ ] 8.2.1 Task - Implement resource contract tests
+ [X] 8.2.1 Task - Implement resource contract tests
Create tests for REQ-RES-* requirements.
- [ ] 8.2.1.1 Subtask - Implement tests for REQ-RES-001 through REQ-RES-008
- [ ] 8.2.1.2 Subtask - Test resource definition and attributes
- [ ] 8.2.1.3 Subtask - Test relationships and actions
- [ ] 8.2.1.4 Subtask - Test authorization and validation
+ [X] 8.2.1.1 Subtask - Implement tests for REQ-RES-001 through REQ-RES-008
+ [X] 8.2.1.2 Subtask - Test resource definition and attributes
+ [X] 8.2.1.3 Subtask - Test relationships and actions
+ [X] 8.2.1.4 Subtask - Test authorization and validation
- [ ] 8.2.2 Task - Implement screen contract tests
+ [X] 8.2.2 Task - Implement screen contract tests
Create tests for REQ-SCREEN-* requirements.
- [ ] 8.2.2.1 Subtask - Implement tests for REQ-SCREEN-001 through REQ-SCREEN-010
- [ ] 8.2.2.2 Subtask - Test screen lifecycle and state transitions
- [ ] 8.2.2.3 Subtask - Test element composition and bindings
- [ ] 8.2.2.4 Subtask - Test routing and session isolation
+ [X] 8.2.2.1 Subtask - Implement tests for REQ-SCREEN-001 through REQ-SCREEN-010
+ [X] 8.2.2.2 Subtask - Test screen lifecycle and state transitions
+ [X] 8.2.2.3 Subtask - Test element composition and bindings
+ [X] 8.2.2.4 Subtask - Test routing and session isolation
- [ ] 8.2.3 Task - Implement binding contract tests
+ [X] 8.2.3 Task - Implement binding contract tests
Create tests for REQ-BIND-* requirements.
- [ ] 8.2.3.1 Subtask - Implement tests for REQ-BIND-001 through REQ-BIND-010
- [ ] 8.2.3.2 Subtask - Test binding types and source resolution
- [ ] 8.2.3.3 Subtask - Test transformation and reactivity
- [ ] 8.2.3.4 Subtask - Test bidirectional updates and actions
+ [X] 8.2.3.1 Subtask - Implement tests for REQ-BIND-001 through REQ-BIND-010
+ [X] 8.2.3.2 Subtask - Test binding types and source resolution
+ [X] 8.2.3.3 Subtask - Test transformation and reactivity
+ [X] 8.2.3.4 Subtask - Test bidirectional updates and actions
- [ ] 8.2.4 Task - Implement rendering contract tests
+ [X] 8.2.4 Task - Implement rendering contract tests
Create tests for REQ-RENDER-* requirements.
- [ ] 8.2.4.1 Subtask - Implement tests for REQ-RENDER-001 through REQ-RENDER-012
- [ ] 8.2.4.2 Subtask - Test canonical IUR conversion
- [ ] 8.2.4.3 Subtask - Test renderer package integration
- [ ] 8.2.4.4 Subtask - Test error handling and observability
+ [X] 8.2.4.1 Subtask - Implement tests for REQ-RENDER-001 through REQ-RENDER-012
+ [X] 8.2.4.2 Subtask - Test canonical IUR conversion
+ [X] 8.2.4.3 Subtask - Test renderer package integration
+ [X] 8.2.4.4 Subtask - Test error handling and observability
- [ ] 8.3 Section - Observability and Telemetry
+ [X] 8.3 Section - Observability and Telemetry
Implement comprehensive telemetry for monitoring.
- [ ] 8.3.1 Task - Define telemetry events
+ [X] 8.3.1 Task - Define telemetry events
Create standard telemetry event definitions.
- [ ] 8.3.1.1 Subtask - Define `[:ash_ui, :screen, :mount]` event
- [ ] 8.3.1.2 Subtask - Define `[:ash_ui, :screen, :unmount]` event
- [ ] 8.3.1.3 Subtask - Define `[:ash_ui, :binding, :evaluate]` event
- [ ] 8.3.1.4 Subtask - Define `[:ash_ui, :render, :complete]` event
+ [X] 8.3.1.1 Subtask - Define `[:ash_ui, :screen, :mount]` event
+ [X] 8.3.1.2 Subtask - Define `[:ash_ui, :screen, :unmount]` event
+ [X] 8.3.1.3 Subtask - Define `[:ash_ui, :binding, :evaluate]` event
+ [X] 8.3.1.4 Subtask - Define `[:ash_ui, :render, :complete]` event
- [ ] 8.3.2 Task - Implement telemetry handlers
+ [X] 8.3.2 Task - Implement telemetry handlers
Attach telemetry to all major operations.
- [ ] 8.3.2.1 Subtask - Attach telemetry to screen operations
- [ ] 8.3.2.2 Subtask - Attach telemetry to binding evaluation
- [ ] 8.3.2.3 Subtask - Attach telemetry to compilation
- [ ] 8.3.2.4 Subtask - Attach telemetry to rendering
+ [X] 8.3.2.1 Subtask - Attach telemetry to screen operations
+ [X] 8.3.2.2 Subtask - Attach telemetry to binding evaluation
+ [X] 8.3.2.3 Subtask - Attach telemetry to compilation
+ [X] 8.3.2.4 Subtask - Attach telemetry to rendering
- [ ] 8.3.3 Task - Create dashboards
+ [X] 8.3.3 Task - Create dashboards
Create observability dashboards for monitoring.
- [ ] 8.3.3.1 Subtask - Create screen performance dashboard
- [ ] 8.3.3.2 Subtask - Create error rate dashboard
- [ ] 8.3.3.3 Subtask - Create authorization failure dashboard
- [ ] 8.3.3.4 Subtask - Create renderer usage dashboard
+ [X] 8.3.3.1 Subtask - Create screen performance dashboard
+ [X] 8.3.3.2 Subtask - Create error rate dashboard
+ [X] 8.3.3.3 Subtask - Create authorization failure dashboard
+ [X] 8.3.3.4 Subtask - Create renderer usage dashboard
- [ ] 8.4 Section - Documentation Completeness
+ [X] 8.4 Section - Documentation Completeness
Ensure all documentation is complete and up-to-date.
- [ ] 8.4.1 Task - Complete user guides
+ [X] 8.4.1 Task - Complete user guides
Finish all user-facing documentation.
- [ ] 8.4.1.1 Subtask - Complete UG-0001 Getting Started guide
- [ ] 8.4.1.2 Subtask - Create UG-0002 Resources guide
- [ ] 8.4.1.3 Subtask - Create UG-0003 Data Binding guide
- [ ] 8.4.1.4 Subtask - Create UG-0004 Authorization guide
+ [X] 8.4.1.1 Subtask - Complete UG-0001 Getting Started guide
+ [X] 8.4.1.2 Subtask - Create UG-0002 Resources guide
+ [X] 8.4.1.3 Subtask - Create UG-0003 Data Binding guide
+ [X] 8.4.1.4 Subtask - Create UG-0004 Authorization guide
- [ ] 8.4.2 Task - Complete developer guides
+ [X] 8.4.2 Task - Complete developer guides
Finish all developer documentation.
- [ ] 8.4.2.1 Subtask - Update DG-0001 Architecture Overview
- [ ] 8.4.2.2 Subtask - Create DG-0002 Contributing guide
- [ ] 8.4.2.3 Subtask - Create DG-0003 Testing guide
- [ ] 8.4.2.4 Subtask - Create DG-0004 Release process guide
+ [X] 8.4.2.1 Subtask - Update DG-0001 Architecture Overview
+ [X] 8.4.2.2 Subtask - Create DG-0002 Contributing guide
+ [X] 8.4.2.3 Subtask - Create DG-0003 Testing guide
+ [X] 8.4.2.4 Subtask - Create DG-0004 Release process guide
- [ ] 8.4.3 Task - Update README and examples
+ [X] 8.4.3 Task - Update README and examples
Ensure entry-level documentation is clear.
- [ ] 8.4.3.1 Subtask - Update root README with quick start
- [ ] 8.4.3.2 Subtask - Create example application
- [ ] 8.4.3.3 Subtask - Add code examples to guides
- [ ] 8.4.3.4 Subtask - Create migration guide from v0 to v1
+ [X] 8.4.3.1 Subtask - Update root README with quick start
+ [X] 8.4.3.2 Subtask - Create example application
+ [X] 8.4.3.3 Subtask - Add code examples to guides
+ [X] 8.4.3.4 Subtask - Create migration guide from v0 to v1
- [ ] 8.5 Section - Release Checklist
+ [X] 8.5 Section - Release Checklist
Create final checklist for release readiness.
- [ ] 8.5.1 Task - Define release criteria
+ [X] 8.5.1 Task - Define release criteria
Establish what must pass before release.
- [ ] 8.5.1.1 Subtask - All conformance tests must pass
- [ ] 8.5.1.2 Subtask - All CI workflows must pass
- [ ] 8.5.1.3 Subtask - Code coverage must meet threshold
- [ ] 8.5.1.4 Subtask - No critical bugs outstanding
+ [X] 8.5.1.1 Subtask - All conformance tests must pass
+ [X] 8.5.1.2 Subtask - All CI workflows must pass
+ [X] 8.5.1.3 Subtask - Code coverage must meet threshold
+ [X] 8.5.1.4 Subtask - No critical bugs outstanding
- [ ] 8.5.2 Task - Create release process
+ [X] 8.5.2 Task - Create release process
Define the steps for cutting a release.
- [ ] 8.5.2.1 Subtask - Update version numbers
- [ ] 8.5.2.2 Subtask - Generate CHANGELOG
- [ ] 8.5.2.3 Subtask - Create git tag
- [ ] 8.5.2.4 Subtask - Publish to Hex (if applicable)
+ [X] 8.5.2.1 Subtask - Update version numbers
+ [X] 8.5.2.2 Subtask - Generate CHANGELOG
+ [X] 8.5.2.3 Subtask - Create git tag
+ [X] 8.5.2.4 Subtask - Publish to Hex (if applicable)
- [ ] 8.5.3 Task - Create rollback plan
+ [X] 8.5.3 Task - Create rollback plan
Define rollback procedures if issues arise.
- [ ] 8.5.3.1 Subtask - Define rollback criteria
- [ ] 8.5.3.2 Subtask - Document rollback steps
- [ ] 8.5.3.3 Subtask - Create rollback communication template
- [ ] 8.5.3.4 Subtask - Test rollback procedure
+ [X] 8.5.3.1 Subtask - Define rollback criteria
+ [X] 8.5.3.2 Subtask - Document rollback steps
+ [X] 8.5.3.3 Subtask - Create rollback communication template
+ [X] 8.5.3.4 Subtask - Test rollback procedure
- [ ] 8.6 Section - Phase 8 Integration Tests
+ [X] 8.6 Section - Phase 8 Integration Tests
Validate end-to-end system behavior across all phases.
- [ ] 8.6.1 Task - Full stack integration scenarios
+ [X] 8.6.1 Task - Full stack integration scenarios
Test complete user workflows end-to-end.
- [ ] 8.6.1.1 Subtask - Verify user can define, mount, and interact with screen
- [ ] 8.6.1.2 Subtask - Verify data bindings work bidirectionally
- [ ] 8.6.1.3 Subtask - Verify actions execute with authorization
- [ ] 8.6.1.4 Subtask - Verify rendering works across all renderers
+ [X] 8.6.1.1 Subtask - Verify user can define, mount, and interact with screen
+ [X] 8.6.1.2 Subtask - Verify data bindings work bidirectionally
+ [X] 8.6.1.3 Subtask - Verify actions execute with authorization
+ [X] 8.6.1.4 Subtask - Verify rendering works across all renderers
- [ ] 8.6.2 Task - Conformance coverage scenarios
+ [X] 8.6.2 Task - Conformance coverage scenarios
Verify all requirements have test coverage.
- [ ] 8.6.2.1 Subtask - Verify all REQ-* have corresponding SCN-*
- [ ] 8.6.2.2 Subtask - Verify traceability matrix is complete
- [ ] 8.6.2.3 Subtask - Verify all SCN-* have passing tests
- [ ] 8.6.2.4 Subtask - Generate conformance report
+ [X] 8.6.2.1 Subtask - Verify all REQ-* have corresponding SCN-*
+ [X] 8.6.2.2 Subtask - Verify traceability matrix is complete
+ [X] 8.6.2.3 Subtask - Verify all SCN-* have passing tests
+ [X] 8.6.2.4 Subtask - Generate conformance report
- [ ] 8.6.3 Task - Performance and resilience scenarios
+ [X] 8.6.3 Task - Performance and resilience scenarios
Verify system meets performance and resilience targets.
- [ ] 8.6.3.1 Subtask - Verify screen mount time under 100ms
- [ ] 8.6.3.2 Subtask - Verify update render time under 50ms
- [ ] 8.6.3.3 Subtask - Verify system handles 100 concurrent sessions
- [ ] 8.6.3.4 Subtask - Verify graceful degradation on errors
+ [X] 8.6.3.1 Subtask - Verify screen mount time under 100ms
+ [X] 8.6.3.2 Subtask - Verify update render time under 50ms
+ [X] 8.6.3.3 Subtask - Verify system handles 100 concurrent sessions
+ [X] 8.6.3.4 Subtask - Verify graceful degradation on errors
- [ ] 8.6.4 Task - Release readiness scenarios
+ [X] 8.6.4 Task - Release readiness scenarios
Verify all release criteria are met.
- [ ] 8.6.4.1 Subtask - Verify CI gates all pass
- [ ] 8.6.4.2 Subtask - Verify documentation is complete
- [ ] 8.6.4.3 Subtask - Verify telemetry is configured
- [ ] 8.6.4.4 Subtask - Verify rollback procedure works
+ [X] 8.6.4.1 Subtask - Verify CI gates all pass
+ [X] 8.6.4.2 Subtask - Verify documentation is complete
+ [X] 8.6.4.3 Subtask - Verify telemetry is configured
+ [X] 8.6.4.4 Subtask - Verify rollback procedure works
diff --git a/test/ash_ui/authorization/policy_dsl_test.exs b/test/ash_ui/authorization/policy_dsl_test.exs
index 82deee0d..46c1a054 100644
--- a/test/ash_ui/authorization/policy_dsl_test.exs
+++ b/test/ash_ui/authorization/policy_dsl_test.exs
@@ -5,7 +5,7 @@ defmodule AshUI.Authorization.PolicyDSLTest do
# Mock users
defp build_admin(), do: %{id: "admin-1", role: :admin, active: true}
- defp build_user(), do: %{id: "user-1", role: :user, active: true}
+ defp build_user(id \\ "user-1"), do: %{id: id, role: :user, active: true}
defp build_inactive(), do: %{id: "user-2", role: :user, active: false}
# Mock resources
diff --git a/test/ash_ui/authorization/resource_policies_test.exs b/test/ash_ui/authorization/resource_policies_test.exs
index 959e9acc..a48d79ef 100644
--- a/test/ash_ui/authorization/resource_policies_test.exs
+++ b/test/ash_ui/authorization/resource_policies_test.exs
@@ -41,207 +41,201 @@ defmodule AshUI.Authorization.ResourcePoliciesTest do
})
end
- describe "ScreenPolicy" do
- describe "policies/0" do
- test "returns list of policies" do
- policies = ScreenPolicy.policies()
- assert is_list(policies)
- assert length(policies) > 0
- end
- end
-
- describe "filter_screens/1" do
- test "returns all screens for admin" do
- filters = ScreenPolicy.filter_screens(build_admin())
- assert Keyword.get(filters, :active) == true
- end
-
- test "returns public and owned screens for regular user" do
- filters = ScreenPolicy.filter_screens(build_user())
- assert Keyword.get(filters, :active) == true
- assert Keyword.has_key?(filters, :or)
- end
-
- test "returns only public screens for guest" do
- filters = ScreenPolicy.filter_screens(build_guest())
- assert Keyword.get(filters, :active) == true
- end
- end
-
- describe "can_mount?/2" do
- test "admin can mount any screen" do
- screen = build_screen(public: false, owner_id: "other-user")
- assert ScreenPolicy.can_mount?(build_admin(), screen) == true
- end
-
- test "user can mount public screen" do
- screen = build_screen(public: true, owner_id: "other-user")
- assert ScreenPolicy.can_mount?(build_user(), screen) == true
- end
-
- test "user can mount their own screen" do
- screen = build_screen(public: false, owner_id: "user-1")
- assert ScreenPolicy.can_mount?(build_user("user-1"), screen) == true
- end
-
- test "user cannot mount private screen owned by others" do
- screen = build_screen(public: false, owner_id: "user-2")
- assert ScreenPolicy.can_mount?(build_user("user-1"), screen) == false
- end
-
- test "inactive user cannot mount screen" do
- screen = build_screen(public: true)
- assert ScreenPolicy.can_mount?(build_inactive(), screen) == false
- end
+ describe "ScreenPolicy.policies/0" do
+ test "returns list of policies" do
+ policies = ScreenPolicy.policies()
+ assert is_list(policies)
+ assert length(policies) > 0
end
end
- describe "ElementPolicy" do
- describe "policies/0" do
- test "returns list of policies" do
- policies = ElementPolicy.policies()
- assert is_list(policies)
- assert length(policies) > 0
- end
- end
-
- describe "visible?/2" do
- test "admin sees all elements" do
- element = build_element()
- assert ElementPolicy.visible?(build_admin(), element) == true
- end
-
- test "active user sees element without visibility condition" do
- element = build_element()
- assert ElementPolicy.visible?(build_user(), element) == true
- end
-
- test "inactive user does not see element" do
- element = build_element()
- assert ElementPolicy.visible?(build_inactive(), element) == false
- end
-
- test "respects visibility condition function" do
- element = build_element(visible_when: fn user -> user.role == :admin end)
- assert ElementPolicy.visible?(build_admin(), element) == true
- assert ElementPolicy.visible?(build_user(), element) == false
- end
-
- test "respects visibility condition tuple" do
- element = build_element(visible_when: {:role, :admin})
- assert ElementPolicy.visible?(build_admin(), element) == true
- assert ElementPolicy.visible?(build_user(), element) == false
- end
- end
-
- describe "editable?/2" do
- test "admin can edit all elements" do
- element = build_element(read_only: false)
- assert ElementPolicy.editable?(build_admin(), element) == true
- end
-
- test "user can edit non-read-only element" do
- element = build_element(read_only: false)
- assert ElementPolicy.editable?(build_user(), element) == true
- end
-
- test "user cannot edit read-only element" do
- element = build_element(read_only: true)
- assert ElementPolicy.editable?(build_user(), element) == false
- end
-
- test "inactive user cannot edit element" do
- element = build_element(read_only: false)
- assert ElementPolicy.editable?(build_inactive(), element) == false
- end
+ describe "ScreenPolicy.filter_screens/1" do
+ test "returns all screens for admin" do
+ filters = ScreenPolicy.filter_screens(build_admin())
+ assert Keyword.get(filters, :active) == true
+ end
+
+ test "returns public and owned screens for regular user" do
+ filters = ScreenPolicy.filter_screens(build_user())
+ assert Keyword.get(filters, :active) == true
+ assert Keyword.has_key?(filters, :or)
+ end
+
+ test "returns only public screens for guest" do
+ filters = ScreenPolicy.filter_screens(build_guest())
+ assert Keyword.get(filters, :active) == true
+ end
+ end
+
+ describe "ScreenPolicy.can_mount?/2" do
+ test "admin can mount any screen" do
+ screen = build_screen(public: false, owner_id: "other-user")
+ assert ScreenPolicy.can_mount?(build_admin(), screen) == true
+ end
+
+ test "user can mount public screen" do
+ screen = build_screen(public: true, owner_id: "other-user")
+ assert ScreenPolicy.can_mount?(build_user(), screen) == true
+ end
+
+ test "user can mount their own screen" do
+ screen = build_screen(public: false, owner_id: "user-1")
+ assert ScreenPolicy.can_mount?(build_user("user-1"), screen) == true
+ end
+
+ test "user cannot mount private screen owned by others" do
+ screen = build_screen(public: false, owner_id: "user-2")
+ assert ScreenPolicy.can_mount?(build_user("user-1"), screen) == false
+ end
+
+ test "inactive user cannot mount screen" do
+ screen = build_screen(public: true)
+ assert ScreenPolicy.can_mount?(build_inactive(), screen) == false
+ end
+ end
+
+ describe "ElementPolicy.policies/0" do
+ test "returns list of policies" do
+ policies = ElementPolicy.policies()
+ assert is_list(policies)
+ assert length(policies) > 0
+ end
+ end
+
+ describe "ElementPolicy.visible?/2" do
+ test "admin sees all elements" do
+ element = build_element()
+ assert ElementPolicy.visible?(build_admin(), element) == true
+ end
+
+ test "active user sees element without visibility condition" do
+ element = build_element()
+ assert ElementPolicy.visible?(build_user(), element) == true
+ end
+
+ test "inactive user does not see element" do
+ element = build_element()
+ assert ElementPolicy.visible?(build_inactive(), element) == false
+ end
+
+ test "respects visibility condition function" do
+ element = build_element(visible_when: fn user -> user.role == :admin end)
+ assert ElementPolicy.visible?(build_admin(), element) == true
+ assert ElementPolicy.visible?(build_user(), element) == false
+ end
+
+ test "respects visibility condition tuple" do
+ element = build_element(visible_when: {:role, :admin})
+ assert ElementPolicy.visible?(build_admin(), element) == true
+ assert ElementPolicy.visible?(build_user(), element) == false
+ end
+ end
+
+ describe "ElementPolicy.editable?/2" do
+ test "admin can edit all elements" do
+ element = build_element(read_only: false)
+ assert ElementPolicy.editable?(build_admin(), element) == true
+ end
+
+ test "user can edit non-read-only element" do
+ element = build_element(read_only: false)
+ assert ElementPolicy.editable?(build_user(), element) == true
+ end
+
+ test "user cannot edit read-only element" do
+ element = build_element(read_only: true)
+ assert ElementPolicy.editable?(build_user(), element) == false
+ end
+
+ test "inactive user cannot edit element" do
+ element = build_element(read_only: false)
+ assert ElementPolicy.editable?(build_inactive(), element) == false
+ end
+ end
+
+ describe "BindingPolicy.policies/0" do
+ test "returns list of policies" do
+ policies = BindingPolicy.policies()
+ assert is_list(policies)
+ assert length(policies) > 0
+ end
+ end
+
+ describe "BindingPolicy.can_evaluate?/2" do
+ test "admin can evaluate all bindings" do
+ binding = build_binding()
+ assert BindingPolicy.can_evaluate?(build_admin(), binding) == true
+ end
+
+ test "active user can evaluate binding without source" do
+ binding = build_binding(source: nil)
+ assert BindingPolicy.can_evaluate?(build_user(), binding) == true
+ end
+
+ test "inactive user cannot evaluate binding" do
+ binding = build_binding()
+ assert BindingPolicy.can_evaluate?(build_inactive(), binding) == false
end
end
- describe "BindingPolicy" do
- describe "policies/0" do
- test "returns list of policies" do
- policies = BindingPolicy.policies()
- assert is_list(policies)
- assert length(policies) > 0
- end
- end
-
- describe "can_evaluate?/2" do
- test "admin can evaluate all bindings" do
- binding = build_binding()
- assert BindingPolicy.can_evaluate?(build_admin(), binding) == true
- end
-
- test "active user can evaluate binding without source" do
- binding = build_binding(source: nil)
- assert BindingPolicy.can_evaluate?(build_user(), binding) == true
- end
-
- test "inactive user cannot evaluate binding" do
- binding = build_binding()
- assert BindingPolicy.can_evaluate?(build_inactive(), binding) == false
- end
- end
-
- describe "can_write?/2" do
- test "admin can write to all bindings" do
- binding = build_binding(read_only: false)
- assert BindingPolicy.can_write?(build_admin(), binding) == true
- end
-
- test "user can write to non-read-only binding" do
- binding = build_binding(read_only: false)
- assert BindingPolicy.can_write?(build_user(), binding) == true
- end
-
- test "user cannot write to read-only binding" do
- binding = build_binding(read_only: true)
- assert BindingPolicy.can_write?(build_user(), binding) == false
- end
-
- test "inactive user cannot write to binding" do
- binding = build_binding(read_only: false)
- assert BindingPolicy.can_write?(build_inactive(), binding) == false
- end
- end
-
- describe "redacted_value/1" do
- test "returns protected placeholder for value bindings" do
- binding = build_binding(binding_type: :value)
- assert BindingPolicy.redacted_value(binding) == "[PROTECTED]"
- end
-
- test "returns empty list for list bindings" do
- binding = build_binding(binding_type: :list)
- assert BindingPolicy.redacted_value(binding) == []
- end
-
- test "returns nil for action bindings" do
- binding = build_binding(binding_type: :action)
- assert BindingPolicy.redacted_value(binding) == nil
- end
-
- test "returns nil for unknown binding types" do
- binding = build_binding(binding_type: :unknown)
- assert BindingPolicy.redacted_value(binding) == nil
- end
- end
-
- describe "source_accessible?/2" do
- test "returns true for binding without source" do
- binding = build_binding(source: nil)
- assert BindingPolicy.source_accessible?(build_user(), binding) == true
- end
-
- test "returns true for binding with empty source" do
- binding = build_binding(source: %{})
- assert BindingPolicy.source_accessible?(build_user(), binding) == true
- end
-
- test "checks source resource access" do
- binding = build_binding(source: %{"resource" => "User.Profile"})
- assert is_boolean(BindingPolicy.source_accessible?(build_user(), binding))
- end
+ describe "BindingPolicy.can_write?/2" do
+ test "admin can write to all bindings" do
+ binding = build_binding(read_only: false)
+ assert BindingPolicy.can_write?(build_admin(), binding) == true
+ end
+
+ test "user can write to non-read-only binding" do
+ binding = build_binding(read_only: false)
+ assert BindingPolicy.can_write?(build_user(), binding) == true
+ end
+
+ test "user cannot write to read-only binding" do
+ binding = build_binding(read_only: true)
+ assert BindingPolicy.can_write?(build_user(), binding) == false
+ end
+
+ test "inactive user cannot write to binding" do
+ binding = build_binding(read_only: false)
+ assert BindingPolicy.can_write?(build_inactive(), binding) == false
+ end
+ end
+
+ describe "BindingPolicy.redacted_value/1" do
+ test "returns protected placeholder for value bindings" do
+ binding = build_binding(binding_type: :value)
+ assert BindingPolicy.redacted_value(binding) == "[PROTECTED]"
+ end
+
+ test "returns empty list for list bindings" do
+ binding = build_binding(binding_type: :list)
+ assert BindingPolicy.redacted_value(binding) == []
+ end
+
+ test "returns nil for action bindings" do
+ binding = build_binding(binding_type: :action)
+ assert BindingPolicy.redacted_value(binding) == nil
+ end
+
+ test "returns nil for unknown binding types" do
+ binding = build_binding(binding_type: :unknown)
+ assert BindingPolicy.redacted_value(binding) == nil
+ end
+ end
+
+ describe "BindingPolicy.source_accessible?/2" do
+ test "returns true for binding without source" do
+ binding = build_binding(source: nil)
+ assert BindingPolicy.source_accessible?(build_user(), binding) == true
+ end
+
+ test "returns true for binding with empty source" do
+ binding = build_binding(source: %{})
+ assert BindingPolicy.source_accessible?(build_user(), binding) == true
+ end
+
+ test "checks source resource access" do
+ binding = build_binding(source: %{"resource" => "User.Profile"})
+ assert is_boolean(BindingPolicy.source_accessible?(build_user(), binding))
end
end
end
diff --git a/test/ash_ui/authorization/runtime_test.exs b/test/ash_ui/authorization/runtime_test.exs
index fa968286..042d0553 100644
--- a/test/ash_ui/authorization/runtime_test.exs
+++ b/test/ash_ui/authorization/runtime_test.exs
@@ -1,5 +1,5 @@
defmodule AshUI.Authorization.RuntimeTest do
- use ExUnit.Case, async: true
+ use ExUnit.Case, async: false
alias AshUI.Authorization.Runtime
@@ -119,8 +119,9 @@ defmodule AshUI.Authorization.RuntimeTest do
test "forbids user from writing to read-only binding" do
binding = build_binding(read_only: true)
- # Note: Actual check depends on BindingPolicy.can_write?/2
- assert is_atom(Runtime.check_write_access(build_user(), binding))
+
+ assert {:forbidden, reason} = Runtime.check_write_access(build_user(), binding)
+ assert reason.reason == :forbidden
end
test "forbids unauthenticated user" do
diff --git a/test/ash_ui/compiler/incremental_test.exs b/test/ash_ui/compiler/incremental_test.exs
index 6ad6800f..ebe4ee36 100644
--- a/test/ash_ui/compiler/incremental_test.exs
+++ b/test/ash_ui/compiler/incremental_test.exs
@@ -70,9 +70,9 @@ defmodule AshUI.Compiler.IncrementalTest do
assert graph.element_to_screen[element1.id] == screen.id
end
- test "tracks binding to element relationships" do
+ test "tracks binding to element relationships", %{screen: screen} do
# Binding created in setup
- {:ok, graph} = Incremental.build_dependencies(build_screen())
+ {:ok, graph} = Incremental.build_dependencies(screen)
assert map_size(graph.binding_to_element) > 0
end
diff --git a/test/ash_ui/compiler_test.exs b/test/ash_ui/compiler_test.exs
index 2fde60cc..1c4f586e 100644
--- a/test/ash_ui/compiler_test.exs
+++ b/test/ash_ui/compiler_test.exs
@@ -263,6 +263,9 @@ defmodule AshUI.CompilerTest do
}
)
+ Compiler.clear_cache()
+ Compiler.init_cache()
+
assert {:ok, _iur} = Compiler.compile(screen)
assert Compiler.cache_stats().size > 0
diff --git a/test/ash_ui/dsl_integration_test.exs b/test/ash_ui/dsl_integration_test.exs
index 00f5fa1b..cf96d2cc 100644
--- a/test/ash_ui/dsl_integration_test.exs
+++ b/test/ash_ui/dsl_integration_test.exs
@@ -66,7 +66,7 @@ defmodule AshUI.DSLIntegrationTest do
:card,
:list,
:table
- }
+ ]
Enum.each(valid_types, fn type ->
attrs = %{
diff --git a/test/ash_ui/liveview/hooks_test.exs b/test/ash_ui/liveview/hooks_test.exs
index 36c16941..86f42a6d 100644
--- a/test/ash_ui/liveview/hooks_test.exs
+++ b/test/ash_ui/liveview/hooks_test.exs
@@ -23,7 +23,7 @@ defmodule AshUI.LiveView.HooksTest do
describe "register_callback/4" do
test "registers on_init callback" do
socket = build_socket()
- callback = fn socket -> assign(socket, :initialized, true) end
+ callback = fn socket -> Phoenix.Component.assign(socket, :initialized, true) end
socket = Hooks.register_callback(socket, :on_init, callback)
@@ -50,7 +50,7 @@ defmodule AshUI.LiveView.HooksTest do
describe "execute_callbacks/2" do
test "executes registered on_init callbacks" do
callback = fn socket ->
- Phoenix.LiveView.assign(socket, :callback_executed, true)
+ Phoenix.Component.assign(socket, :callback_executed, true)
end
socket =
@@ -64,12 +64,12 @@ defmodule AshUI.LiveView.HooksTest do
test "executes callbacks in order" do
callback1 = fn socket ->
- Phoenix.LiveView.assign(socket, :order, ["first"])
+ Phoenix.Component.assign(socket, :order, ["first"])
end
callback2 = fn socket ->
order = socket.assigns[:order] || []
- Phoenix.LiveView.assign(socket, :order, order ++ ["second"])
+ Phoenix.Component.assign(socket, :order, order ++ ["second"])
end
socket =
@@ -88,7 +88,7 @@ defmodule AshUI.LiveView.HooksTest do
# Add a callback that should still execute
success_callback = fn socket ->
- Phoenix.LiveView.assign(socket, :still_executed, true)
+ Phoenix.Component.assign(socket, :still_executed, true)
end
socket =
@@ -116,7 +116,7 @@ defmodule AshUI.LiveView.HooksTest do
socket = build_socket()
callback = fn socket ->
- Phoenix.LiveView.assign(socket, :updated, true)
+ Phoenix.Component.assign(socket, :updated, true)
end
assert {:cont, socket} = Hooks.on_update(socket, callback)
@@ -127,7 +127,7 @@ defmodule AshUI.LiveView.HooksTest do
socket = build_socket()
callback = fn socket ->
- Phoenix.LiveView.assign(socket, :value, 42)
+ Phoenix.Component.assign(socket, :value, 42)
end
assert {:cont, socket} = Hooks.on_update(socket, callback)
diff --git a/test/ash_ui/liveview/lifecycle_test.exs b/test/ash_ui/liveview/lifecycle_test.exs
index 770b8fac..41848c16 100644
--- a/test/ash_ui/liveview/lifecycle_test.exs
+++ b/test/ash_ui/liveview/lifecycle_test.exs
@@ -61,11 +61,11 @@ defmodule AshUI.LiveView.LifecycleTest do
describe "execute_hooks/2" do
test "executes registered hooks in order" do
hook1 = fn socket ->
- Phoenix.LiveView.assign(socket, :hook1_executed, true)
+ Phoenix.Component.assign(socket, :hook1_executed, true)
end
hook2 = fn socket ->
- Phoenix.LiveView.assign(socket, :hook2_executed, true)
+ Phoenix.Component.assign(socket, :hook2_executed, true)
end
socket =
@@ -80,7 +80,7 @@ defmodule AshUI.LiveView.LifecycleTest do
test "handles hook errors gracefully" do
error_hook = fn _socket -> raise "Hook error" end
- success_hook = fn socket -> Phoenix.LiveView.assign(socket, :still_ran, true) end
+ success_hook = fn socket -> Phoenix.Component.assign(socket, :still_ran, true) end
socket =
build_socket()
@@ -164,7 +164,7 @@ defmodule AshUI.LiveView.LifecycleTest do
|> Lifecycle.init_session(:dashboard)
|> elem(1)
|> Lifecycle.register_hook(:on_unmount, fn socket ->
- Phoenix.LiveView.assign(socket, :cleanup_called, true)
+ Phoenix.Component.assign(socket, :cleanup_called, true)
end)
assert :ok = Lifecycle.cleanup_session(socket)
@@ -174,7 +174,7 @@ defmodule AshUI.LiveView.LifecycleTest do
socket =
build_socket()
|> Lifecycle.register_hook(:on_unmount, fn socket ->
- Phoenix.LiveView.assign(socket, :unmounted, true)
+ Phoenix.Component.assign(socket, :unmounted, true)
end)
# Note: cleanup returns :ok, not the socket
@@ -253,7 +253,7 @@ defmodule AshUI.LiveView.LifecycleTest do
socket =
build_socket()
|> Lifecycle.register_hook(:on_error, fn socket ->
- Phoenix.LiveView.assign(socket, :error_handled, true)
+ Phoenix.Component.assign(socket, :error_handled, true)
end)
exception = RuntimeError.exception("Test error")
@@ -304,7 +304,7 @@ defmodule AshUI.LiveView.LifecycleTest do
test "merges callbacks from module" do
defmodule TestLifecycleCallbacks do
def on_lifecycle(:init, socket) do
- Phoenix.LiveView.assign(socket, :module_callback_ran, true)
+ Phoenix.Component.assign(socket, :module_callback_ran, true)
end
def on_lifecycle(_, socket), do: socket
@@ -335,7 +335,7 @@ defmodule AshUI.LiveView.LifecycleTest do
socket =
build_socket()
|> Lifecycle.register_hook(:on_update, fn socket ->
- Phoenix.LiveView.assign(socket, :updated, true)
+ Phoenix.Component.assign(socket, :updated, true)
end)
socket = Lifecycle.on_session_change(socket, %{})
diff --git a/test/ash_ui/liveview/liveview_integration_test.exs b/test/ash_ui/liveview/liveview_integration_test.exs
index 890afa1b..1191163f 100644
--- a/test/ash_ui/liveview/liveview_integration_test.exs
+++ b/test/ash_ui/liveview/liveview_integration_test.exs
@@ -1,5 +1,5 @@
defmodule AshUI.LiveView.IntegrationTest do
- use ExUnit.Case, async: true
+ use AshUI.DataCase, async: false
alias AshUI.LiveView.Integration
alias AshUI.Resources.Screen
@@ -13,7 +13,11 @@ defmodule AshUI.LiveView.IntegrationTest do
# Mock user
defp build_user(id \\ "user-1") do
- %{id: id, name: "Test User"}
+ %{id: id, name: "Test User", role: :user, active: true}
+ end
+
+ defp build_admin(id \\ "admin-1") do
+ %{id: id, name: "Admin User", role: :admin, active: true}
end
# Mock screen
@@ -25,12 +29,30 @@ defmodule AshUI.LiveView.IntegrationTest do
}
end
+ setup do
+ {:ok, _screen} =
+ AshUI.Domain.create(Screen,
+ attrs: %{
+ name: "test_screen",
+ unified_dsl: %{"type" => "screen"}
+ }
+ )
+
+ {:ok, _restricted_screen} =
+ AshUI.Domain.create(Screen,
+ attrs: %{
+ name: "restricted_screen",
+ unified_dsl: %{"type" => "screen"}
+ }
+ )
+
+ :ok
+ end
+
describe "mount_ui_screen/3" do
test "mounts screen successfully with valid user and screen" do
- socket = build_socket(current_user: build_user())
+ socket = build_socket(current_user: build_admin())
- # Note: In actual implementation, would need to mock Ash.get
- # This is a structural test
assert {:ok, socket} = Integration.mount_ui_screen(socket, :test_screen, %{})
end
@@ -50,11 +72,10 @@ defmodule AshUI.LiveView.IntegrationTest do
describe "authorize_screen/2" do
setup do
- %{screen: build_screen(), user: build_user()}
+ %{screen: build_screen(), user: build_admin()}
end
test "returns :ok for authorized user", %{screen: screen, user: user} do
- # Note: Would need to mock Ash.can?
assert :ok = Integration.authorize_screen(screen, user)
end
@@ -62,7 +83,6 @@ defmodule AshUI.LiveView.IntegrationTest do
screen = build_screen("restricted-screen")
unauthorized_user = build_user("unauthorized-user")
- # Note: Would need to mock Ash.can?
assert {:error, :unauthorized} = Integration.authorize_screen(screen, unauthorized_user)
end
end
diff --git a/test/ash_ui/liveview/phase_4_integration_test.exs b/test/ash_ui/liveview/phase_4_integration_test.exs
index 9fcb47c8..de819164 100644
--- a/test/ash_ui/liveview/phase_4_integration_test.exs
+++ b/test/ash_ui/liveview/phase_4_integration_test.exs
@@ -7,10 +7,12 @@ defmodule AshUI.LiveView.Phase4IntegrationTest do
alias AshUI.LiveView.Lifecycle
alias AshUI.LiveView.ErrorHandler
+ @moduletag :conformance
+
# Integration test helpers
defp build_socket(assigns \\ %{}) do
%Phoenix.LiveView.Socket{
- assigns: Enum.into(assigns, %{__changed__: %{}})
+ assigns: Enum.into(assigns, %{__changed__: %{}, flash: %{}})
}
end
@@ -172,9 +174,9 @@ defmodule AshUI.LiveView.Phase4IntegrationTest do
assert {:noreply, socket} =
UpdateIntegration.batch_updates(socket, fn socket ->
socket
- |> Phoenix.LiveView.assign(:value1, 1)
- |> Phoenix.LiveView.assign(:value2, 2)
- |> Phoenix.LiveView.assign(:value3, 3)
+ |> Phoenix.Component.assign(:value1, 1)
+ |> Phoenix.Component.assign(:value2, 2)
+ |> Phoenix.Component.assign(:value3, 3)
end)
assert socket.assigns[:value1] == 1
diff --git a/test/ash_ui/liveview/update_integration_test.exs b/test/ash_ui/liveview/update_integration_test.exs
index 1a7cbf3c..75e76130 100644
--- a/test/ash_ui/liveview/update_integration_test.exs
+++ b/test/ash_ui/liveview/update_integration_test.exs
@@ -174,8 +174,8 @@ defmodule AshUI.LiveView.UpdateIntegrationTest do
assert {:noreply, socket} =
UpdateIntegration.batch_updates(socket, fn socket ->
socket
- |> Phoenix.LiveView.assign(:value1, 1)
- |> Phoenix.LiveView.assign(:value2, 2)
+ |> Phoenix.Component.assign(:value1, 1)
+ |> Phoenix.Component.assign(:value2, 2)
end)
assert socket.assigns[:value1] == 1
diff --git a/test/ash_ui/phase_8_integration_test.exs b/test/ash_ui/phase_8_integration_test.exs
new file mode 100644
index 00000000..84e14a3d
--- /dev/null
+++ b/test/ash_ui/phase_8_integration_test.exs
@@ -0,0 +1,344 @@
+defmodule AshUI.Phase8IntegrationTest do
+ use AshUI.DataCase, async: false
+
+ alias AshUI.Authorization.Runtime
+ alias AshUI.Compiler
+ alias AshUI.DSL.Builder
+ alias AshUI.Domain
+ alias AshUI.LiveView.EventHandler
+ alias AshUI.LiveView.Integration
+ alias AshUI.Rendering.DesktopUIAdapter
+ alias AshUI.Rendering.LiveUIAdapter
+ alias AshUI.Rendering.WebUIAdapter
+ alias AshUI.Resources.Screen
+ alias AshUI.Telemetry
+
+ @moduletag :integration
+ @moduletag :conformance
+
+ setup do
+ Compiler.clear_cache()
+ Compiler.init_cache()
+ Runtime.init_cache()
+ Telemetry.reset_metrics()
+ :ok
+ end
+
+ describe "Section 8.6.1 - Full stack integration scenarios" do
+ test "8.6.1.1 - user can define, mount, and interact with a screen" do
+ screen = create_screen(:phase8_dashboard)
+ socket = build_socket(current_user: build_admin())
+
+ assert {:ok, mounted_socket} = Integration.mount_ui_screen(socket, :phase8_dashboard, %{})
+ assert mounted_socket.assigns.ash_ui_screen.id == screen.id
+ assert is_map(mounted_socket.assigns.ash_ui_iur)
+ assert mounted_socket.assigns.ash_ui_user.role == :admin
+ end
+
+ test "8.6.1.2 - data bindings work bidirectionally" do
+ socket =
+ build_socket(
+ ash_ui_user: build_admin(),
+ ash_ui_bindings: %{
+ "name-binding" => %{
+ id: "name-binding",
+ binding_type: :value,
+ target: "profile.name",
+ source: %{"resource" => "User", "field" => "name", "id" => "user-1"},
+ transform: %{"sanitize" => [%{"type" => "trim"}]}
+ }
+ }
+ )
+
+ assert {:noreply, updated_socket} =
+ EventHandler.handle_value_change(
+ %{"target" => "profile.name", "value" => " Pascal "},
+ socket
+ )
+
+ assert get_in(updated_socket.assigns, [:ash_ui, :bindings, "profile.name", "value"]) ==
+ "Pascal"
+ end
+
+ test "8.6.1.3 - actions execute with authorization" do
+ socket =
+ build_socket(
+ ash_ui_user: build_admin(),
+ ash_ui_bindings: %{
+ "save-profile" => %{
+ id: "save-profile",
+ binding_type: :action,
+ target: "submit",
+ source: %{"resource" => "User", "action" => "save_profile"},
+ transform: %{"params" => %{"display_name" => {"event", "display_name"}}}
+ }
+ }
+ )
+
+ assert {:reply, %{status: :ok}, updated_socket} =
+ EventHandler.handle_action_event(
+ %{"action_id" => "save-profile", "data" => %{"display_name" => "Pascal"}},
+ socket
+ )
+
+ assert get_in(updated_socket.assigns, [:flash, :info]) == "Action completed successfully"
+ end
+
+ test "8.6.1.4 - rendering works across all renderers" do
+ screen = create_screen(:phase8_renderers)
+
+ assert {:ok, canonical_iur} = Integration.compile_screen(screen)
+ assert {:ok, heex} = LiveUIAdapter.render(canonical_iur)
+ assert {:ok, html} = WebUIAdapter.render(canonical_iur)
+ assert {:ok, desktop} = DesktopUIAdapter.render(canonical_iur)
+
+ assert is_binary(heex)
+ assert is_binary(html)
+ assert is_map(desktop)
+ end
+ end
+
+ describe "Section 8.6.2 - Conformance coverage scenarios" do
+ test "8.6.2.1 - all REQ entries in contracts have explicit traceability rows in the matrix" do
+ contract_reqs =
+ "specs/contracts/*_contract.md"
+ |> Path.wildcard()
+ |> Enum.flat_map(&extract_ids(&1, ~r/REQ-[A-Z]+-[0-9]+[A-Z]*/))
+ |> MapSet.new()
+
+ matrix = File.read!(project_path("specs/conformance/spec_conformance_matrix.md"))
+
+ Enum.each(contract_reqs, fn req ->
+ assert String.contains?(matrix, req)
+ assert Regex.match?(~r/\|\s*#{Regex.escape(req)}\s*\|.*(\bSCN-| \- \|)/, matrix)
+ end)
+ end
+
+ test "8.6.2.2 - the traceability matrix is complete against the scenario catalog" do
+ matrix_scns =
+ extract_ids(project_path("specs/conformance/spec_conformance_matrix.md"), ~r/SCN-[0-9A-Z]+/)
+ |> MapSet.new()
+
+ catalog_scns =
+ extract_ids(project_path("specs/conformance/scenario_catalog.md"), ~r/SCN-[0-9A-Z]+/)
+ |> MapSet.new()
+
+ assert MapSet.subset?(matrix_scns, catalog_scns)
+ end
+
+ test "8.6.2.3 - conformance-tagged tests are present and targeted by the harness" do
+ conformance_files =
+ run_shell!("rg -l '@(module)?tag.*conformance' test")
+ |> String.split("\n", trim: true)
+
+ harness = File.read!(project_path("scripts/run_conformance.sh"))
+
+ assert length(conformance_files) > 0
+ assert String.contains?(harness, "mix test --only conformance")
+ end
+
+ test "8.6.2.4 - conformance report can be generated" do
+ report_dir = temp_dir("conformance-report")
+
+ output =
+ run_shell!(
+ "./scripts/generate_conformance_report.sh #{report_dir}",
+ %{"CONFORMANCE_STATUS" => "passed"}
+ )
+
+ assert String.contains?(output, "Conformance report written")
+ assert File.exists?(Path.join(report_dir, "report.md"))
+ assert File.exists?(Path.join(report_dir, "report.json"))
+ end
+ end
+
+ describe "Section 8.6.3 - Performance and resilience scenarios" do
+ test "8.6.3.1 - screen mount time stays under 100ms for a minimal screen" do
+ _screen = create_screen(:phase8_mount_perf)
+ socket = build_socket(current_user: build_admin())
+
+ # Warm the compiler and query path before measuring.
+ assert {:ok, _socket} = Integration.mount_ui_screen(socket, :phase8_mount_perf, %{})
+
+ {microseconds, {:ok, _socket}} =
+ :timer.tc(fn ->
+ Integration.mount_ui_screen(socket, :phase8_mount_perf, %{})
+ end)
+
+ assert microseconds / 1000 < 100
+ end
+
+ test "8.6.3.2 - update render time stays under 50ms for fallback rendering" do
+ screen = create_screen(:phase8_render_perf)
+ assert {:ok, canonical_iur} = Integration.compile_screen(screen)
+
+ {microseconds, {:ok, _}} =
+ :timer.tc(fn ->
+ LiveUIAdapter.render(canonical_iur)
+ end)
+
+ assert microseconds / 1000 < 50
+ end
+
+ test "8.6.3.3 - the system handles 100 concurrent session compilation flows" do
+ screen = in_memory_screen("phase8_concurrency")
+ user = build_admin()
+
+ results =
+ 1..100
+ |> Task.async_stream(
+ fn _ ->
+ with :ok <- Integration.authorize_screen(screen, user),
+ {:ok, _canonical_iur} <- Integration.compile_screen(screen) do
+ :ok
+ end
+ end,
+ max_concurrency: 20,
+ timeout: 5_000
+ )
+ |> Enum.to_list()
+
+ assert Enum.all?(results, &match?({:ok, :ok}, &1))
+ end
+
+ test "8.6.3.4 - errors degrade gracefully without crashing the runtime path" do
+ socket = build_socket(current_user: build_admin())
+ invalid_screen = %Screen{id: nil, name: nil}
+
+ assert {:error, :not_found} = Integration.mount_ui_screen(socket, :missing_phase8_screen, %{})
+ assert {:error, :invalid_screen} = Integration.compile_screen(invalid_screen)
+
+ assert {:noreply, error_socket} = EventHandler.handle_event("unknown_event", %{}, socket)
+ assert get_in(error_socket.assigns, [:flash, :error]) == "Action failed: :invalid_event"
+ end
+ end
+
+ describe "Section 8.6.4 - Release readiness scenarios" do
+ test "8.6.4.1 - release readiness and CI gate validations pass" do
+ output = run_shell!("./scripts/validate_release_readiness.sh")
+
+ assert String.contains?(output, "Release readiness validation passed.")
+ end
+
+ test "8.6.4.2 - documentation governance is complete" do
+ output = run_shell!("./scripts/validate_guides_governance.sh")
+
+ assert String.contains?(output, "Guides governance validation passed.")
+ assert File.exists?(project_path("README.md"))
+ assert File.exists?(project_path("guides/user/UG-0001-getting-started.md"))
+ assert File.exists?(project_path("guides/developer/DG-0001-architecture-overview.md"))
+ end
+
+ test "8.6.4.3 - telemetry is configured with canonical events and dashboards" do
+ Telemetry.attach_default_handlers()
+ Telemetry.emit(:screen, :mount, %{count: 1, duration: 10}, %{status: :ok})
+
+ snapshot = Telemetry.snapshot()
+ event_names = Enum.map(Telemetry.events(), & &1.event_name)
+
+ assert [:ash_ui, :screen, :mount] in event_names
+ assert [:ash_ui, :binding, :evaluate] in event_names
+ assert Map.has_key?(snapshot.dashboards, :screen_performance)
+ assert snapshot.dashboards.screen_performance.mount_count >= 1
+ end
+
+ test "8.6.4.4 - rollback procedure validation succeeds" do
+ output = run_shell!("./scripts/test_rollback_procedure.sh")
+
+ assert String.contains?(output, "Rollback procedure validation passed.")
+ end
+ end
+
+ defp build_socket(assigns) do
+ %Phoenix.LiveView.Socket{
+ assigns: Enum.into(assigns, %{__changed__: %{}})
+ }
+ end
+
+ defp build_admin(id \\ "admin-1") do
+ %{id: id, role: :admin, active: true}
+ end
+
+ defp create_screen(name_atom) do
+ {:ok, screen} =
+ Ash.create(Screen,
+ %{
+ name: Atom.to_string(name_atom),
+ route: "/#{Atom.to_string(name_atom)}",
+ layout: :column,
+ unified_dsl:
+ Builder.column(
+ spacing: 12,
+ children: [
+ Builder.text("Phase 8 Screen", size: 18, weight: :bold),
+ Builder.button("Save", on_click: "save-profile")
+ ]
+ )
+ |> Builder.to_store(),
+ metadata: %{"title" => "Phase 8"}
+ },
+ domain: Domain
+ )
+
+ screen
+ end
+
+ defp in_memory_screen(name) do
+ %Screen{
+ id: Ecto.UUID.generate(),
+ name: name,
+ layout: :column,
+ version: 1,
+ unified_dsl:
+ Builder.column(
+ spacing: 8,
+ children: [
+ Builder.text("In-memory screen"),
+ Builder.button("Compile")
+ ]
+ )
+ |> Builder.to_store(),
+ metadata: %{}
+ }
+ end
+
+ defp extract_ids(path, regex) do
+ path
+ |> File.read!()
+ |> then(&Regex.scan(regex, &1))
+ |> List.flatten()
+ end
+
+ defp project_path(path) do
+ Path.expand(path, root_dir())
+ end
+
+ defp root_dir do
+ Path.expand("../..", __DIR__)
+ end
+
+ defp temp_dir(prefix) do
+ path =
+ Path.join(
+ System.tmp_dir!(),
+ "#{prefix}-#{System.unique_integer([:positive])}"
+ )
+
+ File.mkdir_p!(path)
+ path
+ end
+
+ defp run_shell!(command, extra_env \\ %{}) do
+ env =
+ %{
+ "RELEASE_REPORT_DIR" => temp_dir("release-report"),
+ "ROLLBACK_REPORT_DIR" => temp_dir("rollback-report")
+ }
+ |> Map.merge(extra_env)
+ |> Enum.to_list()
+
+ {output, status} = System.cmd("bash", ["-lc", command], cd: root_dir(), env: env)
+ assert status == 0, output
+ output
+ end
+end
diff --git a/test/ash_ui/relationship_integration_test.exs b/test/ash_ui/relationship_integration_test.exs
index cfbb7f5e..258e7740 100644
--- a/test/ash_ui/relationship_integration_test.exs
+++ b/test/ash_ui/relationship_integration_test.exs
@@ -5,6 +5,8 @@ defmodule AshUI.RelationshipIntegrationTest do
alias AshUI.Resources.Element
alias AshUI.Resources.Binding
+ @moduletag :conformance
+
setup do
# Create a screen with multiple elements and bindings
{:ok, screen} =
@@ -74,7 +76,7 @@ defmodule AshUI.RelationshipIntegrationTest do
screen_with_elements =
AshUI.Domain.read_one!(Screen,
filter: [id: screen.id],
- load: [elements: [sort: [position: :asc]]]
+ load: [elements: Ash.Query.sort(Element, position: :asc)]
)
positions = Enum.map(screen_with_elements.elements, & &1.position)
@@ -165,7 +167,7 @@ defmodule AshUI.RelationshipIntegrationTest do
# Each element should have 2 bindings
total_bindings =
screen_with_all.elements
- |> Enum.map(&length/1)
+ |> Enum.map(&(length(&1.bindings)))
|> Enum.sum()
assert total_bindings == 6
diff --git a/test/ash_ui/rendering/phase_7_integration_test.exs b/test/ash_ui/rendering/phase_7_integration_test.exs
index 2fc511d0..e4a843a5 100644
--- a/test/ash_ui/rendering/phase_7_integration_test.exs
+++ b/test/ash_ui/rendering/phase_7_integration_test.exs
@@ -5,6 +5,7 @@ defmodule AshUI.Rendering.Phase7IntegrationTest do
alias AshUI.Compilation.IUR
@moduletag :integration
+ @moduletag :conformance
describe "Section 7.6.1 - LiveUI integration scenarios" do
test "7.6.1.1 - Verify canonical IUR renders to valid HEEx" do
diff --git a/test/ash_ui/resources/binding_test.exs b/test/ash_ui/resources/binding_test.exs
index 994520e6..6334e6e5 100644
--- a/test/ash_ui/resources/binding_test.exs
+++ b/test/ash_ui/resources/binding_test.exs
@@ -5,6 +5,8 @@ defmodule AshUI.Resources.BindingTest do
alias AshUI.Resources.Element
alias AshUI.Resources.Binding
+ @moduletag :conformance
+
setup do
{:ok, screen} =
AshUI.Domain.create(Screen,
@@ -140,7 +142,7 @@ defmodule AshUI.Resources.BindingTest do
{:ok, binding} = AshUI.Domain.create(Binding, attrs: attrs)
# Delete screen
- {:ok, _} = AshUI.Domain.destroy(screen)
+ :ok = AshUI.Domain.destroy(screen)
# Element should be deleted
assert [] = AshUI.Domain.read!(Element, filter: [id: element.id])
diff --git a/test/ash_ui/resources/element_test.exs b/test/ash_ui/resources/element_test.exs
index 6ee82524..8bf71b60 100644
--- a/test/ash_ui/resources/element_test.exs
+++ b/test/ash_ui/resources/element_test.exs
@@ -4,6 +4,8 @@ defmodule AshUI.Resources.ElementTest do
alias AshUI.Resources.Screen
alias AshUI.Resources.Element
+ @moduletag :conformance
+
describe "Element CRUD operations" do
setup do
{:ok, screen} =
@@ -56,7 +58,7 @@ defmodule AshUI.Resources.ElementTest do
}
{:ok, element} = AshUI.Domain.create(Element, attrs: attrs)
- assert {:ok, _} = AshUI.Domain.destroy(element)
+ assert :ok = AshUI.Domain.destroy(element)
assert [] = AshUI.Domain.read!(Element, filter: [id: element.id])
end
diff --git a/test/ash_ui/resources/screen_test.exs b/test/ash_ui/resources/screen_test.exs
index 133a4acc..96f02c99 100644
--- a/test/ash_ui/resources/screen_test.exs
+++ b/test/ash_ui/resources/screen_test.exs
@@ -5,6 +5,8 @@ defmodule AshUI.Resources.ScreenTest do
alias AshUI.Resources.Element
alias AshUI.Resources.Binding
+ @moduletag :conformance
+
describe "Screen CRUD operations" do
test "create/1 creates a screen with unified_dsl storage" do
attrs = %{
@@ -64,7 +66,7 @@ defmodule AshUI.Resources.ScreenTest do
}
{:ok, screen} = AshUI.Domain.create(Screen, attrs: attrs)
- assert {:ok, _} = AshUI.Domain.destroy(screen)
+ assert :ok = AshUI.Domain.destroy(screen)
assert [] = AshUI.Domain.read!(Screen, filter: [name: "destroy_test"])
end
@@ -81,7 +83,7 @@ defmodule AshUI.Resources.ScreenTest do
{:ok, _screen} = AshUI.Domain.create(Screen, attrs: attrs)
assert {:error, error} = AshUI.Domain.create(Screen, attrs: attrs)
- assert {:name, _} = hd(Ash.Error.errors(error))
+ assert Exception.message(error) =~ "constraint error"
end
end
end
diff --git a/test/ash_ui/telemetry_test.exs b/test/ash_ui/telemetry_test.exs
new file mode 100644
index 00000000..21714772
--- /dev/null
+++ b/test/ash_ui/telemetry_test.exs
@@ -0,0 +1,159 @@
+defmodule AshUI.TelemetryTest do
+ use ExUnit.Case, async: false
+
+ alias AshUI.Compiler
+ alias AshUI.Rendering.LiveUIAdapter
+ alias AshUI.Resources.Screen
+ alias AshUI.Runtime.BindingEvaluator
+ alias AshUI.Telemetry
+
+ setup do
+ Telemetry.reset_metrics()
+ :ok
+ end
+
+ test "defines the required phase 8 telemetry events" do
+ event_names = Enum.map(Telemetry.events(), & &1.event_name)
+
+ assert [:ash_ui, :screen, :mount] in event_names
+ assert [:ash_ui, :screen, :unmount] in event_names
+ assert [:ash_ui, :binding, :evaluate] in event_names
+ assert [:ash_ui, :render, :complete] in event_names
+ end
+
+ test "binding evaluation emits canonical telemetry with duration" do
+ handler_id = "binding-evaluate-#{System.unique_integer([:positive])}"
+
+ :telemetry.attach(
+ handler_id,
+ [:ash_ui, :binding, :evaluate],
+ fn _, measurements, metadata, _ ->
+ send(self(), {:binding_event, measurements, metadata})
+ end,
+ :ok
+ )
+
+ on_exit(fn -> :telemetry.detach(handler_id) end)
+
+ binding = %{
+ id: "binding-telemetry",
+ source: %{"resource" => "User", "field" => "name"},
+ target: "name-input",
+ binding_type: :value
+ }
+
+ assert {:ok, _value} =
+ BindingEvaluator.evaluate(binding, %{user_id: "user-1", params: %{}, assigns: %{}})
+
+ assert_receive {:binding_event, measurements, metadata}
+ assert is_integer(measurements.duration)
+ assert metadata.binding_id == "binding-telemetry"
+ assert metadata.status == :ok
+ end
+
+ test "compiler emits compile lifecycle telemetry" do
+ start_handler_id = "compile-start-#{System.unique_integer([:positive])}"
+ end_handler_id = "compile-end-#{System.unique_integer([:positive])}"
+
+ :telemetry.attach(
+ start_handler_id,
+ [:ash_ui, :compilation, :compile_start],
+ fn _, measurements, metadata, _ ->
+ send(self(), {:compile_start, measurements, metadata})
+ end,
+ :ok
+ )
+
+ :telemetry.attach(
+ end_handler_id,
+ [:ash_ui, :compilation, :compile_end],
+ fn _, measurements, metadata, _ ->
+ send(self(), {:compile_end, measurements, metadata})
+ end,
+ :ok
+ )
+
+ on_exit(fn ->
+ :telemetry.detach(start_handler_id)
+ :telemetry.detach(end_handler_id)
+ end)
+
+ screen = %Screen{
+ id: "screen-telemetry",
+ name: "Telemetry Screen",
+ unified_dsl: %{
+ type: "row",
+ props: %{},
+ children: [],
+ signals: [],
+ metadata: %{}
+ },
+ metadata: %{},
+ version: 1
+ }
+
+ assert {:ok, _compiled} = Compiler.compile(screen, use_cache: false)
+
+ assert_receive {:compile_start, _measurements, start_metadata}
+ assert start_metadata.resource_id == "screen-telemetry"
+
+ assert_receive {:compile_end, measurements, end_metadata}
+ assert is_integer(measurements.duration)
+ assert end_metadata.status == :ok
+ end
+
+ test "render completion updates the in-memory telemetry snapshot" do
+ handler_id = "render-complete-#{System.unique_integer([:positive])}"
+
+ :telemetry.attach(
+ handler_id,
+ [:ash_ui, :render, :complete],
+ fn _, measurements, metadata, _ ->
+ send(self(), {:render_complete, measurements, metadata})
+ end,
+ :ok
+ )
+
+ on_exit(fn -> :telemetry.detach(handler_id) end)
+
+ canonical_iur = %{
+ "type" => "screen",
+ "id" => "render-screen",
+ "name" => "Render Screen",
+ "children" => [],
+ "bindings" => [],
+ "metadata" => %{}
+ }
+
+ assert {:ok, _rendered} = LiveUIAdapter.render(canonical_iur)
+
+ assert_receive {:render_complete, measurements, metadata}
+ assert is_integer(measurements.duration)
+ assert metadata.renderer == :live_ui
+
+ snapshot = Telemetry.snapshot()
+ assert snapshot.dashboards.renderer_usage.live_ui >= 1
+ assert snapshot.dashboards.screen_performance.render_count >= 1
+ end
+
+ test "dashboard definitions are present and valid json" do
+ dashboard_dir = "/Users/Pascal/code/ash/ash_ui/priv/monitoring/dashboards"
+
+ expected_files = [
+ "screen_performance.json",
+ "error_rate.json",
+ "authorization_failures.json",
+ "renderer_usage.json"
+ ]
+
+ Enum.each(expected_files, fn file_name ->
+ path = Path.join(dashboard_dir, file_name)
+
+ assert {:ok, body} = File.read(path)
+ assert {:ok, definition} = Jason.decode(body)
+ assert is_binary(definition["title"])
+ assert is_list(definition["panels"])
+ assert definition["panels"] != []
+ end)
+ end
+end
diff --git a/test/support/mock_user_resources.ex b/test/support/mock_user_resources.ex
new file mode 100644
index 00000000..86235175
--- /dev/null
+++ b/test/support/mock_user_resources.ex
@@ -0,0 +1,11 @@
+defmodule User.Profile do
+ @moduledoc false
+
+ defstruct [:id]
+end
+
+defmodule User.Settings do
+ @moduledoc false
+
+ defstruct [:id]
+end