textus 0.26.0 → 0.30.0

data/lib/textus/application/write/mv.rb

@@ -1,118 +0,0 @@
-module Textus
-  module Application
-    module Write
-      module Mv
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            reader: session.envelope_reader,
-            writer: session.envelope_writer,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:, reader:, writer:, hook_context:)
-            @ctx          = ctx
-            @manifest     = caps.manifest
-            @events       = caps.events
-            @authorizer   = caps.authorizer
-            @reader       = reader
-            @writer       = writer
-            @hook_context = hook_context
-          end
-
-          def call(old_key, new_key, dry_run: false)
-            old_res, new_res = prepare(old_key, new_key)
-            return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
-
-            ensure_uid!(old_key, old_res.entry)
-            envelope = @writer.move(
-              from_key: old_key, to_key: new_key,
-              new_mentry: new_res.entry
-            )
-            publish_renamed(old_key, new_key, envelope)
-            success_result(old_key, new_key, old_res, new_res, envelope)
-          end
-
-          private
-
-          def prepare(old_key, new_key)
-            Textus::Manifest::Data.validate_key!(old_key)
-            Textus::Manifest::Data.validate_key!(new_key)
-            raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
-
-            old_res = @manifest.resolver.resolve(old_key)
-            new_res = @manifest.resolver.resolve(new_key)
-            raise UnknownKey.new(old_key) unless @reader.exists?(old_key)
-
-            validate_zone_and_format!(old_res.entry, new_res.entry)
-            @authorizer.authorize_write!(old_res.entry, role: @ctx.role)
-            @authorizer.authorize_write!(new_res.entry, role: @ctx.role)
-            raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if @reader.exists?(new_key)
-
-            [old_res, new_res]
-          end
-
-          def validate_zone_and_format!(old_mentry, new_mentry)
-            if old_mentry.zone != new_mentry.zone
-              raise UsageError.new(
-                "mv: cross-zone move refused (#{old_mentry.zone} → #{new_mentry.zone}). " \
-                "Use put+delete for cross-zone moves.",
-              )
-            end
-            return if old_mentry.format == new_mentry.format
-
-            raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
-          end
-
-          # If the source file lacks a UID, rewrite it in-place via the writer
-          # so a UID gets injected before the move. This produces one "put"
-          # audit row, then the "mv" row from Writer#move.
-          def ensure_uid!(old_key, old_mentry)
-            pre_env = @reader.read(old_key)
-            return if pre_env.uid
-
-            @writer.put(
-              old_key, mentry: old_mentry,
-                       payload: Textus::Application::Envelope::Writer::Payload.new(
-                         meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
-                       )
-            )
-          end
-
-          def publish_renamed(old_key, new_key, envelope)
-            @events.publish(:entry_renamed,
-                            ctx: @hook_context,
-                            key: new_key,
-                            from_key: old_key,
-                            to_key: new_key,
-                            envelope: envelope)
-          end
-
-          def dry_run_result(old_key, new_key, old_res, new_res)
-            pre_env = @reader.read(old_key)
-            {
-              "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-              "from_key" => old_key, "to_key" => new_key,
-              "from_path" => old_res.path, "to_path" => new_res.path,
-              "uid" => pre_env.uid
-            }
-          end
-
-          def success_result(old_key, new_key, old_res, new_res, envelope)
-            {
-              "protocol" => PROTOCOL, "ok" => true,
-              "from_key" => old_key, "to_key" => new_key,
-              "from_path" => old_res.path, "to_path" => new_res.path,
-              "uid" => envelope.uid,
-              "envelope" => envelope.to_h_for_wire
-            }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:mv, Textus::Application::Write::Mv, caps: :write)

data/lib/textus/application/write/publish.rb

