decision_agent 0.1.1 → 0.1.2

data/lib/decision_agent/web/server.rb

@@ -12,7 +12,7 @@ module DecisionAgent
       # Enable CORS for API calls
       before do
         headers["Access-Control-Allow-Origin"] = "*"
-        headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
+        headers["Access-Control-Allow-Methods"] = "GET, POST, DELETE, OPTIONS"
         headers["Access-Control-Allow-Headers"] = "Content-Type"
       end
 
@@ -223,8 +223,173 @@ module DecisionAgent
         { status: "ok", version: DecisionAgent::VERSION }.to_json
       end
 
+      # Versioning API endpoints
+
+      # Create a new version
+      post "/api/versions" do
+        content_type :json
+
+        begin
+          request_body = request.body.read
+          data = JSON.parse(request_body)
+
+          rule_id = data["rule_id"]
+          rule_content = data["content"]
+          created_by = data["created_by"] || "system"
+          changelog = data["changelog"]
+
+          version = version_manager.save_version(
+            rule_id: rule_id,
+            rule_content: rule_content,
+            created_by: created_by,
+            changelog: changelog
+          )
+
+          status 201
+          version.to_json
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # List all versions for a rule
+      get "/api/rules/:rule_id/versions" do
+        content_type :json
+
+        begin
+          rule_id = params[:rule_id]
+          limit = params[:limit]&.to_i
+
+          versions = version_manager.get_versions(rule_id: rule_id, limit: limit)
+
+          versions.to_json
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Get version history with metadata
+      get "/api/rules/:rule_id/history" do
+        content_type :json
+
+        begin
+          rule_id = params[:rule_id]
+          history = version_manager.get_history(rule_id: rule_id)
+
+          history.to_json
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Get a specific version
+      get "/api/versions/:version_id" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+          version = version_manager.get_version(version_id: version_id)
+
+          if version
+            version.to_json
+          else
+            status 404
+            { error: "Version not found" }.to_json
+          end
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Activate a version (rollback)
+      post "/api/versions/:version_id/activate" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+          request_body = request.body.read
+          data = request_body.empty? ? {} : JSON.parse(request_body)
+          performed_by = data["performed_by"] || "system"
+
+          version = version_manager.rollback(
+            version_id: version_id,
+            performed_by: performed_by
+          )
+
+          version.to_json
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Compare two versions
+      get "/api/versions/:version_id_1/compare/:version_id_2" do
+        content_type :json
+
+        begin
+          version_id_1 = params[:version_id_1]
+          version_id_2 = params[:version_id_2]
+
+          comparison = version_manager.compare(
+            version_id_1: version_id_1,
+            version_id_2: version_id_2
+          )
+
+          if comparison
+            comparison.to_json
+          else
+            status 404
+            { error: "One or both versions not found" }.to_json
+          end
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
+      # Delete a version
+      delete "/api/versions/:version_id" do
+        content_type :json
+
+        begin
+          version_id = params[:version_id]
+
+          version_manager.delete_version(version_id: version_id)
+
+          status 200
+          { success: true, message: "Version deleted successfully" }.to_json
+
+        rescue DecisionAgent::NotFoundError => e
+          status 404
+          { error: e.message }.to_json
+
+        rescue DecisionAgent::ValidationError => e
+          status 422
+          { error: e.message }.to_json
+
+        rescue => e
+          status 500
+          { error: e.message }.to_json
+        end
+      end
+
       private
 
+      def version_manager
+        @version_manager ||= DecisionAgent::Versioning::VersionManager.new
+      end
+
       def parse_validation_errors(error_message)
         # Extract individual errors from the formatted error message
         errors = []

data/lib/decision_agent.rb

@@ -25,5 +25,9 @@ require_relative "decision_agent/audit/logger_adapter"
 
 require_relative "decision_agent/replay/replay"
 
+require_relative "decision_agent/versioning/adapter"
+require_relative "decision_agent/versioning/file_storage_adapter"
+require_relative "decision_agent/versioning/version_manager"
+
 module DecisionAgent
 end

data/lib/generators/decision_agent/install/install_generator.rb

@@ -0,0 +1,40 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module DecisionAgent
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+
+      desc "Installs DecisionAgent models and migrations for Rails"
+
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def copy_migration
+        migration_template "migration.rb",
+                          "db/migrate/create_decision_agent_tables.rb",
+                          migration_version: migration_version
+      end
+
+      def copy_models
+        copy_file "rule.rb", "app/models/rule.rb"
+        copy_file "rule_version.rb", "app/models/rule_version.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+
+      private
+
+      def migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/decision_agent/install/templates/README

