textus 0.15.0 → 0.18.0

data/lib/textus/operations/reads.rb

@@ -1,56 +0,0 @@
-module Textus
-  class Operations
-    class Reads
-      # `get`              — pure read; returns envelope + freshness verdict;
-      #                      never triggers refresh; no orchestrator dependency.
-      # `get_or_refresh`   — composes `get` with the refresh orchestrator; runs
-      #                      refresh per policy when the verdict says stale.
-      #                      Use this for interactive reads where the caller
-      #                      wants the freshest envelope obtainable.
-      #
-      # Pick `get` for materialization paths (build, projection, schema tooling).
-      # Pick `get_or_refresh` for interactive `textus get` and equivalent.
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def get
-        Application::Reads::Get.new(ctx: @ctx)
-      end
-
-      def get_or_refresh # rubocop:disable Naming/AccessorMethodName
-        Application::Reads::GetOrRefresh.new(
-          ctx: @ctx,
-          get: get,
-          orchestrator: orchestrator,
-        )
-      end
-
-      def freshness      = Application::Reads::Freshness.new(ctx: @ctx)
-      def audit          = Application::Reads::Audit.new(ctx: @ctx)
-      def blame          = Application::Reads::Blame.new(ctx: @ctx)
-      def policy_explain = Application::Reads::PolicyExplain.new(ctx: @ctx)
-      def list           = Application::Reads::List.new(ctx: @ctx)
-      def where           = Application::Reads::Where.new(ctx: @ctx)
-      def uid             = Application::Reads::Uid.new(ctx: @ctx)
-      def schema_envelope = Application::Reads::SchemaEnvelope.new(ctx: @ctx)
-      def deps            = Application::Reads::Deps.new(ctx: @ctx)
-      def rdeps           = Application::Reads::Rdeps.new(ctx: @ctx)
-      def published       = Application::Reads::Published.new(ctx: @ctx)
-      def stale           = Application::Reads::Stale.new(ctx: @ctx)
-      def validate_all    = Application::Reads::ValidateAll.new(ctx: @ctx)
-
-      private
-
-      def orchestrator
-        Application::Refresh::Orchestrator.new(
-          worker: Application::Refresh::Worker.new(ctx: @ctx, bus: @ctx.store.bus),
-          bus: @ctx.store.bus,
-          store_root: @ctx.store.root,
-          store: @ctx.store,
-          role: @ctx.role,
-        )
-      end
-    end
-  end
-end

data/lib/textus/operations/refresh.rb

@@ -1,27 +0,0 @@
-module Textus
-  class Operations
-    class Refresh
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def worker
-        Application::Refresh::Worker.new(ctx: @ctx, bus: @ctx.store.bus)
-      end
-
-      def orchestrator
-        Application::Refresh::Orchestrator.new(
-          worker: worker,
-          bus: @ctx.store.bus,
-          store_root: @ctx.store.root,
-          store: @ctx.store,
-          role: @ctx.role,
-        )
-      end
-
-      def all
-        Application::Refresh::All.new(ctx: @ctx, bus: @ctx.store.bus)
-      end
-    end
-  end
-end

data/lib/textus/operations/writes.rb

@@ -1,21 +0,0 @@
-module Textus
-  class Operations
-    class Writes
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def put     = Application::Writes::Put.new(ctx: @ctx, bus: bus)
-      def delete  = Application::Writes::Delete.new(ctx: @ctx, bus: bus)
-      def mv      = Application::Writes::Mv.new(ctx: @ctx, bus: bus)
-      def accept  = Application::Writes::Accept.new(ctx: @ctx, bus: bus)
-      def build   = Application::Writes::Build.new(ctx: @ctx, bus: bus)
-      def publish = Application::Writes::Publish.new(ctx: @ctx, bus: bus)
-      def reject  = Application::Writes::Reject.new(ctx: @ctx, bus: bus)
-
-      private
-
-      def bus = @ctx.store.bus
-    end
-  end
-end

data/lib/textus/store/reader.rb

