textus 0.26.0 → 0.29.0

data/lib/textus/application/read/rdeps.rb

@@ -1,35 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module Rdeps
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(caps:)
-            @manifest = caps.manifest
-          end
-
-          def call(key)
-            @manifest.data.entries.each_with_object([]) do |e, acc|
-              next unless e.is_a?(Textus::Manifest::Entry::Derived)
-
-              src = e.source
-              sources = if src.is_a?(Textus::Manifest::Entry::Derived::Projection)
-                          Array(src.select).compact
-                        elsif src.is_a?(Textus::Manifest::Entry::Derived::External)
-                          Array(src.sources).compact
-                        else
-                          []
-                        end
-              acc << e.key if sources.any? { |s| s == key || key.start_with?("#{s}.") }
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:rdeps, Textus::Application::Read::Rdeps, caps: :read)

data/lib/textus/application/read/schema_envelope.rb

@@ -1,26 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module SchemaEnvelope
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(caps:)
-            @manifest = caps.manifest
-            @schemas  = caps.schemas
-          end
-
-          def call(key)
-            mentry = @manifest.resolver.resolve(key).entry
-            schema = @schemas.fetch_or_nil(mentry.schema)
-            { "protocol" => PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:schema_envelope, Textus::Application::Read::SchemaEnvelope, caps: :read)

data/lib/textus/application/read/stale.rb

@@ -1,23 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module Stale
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(caps:)
-            @manifest = caps.manifest
-          end
-
-          def call(prefix: nil, zone: nil)
-            Textus::Domain::Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:stale, Textus::Application::Read::Stale, caps: :read)

data/lib/textus/application/read/uid.rb

@@ -1,30 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module Uid
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(ctx: ctx, caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:)
-            @ctx = ctx
-            @caps = caps
-          end
-
-          def call(key)
-            get.get(key).uid
-          end
-
-          private
-
-          def get
-            @get ||= Get::Impl.new(ctx: @ctx, caps: @caps)
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:uid, Textus::Application::Read::Uid, caps: :read)

data/lib/textus/application/read/validate_all.rb

@@ -1,32 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module ValidateAll
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(ctx: ctx, caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(ctx:, caps:)
-            @ctx = ctx
-            @caps = caps
-            @manifest  = caps.manifest
-            @schemas   = caps.schemas
-            @audit_log = caps.audit_log
-          end
-
-          def call
-            Validator.new(
-              reader: Get::Impl.new(ctx: @ctx, caps: @caps),
-              manifest: @manifest,
-              audit_log: @audit_log,
-              schema_for: ->(name) { @schemas.fetch_or_nil(name) },
-            ).call
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:validate_all, Textus::Application::Read::ValidateAll, caps: :read)

data/lib/textus/application/read/validator.rb

