textus 0.18.0 → 0.20.2

data/lib/textus/{domain → application}/policy/promotion.rb

@@ -1,14 +1,15 @@
+require_relative "predicates/schema_valid"
+require_relative "predicates/accept_authority_signed"
+
 module Textus
-  module Domain
+  module Application
     module Policy
-      # Promotion evaluates a list of named predicates against a pending-proposal
-      # entry and returns a Result indicating whether all requirements are met.
       class Promotion
         Result = Struct.new(:ok?, :reasons, keyword_init: true)
 
         REGISTRY = {
           "schema_valid" => -> { Predicates::SchemaValid.new },
-          "human_accept" => -> { Predicates::HumanAccept.new },
+          "accept_authority_signed" => -> { Predicates::AcceptAuthoritySigned.new },
         }.freeze
 
         def self.from_names(names)
@@ -31,14 +32,25 @@ module Textus
           @predicates.map(&:name)
         end
 
-        def evaluate(entry:, store:)
+        def evaluate(entry:, schemas:, manifest:, role:)
           reasons = []
           @predicates.each do |pred|
-            ok = pred.call(entry: entry, store: store)
+            ok = invoke(pred, entry: entry, schemas: schemas, manifest: manifest, role: role)
             reasons << "#{pred.name}: #{pred.reason || "predicate failed"}" unless ok
           end
           Result.new(ok?: reasons.empty?, reasons: reasons)
         end
+
+        private
+
+        def invoke(pred, entry:, schemas:, manifest:, role:)
+          case pred.name
+          when "accept_authority_signed"
+            pred.call(role: role, manifest: manifest, entry: entry)
+          else
+            pred.call(entry: entry, schemas: schemas, manifest: manifest)
+          end
+        end
       end
     end
   end

data/lib/textus/application/projection.rb

@@ -0,0 +1,91 @@
+require "time"
+require "timeout"
+
+module Textus
+  module Application
+    class Projection
+      MAX_LIMIT = 1000
+      REDUCER_TIMEOUT_SECONDS = 2
+
+      # `reader` — a callable `->(key) { envelope_or_nil }`. Caller picks
+      #   semantics: pure read (`ops.get`) for materialization paths;
+      #   `ops.get_or_refresh` if you want refresh-on-stale.
+      # `lister` — a callable `->(prefix:) { [ { "key" => ... }, ... ] }`.
+      # `transform_resolver` — a callable `->(name) { callable_or_raise }`.
+      # `transform_context` — `Application::Context` handed to the transform reducer.
+      def initialize(reader:, spec:, lister:, transform_resolver:, transform_context:)
+        @reader             = reader
+        @spec               = spec || {}
+        @lister             = lister
+        @transform_resolver = transform_resolver
+        @transform_context  = transform_context
+        @limit = (@spec["limit"] || MAX_LIMIT).to_i
+        raise InvalidProjection.new("limit #{@limit} exceeds max #{MAX_LIMIT}") if @limit > MAX_LIMIT
+      end
+
+      def run
+        keys = collect_keys
+        explicit_pluck = !@spec["pluck"].nil? && @spec["pluck"] != "*"
+        rows = keys.map do |key|
+          env = @reader.call(key)
+          row = pluck(env.meta, env.body)
+          explicit_pluck ? row : row.merge("_key" => key)
+        end
+        reduced = apply_reducer(rows)
+        # Reducers may return either an Array of rows (legacy / templated builds)
+        # or a Hash that becomes the structured-format payload base. In the Hash
+        # case, downstream sort/limit/position markers don't apply, and the
+        # builder owns `_meta.generated_at` so we don't stamp it here.
+        return reduced if reduced.is_a?(Hash)
+
+        rows = reduced
+        rows = sort(rows)
+        rows = rows.first(@limit)
+        mark_positions(rows)
+        { "entries" => rows, "count" => rows.length, "generated_at" => Time.now.utc.iso8601 }
+      end
+
+      private
+
+      def apply_reducer(rows)
+        name = @spec["transform"] or return rows
+        callable = @transform_resolver.call(name)
+        Timeout.timeout(REDUCER_TIMEOUT_SECONDS) do
+          callable.call(store: @transform_context, rows: rows, config: @spec["transform_config"] || {})
+        end
+      rescue Timeout::Error
+        raise UsageError.new("transform_rows '#{name}' exceeded #{REDUCER_TIMEOUT_SECONDS}s timeout")
+      end
+
+      def collect_keys
+        prefixes = Array(@spec["select"])
+        prefixes.flat_map { |p| @lister.call(prefix: p).map { |row| row["key"] } }.uniq
+      end
+
+      def pluck(frontmatter, _body)
+        fields = @spec["pluck"]
+        if fields.nil? || fields == "*"
+          frontmatter
+        else
+          Array(fields).each_with_object({}) { |f, h| h[f] = frontmatter[f] if frontmatter.key?(f) }
+        end
+      end
+
+      # Adds `_first`, `_last`, and `_index` markers so templates can emit
+      # delimiters (e.g. JSON commas) via {{^_last}},{{/_last}}.
+      def mark_positions(rows)
+        last_idx = rows.length - 1
+        rows.each_with_index do |row, i|
+          row["_index"] = i
+          row["_first"] = i.zero?
+          row["_last"]  = (i == last_idx)
+        end
+      end
+
+      def sort(rows)
+        sb = @spec["sort_by"] or return rows
+        rows.sort_by { |r| r[sb].to_s }
+      end
+    end
+  end
+end

