orfeas_lyra 0.6.0 → 0.8.0

data/config/privacy_policies.rb

@@ -110,9 +110,9 @@ PamDsl.define_policy :university_system do
   purpose :communication do
     describe "Important academic and administrative communications"
     basis :legitimate_interests
+    lia_documented!
     requires :email
     optionally :phone, :name
-    meta :balancing_test_performed, true
   end
 
   purpose :academic_records do
@@ -140,6 +140,7 @@ PamDsl.define_policy :university_system do
   purpose :analytics do
     describe "Improving educational services and user experience"
     basis :legitimate_interests
+    lia_documented!
     requires :student_id
     meta :anonymization_applied, true
   end

data/lib/lyra/engine.rb

@@ -61,6 +61,7 @@ module Lyra
       # Load rake tasks
       rake_tasks do
         load "tasks/lyra_schema.rake"
+        load "tasks/lyra_projections.rake"
       end
     end
   end

data/lib/lyra/interceptors/crud_interceptor.rb

@@ -8,10 +8,12 @@ module Lyra
         class_attribute :lyra_monitored, default: false
         class_attribute :lyra_config
 
-        # Callbacks for monitoring CRUD operations (after_* = non-blocking)
-        after_create :lyra_intercept_create, if: :lyra_monitored?
-        after_update :lyra_intercept_update, if: :lyra_monitored?
-        after_destroy :lyra_intercept_destroy, if: :lyra_monitored?
+        # Callbacks for monitoring CRUD operations (after_* = non-blocking).
+        # Gated on the mode as well as the model: in :disabled mode a monitored
+        # model must behave exactly like plain ActiveRecord and emit no events.
+        after_create :lyra_intercept_create, if: :lyra_events_enabled?
+        after_update :lyra_intercept_update, if: :lyra_events_enabled?
+        after_destroy :lyra_intercept_destroy, if: :lyra_events_enabled?
 
         # For hijack mode - run before operation, store event, then let save proceed
         before_create :lyra_hijack_create, if: :lyra_hijack_mode?
@@ -184,6 +186,13 @@ module Lyra
         self.class.lyra_monitored
       end
 
+      # Monitoring a model is not enough to emit events: :disabled mode must be a
+      # true ORM baseline. Hijack and event-sourcing modes still pass this guard;
+      # their after_* callbacks return early via @lyra_hijacked.
+      def lyra_events_enabled?
+        lyra_monitored? && !Lyra.disabled_mode?
+      end
+
       def lyra_hijack_mode?
         lyra_monitored? && Lyra.hijack_mode?
       end

data/lib/lyra/privacy/gdpr_compliance.rb

