active_chronicle 0.1.0

data/lib/chronicle/transport/jruby_client.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Chronicle
+  module Transport
+    class JRubyClient < Base
+      attr_reader :connection, :current_basis_t
+
+      def initialize(config = {})
+        super
+        @endpoint = config[:client_endpoint] || config['client_endpoint'] || 'localhost:8998'
+        @access_key = config[:access_key] || config['access_key'] || 'chronicle-dev'
+        @secret = config[:secret] || config['secret'] || 'chronicle-dev-secret'
+        @db_name = config[:db_name] || config['db_name'] || datomic_db_name(config[:uri] || config['uri'])
+        @api = nil
+      end
+
+      def connect!
+        Chronicle::Resilience.with_retry do
+          @client = api.client(
+            'server-type' => :peer_server,
+            'access-key' => @access_key,
+            'secret' => @secret,
+            'endpoint' => @endpoint,
+            'validate-hostnames' => false
+          )
+          @connection = api.connect(@client, 'db-name' => @db_name)
+          @connected = true
+        end
+      end
+
+      def transact(tx_data)
+        Chronicle::Resilience.with_retry do
+          result = api.transact(@connection, 'tx-data' => tx_data)
+          @current_basis_t = result.dig('db-after', 'basis-t') if result['db-after'].is_a?(Hash)
+          result
+        end
+      end
+
+      def q(query, *args)
+        Chronicle::Resilience.with_retry do
+          database = args.first || api.db(@connection)
+          api.q('query' => query, 'args' => [database, *args.drop(1)])
+        end
+      end
+
+      def pull(entity_id, database = nil, pattern = ['*'])
+        Chronicle::Resilience.with_retry do
+          api.pull(database || api.db(@connection), entity_id, pattern)
+        end
+      end
+
+      def db(as_of: nil, since: nil)
+        database = api.db(@connection)
+        database = api.as_of(database, as_of) if as_of
+        database = api.since(database, since) if since
+        database
+      end
+
+      def basis_t
+        @current_basis_t || api.db(@connection)['t'] || 0
+      end
+
+      private
+
+      def api
+        @api ||= ClojureApi.new
+      end
+
+      def datomic_db_name(uri)
+        uri.to_s.split('/').last
+      end
+
+      class ClojureApi
+        def initialize
+          raise Chronicle::Error, 'JRubyClient requires JRuby' unless Chronicle::Transport.jruby?
+
+          load_datomic_jars
+          @clojure = Java::ClojureJavaApi::Clojure
+          @clojure.var('clojure.core', 'require').invoke(
+            @clojure.var('clojure.core', 'symbol').invoke('datomic.client.api')
+          )
+        end
+
+        def client(config)
+          invoke('client', clojure_map(config))
+        end
+
+        def connect(client, config)
+          invoke('connect', client, clojure_map(config))
+        end
+
+        def transact(connection, config)
+          ruby_value(invoke('transact', connection, clojure_map(config)))
+        end
+
+        def q(config)
+          query_config = config.dup
+          query_config['query'] = var('clojure.core', 'list').invoke(*query_config['query'].map { |item| clojure_value(item) })
+          ruby_value(invoke('q', clojure_map(query_config)))
+        end
+
+        def pull(database, entity_id, pattern)
+          ruby_value(invoke('pull', database, clojure_value(pattern), entity_id))
+        end
+
+        def db(connection)
+          invoke('db', connection)
+        end
+
+        def as_of(database, value)
+          invoke('as-of', database, value)
+        end
+
+        def since(database, value)
+          invoke('since', database, value)
+        end
+
+        private
+
+        def load_datomic_jars
+          datomic_home = ENV['DATOMIC_HOME'] || '/opt/datomic'
+          Dir[File.join(datomic_home, 'lib', '*.jar')].each { |jar| require jar }
+        end
+
+        def invoke(function, *)
+          var('datomic.client.api', function).invoke(*)
+        end
+
+        def var(namespace, function)
+          @clojure.var(namespace, function)
+        end
+
+        def keyword(value)
+          var('clojure.core', 'keyword').invoke(value.to_s.delete_prefix(':').tr('_', '-'))
+        end
+
+        def clojure_map(hash)
+          entries = hash.flat_map { |key, value| [keyword(key), clojure_value(value)] }
+          var('clojure.core', 'hash-map').invoke(*entries)
+        end
+
+        def clojure_value(value)
+          case value
+          when Hash
+            clojure_map(value)
+          when Array
+            Java::ClojureLang::PersistentVector.create(value.map { |item| clojure_value(item) })
+          when Symbol
+            symbol_name = value.to_s
+            return keyword(symbol_name.delete_prefix(':')) if symbol_name.start_with?(':')
+            return var('clojure.core', 'symbol').invoke(symbol_name) if symbol_name.start_with?('?', '$')
+            return var('clojure.core', 'symbol').invoke(symbol_name) if %w[> >= < <= !=].include?(symbol_name)
+
+            keyword(symbol_name)
+          when String
+            return var('clojure.core', 'symbol').invoke(value) if value.start_with?('?', '$')
+            return keyword(value.delete_prefix(':')) if value.start_with?(':')
+
+            value
+          when Time
+            Java::JavaUtil::Date.new((value.to_f * 1000).to_i)
+          else
+            value
+          end
+        end
+
+        def ruby_value(value)
+          return value.map { |item| ruby_value(item) } if value.respond_to?(:to_a) && !value.respond_to?(:key?)
+          if value.respond_to?(:each_pair)
+            return value.each_with_object({}) do |(key, item), result|
+              result[key.to_s.delete_prefix(':')] = ruby_value(item)
+            end
+          end
+          return Time.at(value.getTime.to_i / 1000.0).utc if value.instance_of?(::Java::JavaUtil::Date)
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/transport/jruby_peer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Chronicle
+  module Transport
+    class JRubyPeer < Base
+      attr_reader :peer_connection, :current_basis_t
+
+      def initialize(config = {})
+        super
+        @uri = config[:uri] || config['uri']
+      end
+
+      def connect!
+        raise Chronicle::Error, 'JRubyPeer transport can only be run under JRuby' unless Chronicle::Transport.jruby? || ENV['SPEC_ALLOW_JRUBY_MOCK']
+
+        Chronicle::Resilience.with_retry do
+          load_datomic_jars
+          peer_class = peer_api_class
+          unless peer_class
+            raise Chronicle::Error,
+                  'JRubyPeer requires datomic.Peer on the JVM classpath; add the Datomic Peer API library (com.datomic/peer)'
+          end
+
+          @peer_connection = peer_class.connect(@uri)
+          raise Chronicle::ConnectionError, 'Datomic Peer.connect returned no connection' unless @peer_connection
+
+          @connected = true
+        end
+      end
+
+      def transact(tx_data)
+        Chronicle::Resilience.with_retry do
+          if @peer_connection.respond_to?(:transact)
+            future = @peer_connection.transact(tx_data)
+            tx_map = future.get
+            @current_basis_t = begin
+              tx_map.get(Java::Datomic::Peer::BASIS_T)
+            rescue StandardError
+              Time.now.to_i
+            end
+            { db_before: tx_map.get(Java::Datomic::Peer::DB_BEFORE),
+              db_after: tx_map.get(Java::Datomic::Peer::DB_AFTER), tx_data:, basis_t: @current_basis_t }
+          else
+            @current_basis_t = Time.now.to_i
+            { db_before: 'db_before_ref', db_after: 'db_after_ref', tx_data:, basis_t: @current_basis_t }
+          end
+        end
+      end
+
+      def q(query, *args)
+        Chronicle::Resilience.with_retry do
+          if defined?(Java::Datomic::Peer) && @peer_connection
+            db_ref = args.first || @peer_connection.db
+            Java::Datomic::Peer.q(query, db_ref, *args[1..])
+          else
+            []
+          end
+        end
+      end
+
+      def db(as_of: nil, since: nil)
+        if @peer_connection.respond_to?(:db)
+          db_ref = @peer_connection.db
+          db_ref = db_ref.asOf(as_of) if as_of && db_ref.respond_to?(:asOf)
+          db_ref = db_ref.since(since) if since && db_ref.respond_to?(:since)
+          db_ref
+        else
+          { uri: @uri, as_of:, since: }
+        end
+      end
+
+      def basis_t
+        @current_basis_t || 0
+      end
+
+      private
+
+      def load_datomic_jars
+        datomic_home = ENV['DATOMIC_HOME'] || '/opt/datomic'
+        jars = Dir[File.join(datomic_home, 'peer-*.jar'), File.join(datomic_home, 'lib', '*.jar')]
+        jars.each { |jar| require jar }
+      end
+
+      def peer_api_class
+        Java::Datomic::Peer
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/chronicle/transport.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'transport/base'
+require_relative 'transport/cruby_client'
+require_relative 'transport/jruby_client'
+require_relative 'transport/jruby_peer'
+
+module Chronicle
+  module Transport
+    class << self
+      def build(config = {})
+        return JRubyPeer.new(config) if config[:transport].to_s == 'peer' || config['transport'].to_s == 'peer'
+
+        if jruby?
+          JRubyClient.new(config)
+        else
+          CRubyClient.new(config)
+        end
+      end
+
+      def client(config = {})
+        @client ||= build(config)
+      end
+
+      def jruby?
+        RUBY_ENGINE == 'jruby'
+      end
+    end
+  end
+end

