igniter 0.5.0 → 0.5.1

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/renderer.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class Renderer < Igniter::Frontend::Component
+      require "igniter-frontend"
+
+      def self.render(schema:, **kwargs)
+        new(schema: schema, **kwargs).render
+      end
+
+      def initialize(schema:, action_resolver: nil, values: {}, errors: {}, notice: nil)
+        @schema = schema.is_a?(Schema) ? schema : Schema.load(schema)
+        @action_resolver = action_resolver
+        @values = stringify_keys(values)
+        @errors = stringify_keys(errors)
+        @notice = notice
+      end
+
+      def call(view)
+        view.raw(
+          Igniter::Frontend::Tailwind.render_page(
+            title: schema.title,
+            lang: schema.meta.fetch("lang", "en"),
+            theme: :schema
+          ) do |main|
+            meta_hint = schema.meta["description"] || schema.meta["subtitle"]
+            main.component(ui_theme.schema_hero(title: schema.title, description: meta_hint))
+
+            main.component(Igniter::Frontend::Tailwind::UI::SubmissionNotice.new(message: notice, tone: :notice, tag: :div)) if notice
+            render_node(main, schema.layout)
+          end
+        )
+      end
+
+      private
+
+      attr_reader :schema, :action_resolver, :values, :errors, :notice
+
+      def render_node(view, node) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        case node.fetch("type")
+        when "stack"
+          render_container(view, :section, node, class_name: "view-stack")
+        when "grid"
+          render_container(view, :section, node, class_name: "view-grid")
+        when "section"
+          render_container(view, :section, node, class_name: "view-section")
+        when "card"
+          render_container(view, :article, node, class_name: "view-card")
+        when "notice"
+          view.component(Igniter::Frontend::Tailwind::UI::SubmissionNotice.new(message: node.fetch("message"), tone: notice_tone(node["tone"]), tag: :div))
+        when "heading"
+          level = [[node.fetch("level", 1).to_i, 1].max, 6].min
+          view.tag(:"h#{level}", node.fetch("text"), class: heading_classes(level))
+        when "text"
+          view.component(ui_theme.schema_intro(text: node.fetch("text"), tone: node.fetch("tone", nil)))
+        when "form"
+          render_form(view, node)
+        when "input", "textarea", "select", "checkbox", "submit"
+          raise ArgumentError, "field node #{node["type"]} must be nested inside a form"
+        else
+          raise ArgumentError, "unsupported node type: #{node["type"]}"
+        end
+      end
+
+      def render_container(view, tag_name, node, class_name:)
+        case class_name
+        when "view-stack"
+          view.component(ui_theme.schema_stack { |container| render_children(container, node) })
+        when "view-grid"
+          view.component(ui_theme.schema_grid { |container| render_children(container, node) })
+        when "view-section"
+          view.component(ui_theme.schema_section(tag: tag_name) { |container| render_children(container, node) })
+        when "view-card"
+          view.component(ui_theme.schema_card { |container| render_children(container, node) })
+        else
+          view.tag(tag_name, class: class_name) { |container| render_children(container, node) }
+        end
+      end
+
+      def render_children(container, node)
+        Array(node["children"]).each { |child| render_node(container, child) }
+      end
+
+      def render_form(view, node)
+        action = resolve_action(node.fetch("action"))
+        method = action.fetch("method", "post")
+        path = action.fetch("path")
+
+        view.component(
+          ui_theme.schema_form(action: path, method: method, hidden_action: node.fetch("action")) do |form, fieldset|
+            Array(node["children"]).each { |child| render_form_child(form, fieldset, child, inline_actions: false) }
+          end
+        )
+      end
+
+      def render_form_child(form, target, node, inline_actions:)
+        field_name = node["name"]
+        field_error = field_name ? errors[field_name] : nil
+        error_class = field_error ? "view-input-error" : nil
+
+        case node.fetch("type")
+        when "fieldset"
+          target.component(
+            ui_theme.schema_fieldset(legend: node["legend"], description: node["description"]) do |fieldset|
+              Array(node["children"]).each do |child|
+                render_form_child(form, fieldset, child, inline_actions: false)
+              end
+            end
+          )
+          when "notice"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::SubmissionNotice.new(message: node.fetch("message"), tone: notice_tone(node["tone"]), tag: :div)
+            )
+          when "actions"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::InlineActions.new do |actions|
+                Array(node["children"]).each do |child|
+                  render_form_child(form, actions, child, inline_actions: true)
+                end
+            end
+          )
+        when "input"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::FieldGroup.new(id: dom_id(node), label: node.fetch("label"), error: field_error) do |field|
+                Igniter::Frontend::FormBuilder.new(field).input(
+                  node.fetch("name"),
+                id: dom_id(node),
+                placeholder: node["placeholder"],
+                value: value_for(node),
+                required: node["required"],
+                class: [field_classes, error_class]
+              )
+            end
+          )
+        when "textarea"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::FieldGroup.new(id: dom_id(node), label: node.fetch("label"), error: field_error) do |field|
+                Igniter::Frontend::FormBuilder.new(field).textarea(
+                  node.fetch("name"),
+                id: dom_id(node),
+                value: value_for(node),
+                placeholder: node["placeholder"],
+                rows: node.fetch("rows", nil),
+                class: [field_classes, "min-h-28", error_class]
+              )
+            end
+          )
+        when "select"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::ChoiceField.new(
+                kind: :select,
+              name: node.fetch("name"),
+              id: dom_id(node),
+              label: node.fetch("label"),
+              error: field_error,
+              selected: value_for(node, fallback: node["selected"]),
+              options: Array(node["options"]).map { |option| [option.fetch("label"), option.fetch("value")] },
+              input_class: [field_classes, error_class]
+            )
+          )
+        when "checkbox"
+            target.component(
+              Igniter::Frontend::Tailwind::UI::ChoiceField.new(
+                kind: :checkbox,
+              name: node.fetch("name"),
+              id: dom_id(node),
+              label: node.fetch("label"),
+              error: field_error,
+              checked: checked_for(node),
+              value: node.fetch("value", "1"),
+              checkbox_label_class: checkbox_label_classes,
+              checkbox_class: checkbox_classes
+            )
+          )
+          when "submit"
+            if inline_actions
+              Igniter::Frontend::FormBuilder.new(target).submit(node.fetch("label"), class: submit_classes)
+            else
+              target.component(
+                Igniter::Frontend::Tailwind::UI::InlineActions.new do |actions|
+                  Igniter::Frontend::FormBuilder.new(actions).submit(node.fetch("label"), class: submit_classes)
+                end
+              )
+          end
+        when "text"
+          target.component(ui_theme.schema_intro(text: node.fetch("text"), tone: :muted))
+        else
+          raise ArgumentError, "unsupported form child: #{node["type"]}"
+        end
+      end
+
+      def resolve_action(action_id)
+        resolved = if action_resolver
+                     action_resolver.call(action_id.to_s)
+                   else
+                     schema.action(action_id)
+                   end
+
+        raise ArgumentError, "unknown schema action: #{action_id}" unless resolved.is_a?(Hash)
+
+        resolved.transform_keys(&:to_s)
+      end
+
+      def dom_id(node)
+        node.fetch("id", "view-#{node.fetch("name").tr("_", "-")}")
+      end
+
+      def value_for(node, fallback: node["value"])
+        values.key?(node.fetch("name")) ? values[node.fetch("name")] : fallback
+      end
+
+      def checked_for(node)
+        return values[node.fetch("name")] if values.key?(node.fetch("name"))
+
+        node.fetch("checked", false)
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, entry), memo| memo[key.to_s] = stringify_keys(entry) }
+        when Array
+          value.map { |entry| stringify_keys(entry) }
+        else
+          value
+        end
+      end
+
+      def checkbox_label_classes
+        ui_theme.checkbox_label_class
+      end
+
+      def checkbox_classes
+        ui_theme.checkbox_class
+      end
+
+      def field_classes
+        ui_theme.input_class
+      end
+
+        def submit_classes
+          Igniter::Frontend::Tailwind::UI::Tokens.action(variant: :primary, theme: :orange)
+        end
+
+      def notice_tone(value)
+        candidate = value.to_s.strip
+        candidate.empty? ? :notice : candidate.to_sym
+      end
+
+        def ui_theme
+          Igniter::Frontend::Tailwind::UI::Theme.fetch(:schema)
+        end
+
+      def heading_classes(level)
+        case level
+        when 1
+          "font-display text-3xl leading-tight text-white sm:text-4xl"
+        when 2
+          "font-display text-2xl text-white"
+        else
+          "font-display text-xl text-white"
+        end
+      end
+
+    end
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/schema.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class Schema
+      Error = Class.new(ArgumentError)
+
+      NODE_TYPES = %w[
+        stack
+        grid
+        section
+        card
+        fieldset
+        notice
+        actions
+        heading
+        text
+        form
+        input
+        textarea
+        select
+        checkbox
+        submit
+      ].freeze
+
+      def self.load(payload)
+        new(payload)
+      end
+
+      attr_reader :data
+
+      def initialize(payload)
+        @data = deep_stringify_keys(payload)
+        validate!
+      end
+
+      def id
+        data.fetch("id")
+      end
+
+      def version
+        data.fetch("version", 1)
+      end
+
+      def kind
+        data.fetch("kind")
+      end
+
+      def title
+        data.fetch("title")
+      end
+
+      def layout
+        data.fetch("layout")
+      end
+
+      def actions
+        data.fetch("actions", {})
+      end
+
+      def meta
+        data.fetch("meta", {})
+      end
+
+      def policy
+        data.fetch("policy", {})
+      end
+
+      def form_for_action(action_id)
+        find_node(layout) do |node|
+          node["type"] == "form" && node["action"].to_s == action_id.to_s
+        end
+      end
+
+      def to_h
+        Marshal.load(Marshal.dump(data))
+      end
+
+      def action(action_id)
+        actions.fetch(action_id.to_s, nil)
+      end
+
+      private
+
+      def validate!
+        raise Error, "schema must be a Hash" unless data.is_a?(Hash)
+        raise Error, "schema id is required" if blank?(data["id"])
+        raise Error, "schema kind must be 'page'" unless data["kind"] == "page"
+        raise Error, "schema title is required" if blank?(data["title"])
+        raise Error, "schema layout must be a Hash" unless data["layout"].is_a?(Hash)
+
+        validate_node!(data["layout"], path: "layout")
+      end
+
+      def validate_node!(node, path:)
+        raise Error, "#{path} must be a Hash" unless node.is_a?(Hash)
+
+        type = node["type"].to_s
+        raise Error, "#{path}.type is required" if type.empty?
+        raise Error, "#{path}.type '#{type}' is not supported" unless NODE_TYPES.include?(type)
+
+        case type
+        when "stack", "grid", "section", "card", "fieldset", "actions"
+          validate_children!(node, path: path)
+        when "heading"
+          raise Error, "#{path}.text is required" if blank?(node["text"])
+        when "notice"
+          raise Error, "#{path}.message is required" if blank?(node["message"])
+        when "text"
+          raise Error, "#{path}.text is required" if blank?(node["text"])
+        when "form"
+          raise Error, "#{path}.action is required" if blank?(node["action"])
+          validate_children!(node, path: path)
+        when "input", "textarea", "select", "checkbox"
+          raise Error, "#{path}.name is required" if blank?(node["name"])
+          raise Error, "#{path}.label is required" if blank?(node["label"])
+          validate_options!(node, path: path) if type == "select"
+        when "submit"
+          raise Error, "#{path}.label is required" if blank?(node["label"])
+        end
+      end
+
+      def validate_children!(node, path:)
+        children = node.fetch("children", [])
+        raise Error, "#{path}.children must be an Array" unless children.is_a?(Array)
+
+        children.each_with_index do |child, index|
+          validate_node!(child, path: "#{path}.children[#{index}]")
+        end
+      end
+
+      def validate_options!(node, path:)
+        options = node.fetch("options", [])
+        raise Error, "#{path}.options must be an Array" unless options.is_a?(Array)
+
+        options.each_with_index do |option, index|
+          unless option.is_a?(Hash) && !blank?(option["label"]) && option.key?("value")
+            raise Error, "#{path}.options[#{index}] must include label and value"
+          end
+        end
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def find_node(node, &block)
+        return node if block.call(node)
+
+        Array(node["children"]).each do |child|
+          found = find_node(child, &block)
+          return found if found
+        end
+
+        nil
+      end
+
+      def deep_stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), memo|
+            memo[key.to_s] = deep_stringify_keys(entry)
+          end
+        when Array
+          value.map { |entry| deep_stringify_keys(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "igniter/sdk/data"
+
+module Igniter
+  module SchemaRendering
+    class SchemaStore
+      DEFAULT_COLLECTION = "igniter_view_schemas"
+
+      def initialize(store: Igniter::Data.default_store, collection: DEFAULT_COLLECTION)
+        @store = store
+        @collection = collection.to_s
+      end
+
+      def put(payload)
+        schema = payload.is_a?(Schema) ? payload : Schema.load(payload)
+        @store.put(collection: @collection, key: schema.id, value: schema.to_h)
+        schema
+      end
+
+      def patch(id, patch:, increment_version: true)
+        current = fetch(id)
+        merged = SchemaPatcher.apply(current.to_h, patch)
+        merged["id"] ||= current.id
+        merged["kind"] ||= current.kind
+        merged["version"] = current.version.to_i + 1 if increment_version
+        put(merged)
+      end
+
+      def get(id)
+        payload = @store.get(collection: @collection, key: id.to_s)
+        payload ? Schema.load(payload) : nil
+      end
+
+      def fetch(id)
+        get(id) || raise(KeyError, "view schema not found: #{id}")
+      end
+
+      def delete(id)
+        payload = @store.delete(collection: @collection, key: id.to_s)
+        payload ? Schema.load(payload) : nil
+      end
+
+      def all
+        @store.all(collection: @collection).transform_values { |payload| Schema.load(payload) }
+      end
+
+      def reset!
+        @store.clear(collection: @collection)
+      end
+    end
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/submission_normalizer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class SubmissionNormalizer
+      class Error < ArgumentError
+        attr_reader :field_errors
+
+        def initialize(message = nil, field_errors: {})
+          super(message)
+          @field_errors = field_errors
+        end
+      end
+
+      def initialize(schema)
+        @schema = schema.is_a?(Schema) ? schema : Schema.load(schema)
+      end
+
+      def normalize(payload, action_id:)
+        form = schema.form_for_action(action_id)
+        raise Error, "no form found for action #{action_id}" unless form
+
+        source = stringify_keys(payload)
+        normalized = {}
+        field_errors = {}
+
+        each_form_field(form) do |field|
+          name = field.fetch("name")
+          begin
+            normalized[name] = normalize_field(field, source[name])
+          rescue Error => e
+            field_errors.merge!(e.field_errors)
+          end
+        end
+
+        raise Error.new("submission contains invalid values", field_errors: field_errors) unless field_errors.empty?
+
+        normalized
+      end
+
+      private
+
+      attr_reader :schema
+
+      def field_node?(node)
+        %w[input textarea select checkbox].include?(node["type"])
+      end
+
+      def each_form_field(node, &block)
+        return unless node.is_a?(Hash)
+
+        if field_node?(node)
+          yield node
+          return
+        end
+
+        Array(node["children"]).each do |child|
+          each_form_field(child, &block)
+        end
+      end
+
+      def normalize_field(field, raw_value)
+        name = field.fetch("name")
+        value =
+          case field["type"]
+          when "checkbox"
+            truthy?(raw_value)
+          else
+            normalize_scalar(raw_value)
+          end
+
+        case field["value_type"]
+        when "integer"
+          value.nil? ? nil : Integer(value, 10)
+        when "float"
+          value.nil? ? nil : Float(value)
+        when "boolean"
+          truthy?(value)
+        else
+          value
+        end
+      rescue ArgumentError
+        raise Error.new("invalid value for #{name}", field_errors: { name => "must be a valid #{field["value_type"]}" })
+      end
+
+      def normalize_scalar(value)
+        return nil if value.nil?
+
+        normalized = value.is_a?(Array) ? value.last : value
+        normalized = normalized.to_s.strip
+        normalized.empty? ? nil : normalized
+      end
+
+      def truthy?(value)
+        case value
+        when true, 1 then true
+        when false, nil, 0 then false
+        else
+          %w[1 true on yes].include?(value.to_s.strip.downcase)
+        end
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, entry), memo|
+            memo[key.to_s] = stringify_keys(entry)
+          end
+        when Array
+          value.map { |entry| stringify_keys(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/packages/igniter-schema-rendering/lib/igniter/schema_rendering/submission_processor.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Igniter
+  module SchemaRendering
+    class SubmissionProcessor
+      class << self
+        def call(schema:, action_id:, submission:)
+          new(schema: schema, action_id: action_id, submission: submission).call
+        end
+      end
+
+      def initialize(schema:, action_id:, submission:)
+        @schema = schema.is_a?(Schema) ? schema : Schema.load(schema)
+        @action_id = action_id.to_s
+        @submission = submission
+      end
+
+      def call
+        action = schema.action(action_id)
+        raise ArgumentError, "unknown schema action: #{action_id}" unless action.is_a?(Hash)
+
+        case action["type"].to_s
+        when "", "store_submission"
+          { "ok" => true, "type" => "store_submission" }
+        when "contract"
+          execute_contract(action)
+        else
+          raise ArgumentError, "unsupported schema action type: #{action["type"]}"
+        end
+      end
+
+      private
+
+      attr_reader :schema, :action_id, :submission
+
+      def execute_contract(action)
+        contract_class = Object.const_get(action.fetch("target"))
+        inputs = build_inputs(action.fetch("input_mapping", {}))
+        contract = contract_class.new(inputs).resolve
+
+        {
+          "ok" => contract.success?,
+          "type" => "contract",
+          "target" => action.fetch("target"),
+          "outputs" => present_outputs(contract)
+        }
+      end
+
+      def build_inputs(mapping)
+        mapping.each_with_object({}) do |(target_path, source_ref), memo|
+          assign_path!(memo, target_path.to_s, resolve_source(source_ref))
+        end
+      end
+
+      def resolve_source(source_ref)
+        ref = source_ref.to_s
+        case ref
+        when "$view.id"
+          schema.id
+        when "$view.version"
+          schema.version
+        when "$submission.id"
+          submission.fetch("id")
+        when "$submission.action_id"
+          submission.fetch("action_id")
+        else
+          submission.fetch("normalized_payload").fetch(ref, nil)
+        end
+      end
+
+      def assign_path!(memo, path, value)
+        keys = path.split(".")
+        leaf = keys.pop
+        cursor = memo
+        keys.each do |key|
+          cursor[key] ||= {}
+          cursor = cursor[key]
+        end
+        cursor[leaf] = value
+      end
+
+      def present_outputs(contract)
+        result = contract.result
+        outputs = contract.class.compiled_graph.outputs.map(&:name)
+        outputs.each_with_object({}) do |output_name, memo|
+          memo[output_name.to_s] = result.public_send(output_name)
+        end
+      end
+    end
+  end
+end