@@ -30,7 +30,7 @@ module Lyra
         @pam_compliance = PamDsl::GDPRCompliance.new(
           subject_id: subject_id,
           subject_type: subject_type,
-          event_reader: method(:read_subject_events),
+          record_reader: method(:read_subject_events),
           attribute_extractor: method(:extract_attributes),
           timestamp_extractor: method(:extract_timestamp),
           operation_extractor: method(:extract_operation),

data/lib/lyra/privacy/policy_integration.rb

@@ -37,16 +37,12 @@ module Lyra
         !@policy.nil?
       end
 
-      # Validate data access for a purpose
-      def validate_access!(field_names, purpose, consent_status = {})
+      # Validate data access for a (fields, purpose, subject) triple.
+      # subject: is the data subject identifier required by Policy#validate_access!
+      def validate_access!(field_names, purpose, subject:)
         return true unless policy_loaded?
 
-        @policy.validate_access!(
-          field_names,
-          purpose,
-          consent_granted: consent_status[:granted] || false,
-          consent_granted_at: consent_status[:granted_at]
-        )
+        @policy.validate_access!(field_names, purpose, subject: subject)
       end
 
       # Get PII fields from attributes using policy and/or detector

data/lib/lyra/projections/cached_projection.rb

@@ -249,7 +249,7 @@ module Lyra
         # Load events from stream
         def load_events(stream_name)
           Lyra.config.event_store.read.stream(stream_name).to_a
-        rescue RubyEventStore::StreamNotFound
+        rescue RubyEventStore::EventNotFoundInStream
           []
         end
 

data/lib/lyra/projections/rebuild.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Lyra
+  module Projections
+    # Rebuilds read-model tables from the event log.
+    #
+    # This is the load-bearing operation of event sourcing: because the event
+    # log is the source of truth and the model tables are a derived projection,
+    # the tables must be reconstructable from the log alone. Rebuild enumerates
+    # every stream for a model, clears the read model, and replays each event
+    # through the *same* +ModelProjection.project+ path used by live sync/async
+    # projection -- so a rebuilt table is byte-for-byte what live projection
+    # would have produced.
+    #
+    # Usage:
+    #   Lyra::Projections::Rebuild.rebuild(Registration)
+    #   Lyra::Projections::Rebuild.rebuild_all            # all monitored models
+    #   Lyra::Projections::Rebuild.rebuild(Order, truncate: false)
+    #
+    # Or via rake:
+    #   rake lyra:projections:rebuild MODEL=Registration
+    #   rake lyra:projections:rebuild                     # all monitored models
+    #
+    class Rebuild
+      class << self
+        # Rebuild a single model's read-model table from its event streams.
+        #
+        # @param model_class [Class] the ActiveRecord model to rebuild
+        # @param truncate [Boolean] clear the table before replaying (default true);
+        #   set false to reconstruct only the streamed rows in place
+        # @return [Hash] statistics for the rebuild
+        def rebuild(model_class, truncate: true)
+          stats = {
+            model: model_class.name,
+            streams: 0, events: 0, records: 0, destroyed: 0
+          }
+          rebuilt_ids = []
+
+          model_class.transaction do
+            clear_read_model(model_class) if truncate
+
+            stream_ids_for(model_class).each do |id|
+              stats[:streams] += 1
+              rebuilt_ids << id
+              replayed, present = replay_stream(model_class, id)
+              stats[:events] += replayed
+              present ? stats[:records] += 1 : stats[:destroyed] += 1
+            end
+          end
+
+          invalidate_caches(model_class, rebuilt_ids)
+          stats
+        end
+
+        # Rebuild every monitored model (or an explicit list).
+        #
+        # @param models [Array<Class>] models to rebuild (defaults to all monitored)
+        # @param truncate [Boolean] clear each table before replaying
+        # @return [Array<Hash>] per-model statistics
+        def rebuild_all(models = Lyra.config.monitored_models, truncate: true)
+          models.map { |model_class| rebuild(model_class, truncate: truncate) }
+        end
+
+        private
+
+        # Replay a single stream (one record's lifecycle) through the live
+        # projector, in append order. Returns [events_replayed, still_present?].
+        def replay_stream(model_class, id)
+          stream_name = "#{model_class.name}$#{id}"
+          events = Lyra.config.event_store.read.stream(stream_name).to_a
+          replayed = 0
+
+          events.each do |event|
+            operation = operation_for(event)
+            next unless operation
+
+            ModelProjection.project(model_class, operation, build_result_from_event(event))
+            replayed += 1
+          end
+
+          present = !(events.last && events.last.event_type.to_s.end_with?("Destroyed"))
+          [replayed, present]
+        end
+
+        # Map an event type to a CRUD operation. Unknown event types are skipped.
+        def operation_for(event)
+          case event.event_type.to_s
+          when /Created$/   then :create
+          when /Updated$/   then :update
+          when /Destroyed$/ then :destroy
+          end
+        end
+
+        # Reconstruct the CommandResult-like struct ModelProjection expects,
+        # identical to Lyra::Projections::AsyncProjectionJob so rebuild and live
+        # async projection share one code path.
+        def build_result_from_event(event)
+          Struct.new(:events, :attributes, :success?, keyword_init: true).new(
+            events: [event],
+            attributes: event.data[:attributes] || event.data["attributes"] || {},
+            success?: true
+          )
+        end
+
+        # Enumerate the record ids that have an event stream for this model.
+        def stream_ids_for(model_class)
+          prefix = "#{model_class.name}$"
+          sql = ActiveRecord::Base.sanitize_sql_array(
+            ["SELECT DISTINCT stream FROM event_store_events_in_streams WHERE stream LIKE ?", "#{prefix}%"]
+          )
+          ActiveRecord::Base.connection.select_values(sql).map { |stream| stream.sub(prefix, "") }
+        end
+
+        # Clear the read-model table, bypassing callbacks/strict-access guards
+        # (this is a legitimate bulk projection operation, like ModelProjection).
+        def clear_read_model(model_class)
+          previous = Thread.current[:lyra_bypass_strict_access]
+          Thread.current[:lyra_bypass_strict_access] = true
+          begin
+            model_class.unscoped.delete_all
+          ensure
+            Thread.current[:lyra_bypass_strict_access] = previous
+          end
+        end
+
+        # Drop any cached (ES-NoProj) reconstructions so reads reflect the rebuild.
+        #
+        # Invalidates the specific rebuilt record ids individually (store-agnostic
+        # +cache_delete+) rather than a wildcard sweep -- SolidCache, the default
+        # backend, advertises +delete_matched+ but raises NotImplementedError.
+        def invalidate_caches(model_class, ids)
+          return unless defined?(CachedProjection)
+
+          ids.each { |id| CachedProjection.invalidate(model_class, id) }
+        rescue StandardError, NotImplementedError => e
+          Rails.logger.warn("Lyra::Projections::Rebuild: cache invalidation failed - #{e.message}") if defined?(Rails)
+        end
+      end
+    end
+  end
+end

data/lib/lyra/version.rb

@@ -1,3 +1,3 @@
 module Lyra
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/lyra.rb

@@ -48,6 +48,7 @@ require "lyra/strict_data_access"
 
 # Event sourcing projections
 require "lyra/projections/model_projection"
+require "lyra/projections/rebuild"
 require "lyra/projections/async_projection_job"
 require "lyra/projections/cached_projection"
 require "lyra/projections/cached_relation"

data/lib/tasks/lyra_projections.rake

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+namespace :lyra do
+  namespace :projections do
+    desc "Rebuild read-model tables from the event log " \
+         "(MODEL=Namespace::Model[,Other] for specific models, or all monitored models; " \
+         "TRUNCATE=false to reconstruct in place)"
+    task rebuild: :environment do
+      models =
+        if ENV["MODEL"]
+          ENV["MODEL"].split(",").map { |name| name.strip.constantize }
+        else
+          Lyra.config.monitored_models
+        end
+
+      if models.empty?
+        puts "No models to rebuild."
+        puts "Pass MODEL=YourModel, or configure models with Lyra.config.monitor_model(YourModel)."
+        exit 1
+      end
+
+      truncate = ENV.fetch("TRUNCATE", "true") != "false"
+
+      puts "Rebuilding #{models.size} model(s) from the event log (truncate=#{truncate})..."
+      models.each do |model_class|
+        stats = Lyra::Projections::Rebuild.rebuild(model_class, truncate: truncate)
+        puts format(
+          "  %-30s %5d records, %4d destroyed, %6d events across %5d streams",
+          stats[:model], stats[:records], stats[:destroyed], stats[:events], stats[:streams]
+        )
+      end
+      puts "Done."
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orfeas_lyra
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Michail Pantelelis
@@ -173,6 +173,7 @@ files:
 - lib/lyra/projections/cached_relation.rb
 - lib/lyra/projections/event_store_reader.rb
 - lib/lyra/projections/model_projection.rb
+- lib/lyra/projections/rebuild.rb
 - lib/lyra/schema/diff.rb
 - lib/lyra/schema/event_class_registrar.rb
 - lib/lyra/schema/generator.rb
@@ -186,13 +187,9 @@ files:
 - lib/lyra/visualization/activity_heatmap.rb
 - lib/lyra/visualization/event_graph.rb
 - lib/lyra/visualization/timeline.rb
-- lib/tasks/dist.rake
-- lib/tasks/gems.rake
+- lib/tasks/lyra_projections.rake
 - lib/tasks/lyra_schema.rake
 - lib/tasks/lyra_workflows.rake
-- lib/tasks/public_release.rake
-- lib/tasks/stats.rake
-- lib/tasks/testbed.rake
 - lib/tasks/version.rake
 homepage: https://github.com/mpantel/lyra-engine
 licenses:
@@ -215,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.20
 specification_version: 4
 summary: CRUD to Event Sourcing transformation engine
 test_files: []