textus 0.15.0 → 0.20.0

data/lib/textus/application/tools/migrate_manifest_to_kinds.rb

@@ -0,0 +1,31 @@
+require "yaml"
+
+module Textus
+  module Application
+    module Tools
+      module MigrateManifestToKinds
+        module_function
+
+        def upgrade_yaml(yaml_text)
+          raw = YAML.safe_load(yaml_text, aliases: false)
+          raw["entries"] = Array(raw["entries"]).map { |row| upgrade_row(row) }
+          YAML.dump(raw)
+        end
+
+        def upgrade_row(row)
+          return row if row["kind"]
+
+          row.merge("kind" => infer_kind(row))
+        end
+
+        def infer_kind(row)
+          return "intake"  if row["intake"].is_a?(Hash) || row["intake_handler"]
+          return "derived" if row["template"] || row["compute"] || row["generator"] || row["projection"]
+          return "nested"  if row["nested"] == true
+
+          "leaf"
+        end
+      end
+    end
+  end
+end

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

@@ -2,15 +2,23 @@ module Textus
   module Application
     module Writes
       class Accept
-        def initialize(ctx:, bus:)
-          @ctx = ctx
-          @bus = bus
+        def initialize(ctx:, manifest:, file_store:, schemas:, envelope_io:, bus:, authorizer:, hook_context:) # rubocop:disable Metrics/ParameterLists
+          @ctx          = ctx
+          @manifest     = manifest
+          @file_store   = file_store
+          @schemas      = schemas
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(pending_key)
           raise ProposalError.new("only human role can accept proposals; got '#{@ctx.role}'") unless @ctx.role == "human"
 
-          env = @ctx.store.reader.get(pending_key)
+          env = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          ).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"
@@ -23,33 +31,48 @@ module Textus
             # target. Not related to the removed intake-handler legacy bridge.
             target_meta = env.meta["frontmatter"] || {}
             target_body = env.body
-            Textus::Application::Writes::Put.new(ctx: @ctx, bus: @bus).call(target, meta: target_meta, body: target_body)
+            put_op.call(target, meta: target_meta, body: target_body)
           when "delete"
-            Textus::Application::Writes::Delete.new(ctx: @ctx, bus: @bus).call(target)
+            delete_op.call(target)
           else
             raise ProposalError.new("unknown action: #{action}")
           end
 
-          Textus::Application::Writes::Delete.new(ctx: @ctx, bus: @bus).call(pending_key)
+          delete_op.call(pending_key)
 
           @bus.publish(:proposal_accepted,
-                       store: @ctx.with_role(@ctx.role),
+                       ctx: @hook_context,
                        key: pending_key,
-                       target_key: target,
-                       correlation_id: @ctx.correlation_id)
+                       target_key: target)
 
           { "protocol" => PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action }
         end
 
         private
 
+        def put_op
+          @put_op ||= Textus::Application::Writes::Put.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          )
+        end
+
+        def delete_op
+          @delete_op ||= Textus::Application::Writes::Delete.new(
+            ctx: @ctx, manifest: @manifest, envelope_io: @envelope_io,
+            bus: @bus, authorizer: @authorizer, hook_context: @hook_context
+          )
+        end
+
         def evaluate_promotion!(env, target_key)
-          rules = @ctx.store.manifest.rules_for(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, store: @ctx.store)
+          policy = Textus::Application::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(

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

@@ -2,29 +2,27 @@ module Textus
   module Application
     module Writes
       class Delete
-        def initialize(ctx:, bus:)
-          @ctx = ctx
-          @bus = bus
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(key, if_etag: nil, suppress_events: false)
-          @ctx.store.manifest.validate_key!(key)
-          mentry, = @ctx.store.manifest.resolve(key)
+          @manifest.validate_key!(key)
+          mentry = @manifest.resolver.resolve(key).entry
 
-          unless @ctx.can_write?(mentry.zone)
-            raise WriteForbidden.new(key, mentry.zone,
-                                     writers: @ctx.store.manifest.zone_writers(mentry.zone))
-          end
+          @authorizer.authorize_write!(mentry, role: @ctx.role)
 
-          @ctx.store.writer.delete_envelope_from_disk(
-            key, ctx: @ctx, if_etag: if_etag
-          )
+          @envelope_io.delete(key, mentry: mentry, if_etag: if_etag)
 
           unless suppress_events
             @bus.publish(:entry_deleted,
-                         store: @ctx.with_role(@ctx.role),
-                         key: key,
-                         correlation_id: @ctx.correlation_id)
+                         ctx: @hook_context,
+                         key: key)
           end
 
           { "protocol" => Textus::PROTOCOL, "ok" => true, "key" => key, "deleted" => true }