data/lib/textus/application/reads/audit.rb

@@ -8,9 +8,9 @@ module Textus
       # correlation_id, limit. Reads the log file as JSON-Lines (legacy TSV
       # rows produce nil and are skipped).
       class Audit
-        def initialize(ctx:)
-          @ctx = ctx
-          @log_path = File.join(@ctx.store.root, "audit.log")
+        def initialize(manifest:, root:)
+          @manifest = manifest
+          @log_path = File.join(root, "audit.log")
         end
 
         # rubocop:disable Metrics/ParameterLists, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -58,7 +58,7 @@ module Textus
         end
 
         def key_in_zone?(key, zone)
-          mentry = @ctx.store.manifest.resolve(key).entry
+          mentry = @manifest.resolver.resolve(key).entry
           mentry && mentry.zone == zone
         rescue Textus::Error
           false

data/lib/textus/application/reads/blame.rb

@@ -8,12 +8,13 @@ module Textus
       # row. Falls back to `git => nil` when not in a git repo or when the
       # file is untracked.
       class Blame
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:, root:)
+          @manifest = manifest
+          @root = root
         end
 
         def call(key:, limit: nil)
-          audit_rows = Textus::Application::Reads::Audit.new(ctx: @ctx).call(key: key, limit: limit)
+          audit_rows = Textus::Application::Reads::Audit.new(manifest: @manifest, root: @root).call(key: key, limit: limit)
           path = resolve_path(key)
           return audit_rows.map { |r| r.merge("git" => nil) } unless git_tracked?(path)
 
@@ -23,13 +24,13 @@ module Textus
         private
 
         def resolve_path(key)
-          res = @ctx.store.manifest.resolve(key)
+          res = @manifest.resolver.resolve(key)
           mentry = res.entry
           path = res.path
           # Nested entries resolve to a file under the entry path; leaf entries
           # already have a fully-resolved path. Either way `path` is what git
           # needs to know about.
-          path || Textus::Key::Path.resolve(@ctx.store.manifest, mentry)
+          path || Textus::Key::Path.resolve(@manifest, mentry)
         rescue Textus::Error
           nil
         end
@@ -41,7 +42,7 @@ module Textus
 
           _out, _err, status = Open3.capture3(
             "git", "ls-files", "--error-unmatch", path,
-            chdir: @ctx.store.root
+            chdir: @root
           )
           status.success?
         rescue Errno::ENOENT
@@ -50,7 +51,7 @@ module Textus
 
         def git_repo?
           # Walk up from store root to find a .git directory.
-          dir = @ctx.store.root
+          dir = @root
           loop do
             return true if File.directory?(File.join(dir, ".git"))
 
@@ -65,7 +66,7 @@ module Textus
           args = ["git", "log", "-1"]
           args << "--before=#{timestamp}" if timestamp
           args += ["--format=%H%x09%an%x09%aI%x09%s", "--", path]