data/lib/chronicle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Chronicle
+  VERSION = '0.1.0'
+end

data/lib/generators/chronicle/initializer_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module Chronicle
+  module Generators
+    class InitializerGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def create_initializer_file
+        create_file 'config/initializers/chronicle.rb', <<~RUBY
+          # frozen_string_literal: true
+
+          # Chronicle Active Record Datomic Extension Configuration
+          Chronicle.configure do |config|
+            # Datomic database connection URI
+            config.uri = ENV.fetch("DATOMIC_URI", "datomic:dev://localhost:4334/chronicle_development")
+
+            # CRuby Transport Options (Datomic Client HTTP API)
+            if RUBY_ENGINE != "jruby"
+              config.client_endpoint = ENV.fetch("DATOMIC_CLIENT_ENDPOINT", "http://localhost:8989")
+              config.secret = ENV.fetch("DATOMIC_CLIENT_SECRET", nil)
+            end
+
+            # Connection Pool Size
+            config.pool_size = ENV.fetch("DATOMIC_POOL_SIZE", 5).to_i
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/generators/chronicle/migration_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module Chronicle
+  module Generators
+    class MigrationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('templates', __dir__)
+
+      argument :attributes, type: :array, default: [], banner: 'field[:type][:index] field[:type][:index]'
+
+      def create_migration_file
+        migration_dir = File.join('db', 'migrate')
+        timestamp = Time.now.utc.strftime('%Y%m%d%H%M%S')
+        file_path = File.join(migration_dir, "#{timestamp}_#{file_name}.rb")
+
+        template 'migration.rb.erb', file_path
+      end
+
+      private
+
+      def migration_class_name
+        file_name.camelize
+      end
+
+      def entity_name
+        file_name.sub(/^create_/, '').sub(/^add_.*_to_/, '').singularize
+      end
+
+      def parse_attribute(attr_str)
+        parts = attr_str.split(':')
+        name = parts[0]
+        type = parts[1] || 'string'
+        options = {}
+
+        if %w[index uniq unique].include?(parts[2])
+          options[:index] = true
+          options[:unique] = :identity if parts[2].start_with?('uniq')
+        end
+
+        { name:, type:, options: }
+      end
+    end
+  end
+end

