textus 0.55.2 → 0.56.0

data/lib/textus/handlers/maintenance/rule_list.rb

@@ -1,32 +0,0 @@
-module Textus
-  module Handlers
-    module Maintenance
-      class RuleList
-        def initialize(manifest:)
-          @manifest = manifest
-        end
-
-        def call(_command, _call)
-          Value::Result.success(@manifest.rules.blocks.map do |block|
-            row = { "match" => block.match }
-            LIST_FIELDS.each do |field|
-              value = block.public_send(field)
-              row[field.to_s] = serialize(field, value) unless value.nil?
-            end
-            row
-          end)
-        end
-
-        LIST_FIELDS = Textus::Manifest::Schema::FIELD_REGISTRY.select { |_, m| m[:in_rule_list] }.keys.freeze
-
-        def serialize(field, value)
-          case field
-          when :retention then { "ttl_seconds" => value.ttl_seconds, "action" => value.action.to_s }
-          when :react then value.to_h
-          else value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/maintenance/schema_envelope.rb

@@ -1,19 +0,0 @@
-module Textus
-  module Handlers
-    module Maintenance
-      class SchemaEnvelope
-        def initialize(manifest:, schemas:)
-          @manifest = manifest
-          @schemas = schemas
-        end
-
-        def call(command, _call)
-          mentry = @manifest.resolver.resolve(command.key).entry
-          schema = @schemas.fetch_or_nil(mentry.schema)
-          Value::Result.success("protocol" => Textus::PROTOCOL, "key" => command.key,
-                                "schema_ref" => mentry.schema, "schema" => schema&.to_h)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/audit_entries.rb

@@ -1,48 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class AuditEntries
-        def initialize(manifest:, audit_log:)
-          @manifest = manifest
-          @audit_log = audit_log
-        end
-
-        def call(command, _call)
-          cursor_check = check_cursor_expiry(command.seq_since)
-          return cursor_check if cursor_check
-
-          rows = @audit_log.scan(
-            seq_since: command.seq_since,
-            key: command.key, role: command.role, verb: command.verb,
-            correlation_id: command.correlation_id, limit: command.limit
-          ).select do |row|
-            next false if command.lane && !key_in_lane?(row["key"], command.lane)
-            next false if command.since && (row["ts"].nil? || Time.parse(row["ts"]) < command.since)
-
-            true
-          end
-          Value::Result.success(rows)
-        end
-
-        private
-
-        def check_cursor_expiry(seq_since)
-          return unless seq_since
-
-          min = @audit_log.min_available_seq
-          return unless min && seq_since < min - 1
-
-          Value::Result.failure(:cursor_expired, "requested seq #{seq_since} is below minimum available #{min}",
-                                details: { requested: seq_since, min_available: min })
-        end
-
-        def key_in_lane?(key, lane)
-          mentry = @manifest.resolver.resolve(key).entry
-          mentry && mentry.lane == lane
-        rescue Textus::Error
-          false
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/blame_entry.rb