@@ -1,96 +0,0 @@
-module Textus
-  module Application
-    module Write
-      # Single-pass publish use case: dispatches polymorphically to each
-      # entry's `publish_via` method. Derived entries materialize their body
-      # via Materializer; Nested entries fan out via publish_each; Leaf and
-      # Intake entries copy their stored body to publish_to targets. The
-      # Publish layer owns wiring (context, accumulation) but not per-kind
-      # logic.
-      #
-      # Return shape: { "protocol", "built", "published_leaves" }
-      module Publish
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            rpc: session.rpc,
-            session: session,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:, rpc:, session:, hook_context:)
-            @ctx          = ctx
-            @caps         = caps
-            @manifest     = caps.manifest
-            @file_store   = caps.file_store
-            @events       = caps.events
-            @root         = caps.root
-            @rpc          = rpc
-            @session      = session
-            @hook_context = hook_context
-          end
-
-          def call(prefix: nil)
-            built  = []
-            leaves = []
-            context = build_context
-
-            @manifest.data.entries.each do |mentry|
-              next if prefix && !entry_matches_prefix?(mentry, prefix)
-
-              result = mentry.publish_via(context, prefix: prefix)
-              next if result.nil?
-
-              case result[:kind]
-              when :built  then built << result[:value]
-              when :leaves then leaves.concat(result[:value])
-              end
-            end
-
-            { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => leaves }
-          end
-
-          private
-
-          def build_context
-            Textus::Manifest::Entry::Base::PublishContext.new(
-              repo_root: File.dirname(@root),
-              manifest: @manifest,
-              file_store: @file_store,
-              root: @root,
-              caps: @caps,
-              rpc: @rpc,
-              session: @session,
-              ctx: @ctx,
-              bus: @events,
-              hook_context: @hook_context,
-              reader: reader,
-              emit: ->(event, **payload) { @events.publish(event, ctx: @hook_context, **payload) },
-            )
-          end
-
-          # Whether the entry should be processed for the given prefix filter.
-          def entry_matches_prefix?(mentry, prefix)
-            return true unless prefix
-
-            case mentry
-            when Textus::Manifest::Entry::Nested
-              mentry.key.start_with?(prefix) ||
-                prefix.start_with?("#{mentry.key}.")
-            else
-              mentry.key.start_with?(prefix)
-            end
-          end
-
-          def reader
-            @reader ||= Textus::Application::Read::Get::Impl.new(ctx: @ctx, caps: @caps)
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:publish, Textus::Application::Write::Publish, caps: :write)

data/lib/textus/application/write/put.rb

@@ -1,49 +0,0 @@
-module Textus
-  module Application
-    module Write
-      module Put
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            writer: session.envelope_writer,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:, writer:, hook_context:)
-            @ctx          = ctx
-            @manifest     = caps.manifest
-            @events       = caps.events
-            @authorizer   = caps.authorizer
-            @writer       = writer
-            @hook_context = hook_context
-          end
-
-          def call(key, meta: nil, body: nil, content: nil, if_etag: nil)
-            Textus::Manifest::Data.validate_key!(key)
-            mentry = @manifest.resolver.resolve(key).entry
-
-            @authorizer.authorize_write!(mentry, role: @ctx.role)
-
-            envelope = @writer.put(
-              key,
-              mentry: mentry,
-              payload: Textus::Application::Envelope::Writer::Payload.new(meta: meta, body: body, content: content),
-              if_etag: if_etag,
-            )
-
-            @events.publish(:entry_put,
-                            ctx: @hook_context,
-                            key: key,
-                            envelope: envelope)
-
-            envelope
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:put, Textus::Application::Write::Put, caps: :write)

data/lib/textus/application/write/refresh_all.rb

@@ -1,63 +0,0 @@
-module Textus
-  module Application
-    module Write
-      module RefreshAll
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            rpc: session.rpc,
-            writer: session.envelope_writer,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:, rpc:, writer:, hook_context:)
-            @ctx          = ctx
-            @caps         = caps
-            @rpc          = rpc
-            @writer       = writer
-            @hook_context = hook_context
-          end
-
-          def call(prefix: nil, zone: nil)
-            worker = Textus::Application::Write::RefreshWorker::Impl.new(
-              ctx: @ctx, caps: @caps, rpc: @rpc, writer: @writer,
-              hook_context: @hook_context
-            )
-
-            stale_rows = Textus::Application::Read::Stale::Impl.new(caps: @caps).call(prefix: prefix, zone: zone)
-            refreshed = []
-            failed = []
-            skipped = []
-
-            stale_rows.each do |row|
-              key = row["key"] || row[:key]
-              reason = row["reason"] || row[:reason]
-              if reason.to_s.match?(/ttl exceeded|never refreshed/)
-                begin
-                  worker.run(key)
-                  refreshed << key
-                rescue Textus::Error => e
-                  failed << { "key" => key, "error" => e.message }
-                end
-              else
-                skipped << { "key" => key, "reason" => reason }
-              end
-            end
-
-            {
-              "protocol" => Textus::PROTOCOL,
-              "ok" => failed.empty?,
-              "refreshed" => refreshed,
-              "failed" => failed,
-              "skipped" => skipped,
-            }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:refresh_all, Textus::Application::Write::RefreshAll, caps: :write)

data/lib/textus/application/write/refresh_orchestrator.rb