-          out, _err, status = Open3.capture3(*args, chdir: @ctx.store.root)
+          out, _err, status = Open3.capture3(*args, chdir: @root)
           return nil unless status.success?
 
           sha, author, date, subject = out.strip.split("\t", 4)

data/lib/textus/application/reads/deps.rb

@@ -2,12 +2,23 @@ module Textus
   module Application
     module Reads
       class Deps
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key)
-          Dependencies.deps_of(@ctx.manifest, key)
+          entry = @manifest.entries.find { |e| e.key == key } or return []
+          return [] unless entry.is_a?(Textus::Manifest::Entry::Derived)
+
+          src = entry.source
+          result = 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
+          result.uniq
         end
       end
     end

data/lib/textus/application/reads/freshness.rb

@@ -8,14 +8,16 @@ module Textus
       # current status. Status is one of :fresh, :stale, :never_refreshed, or
       # :no_policy.
       class Freshness
-        def initialize(ctx:, evaluator: Textus::Domain::Freshness::Evaluator)
-          @ctx = ctx
-          @evaluator = evaluator
+        def initialize(ctx:, manifest:, file_store:, evaluator: Textus::Domain::Freshness::Evaluator)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @evaluator  = evaluator
         end
 
         def call(prefix: nil, zone: nil)
           rows = []
-          @ctx.manifest.entries.each do |mentry|
+          @manifest.entries.each do |mentry|
             next if prefix && !mentry.key.start_with?(prefix)
             next if zone && mentry.zone != zone
 
@@ -27,7 +29,7 @@ module Textus
         private
 
         def row_for(mentry)
-          set = @ctx.manifest.rules_for(mentry.key)
+          set = @manifest.rules_for(mentry.key)
           refresh = set.refresh
           envelope = safe_get(mentry.key)
           last = envelope&.meta&.dig("last_refreshed_at")
@@ -61,10 +63,10 @@ module Textus
         # Returns the raw envelope or nil. Nested entries (mentry.key is a
         # prefix, not a leaf) and missing files both resolve to nil.
         def safe_get(key)
-          res = @ctx.manifest.resolve(key)
-          return nil unless @ctx.file_store.exists?(res.path)
+          res = @manifest.resolver.resolve(key)
+          return nil unless @file_store.exists?(res.path)
 