@@ -1,71 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class BlameEntry
-        def initialize(manifest:, orchestration:)
-          @manifest = manifest
-          @orchestration = orchestration
-        end
-
-        def call(command, call)
-          root = @manifest.data.root
-          audit = @orchestration.audit_entries(key: command.key, limit: command.limit, call: call)
-          return audit if audit.failure?
-
-          audit_rows = audit.value.fetch("rows")
-
-          path = resolve_path(command.key)
-          return Value::Result.success(audit_rows.map { |row| row.merge("git" => nil) }) unless git_tracked?(path, root: root)
-
-          Value::Result.success(audit_rows.map { |row| row.merge("git" => git_commit_at(path, timestamp: row["ts"], root: root)) })
-        end
-
-        private
-
-        def resolve_path(key)
-          res = @manifest.resolver.resolve(key)
-          path = res.path
-          path || Textus::Key::Path.resolve(@manifest.data, res.entry)
-        rescue Textus::Error
-          nil
-        end
-
-        def git_tracked?(path, root:)
-          return false if path.nil? || !File.exist?(path) || !git_repo?(root)
-
-          _out, _err, status = Open3.capture3("git", "ls-files", "--error-unmatch", path, chdir: root)
-          status.success?
-        rescue Errno::ENOENT
-          false
-        end
-
-        def git_repo?(root)
-          dir = root
-          loop do
-            return true if File.directory?(File.join(dir, ".git"))
-
-            parent = File.dirname(dir)
-            return false if parent == dir
-
-            dir = parent
-          end
-        end
-
-        def git_commit_at(path, timestamp:, root:)
-          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: root)
-          return nil unless status.success?
-
-          sha, author, date, subject = out.strip.split("\t", 4)
-          return nil if sha.nil? || sha.empty?
-
-          { "sha" => sha, "author" => author, "date" => date, "subject" => subject }
-        rescue Errno::ENOENT
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/deps_entry.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class DepsEntry
-        def initialize(manifest:)
-          @manifest = manifest
-        end
-
-        def call(command, _call)
-          entry = @manifest.data.entries.find { |e| e.key == command.key }
-          deps = entry&.external? ? Array(entry.source&.sources).compact : []
-          Value::Result.success("key" => command.key, "deps" => deps.uniq)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/get_entry.rb

@@ -1,68 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class GetEntry
-        def initialize(container:, freshness_evaluator:)
-          @container = container
-          @freshness_evaluator = freshness_evaluator
-        end
-
-        def call(command, _call)
-          envelope = Store::Entry::Reader.from(container: @container).read(command.key)
-          return Value::Result.failure(:not_found, "no entry at #{command.key}") unless envelope
-
-          envelope = expand_sources(envelope, depth: 0)
-          Value::Result.success(envelope.with(freshness: @freshness_evaluator.verdict(resolve_entry(command.key))))
-        end
-
-        MAX_SOURCE_DEPTH = 5
-
-        private
-
-        def expand_sources(envelope, depth:)
-          return envelope if depth >= MAX_SOURCE_DEPTH
-
-          raw_sources = Array(envelope.meta["sources"])
-          return envelope if raw_sources.empty?
-
-          expanded = raw_sources.map { |src| expand_one_source(src, depth: depth) }
-          envelope.with(sources: expanded)
-        end
-
-        def expand_one_source(src, depth:)
-          src = { "key" => src } if src.is_a?(String)
-          return src unless src.is_a?(Hash) && src["key"].is_a?(String)
-
-          key = src["key"]
-          stored_etag = src["etag"]
-          current_etag = resolve_current_etag(key)
-          suspended = stored_etag && current_etag ? stored_etag != current_etag : false
-
-          result = src.merge("suspended" => suspended)
-
-          child_env = @container.reader.read(key)
-          if child_env
-            child_expanded = expand_sources(child_env, depth: depth + 1)
-            child_sources = Array(child_expanded.sources)
-            result = result.merge("sources" => child_sources) unless child_sources.empty?
-          end
-
-          result
-        end
-
-        def resolve_current_etag(key)
-          path = @container.manifest.resolver.resolve(key).path
-          return nil unless @container.file_store.exists?(path)
-
-          @container.file_store.etag(path)
-        rescue Textus::Error
-          nil
-        end
-
-        def resolve_entry(key)
-          @container.manifest.resolver.resolve(key).entry
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/list_keys.rb