@@ -1,69 +0,0 @@
-module Textus
-  class Store
-    class Reader
-      def initialize(store)
-        @store = store
-        @manifest = store.manifest
-      end
-
-      def get(key)
-        read_raw_envelope(key) || raise(UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)))
-      end
-
-      # Reads the current on-disk state of key as a bare envelope, skipping
-      # freshness annotation to avoid recursion. Used by Freshness.refresh_sync
-      # after a sync refresh completes.
-      def read_raw_envelope(key)
-        mentry, path, = @manifest.resolve(key)
-        return nil unless File.exist?(path)
-
-        raw = File.binread(path)
-        parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        Envelope.build(
-          key: key, mentry: mentry, path: path,
-          meta: parsed["_meta"], body: parsed["body"],
-          etag: Etag.for_bytes(raw), content: parsed["content"]
-        )
-      end
-
-      def list(prefix: nil, zone: nil)
-        rows = @manifest.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
-
-      def where(key)
-        mentry, path, = @manifest.resolve(key)
-        { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }
-      end
-
-      def schema_envelope(key)
-        mentry, = @manifest.resolve(key)
-        schema = @store.schema_for(mentry.schema)
-        { "protocol" => PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
-      end
-
-      # Returns the Textus UID for a key (or nil if the entry has none yet).
-      # Raises UnknownKey if the key doesn't resolve to a real file.
-      def uid(key)
-        get(key).uid
-      end
-
-      def deps(key)   = Dependencies.deps_of(@manifest, key)
-      def rdeps(key)  = Dependencies.rdeps_of(@manifest, key)
-      def published   = Dependencies.published_of(@manifest)
-
-      def stale(prefix: nil, zone: nil)
-        Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
-      end
-
-      def validate_all
-        Validator.new(
-          reader: self, manifest: @manifest,
-          audit_log: @store.audit_log,
-          schema_for: ->(name) { @store.schema_for(name) }
-        ).call
-      end
-    end
-  end
-end

data/lib/textus/store/validator.rb

@@ -1,82 +0,0 @@
-module Textus
-  class Store
-    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.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.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?
-
-        env.meta.each_key do |field|
-          owner = schema.maintained_by(field)
-          next if owner.nil? || last_writer == owner || last_writer == "human"
-
-          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

data/lib/textus/store/writer.rb

@@ -1,102 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    class Writer
-      Payload = Data.define(:meta, :body, :content)
-
-      def initialize(store)
-        @store = store
-        @manifest = store.manifest
-        @reader = store.reader
-      end
-
-      # Pure I/O: validate, serialize, etag-check, write to disk, audit. No
-      # permission check and no event firing — those are handled by the caller
-      # (Application::Writes::Put).
-      def write_envelope_to_disk(key, mentry:, payload:, ctx:, if_etag: nil)
-        _, path, = @manifest.resolve(key)
-
-        meta = payload.meta || {}
-        strategy = Entry.for_format(mentry.format)
-
-        existing_uid = existing_uid_for(mentry, path)
-        meta, content = ensure_uid(mentry.format, meta, payload.content, existing_uid)
-
-        bytes, eff_meta, eff_body, eff_content = serialize_for_put(
-          mentry: mentry, path: path, strategy: strategy,
-          meta: meta, body: payload.body, content: content
-        )
-
-        enforce_name_match!(path, eff_meta, mentry.format)
-
-        schema = @store.schema_for(mentry.schema)
-        if schema
-          Entry.for_format(mentry.format).validate_against(
-            schema,
-            { "_meta" => eff_meta, "content" => eff_content },
-          )
-        end
-
-        etag_before = File.exist?(path) ? Etag.for_file(path) : nil
-        raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && (etag_before != if_etag)
-
-        FileUtils.mkdir_p(File.dirname(path))
-        File.binwrite(path, bytes)
-        etag_after = Etag.for_bytes(bytes)
-        @store.audit_log.append(
-          role: ctx.role, verb: "put", key: key,
-          etag_before: etag_before, etag_after: etag_after,
-          extras: ctx.correlation_id ? { "correlation_id" => ctx.correlation_id } : nil
-        )
-        Envelope.build(
-          key: key, mentry: mentry, path: path,
-          meta: eff_meta, body: eff_body, etag: etag_after, content: eff_content
-        )
-      end
-
-      def existing_uid_for(mentry, path)
-        return nil unless File.exist?(path)
-
-        raw = File.binread(path)
-        parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        Envelope.extract_uid(parsed["_meta"])
-      rescue StandardError
-        nil
-      end
-
-      def ensure_uid(format, meta, content, existing_uid)
-        Textus::Entry.for_format(format).inject_uid(meta, content, existing_uid)
-      end
-
-      def enforce_name_match!(path, meta, format)
-        Textus::Entry.for_format(format).enforce_name_match!(path, meta)
-      end
-
-      def serialize_for_put(mentry:, path:, strategy:, meta:, body:, content:)
-        _ = strategy
-        Textus::Entry.for_format(mentry.format).serialize_for_put(
-          meta: meta, body: body, content: content, path: path,
-        )
-      end
-
-      # Pure I/O: resolve path, validate etag, delete from disk, audit. No
-      # permission check and no event firing — those are handled by the caller
-      # (Application::Writes::Delete).
-      def delete_envelope_from_disk(key, ctx:, if_etag: nil)
-        _, path, = @manifest.resolve(key)
-        raise UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)) unless File.exist?(path)
-
-        etag_before = Etag.for_file(path)
-        raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && if_etag != etag_before
-
-        File.delete(path)
-        @store.audit_log.append(
-          role: ctx.role, verb: "delete", key: key,
-          etag_before: etag_before, etag_after: nil,
-          extras: ctx.correlation_id ? { "correlation_id" => ctx.correlation_id } : nil
-        )
-      end
-    end
-  end
-end