-          raw = @ctx.file_store.read(res.path)
+          raw = @file_store.read(res.path)
           parsed = Entry.for_format(res.entry.format).parse(raw, path: res.path)
           Envelope.build(
             key: key, mentry: res.entry, path: res.path,

data/lib/textus/application/reads/get.rb

@@ -7,16 +7,18 @@ module Textus
       # For interactive reads that want refresh-on-stale, use
       # `Reads::GetOrRefresh`, which composes this with the orchestrator.
       class Get
-        def initialize(ctx:, evaluator: Textus::Domain::Freshness::Evaluator)
-          @ctx       = ctx
-          @evaluator = evaluator
+        def initialize(ctx:, manifest:, file_store:, evaluator: Textus::Domain::Freshness::Evaluator)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @evaluator  = evaluator
         end
 
         def call(key)
           envelope = read_raw_envelope(key)
           return nil if envelope.nil?
 
-          policy_set = @ctx.manifest.rules_for(key)
+          policy_set = @manifest.rules_for(key)
           refresh_policy = policy_set.refresh
           return annotate_fresh(envelope) if refresh_policy.nil?
 
@@ -34,18 +36,18 @@ module Textus
         # Used by consumers (e.g. Validator) that need to distinguish absence
         # from emptiness.
         def get(key)
-          call(key) || raise(UnknownKey.new(key, suggestions: @ctx.manifest.suggestions_for(key)))
+          call(key) || raise(UnknownKey.new(key, suggestions: @manifest.resolver.suggestions_for(key)))
         end
 
         private
 
         def read_raw_envelope(key)
-          res = @ctx.manifest.resolve(key)
+          res = @manifest.resolver.resolve(key)
           mentry = res.entry
           path = res.path
-          return nil unless @ctx.file_store.exists?(path)
+          return nil unless @file_store.exists?(path)
 
-          raw = @ctx.file_store.read(path)
+          raw = @file_store.read(path)
           parsed = Entry.for_format(mentry.format).parse(raw, path: path)
           Envelope.build(
             key: key, mentry: mentry, path: path,

data/lib/textus/application/reads/get_or_refresh.rb

@@ -10,8 +10,8 @@ module Textus
       # Pure reads (build, projection, schema tooling) should use
       # `Reads::Get` directly; it has no orchestrator dependency.
       class GetOrRefresh
-        def initialize(ctx:, get:, orchestrator:)
-          @ctx          = ctx
+        def initialize(manifest:, get:, orchestrator:)
+          @manifest     = manifest
           @get          = get
           @orchestrator = orchestrator
         end
@@ -21,7 +21,7 @@ module Textus
           return nil if envelope.nil?
           return envelope unless envelope.freshness&.stale
 
-          policy_set = @ctx.store.manifest.rules_for(key)
+          policy_set = @manifest.rules_for(key)
           refresh_policy = policy_set.refresh
           return envelope if refresh_policy.nil?
 

data/lib/textus/application/reads/list.rb

@@ -2,12 +2,12 @@ module Textus
   module Application
     module Reads
       class List
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(prefix: nil, zone: nil)
-          rows = @ctx.manifest.enumerate(prefix: prefix)
+          rows = @manifest.resolver.enumerate(prefix: prefix)
           rows = rows.select { |r| r[:manifest_entry].zone == zone } if zone
           rows.map { |row| { "key" => row[:key], "zone" => row[:manifest_entry].zone, "path" => row[:path] } }
         end

data/lib/textus/application/reads/policy_explain.rb

@@ -4,12 +4,12 @@ module Textus
       # For one key, surface every matching policy block along with the
       # per-slot effective value (which loses ties win-by-specificity).
       class PolicyExplain
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key:)
-          policies = @ctx.store.manifest.rules
+          policies = @manifest.rules
           matching = policies.explain(key)
           winners  = policies.for(key)
 

data/lib/textus/application/reads/published.rb

@@ -2,12 +2,14 @@ module Textus
   module Application
     module Reads
       class Published
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call
-          Dependencies.published_of(@ctx.manifest)
+          @manifest.entries.reject { |e| e.publish_to.empty? }.map do |e|
+            { "key" => e.key, "publish_to" => e.publish_to }
+          end
         end
       end
     end

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

@@ -2,12 +2,24 @@ module Textus
   module Application
     module Reads
       class Rdeps
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key)
-          Dependencies.rdeps_of(@ctx.manifest, key)
+          @manifest.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

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

@@ -2,13 +2,14 @@ module Textus
   module Application
     module Reads
       class SchemaEnvelope
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:, schemas:)
+          @manifest = manifest
+          @schemas = schemas
         end
 
         def call(key)
-          mentry = @ctx.manifest.resolve(key).entry
-          schema = @ctx.schemas.fetch_or_nil(mentry.schema)
+          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

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

@@ -2,12 +2,12 @@ module Textus
   module Application
     module Reads
       class Stale
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(prefix: nil, zone: nil)
-          Textus::Domain::Staleness.new(manifest: @ctx.manifest).call(prefix: prefix, zone: zone)
+          Textus::Domain::Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
         end
       end
     end

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

@@ -2,12 +2,20 @@ module Textus
   module Application
     module Reads
       class Uid
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
         end
 
         def call(key)
-          Get.new(ctx: @ctx).get(key).uid
+          get.get(key).uid
+        end
+
+        private
+
+        def get
+          @get ||= Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store)
         end
       end
     end

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