@@ -1,36 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class ListKeys
-        def initialize(manifest:, job_store: nil)
-          @manifest  = manifest
-          @job_store = job_store
-        end
-
-        def call(command, _call)
-          q      = command.respond_to?(:q)      ? command.q      : nil
-          schema = command.respond_to?(:schema) ? command.schema : nil
-
-          return sqlite_list(q: q, schema: schema, lane: command.lane, prefix: command.prefix) if @job_store && (q || schema)
-
-          manifest_list(prefix: command.prefix, lane: command.lane)
-        end
-
-        private
-
-        def sqlite_list(q:, schema:, lane:, prefix:) # rubocop:disable Naming/MethodParameterName
-          rows = @job_store.search_entries(q: q, schema: schema, lane: lane, prefix: prefix)
-          Value::Result.success((rows || []).map { |r| { "key" => r["key"], "lane" => r["lane"] } })
-        end
-
-        def manifest_list(prefix:, lane:)
-          rows = @manifest.resolver.enumerate(prefix: prefix)
-          rows = rows.select { |row| row[:manifest_entry].lane == lane } if lane
-          Value::Result.success(rows.map do |row|
-            { "key" => row[:key], "lane" => row[:manifest_entry].lane, "path" => row[:path] }
-          end)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/pulse_entries.rb

@@ -1,66 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class PulseEntries
-        def initialize(manifest:, audit_log:, file_store:, orchestration:, job_store: nil)
-          @manifest = manifest
-          @audit_log = audit_log
-          @file_store = file_store
-          @orchestration = orchestration
-          @job_store = job_store
-        end
-
-        def call(command, call)
-          root  = @manifest.data.root
-          since = command.since || Textus::Store::Cursor.new(root: root, role: call.role).read
-
-          changed = changed_since(since, call)
-
-          result = {
-            "cursor" => @audit_log.latest_seq,
-            "changed" => changed,
-            "pending_review" => review_keys(call),
-            "contract_etag" => Textus::Value::Etag.for_contract(root),
-            "index_etag" => index_etag,
-          }
-
-          Textus::Store::Cursor.new(root: root, role: call.role).write(result["cursor"])
-          Value::Result.success(result)
-        end
-
-        private
-
-        def changed_since(since, call)
-          if @job_store
-            sqlite_rows = @job_store.audit_events_since(seq: since)
-            return sqlite_rows.map { |r| { "key" => r["key"], "verb" => r["verb"], "seq" => r["seq"] } } if sqlite_rows.any?
-          end
-
-          # Fall back to flat-log scan when SQLite index is empty for this window
-          # (writes that bypassed dispatch, fresh stores, or pre-migration entries).
-          audit = @orchestration.audit_entries(seq_since: since, call: call)
-          return [] if audit.failure?
-
-          audit.value.fetch("rows") || []
-        end
-
-        def review_keys(call)
-          queue = @manifest.policy.queue_lane
-          return [] unless queue
-
-          result = @orchestration.list_keys(prefix: nil, lane: queue, call: call)
-          return [] unless result.success?
-
-          result.value.fetch("rows").map { |r| r["key"] }
-        end
-
-        def index_etag
-          path = @manifest.resolver.resolve("artifacts.system.index").path
-          File.exist?(path) ? @file_store.etag(path) : nil
-        rescue Textus::Error
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/rdeps_entry.rb

@@ -1,21 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class RdepsEntry
-        def initialize(manifest:)
-          @manifest = manifest
-        end
-
-        def call(command, _call)
-          rdeps = @manifest.data.entries.each_with_object([]) do |entry, acc|
-            next unless entry.external?
-
-            sources = Array(entry.source&.sources).compact
-            acc << entry.key if sources.any? { |source| source == command.key || command.key.start_with?("#{source}.") }
-          end
-          Value::Result.success("key" => command.key, "rdeps" => rdeps)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/uid_entry.rb

@@ -1,18 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class UidEntry
-        def initialize(container:)
-          @container = container
-        end
-
-        def call(command, _call)
-          envelope = Store::Entry::Reader.from(container: @container).read(command.key)
-          return Value::Result.failure(:not_found, "no entry at #{command.key}") unless envelope
-
-          Value::Result.success(envelope.uid)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/read/where_entry.rb

@@ -1,18 +0,0 @@
-module Textus
-  module Handlers
-    module Read
-      class WhereEntry
-        def initialize(manifest:)
-          @manifest = manifest
-        end
-
-        def call(command, _call)
-          res = @manifest.resolver.resolve(command.key)
-          mentry = res.entry
-          Value::Result.success("protocol" => Textus::PROTOCOL, "key" => command.key,
-                                "lane" => mentry.lane, "owner" => mentry.owner, "path" => res.path)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/accept_proposal.rb