@@ -1,102 +0,0 @@
-module Textus
-  module Application
-    module Write
-      class RefreshOrchestrator
-        def initialize(worker:, store_root:, events:, ctx: nil, hook_context: nil, detached_spawner: nil)
-          @worker       = worker
-          @store_root   = store_root
-          @events       = events
-          @ctx          = ctx
-          @hook_context = hook_context
-          @detached_spawner = detached_spawner || default_spawner
-        end
-
-        def execute(action, key:)
-          case action
-          when Textus::Domain::Action::Return       then Textus::Domain::Outcome::Skipped.new
-          when Textus::Domain::Action::RefreshSync  then run_sync(key)
-          when Textus::Domain::Action::RefreshTimed then run_timed(action.budget_ms, key)
-          else raise ArgumentError.new("unknown action: #{action.inspect}")
-          end
-        end
-
-        private
-
-        def run_sync(key)
-          envelope = @worker.run(key)
-          Textus::Domain::Outcome::Refreshed.new(envelope: envelope)
-        rescue Textus::Error => e
-          Textus::Domain::Outcome::Failed.new(error: e)
-        end
-
-        def run_timed(budget_ms, key)
-          return run_timed_with_fork(budget_ms, key) if Textus::Infra::Refresh::Detached.supported?
-
-          run_timed_cooperative(budget_ms, key)
-        end
-
-        def run_timed_cooperative(budget_ms, key)
-          result = nil
-          thread = Thread.new do
-            result = @worker.run(key)
-          rescue Textus::Error => e
-            result = e
-          end
-
-          thread.join(budget_ms / 1000.0)
-          if thread.alive?
-            thread.kill
-            return Textus::Domain::Outcome::Failed.new(
-              error: Textus::UsageError.new(
-                "refresh exceeded budget #{budget_ms}ms (no fork available — cooperative cancel)",
-              ),
-            )
-          end
-
-          if result.is_a?(Textus::Error)
-            Textus::Domain::Outcome::Failed.new(error: result)
-          else
-            Textus::Domain::Outcome::Refreshed.new(envelope: result)
-          end
-        end
-
-        def run_timed_with_fork(budget_ms, key)
-          result = nil
-          thread = Thread.new do
-            result = @worker.run(key)
-          rescue Textus::Error => e
-            result = e
-          end
-
-          thread.join(budget_ms / 1000.0)
-
-          if thread.alive?
-            thread.kill
-
-            # Single-flight: if a sibling process / earlier fork holds the
-            # per-leaf lock, don't fork another worker — they're already
-            # doing this work.
-            probe = Textus::Infra::Refresh::Lock.new(root: @store_root, key: key)
-            return Textus::Domain::Outcome::Detached.new unless probe.try_acquire
-
-            probe.release
-
-            payload = { key: key, started_at: Time.now.utc.iso8601, budget_ms: budget_ms }
-            payload[:ctx] = @hook_context if @hook_context
-            @events.publish(:refresh_backgrounded, **payload)
-            @detached_spawner.call(store_root: @store_root, key: key)
-            Textus::Domain::Outcome::Detached.new
-          elsif result.is_a?(Textus::Error)
-            Textus::Domain::Outcome::Failed.new(error: result)
-          else
-            Textus::Domain::Outcome::Refreshed.new(envelope: result)
-          end
-        end
-
-        def default_spawner
-          Textus::Infra::Refresh::Detached.method(:spawn)
-        end
-      end
-    end
-  end
-end

data/lib/textus/application/write/refresh_worker.rb