@@ -1,86 +0,0 @@
-module Textus
-  module Application
-    module Read
-      class Validator
-        def initialize(reader:, manifest:, audit_log:, schema_for:)
-          @reader = reader
-          @manifest = manifest
-          @audit_log = audit_log
-          @schema_for = schema_for
-        end
-
-        def call
-          violations = []
-          check_content_violations(violations)
-          check_role_authority_violations(violations)
-          { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
-        end
-
-        private
-
-        def check_content_violations(violations)
-          @manifest.resolver.enumerate.each do |row|
-            key = row[:key]
-            mentry = row[:manifest_entry]
-            env = fetch_envelope(key, violations) or next
-            schema = mentry.schema && @schema_for.call(mentry.schema)
-            next unless schema
-
-            begin
-              validate_schema!(schema, env, mentry.format)
-            rescue Textus::Error => e
-              violations << { "key" => key, "code" => e.code, "message" => e.message }
-            end
-          end
-        end
-
-        def check_role_authority_violations(violations)
-          @manifest.resolver.enumerate.each do |row|
-            mentry = row[:manifest_entry]
-            next unless mentry.schema
-
-            schema = @schema_for.call(mentry.schema)
-            next unless schema
-
-            env = begin
-              @reader.get(row[:key])
-            rescue StandardError
-              next
-            end
-            append_authority_violations(violations, row[:key], env, schema)
-          end
-        end
-
-        def append_authority_violations(violations, key, env, schema)
-          last_writer = @audit_log.last_writer_for(key)
-          return if last_writer.nil?
-
-          last_writer_is_authority = @manifest.policy.role_kind(last_writer) == :accept_authority
-
-          env.meta.each_key do |field|
-            owner = schema.maintained_by(field)
-            next if owner.nil? || last_writer == owner || last_writer_is_authority
-
-            violations << { "key" => key, "code" => "role_authority",
-                            "field" => field, "expected" => owner, "last_writer" => last_writer }
-          end
-        end
-
-        def fetch_envelope(key, violations)
-          @reader.get(key)
-        rescue Textus::Error => e
-          violations << { "key" => key, "code" => e.code, "message" => e.message }
-          nil
-        end
-
-        def validate_schema!(schema, envelope, format)
-          payload = case format
-                    when "json", "yaml" then envelope.content || {}
-                    else envelope.meta || {}
-                    end
-          schema.validate!(payload)
-        end
-      end
-    end
-  end
-end

data/lib/textus/application/read/where.rb

@@ -1,26 +0,0 @@
-module Textus
-  module Application
-    module Read
-      module Where
-        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
-          Impl.new(caps: caps).call(*, **)
-        end
-
-        class Impl
-          def initialize(caps:)
-            @manifest = caps.manifest
-          end
-
-          def call(key)
-            res = @manifest.resolver.resolve(key)
-            mentry = res.entry
-            path = res.path
-            { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:where, Textus::Application::Read::Where, caps: :read)

data/lib/textus/application/use_case.rb

@@ -1,22 +0,0 @@
-module Textus
-  module Application
-    # Registry mapping verb symbols to use-case modules. Each entry says
-    # which caps slice the use case needs (:read or :write); Session
-    # uses this to define one method per verb.
-    module UseCase
-      Entry = Data.define(:verb, :mod, :caps_kind)
-
-      @entries = []
-
-      class << self
-        attr_reader :entries
-
-        def register(verb, mod, caps:)
-          @entries << Entry.new(verb: verb.to_sym, mod: mod, caps_kind: caps.to_sym)
-        end
-
-        def each(&) = @entries.each(&)
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require_relative "authority_gate"
-
-module Textus
-  module Application
-    module Write
-      module Accept
-        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
-            @file_store   = caps.file_store
-            @schemas      = caps.schemas
-            @writer       = writer
-            @events       = caps.events
-            @authorizer   = caps.authorizer
-            @hook_context = hook_context
-          end
-
-          def call(pending_key)
-            assert_accept_authority!("accept")
-
-            env = Textus::Application::Read::Get::Impl.new(
-              ctx: @ctx, caps: @caps,
-            ).call(pending_key)
-            proposal = env.meta["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
-            target = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
-            action = proposal["action"] || "put"
-
-            evaluate_promotion!(env, target)
-
-            case action
-            when "put"
-              # Nested proposal "frontmatter" — the meta to write to the accepted
-              # target. Not related to the removed intake-handler legacy bridge.
-              target_meta = env.meta["frontmatter"] || {}
-              target_body = env.body
-              put_op.call(target, meta: target_meta, body: target_body)
-            when "delete"
-              delete_op.call(target)
-            else
-              raise ProposalError.new("unknown action: #{action}")
-            end
-
-            delete_op.call(pending_key)
-
-            @events.publish(:proposal_accepted,
-                            ctx: @hook_context,
-                            key: pending_key,
-                            target_key: target)
-
-            { "protocol" => PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action }
-          end
-
-          private
-
-          def put_op
-            @put_op ||= Textus::Application::Write::Put::Impl.new(
-              ctx: @ctx, caps: @caps, writer: @writer,
-              hook_context: @hook_context
-            )
-          end
-
-          def delete_op
-            @delete_op ||= Textus::Application::Write::Delete::Impl.new(
-              ctx: @ctx, caps: @caps, writer: @writer,
-              hook_context: @hook_context
-            )
-          end
-
-          def evaluate_promotion!(env, target_key)
-            rules = @manifest.rules.for(target_key)
-            promote = rules.promote
-            return if promote.nil? || promote.requires.empty?
-
-            policy = Textus::Domain::Policy::Promotion.from_names(promote.requires)
-            result = policy.evaluate(
-              entry: env, schemas: @schemas, manifest: @manifest, role: @ctx.role,
-            )
-            return if result.ok?
-
-            raise ProposalError.new(
-              "promotion gate failed: #{result.reasons.join("; ")}",
-            )
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:accept, Textus::Application::Write::Accept, caps: :write)

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

@@ -1,26 +0,0 @@
-module Textus
-  module Application
-    module Write
-      # Shared gate for write verbs that require the caller to hold the
-      # manifest's accept_authority role. Provides one method, expressed
-      # as two early-returns rather than a ternary, so each failure mode
-      # reads on its own line.
-      module AuthorityGate
-        def assert_accept_authority!(verb)
-          return if @manifest.policy.role_kind(@ctx.role) == :accept_authority
-
-          authority = @manifest.policy.roles_with_kind(:accept_authority).first
-          if authority.nil?
-            raise ProposalError.new(
-              "no role with accept_authority kind is declared in this manifest; #{verb} is disabled",
-            )
-          end
-
-          raise ProposalError.new(
-            "only #{authority} role can #{verb} proposals; got '#{@ctx.role}'",
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Textus
-  module Application
-    module Write
-      module Delete
-        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, if_etag: nil, suppress_events: false)
-            Textus::Manifest::Data.validate_key!(key)
-            mentry = @manifest.resolver.resolve(key).entry
-
-            @authorizer.authorize_write!(mentry, role: @ctx.role)
-
-            @writer.delete(key, mentry: mentry, if_etag: if_etag)
-
-            unless suppress_events
-              @events.publish(:entry_deleted,
-                              ctx: @hook_context,
-                              key: key)
-            end
-
-            { "protocol" => Textus::PROTOCOL, "ok" => true, "key" => key, "deleted" => true }
-          end
-        end
-      end
-    end
-  end
-end
-
-Textus::Application::UseCase.register(:delete, Textus::Application::Write::Delete, caps: :write)

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

@@ -1,49 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Application
-    module Write
-      # Materializes a single Derived manifest entry onto disk by running
-      # the builder pipeline (template + projection + external runner).
-      # Extracted from Application::Write::Build so that Publish can reuse
-      # it without creating a Build dependency.
-      class Materializer
-        def initialize(ctx:, caps:, rpc:, session:)
-          @ctx        = ctx
-          @caps       = caps
-          @manifest   = caps.manifest
-          @file_store = caps.file_store
-          @rpc        = rpc
-          @root       = caps.root
-          @session    = session
-        end
-
-        # Runs the builder pipeline for `mentry` and returns the on-disk
-        # target_path string.
-        def run(mentry)
-          reader = Textus::Application::Read::Get::Impl.new(ctx: @ctx, caps: @caps)
-          lister = Textus::Application::Read::List::Impl.new(caps: @caps)
-          Builder::Pipeline.run(
-            mentry: mentry,
-            manifest: @manifest,
-            reader: reader.method(:call),
-            lister: lister.method(:call),
-            rpc: @rpc,
-            template_loader: ->(name) { read_template(name) },
-            transform_context: @caps,
-            inject_boot: -> { Textus::Boot.run(@session) },
-          )
-        end
-
-        private
-
-        def read_template(name)
-          tpl_path = File.join(@root, "templates", name)
-          raise TemplateError.new("template not found: #{tpl_path}", template_name: name) unless File.exist?(tpl_path)
-
-          File.read(tpl_path)
-        end
-      end
-    end
-  end
-end

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)