@@ -1,39 +0,0 @@
-module Textus
-  module Handlers
-    module Write
-      class AcceptProposal
-        def initialize(container:)
-          @container = container
-        end
-
-        def call(command, call)
-          reader = Store::Entry::Reader.from(container: @container)
-          env = reader.read(command.pending_key)
-          proposal = env&.meta&.dig("proposal") or
-            return Value::Result.failure(:proposal_error, "entry has no proposal block: #{command.pending_key}")
-          target = proposal["target_key"] or
-            return Value::Result.failure(:proposal_error, "proposal missing target_key")
-          action = proposal["action"] || "put"
-
-          writer = Store::Entry::Writer.from(container: @container, call: call)
-          case action
-          when "put"
-            mentry = @container.manifest.resolver.resolve(target).entry
-            writer.put(
-              target, mentry: mentry,
-                      payload: Textus::Value::Payload.new(meta: env.meta["_meta"] || {}, body: env.body, content: nil)
-            )
-          when "delete"
-            writer.delete(target)
-          else
-            return Value::Result.failure(:proposal_error, "unknown action: #{action}")
-          end
-
-          writer.delete(command.pending_key)
-          Value::Result.success("protocol" => Textus::PROTOCOL, "accepted" => command.pending_key,
-                                "target_key" => target, "action" => action, "cascade_key" => target)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/data_mv.rb