@@ -0,0 +1,47 @@
+===============================================================================
+
+DecisionAgent has been installed!
+
+Next steps:
+
+1. Run the migrations:
+
+   rails db:migrate
+
+2. The following models have been created:
+   - Rule (app/models/rule.rb)
+   - RuleVersion (app/models/rule_version.rb)
+
+3. Start using the versioning system:
+
+   # Create a rule with a version
+   rule = Rule.create!(
+     rule_id: 'approval_rule_001',
+     ruleset: 'approval',
+     description: 'Approval decision rules'
+   )
+
+   # Create a version
+   rule.create_version(
+     content: { /* your rule JSON */ },
+     created_by: 'admin',
+     changelog: 'Initial version'
+   )
+
+   # Or use the VersionManager directly
+   manager = DecisionAgent::Versioning::VersionManager.new
+   manager.save_version(
+     rule_id: 'approval_rule_001',
+     rule_content: { /* your rule JSON */ },
+     created_by: 'admin'
+   )
+
+4. Optional: Mount the DecisionAgent routes in config/routes.rb:
+
+   # This is planned for a future release
+   # mount DecisionAgent::Engine => '/decision_agent'
+
+For more information, visit:
+https://github.com/samaswin87/decision_agent
+
+===============================================================================

data/lib/generators/decision_agent/install/templates/migration.rb

@@ -0,0 +1,26 @@
+class CreateDecisionAgentTables < ActiveRecord::Migration[7.0]
+  def change
+    # Rules table
+    create_table :rules do |t|
+      t.string :rule_id, null: false, index: { unique: true }
+      t.string :ruleset, null: false
+      t.text :description
+      t.string :status, default: 'active'
+      t.timestamps
+    end
+
+    # Rule versions table
+    create_table :rule_versions do |t|
+      t.string :rule_id, null: false, index: true
+      t.integer :version_number, null: false
+      t.text :content, null: false  # JSON rule definition
+      t.string :created_by, null: false, default: 'system'
+      t.text :changelog
+      t.string :status, null: false, default: 'draft'  # draft, active, archived
+      t.timestamps
+    end
+
+    add_index :rule_versions, [:rule_id, :version_number], unique: true
+    add_index :rule_versions, [:rule_id, :status]
+  end
+end

data/lib/generators/decision_agent/install/templates/rule.rb

@@ -0,0 +1,30 @@
+class Rule < ApplicationRecord
+  has_many :rule_versions, primary_key: :rule_id, foreign_key: :rule_id, dependent: :destroy
+
+  validates :rule_id, presence: true, uniqueness: true
+  validates :ruleset, presence: true
+  validates :status, inclusion: { in: %w[active inactive archived] }
+
+  scope :active, -> { where(status: 'active') }
+  scope :by_ruleset, ->(ruleset) { where(ruleset: ruleset) }
+
+  # Get the active version for this rule
+  def active_version
+    rule_versions.find_by(status: 'active')
+  end
+
+  # Get all versions ordered by version number
+  def versions
+    rule_versions.order(version_number: :desc)
+  end
+
+  # Create a new version
+  def create_version(content:, created_by: 'system', changelog: nil)
+    DecisionAgent::Versioning::VersionManager.new.save_version(
+      rule_id: rule_id,
+      rule_content: content,
+      created_by: created_by,
+      changelog: changelog
+    )
+  end
+end

data/lib/generators/decision_agent/install/templates/rule_version.rb

@@ -0,0 +1,60 @@
+class RuleVersion < ApplicationRecord
+  belongs_to :rule, primary_key: :rule_id, foreign_key: :rule_id, optional: true
+
+  validates :rule_id, presence: true
+  validates :version_number, presence: true, uniqueness: { scope: :rule_id }
+  validates :content, presence: true
+  validates :status, inclusion: { in: %w[draft active archived] }
+  validates :created_by, presence: true
+
+  scope :active, -> { where(status: 'active') }
+  scope :for_rule, ->(rule_id) { where(rule_id: rule_id).order(version_number: :desc) }
+  scope :latest, -> { order(version_number: :desc).limit(1) }
+
+  before_create :set_next_version_number
+
+  # Parse the JSON content
+  def parsed_content
+    JSON.parse(content, symbolize_names: true)
+  rescue JSON::ParserError
+    {}
+  end
+
+  # Set content from a hash
+  def content_hash=(hash)
+    self.content = hash.to_json
+  end
+
+  # Activate this version (deactivates others)
+  def activate!
+    transaction do
+      # Deactivate all other versions for this rule
+      self.class.where(rule_id: rule_id, status: 'active')
+                .where.not(id: id)
+                .update_all(status: 'archived')
+
+      # Activate this version
+      update!(status: 'active')
+    end
+  end
+
+  # Compare with another version
+  def compare_with(other_version)
+    DecisionAgent::Versioning::VersionManager.new.compare(
+      version_id_1: id,
+      version_id_2: other_version.id
+    )
+  end
+
+  private
+
+  def set_next_version_number
+    return if version_number.present?
+
+    last_version = self.class.where(rule_id: rule_id)
+                             .order(version_number: :desc)
+                             .first
+
+    self.version_number = last_version ? last_version.version_number + 1 : 1
+  end
+end