@@ -1,134 +0,0 @@
-require "timeout"
-
-module Textus
-  module Application
-    module Write
-      module RefreshWorker
-        FETCH_TIMEOUT_SECONDS = 30
-
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            rpc: session.rpc,
-            writer: session.envelope_writer,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:, rpc:, writer:, hook_context:)
-            @ctx          = ctx
-            @caps         = caps
-            @manifest     = caps.manifest
-            @writer       = writer
-            @events       = caps.events
-            @rpc          = rpc
-            @authorizer   = caps.authorizer
-            @hook_context = hook_context
-          end
-
-          # call(key) is the primary entry; run is kept as an alias for
-          # Orchestrator and RefreshAll which call worker.run(key).
-          def call(key)
-            run(key)
-          end
-
-          def run(key)
-            res = @manifest.resolver.resolve(key)
-            mentry = res.entry
-            path = res.path
-            remaining = res.remaining
-            raise UsageError.new("no intake declared for '#{key}'") unless mentry.is_a?(Textus::Manifest::Entry::Intake)
-
-            before_etag = File.exist?(path) ? Etag.for_file(path) : nil
-            result = fetch_with_events(key, mentry, remaining)
-            persist_and_notify(key, mentry, result, before_etag)
-          end
-
-          private
-
-          def fetch_timeout_for(key)
-            rule = @manifest.rules.for(key)
-            rule&.refresh&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
-          end
-
-          def fetch_with_events(key, mentry, remaining)
-            @events.publish(:refresh_started, ctx: @hook_context, key: key, mode: :sync)
-            call_intake(key, mentry, remaining)
-          end
-
-          def call_intake(key, mentry, remaining)
-            timeout = fetch_timeout_for(key)
-            Timeout.timeout(timeout) do
-              @rpc.invoke(:resolve_intake, mentry.handler,
-                          caps: @caps,
-                          config: mentry.config,
-                          args: { trigger_key: key, leaf_segments: remaining || [] })
-            end
-          rescue Timeout::Error
-            @events.publish(:refresh_failed, ctx: @hook_context, key: key,
-                                             error_class: "Timeout::Error",
-                                             error_message: "intake '#{mentry.handler}' exceeded #{timeout}s")
-            raise UsageError.new("intake '#{mentry.handler}' exceeded #{timeout}s timeout")
-          rescue Textus::Error => e
-            @events.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
-                                             error_message: e.message)
-            raise
-          rescue StandardError => e
-            @events.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
-                                             error_message: e.message)
-            raise UsageError.new("intake '#{mentry.handler}' raised: #{e.class}: #{e.message}")
-          end
-
-          def persist_and_notify(key, mentry, result, before_etag)
-            normalized = RefreshWorker.send(:normalize_action_result, result, format: mentry.format)
-            @authorizer.authorize_write!(mentry, role: @ctx.role)
-            envelope = @writer.put(
-              key,
-              mentry: mentry,
-              payload: Textus::Application::Envelope::Writer::Payload.new(
-                meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
-              ),
-            )
-            change = detect_change(before_etag, envelope)
-            @events.publish(:entry_refreshed, ctx: @hook_context, key: key, envelope: envelope, change: change) unless change == :unchanged
-            envelope
-          end
-
-          def detect_change(before_etag, envelope)
-            if before_etag.nil? then :created
-            elsif envelope.etag == before_etag then :unchanged
-            else :updated
-            end
-          end
-        end
-
-        def self.normalize_action_result(res, format:)
-          res = res.transform_keys(&:to_s) if res.is_a?(Hash)
-          res ||= {}
-          meta_val = res["_meta"]
-          body     = res["body"]
-          content  = res["content"]
-
-          case format
-          when "markdown" then { meta: meta_val || {}, body: body.to_s, content: nil }
-          when "text"     then { meta: {}, body: body.to_s, content: nil }
-          when "json", "yaml"
-            if !content.nil?
-              { meta: meta_val || {}, body: nil, content: content }
-            elsif !body.nil?
-              { meta: {}, body: body.to_s, content: nil }
-            else
-              raise Textus::UsageError.new("intake for #{format} returned neither content nor body")
-            end
-          else
-            raise Textus::UsageError.new("unknown format #{format.inspect}")
-          end
-        end
-        private_class_method :normalize_action_result
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:refresh, Textus::Application::Write::RefreshWorker, caps: :write)

data/lib/textus/application/write/reject.rb

@@ -1,62 +0,0 @@
-require_relative "authority_gate"
-
-module Textus
-  module Application
-    module Write
-      module Reject
-        def self.call(*, session:, ctx:, caps:, **)
-          Impl.new(
-            ctx: ctx, caps: caps,
-            writer: session.envelope_writer,
-            hook_context: session.hook_context
-          ).call(*, **)
-        end
-
-        class Impl
-          include AuthorityGate
-
-          def initialize(ctx:, caps:, writer:, hook_context:)
-            @ctx          = ctx
-            @caps         = caps
-            @manifest     = caps.manifest
-            @writer       = writer
-            @events       = caps.events
-            @authorizer   = caps.authorizer
-            @hook_context = hook_context
-          end
-
-          def call(pending_key)
-            assert_accept_authority!("reject")
-
-            mentry = @manifest.resolver.resolve(pending_key).entry
-            unless mentry.in_proposal_zone?
-              raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})")
-            end
-
-            env = Textus::Application::Read::Get::Impl.new(
-              ctx: @ctx, caps: @caps,
-            ).call(pending_key)
-            proposal = env.meta&.dig("proposal") or
-              raise ProposalError.new("entry has no proposal block: #{pending_key}")
-            target_key = proposal["target_key"] or
-              raise ProposalError.new("proposal missing target_key")
-
-            Textus::Application::Write::Delete::Impl.new(
-              ctx: @ctx, caps: @caps, writer: @writer,
-              hook_context: @hook_context
-            ).call(pending_key, suppress_events: true)
-
-            @events.publish(:proposal_rejected,
-                            ctx: @hook_context,
-                            key: pending_key,
-                            target_key: target_key)
-
-            { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:reject, Textus::Application::Write::Reject, caps: :write)