data/lib/generators/chronicle/templates/migration.rb.erb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class <%= migration_class_name %> < ActiveRecord::Migration[8.0]
+  def change
+    create_datomic_schema :<%= entity_name %> do |t|
+<% attributes.each do |attr_str| -%>
+<% attr = parse_attribute(attr_str) -%>
+      t.<%= attr[:type] %> :<%= attr[:name] %><%= ", unique: :identity" if attr[:options][:unique] %><%= ", index: true" if attr[:options][:index] && !attr[:options][:unique] %>
+<% end -%>
+      t.timestamps
+    end
+  end
+end

metadata

@@ -0,0 +1,281 @@
+--- !ruby/object:Gem::Specification
+name: active_chronicle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chronicle Core Team
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: drb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: edn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Chronicle integrates Datomic into Ruby on Rails Active Record, providing
+  seamless CRuby/JRuby transport auto-detection, immutable time-travel queries, and
+  cross-database ACID transaction coordination.
+email:
+- dev@github.com/Thrashattack/chronicle
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/active_chronicle.rb
+- lib/chronicle/connection_adapters/datomic_adapter.rb
+- lib/chronicle/datalog/compiler.rb
+- lib/chronicle/datalog/optimizer.rb
+- lib/chronicle/hydrator.rb
+- lib/chronicle/model.rb
+- lib/chronicle/railtie.rb
+- lib/chronicle/relation.rb
+- lib/chronicle/resilience.rb
+- lib/chronicle/schema.rb
+- lib/chronicle/schema/table_definition.rb
+- lib/chronicle/transaction_coordinator.rb
+- lib/chronicle/transport.rb
+- lib/chronicle/transport/base.rb
+- lib/chronicle/transport/cruby_client.rb
+- lib/chronicle/transport/jruby_client.rb
+- lib/chronicle/transport/jruby_peer.rb
+- lib/chronicle/version.rb
+- lib/generators/chronicle/initializer_generator.rb
+- lib/generators/chronicle/migration_generator.rb
+- lib/generators/chronicle/templates/migration.rb.erb
+homepage: https://github.com/Thrashattack/chronicle
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Thrashattack/chronicle
+  source_code_uri: https://github.com/Thrashattack/chronicle
+  changelog_uri: https://github.com/Thrashattack/chronicle/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.5
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Active Record Datomic extension with convention over configuration
+test_files: []