igniter-ledger 0.5.2

data/lib/igniter/store/protocol/handlers/command_handler.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        # Command descriptors are metadata-only. Ledger records the app-owned
+        # mutation contract but never executes application commands.
+        class CommandHandler
+          REQUIRED = %i[name owner operation].freeze
+          OPERATIONS = %i[record_append record_update history_append none].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |field| descriptor[field].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :command) if missing.any?
+
+            name = descriptor[:name].to_sym
+            owner = descriptor[:owner].to_sym
+            operation = descriptor[:operation].to_sym
+            unless OPERATIONS.include?(operation)
+              return Receipt.rejection("Unsupported command operation: #{operation.inspect}", kind: :command)
+            end
+
+            normalized = descriptor.merge(
+              name: name,
+              owner: owner,
+              operation: operation,
+              target_shape: token(descriptor[:target_shape] || target_shape_for(operation)),
+              boundary: token(descriptor[:boundary] || :app),
+              mutation_intent: token(descriptor[:mutation_intent] || operation)
+            )
+
+            @store.schema_graph.register_command_descriptor(normalized)
+            Receipt.accepted(kind: :command, name: name)
+          end
+
+          private
+
+          def target_shape_for(operation)
+            case operation
+            when :record_append, :record_update
+              :store
+            when :history_append
+              :history
+            else
+              :none
+            end
+          end
+
+          def token(value)
+            value.nil? || value.is_a?(Symbol) ? value : value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/derivation_handler.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        # Derivation descriptors are metadata-only in OP1.
+        # Execution requires a rule callable which external descriptor packets cannot carry.
+        # The descriptor is stored in the schema graph for OP2 introspection.
+        class DerivationHandler
+          REQUIRED = %i[name inputs output].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |f| descriptor[f].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :derivation) if missing.any?
+
+            name = descriptor[:name].to_sym
+            warnings = ["derivation: #{name.inspect} registered as metadata only; attach a rule callable via register_derivation to enable execution"]
+            Receipt.accepted(kind: :derivation, name: name, warnings: warnings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/effect_handler.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        # Effect descriptors describe the app-boundary persistence intent that a
+        # command lowers to. They are metadata-only and do not execute effects.
+        class EffectHandler
+          REQUIRED = %i[name owner store_op write_kind].freeze
+          STORE_OPS = %i[store_write store_append none].freeze
+          WRITE_KINDS = %i[insert update append none].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |field| descriptor[field].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :effect) if missing.any?
+
+            name = descriptor[:name].to_sym
+            owner = descriptor[:owner].to_sym
+            store_op = descriptor[:store_op].to_sym
+            write_kind = descriptor[:write_kind].to_sym
+            unless STORE_OPS.include?(store_op)
+              return Receipt.rejection("Unsupported effect store_op: #{store_op.inspect}", kind: :effect)
+            end
+            unless WRITE_KINDS.include?(write_kind)
+              return Receipt.rejection("Unsupported effect write_kind: #{write_kind.inspect}", kind: :effect)
+            end
+
+            normalized = descriptor.merge(
+              name: name,
+              owner: owner,
+              store_op: store_op,
+              write_kind: write_kind,
+              lowers_to: token(descriptor[:lowers_to] || lowers_to_for(store_op)),
+              boundary: token(descriptor[:boundary] || :app)
+            )
+            normalized[:source_operation] = token(descriptor[:source_operation]) if descriptor.key?(:source_operation)
+
+            @store.schema_graph.register_effect_descriptor(normalized)
+            Receipt.accepted(kind: :effect, name: name)
+          end
+
+          private
+
+          def lowers_to_for(store_op)
+            case store_op
+            when :store_write
+              :store_t
+            when :store_append
+              :history_t
+            else
+              :none
+            end
+          end
+
+          def token(value)
+            value.nil? || value.is_a?(Symbol) ? value : value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/history_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        class HistoryHandler
+          REQUIRED = %i[name key].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |f| descriptor[f].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :history) if missing.any?
+
+            name = descriptor[:name].to_sym
+            @store.schema_graph.register_history_descriptor(descriptor.merge(name: name))
+            Receipt.accepted(kind: :history, name: name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/projection_handler.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        class ProjectionHandler
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            return Receipt.rejection("Missing required fields: name", kind: :projection) if descriptor[:name].nil?
+            if descriptor[:reads].nil? && descriptor[:source].nil?
+              return Receipt.rejection("Missing required fields: reads or source", kind: :projection)
+            end
+
+            name    = descriptor[:name].to_sym
+            source  = descriptor[:source]
+            reads   = descriptor[:reads] || source
+            reads   = Array(reads).map(&:to_sym)
+            relations = Array(descriptor[:relations]).map(&:to_sym)
+            consumer_hint = (descriptor[:consumer_hint] || :protocol_client).to_sym
+            mode    = descriptor.fetch(:mode, :on_demand)
+            reactive = descriptor.key?(:reactive) ? !!descriptor[:reactive] : mode == :materialized
+
+            @store.register_projection(
+              ProjectionPath.new(
+                name:          name,
+                reads:         reads,
+                relations:     relations,
+                consumer_hint: consumer_hint,
+                reactive:      reactive
+              )
+            )
+
+            Receipt.accepted(kind: :projection, name: name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/relation_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        class RelationHandler
+          REQUIRED = %i[name from to].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |f| descriptor[f].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :relation) if missing.any?
+
+            name       = descriptor[:name].to_sym
+            from_desc  = descriptor[:from]
+            to_desc    = descriptor[:to]
+
+            unless from_desc.is_a?(Hash) && from_desc[:store] && from_desc[:key]
+              return Receipt.rejection("from: must be { store:, key: }", kind: :relation, name: name)
+            end
+            unless to_desc.is_a?(Hash) && to_desc[:store] && to_desc[:field]
+              return Receipt.rejection("to: must be { store:, field: }", kind: :relation, name: name)
+            end
+
+            cardinality = descriptor.fetch(:cardinality, :many)
+            warnings    = cardinality == :one ? ["cardinality: :one is informational only; engine always stores as G-Set"] : []
+
+            @store.register_relation(
+              name,
+              source:    to_desc[:store].to_sym,
+              partition: to_desc[:field].to_sym,
+              target:    from_desc[:store].to_sym
+            )
+
+            Receipt.accepted(kind: :relation, name: name, warnings: warnings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/store_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        class StoreHandler
+          REQUIRED = %i[name key].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |f| descriptor[f].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :store) if missing.any?
+
+            name = descriptor[:name].to_sym
+            @store.schema_graph.register_store_descriptor(descriptor.merge(name: name))
+            Receipt.accepted(kind: :store, name: name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/igniter/store/protocol/handlers/subscription_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Store
+    module Protocol
+      module Handlers
+        class SubscriptionHandler
+          REQUIRED = %i[name source].freeze
+
+          def initialize(store) = @store = store
+
+          def call(descriptor)
+            missing = REQUIRED.select { |f| descriptor[f].nil? }
+            return Receipt.rejection("Missing required fields: #{missing.join(", ")}", kind: :subscription) if missing.any?
+
+            name = descriptor[:name].to_sym
+            @store.schema_graph.register_subscription_descriptor(descriptor.merge(name: name))
+            Receipt.accepted(kind: :subscription, name: name)
+          end
+        end
+      end
+    end
+  end
+end