@@ -1,55 +0,0 @@
-require "yaml"
-
-module Textus
-  module Handlers
-    module Write
-      class DataMv
-        def initialize(container:)
-          @container = container
-        end
-
-        def call(command, _call)
-          manifest = @container.manifest
-          geom = @container.layout
-
-          return Value::Result.failure(:usage_error, "from and to required") if command.from.nil? || command.to.nil?
-          unless manifest.data.declared_lane_kinds.key?(command.from)
-            return Value::Result.failure(:usage_error,
-                                         "data lane '#{command.from}' not declared")
-          end
-
-          dest_dir = geom.lane_path(command.to)
-          return Value::Result.failure(:usage_error, "destination 'data/#{command.to}' already exists") if File.exist?(dest_dir)
-
-          affected_keys = manifest.data.entries.select { |entry| entry.lane == command.from }.map(&:key)
-
-          steps = [{ "op" => "rename_zone", "from" => command.from, "to" => command.to }]
-          steps += affected_keys.map do |key|
-            { "op" => "mv", "from" => key, "to" => "#{command.to}#{key[command.from.length..]}" }
-          end
-
-          plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: [])
-          return Value::Result.success(plan) if command.dry_run
-
-          rewrite_manifest!(geom, from: command.from, to: command.to)
-          FileUtils.mv(geom.lane_path(command.from), dest_dir)
-          Value::Result.success(plan)
-        end
-
-        private
-
-        def rewrite_manifest!(geom, from:, to:)
-          path = geom.manifest_path
-          raw = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: false)
-          raw["lanes"].each { |lane| lane["name"] = to if lane["name"] == from }
-          raw["entries"].each do |entry|
-            entry["lane"] = to if entry["lane"] == from
-            entry["key"] = entry["key"].sub(/\A#{Regexp.escape(from)}(\.|\z)/, "#{to}\\1")
-            entry["path"] = entry["path"].sub(%r{\A(data/)?#{Regexp.escape(from)}(/|\z)}, "\\1#{to}\\2")
-          end
-          File.write(path, YAML.dump(raw))
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/delete_key.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Handlers
-    module Write
-      class DeleteKey
-        def initialize(container:)
-          @container = container
-        end
-
-        def call(command, call)
-          writer = Store::Entry::Writer.from(container: @container, call: call)
-          writer.delete(command.key, if_etag: command.if_etag)
-          Value::Result.success("protocol" => Textus::PROTOCOL, "ok" => true, "key" => command.key, "deleted" => true)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/enqueue_job.rb

@@ -1,27 +0,0 @@
-module Textus
-  module Handlers
-    module Write
-      class EnqueueJob
-        def initialize(job_store:)
-          @job_store = job_store
-        end
-
-        def call(command, call)
-          action_class = Textus::Jobs.fetch(command.type.to_s)
-
-          if action_class.const_defined?(:REQUIRED_ROLE) && call.role != action_class::REQUIRED_ROLE
-            return Value::Result.failure(:forbidden,
-                                         "role '#{call.role}' is not authorized to enqueue this job type",
-                                         details: { "role" => call.role, "required_role" => action_class::REQUIRED_ROLE })
-          end
-
-          job = Textus::Store::Jobs::Queue::Job.new(type: command.type, args: command.args, role: call.role, max_attempts: 3)
-          Textus::Store::Jobs::Queue.new(store: @job_store).enqueue(job)
-          Value::Result.success("protocol" => Textus::PROTOCOL, "ok" => true, "id" => job.id)
-        rescue Textus::UsageError
-          Value::Result.failure(:usage_error, "unregistered job type '#{command.type}'")
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/key_delete_prefix.rb

@@ -1,32 +0,0 @@
-module Textus
-  module Handlers
-    module Write
-      class KeyDeletePrefix
-        def initialize(orchestration:)
-          @orchestration = orchestration
-        end
-
-        def call(command, call)
-          return Value::Result.failure(:usage_error, "prefix required") if command.prefix.nil? || command.prefix.empty?
-
-          list = @orchestration.list_keys(prefix: command.prefix, lane: nil, call: call)
-          return list if list.failure?
-
-          leaves = list.value.fetch("rows")
-
-          warnings = leaves.empty? ? ["no keys under #{command.prefix}"] : []
-          steps = leaves.map { |row| { "op" => "delete", "key" => row["key"] } }
-
-          plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: warnings)
-          return Value::Result.success(plan) if command.dry_run
-
-          steps.each do |step|
-            delete = @orchestration.delete_key(key: step["key"], call: call)
-            return delete if delete.failure?
-          end
-          Value::Result.success(plan)
-        end
-      end
-    end
-  end
-end

data/lib/textus/handlers/write/key_mv_prefix.rb

@@ -1,45 +0,0 @@
-module Textus
-  module Handlers
-    module Write
-      class KeyMvPrefix
-        def initialize(orchestration:)
-          @orchestration = orchestration
-        end
-
-        def call(command, call)
-          if command.from_prefix.nil? || command.to_prefix.nil?
-            return Value::Result.failure(:usage_error,
-                                         "from_prefix and to_prefix required")
-          end
-
-          list = @orchestration.list_keys(prefix: command.from_prefix, lane: nil, call: call)
-          return list if list.failure?
-
-          leaves = list.value.fetch("rows")
-
-          if leaves.any? { |r| r["key"] == command.from_prefix }
-            return Value::Result.failure(:usage_error,
-                                         "from_prefix '#{command.from_prefix}' is itself a leaf — use `mv` to rename a single key")
-          end
-
-          warnings = leaves.empty? ? ["no keys under #{command.from_prefix}"] : []
-          steps = leaves.map do |row|
-            old_key = row["key"]
-            tail = old_key.delete_prefix("#{command.from_prefix}.")
-            new_key = "#{command.to_prefix}.#{tail}"
-            { "op" => "mv", "from" => old_key, "to" => new_key }
-          end
-
-          plan = Textus::Store::Jobs::Plan.new(steps: steps, warnings: warnings)
-          return Value::Result.success(plan) if command.dry_run
-
-          steps.each do |step|
-            move = @orchestration.move_key(old_key: step["from"], new_key: step["to"], call: call)
-            return move if move.failure?
-          end
-          Value::Result.success(plan)
-        end
-      end
-    end
-  end
-end