textus 0.18.0 → 0.20.0

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
 

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)

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

@@ -6,17 +6,22 @@ module Textus
       class Worker
         FETCH_TIMEOUT_SECONDS = 30
 
-        def initialize(ctx:, envelope_io:)
-          @ctx = ctx
-          @envelope_io = envelope_io
+        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 run(key)
-          res = @ctx.store.manifest.resolve(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.intake_handler
+          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_bus(key, mentry, remaining)
@@ -25,19 +30,14 @@ module Textus
 
         private
 
-        def read_view
-          Application::Context.new(store: @ctx.store, role: @ctx.role)
-        end
-
         def fetch_timeout_for(key)
-          rule = @ctx.store.manifest.rules_for(key)
+          rule = @manifest.rules_for(key)
           rule&.refresh&.fetch_timeout_seconds || FETCH_TIMEOUT_SECONDS
         end
 
         def fetch_with_bus(key, mentry, remaining)
-          callable = @ctx.store.registry.rpc_callable(:resolve_intake, mentry.intake_handler)
-          @ctx.bus.publish(:refresh_started, store: read_view, key: key, mode: :sync,
-                                             correlation_id: @ctx.correlation_id)
+          callable = @bus.rpc_callable(:resolve_intake, mentry.handler)
+          @bus.publish(:refresh_started, ctx: @hook_context, key: key, mode: :sync)
           call_intake(key, mentry, callable, remaining)
         end
 
@@ -45,38 +45,38 @@ module Textus
           timeout = fetch_timeout_for(key)
           Timeout.timeout(timeout) do
             callable.call(
-              store: @ctx,
-              config: mentry.intake_config,
+              store: @store,
+              config: mentry.config,
               args: { trigger_key: key, leaf_segments: remaining || [] },
             )
           end
         rescue Timeout::Error
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: "Timeout::Error",
-                                            error_message: "intake '#{mentry.intake_handler}' exceeded #{timeout}s",
-                                            correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' exceeded #{timeout}s timeout")
+          @bus.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
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                            error_message: e.message, correlation_id: @ctx.correlation_id)
+          @bus.publish(:refresh_failed, ctx: @hook_context, key: key, error_class: e.class.name,
+                                        error_message: e.message)
           raise
         rescue StandardError => e
-          @ctx.bus.publish(:refresh_failed, store: read_view, key: key, error_class: e.class.name,
-                                            error_message: e.message, correlation_id: @ctx.correlation_id)
-          raise UsageError.new("intake '#{mentry.intake_handler}' raised: #{e.class}: #{e.message}")
+          @bus.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 = Textus::Refresh.normalize_action_result(result, format: mentry.format)
-          envelope = Textus::Application::Writes::Put.new(ctx: @ctx, envelope_io: @envelope_io).call(
+          normalized = self.class.send(:normalize_action_result, result, format: mentry.format)
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
+          envelope = @envelope_io.write(
             key,
-            meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
-            suppress_events: true
+            mentry: mentry,
+            payload: Textus::Application::Writes::EnvelopeIO::Payload.new(
+              meta: normalized[:meta], body: normalized[:body], content: normalized[:content],
+            ),
           )
           change = detect_change(before_etag, envelope)
-          unless change == :unchanged
-            @ctx.bus.publish(:entry_refreshed, store: read_view, key: key, envelope: envelope, change: change,
-                                               correlation_id: @ctx.correlation_id)
-          end
+          @bus.publish(:entry_refreshed, ctx: @hook_context, key: key, envelope: envelope, change: change) unless change == :unchanged
           envelope
         end
 
@@ -86,6 +86,30 @@ module Textus
           else :updated
           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