data/lib/textus/application/writes/envelope_io.rb

@@ -0,0 +1,166 @@
+require "fileutils"
+
+module Textus
+  module Application
+    module Writes
+      # Owns the write pipeline (validate, serialize, etag-check, write, audit)
+      # extracted from Store::Writer. Talks to ports (FileStore, Schemas,
+      # AuditLog, Manifest) instead of File/FileUtils and Store directly.
+      #
+      # No permission check, no event firing — those belong to the caller
+      # (Application::Writes::Put / ::Delete / ::Mv).
+      class EnvelopeIO
+        Payload = Data.define(:meta, :body, :content)
+
+        def initialize(file_store:, manifest:, schemas:, audit_log:, ctx:)
+          @file_store = file_store
+          @manifest   = manifest
+          @schemas    = schemas
+          @audit_log  = audit_log
+          @ctx        = ctx
+        end
+
+        def exists?(path) = @file_store.exists?(path)
+
+        # Reads an envelope by key, returning nil when absent. Used by Mv
+        # to inspect pre-move state (UID presence, content surfacing) so
+        # the move pipeline can consolidate I/O in one place.
+        def read_envelope(key)
+          res = @manifest.resolver.resolve(key)
+          path = res.path
+          return nil unless @file_store.exists?(path)
+
+          mentry = res.entry
+          raw = @file_store.read(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 write(key, mentry:, payload:, if_etag: nil)
+          path = @manifest.resolver.resolve(key).path
+
+          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 = @schemas.fetch_or_nil(mentry.schema)
+          if schema
+            Entry.for_format(mentry.format).validate_against(
+              schema,
+              { "_meta" => eff_meta, "content" => eff_content },
+            )
+          end
+
+          etag_before = @file_store.exists?(path) ? @file_store.etag(path) : nil
+          raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && (etag_before != if_etag)
+
+          @file_store.write(path, bytes)
+          etag_after = Etag.for_bytes(bytes)
+          @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 delete(key, mentry:, if_etag: nil)
+          _ = mentry
+          path = @manifest.resolver.resolve(key).path
+          raise UnknownKey.new(key, suggestions: @manifest.resolver.suggestions_for(key)) unless @file_store.exists?(path)
+
+          etag_before = @file_store.etag(path)
+          raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && if_etag != etag_before
+
+          @file_store.delete(path)
+          @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
+
+        def move(from_key:, to_key:, new_mentry:, if_etag: nil)
+          from_path = @manifest.resolver.resolve(from_key).path
+          to_path   = @manifest.resolver.resolve(to_key).path
+          raise UnknownKey.new(from_key, suggestions: @manifest.resolver.suggestions_for(from_key)) unless @file_store.exists?(from_path)
+
+          etag_before = @file_store.etag(from_path)
+          raise EtagMismatch.new(from_key, if_etag, etag_before) if if_etag && if_etag != etag_before
+
+          FileUtils.mkdir_p(File.dirname(to_path))
+          FileUtils.mv(from_path, to_path)
+          basename = to_key.split(".").last
+          Entry.for_format(new_mentry.format).rewrite_name(to_path, basename)
+          etag_after = Etag.for_file(to_path)
+
+          raw = @file_store.read(to_path)
+          parsed = Entry.for_format(new_mentry.format).parse(raw, path: to_path)
+          envelope = Envelope.build(
+            key: to_key, mentry: new_mentry, path: to_path,
+            meta: parsed["_meta"], body: parsed["body"],
+            etag: etag_after, content: parsed["content"]
+          )
+
+          extras = {
+            "from_key" => from_key, "to_key" => to_key,
+            "from_path" => from_path, "to_path" => to_path,
+            "uid" => envelope.uid
+          }
+          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
+
+          @audit_log.append(
+            role: @ctx.role, verb: "mv", key: to_key,
+            etag_before: etag_before, etag_after: etag_after,
+            extras: extras
+          )
+
+          envelope
+        end
+
+        private
+
+        def existing_uid_for(mentry, path)
+          return nil unless @file_store.exists?(path)
+
+          raw = @file_store.read(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require "fileutils"
+
+module Textus
+  module Application
+    module Writes
+      # Materializes a single Derived manifest entry onto disk by running
+      # the builder pipeline (template + projection + external runner).
+      # Extracted from Application::Writes::Build so that Publish can reuse
+      # it without creating a Build dependency.
+      class Materializer
+        def initialize(ctx:, manifest:, file_store:, bus:, root:, store:)
+          @ctx        = ctx
+          @manifest   = manifest
+          @file_store = file_store
+          @bus        = bus
+          @root       = root
+          @store      = store
+        end
+
+        # Runs the builder pipeline for `mentry` and returns the on-disk
+        # target_path string.
+        def run(mentry)
+          reader = Textus::Application::Reads::Get.new(
+            ctx: @ctx, manifest: @manifest, file_store: @file_store,
+          )
+          lister = Textus::Application::Reads::List.new(manifest: @manifest)
+          Builder::Pipeline.run(
+            mentry: mentry,
+            manifest: @manifest,
+            reader: reader.method(:call),
+            lister: lister.method(:call),
+            transform_resolver: ->(name) { @bus.rpc_callable(:transform_rows, name) },
+            template_loader: ->(name) { read_template(name) },
+            transform_context: @store,
+            inject_intro: -> { Textus::Intro.run(@store) },
+          )
+        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/writes/mv.rb

@@ -1,55 +1,46 @@
-require "fileutils"
-
 module Textus
   module Application
     module Writes
       class Mv
-        MovePlan = Data.define(
-          :old_key, :new_key, :old_path, :new_path,
-          :new_mentry, :uid, :etag_before
-        )
-
-        def initialize(ctx:, bus:)
-          @ctx = ctx
-          @bus = bus
+        def initialize(ctx:, manifest:, envelope_io:, bus:, authorizer:, hook_context:)
+          @ctx          = ctx
+          @manifest     = manifest
+          @envelope_io  = envelope_io
+          @bus          = bus
+          @authorizer   = authorizer
+          @hook_context = hook_context
         end
 
         def call(old_key, new_key, dry_run: false)
-          plan, pre_env = prepare_plan(old_key, new_key)
-          return dry_run_result(plan) if dry_run
+          old_res, new_res = prepare(old_key, new_key)
+          return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
 
-          plan = ensure_uid!(plan, pre_env: pre_env)
-          etag_after = perform_move!(plan)
-          new_envelope = record_move(plan, etag_after: etag_after)
-          success_result(plan, new_envelope: new_envelope)
+          ensure_uid!(old_key, old_res.entry)
+          envelope = @envelope_io.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 manifest = @ctx.store.manifest
-        def reader   = @ctx.store.reader
-
-        def prepare_plan(old_key, new_key)
-          manifest.validate_key!(old_key)
-          manifest.validate_key!(new_key)
+        def prepare(old_key, new_key)
+          @manifest.validate_key!(old_key)
+          @manifest.validate_key!(new_key)
           raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
 
-          old_mentry, old_path, = manifest.resolve(old_key)
-          raise UnknownKey.new(old_key) unless File.exist?(old_path)
+          old_res = @manifest.resolver.resolve(old_key)
+          new_res = @manifest.resolver.resolve(new_key)
+          raise UnknownKey.new(old_key) unless @envelope_io.exists?(old_res.path)
 
-          new_mentry, new_path, = manifest.resolve(new_key)
-          validate_zone_and_format!(old_mentry, new_mentry)
-          validate_writer!(old_mentry, old_key)
-          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_path)
+          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 @envelope_io.exists?(new_res.path)
 
-          pre_env = reader.get(old_key)
-          plan = MovePlan.new(
-            old_key: old_key, new_key: new_key,
-            old_path: old_path, new_path: new_path,
-            new_mentry: new_mentry,
-            uid: pre_env.uid, etag_before: pre_env.etag
-          )
-          [plan, pre_env]
+          [old_res, new_res]
         end
 
         def validate_zone_and_format!(old_mentry, new_mentry)
@@ -64,80 +55,50 @@ module Textus
           raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
         end
 
-        def validate_writer!(mentry, key)
-          writers = manifest.zone_writers(mentry.zone)
-          return if writers.include?(@ctx.role)
-
-          raise WriteForbidden.new(key, mentry.zone, writers: writers)
-        end
-
-        def ensure_uid!(plan, pre_env:)
-          return plan if plan.uid
-
-          env = Textus::Application::Writes::Put.new(ctx: @ctx, bus: @bus).call(
-            plan.old_key,
-            meta: pre_env.meta,
-            body: pre_env.body,
-            content: pre_env.content,
-            suppress_events: true,
+        # If the source file lacks a UID, rewrite it in-place via EnvelopeIO#write
+        # so a UID gets injected before the move. This replaces the previous
+        # Put(suppress_events: true) bypass with a direct EnvelopeIO call —
+        # producing one "put" audit row, then the "mv" row from EnvelopeIO#move.
+        def ensure_uid!(old_key, old_mentry)
+          pre_env = @envelope_io.read_envelope(old_key)
+          return if pre_env.uid
+
+          @envelope_io.write(
+            old_key, mentry: old_mentry,
+                     payload: EnvelopeIO::Payload.new(
+                       meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
+                     )
           )
-          plan.with(uid: env.uid, etag_before: env.etag)
-        end
-
-        def perform_move!(plan)
-          FileUtils.mkdir_p(File.dirname(plan.new_path))
-          FileUtils.mv(plan.old_path, plan.new_path)
-          rewrite_name_for_mv!(plan.new_mentry, plan.new_path, plan.new_key)
-          Etag.for_file(plan.new_path)
         end
 
-        def record_move(plan, etag_after:)
-          extras = {
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
-          }
-          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
-
-          @ctx.store.audit_log.append(
-            role: @ctx.role, verb: "mv", key: plan.new_key,
-            etag_before: plan.etag_before, etag_after: etag_after,
-            extras: extras
-          )
-          new_envelope = reader.get(plan.new_key)
+        def publish_renamed(old_key, new_key, envelope)
           @bus.publish(:entry_renamed,
-                       store: @ctx.with_role(@ctx.role),
-                       key: plan.new_key,
-                       from_key: plan.old_key,
-                       to_key: plan.new_key,
-                       envelope: new_envelope,
-                       correlation_id: @ctx.correlation_id)
-          new_envelope
+                       ctx: @hook_context,
+                       key: new_key,
+                       from_key: old_key,
+                       to_key: new_key,
+                       envelope: envelope)
         end
 
-        def dry_run_result(plan)
+        def dry_run_result(old_key, new_key, old_res, new_res)
+          pre_env = @envelope_io.read_envelope(old_key)
           {
             "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid
+            "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(plan, new_envelope:)
+        def success_result(old_key, new_key, old_res, new_res, envelope)
           {
             "protocol" => PROTOCOL, "ok" => true,
-            "from_key" => plan.old_key, "to_key" => plan.new_key,
-            "from_path" => plan.old_path, "to_path" => plan.new_path,
-            "uid" => plan.uid,
-            "envelope" => new_envelope.to_h_for_wire
+            "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
-
-        def rewrite_name_for_mv!(mentry, new_path, new_key)
-          basename = new_key.split(".").last
-          Entry.for_format(mentry.format).rewrite_name(new_path, basename)
-        end
       end
     end
   end