@@ -2,16 +2,20 @@ module Textus
   module Application
     module Reads
       class ValidateAll
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(ctx:, manifest:, file_store:, schemas:, audit_log:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @schemas    = schemas
+          @audit_log  = audit_log
         end
 
         def call
           Validator.new(
-            reader: Get.new(ctx: @ctx),
-            manifest: @ctx.manifest,
-            audit_log: @ctx.audit_log,
-            schema_for: ->(name) { @ctx.schemas.fetch_or_nil(name) },
+            reader: Get.new(ctx: @ctx, manifest: @manifest, file_store: @file_store),
+            manifest: @manifest,
+            audit_log: @audit_log,
+            schema_for: ->(name) { @schemas.fetch_or_nil(name) },
           ).call
         end
       end

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

@@ -19,7 +19,7 @@ module Textus
         private
 
         def check_content_violations(violations)
-          @manifest.enumerate.each do |row|
+          @manifest.resolver.enumerate.each do |row|
             key = row[:key]
             mentry = row[:manifest_entry]
             env = fetch_envelope(key, violations) or next
@@ -35,7 +35,7 @@ module Textus
         end
 
         def check_role_authority_violations(violations)
-          @manifest.enumerate.each do |row|
+          @manifest.resolver.enumerate.each do |row|
             mentry = row[:manifest_entry]
             next unless mentry.schema
 
@@ -55,9 +55,11 @@ module Textus
           last_writer = @audit_log.last_writer_for(key)
           return if last_writer.nil?
 
+          last_writer_is_authority = @manifest.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 == "human"
+            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 }

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

@@ -2,12 +2,12 @@ module Textus
   module Application
     module Reads
       class Where
-        def initialize(ctx:)
-          @ctx = ctx
+        def initialize(manifest:)
+          @manifest = manifest
         end
 
         def call(key)
-          res = @ctx.manifest.resolve(key)
+          res = @manifest.resolver.resolve(key)
           mentry = res.entry
           path = res.path
           { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }

data/lib/textus/application/refresh/all.rb

@@ -1,20 +1,24 @@
 module Textus
   module Application
     module Refresh
-      module All
-        module_function
+      class All
+        def initialize(ctx:, manifest:, envelope_io:, bus:, store:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @store        = store
+          @authorizer   = authorizer
+          @hook_context = hook_context
+        end
 
-        def call(ctx, prefix: nil, zone: nil)
-          envelope_io = Textus::Application::Writes::EnvelopeIO.new(
-            file_store: ctx.file_store,
-            manifest: ctx.manifest,
-            schemas: ctx.schemas,
-            audit_log: ctx.audit_log,
-            ctx: ctx,
+        def call(prefix: nil, zone: nil)
+          worker = Textus::Application::Refresh::Worker.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io, bus: @bus,
+            store: @store, authorizer: @authorizer, hook_context: @hook_context
           )
-          worker = Textus::Application::Refresh::Worker.new(ctx: ctx, envelope_io: envelope_io)
 
-          stale_rows = Textus::Application::Reads::Stale.new(ctx: ctx).call(prefix: prefix, zone: zone)
+          stale_rows = Textus::Application::Reads::Stale.new(manifest: @manifest).call(prefix: prefix, zone: zone)
           refreshed = []
           failed = []
           skipped = []

data/lib/textus/application/refresh/orchestrator.rb

@@ -2,11 +2,13 @@ module Textus
   module Application
     module Refresh
       class Orchestrator
-        def initialize(worker:, store_root:, store: nil, role: "human", detached_spawner: nil)
-          @worker = worker
-          @store_root = store_root
-          @store = store
-          @role = role
+        def initialize(worker:, store_root:, bus: nil, store: nil, ctx: nil, hook_context: nil, detached_spawner: nil) # rubocop:disable Metrics/ParameterLists
+          @worker       = worker
+          @store_root   = store_root
+          @bus          = bus
+          @store        = store
+          @ctx          = ctx
+          @hook_context = hook_context
           @detached_spawner = detached_spawner || default_spawner
         end
 
@@ -55,10 +57,9 @@ module Textus
 
             probe.release
 
-            store_view = @store ? Textus::Application::Context.new(store: @store, role: @role) : nil
             payload = { key: key, started_at: Time.now.utc.iso8601, budget_ms: budget_ms }
-            payload[:store] = store_view if store_view
-            @store&.bus&.publish(:refresh_backgrounded, **payload)
+            payload[:ctx] = @hook_context if @hook_context
+            @bus&.publish(:refresh_backgrounded, **payload)
             @detached_spawner.call(store_root: @store_root, key: key)
             Textus::Domain::Outcome::Detached.new
           elsif result.is_a?(Textus::Error)