active_chronicle 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e9591048e619042697a08f52bca32f1eb5a29f799df5e2712821a72e4daa03f
+  data.tar.gz: 47508468ff233dd841e2e07295e130fb8bc4f84b8a857cc52eeeaac9e396ea6f
+SHA512:
+  metadata.gz: 3792343f538b15c26a8bae3fb96e7aba9f0321e0ea011f6868eb218b96a53002acdb25e0285cbf3605c0961a5495c7fc38beb35e0fe65bb0cd3c782416d4167c
+  data.tar.gz: ffff69d99a41a44c0ac23493ef2cfad47e89a08b0bf39aa20df78fd7d1f5e9048987aebb4cb1140d9a270ce599c67d52454cacb995369061ccecef65d1c96445

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+## 0.1.0
+
+### Core
+
+- Added Active Record integration through `Chronicle::Model`.
+- Added Datomic attribute declarations and schema migration helpers.
+- Added Datalog compilation for predicates, projections, `IN` values, and pull queries.
+- Added association hydration from Datomic pull results.
+- Added `.as_of` and `.since` time-travel relations.
+- Added coordinated Datomic and relational transactions with compensating retractions.
+- Added retry backoff, jitter, circuit breaking, and Fiber-aware sleeping.
+
+### Transports
+
+- Added CRuby transport support for Datomic REST with EDN requests and responses.
+- Added JRuby Client API support through a Datomic peer server.
+- Added JRuby Peer API support for direct transactor connections.
+- Added explicit peer transport selection with `transport: peer`.
+- Added Datomic jar loading for JRuby containers.
+
+### Examples
+
+- Added `news_feed`, a CRuby Rails application that displays story revisions.
+- Added `wallet`, a JRuby Rails application that uses the Datomic Client API to track balance changes.
+- Added `animal_tracker`, a JRuby Rails application that uses the Datomic Peer API to draw historical paths.
+- Added `cross_store`, a CRuby Rails application that references Datomic customer IDs from SQLite purchases.
+- Added a real cross-store benchmark for coordinated Datomic and SQLite writes.
+- Added a Docker Compose stack that installs the Datomic distribution in a container and runs the transactor, peer server, REST service, and all examples.
+
+### Tooling and Release
+
+- Raised the supported Ruby version to 3.4.5.
+- Added RuboCop CI validation and a pre-commit quality hook.
+- Added SimpleCov and Codecov reporting.
+- Limited the published gem to library code and release documentation.
+- Excluded specs, CI files, examples, and development files from the gem archive.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Carlos Cunha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,254 @@
+# Active Chronicle
+
+[![CI](https://github.com/Thrashattack/chronicle/actions/workflows/ci.yml/badge.svg)](https://github.com/Thrashattack/chronicle/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/Thrashattack/chronicle/branch/main/graph/badge.svg)](https://codecov.io/gh/Thrashattack/chronicle)
+[![Gem Version](https://img.shields.io/gem/v/chronicle.svg)](https://rubygems.org/gems/chronicle)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.4.5-CC342D.svg)](https://www.ruby-lang.org/)
+
+Chronicle connects Datomic to Ruby on Rails Active Record. It maps Active Record models to Datomic facts and exposes immutable history through normal Rails query patterns. Check [Datomic](https://www.datomic.com/) page
+
+## Requirements
+
+- Ruby 3.4.5 or newer.
+- Rails Active Record 7.0 or newer.
+- Datomic Pro for the Docker examples and JRuby integrations.
+- Java 17 for the Datomic container.
+- Java 21 for JRuby 10 workloads.
+
+## Capabilities
+
+- Active Record integration through `Chronicle::Model`.
+- Datomic attributes with types and schema options.
+- Datalog compilation for equality, comparison, `IN`, projection, and pull queries.
+- Association preloading through Datomic pull results.
+- Time travel with `.as_of` and `.since`.
+- Datomic schema and migration helpers.
+- Cross-database transactions with compensating Datomic retractions.
+- Retry handling with exponential backoff and jitter.
+- Circuit breaker support.
+- Fiber-aware backoff when a Ruby scheduler is active.
+- CRuby transport through Datomic REST using EDN.
+- JRuby Client API transport through a Datomic peer server.
+- JRuby Peer API transport with direct access to the Datomic transactor.
+- Rails initializer and migration generators.
+
+## Installation
+
+Add Active Chronicle to the application Gemfile:
+
+```ruby
+gem "active_chronicle"
+```
+
+Then install the bundle:
+
+```bash
+bundle install
+```
+
+## Configuration
+
+Generate an initializer:
+
+```bash
+bin/rails generate chronicle:initializer
+```
+
+Configure a Datomic connection in `config/database.yml`.
+
+### CRuby and REST
+
+Chronicle's CRuby transport uses Datomic's REST service. Datomic marks REST as a legacy interface, but it remains useful for existing integrations and supports the Ruby transport.
+
+```yaml
+datomic:
+  adapter: datomic
+  uri: datomic:dev://localhost:4334/app_dev
+  client_endpoint: https://localhost:8001
+  rest: true
+```
+
+### JRuby Client API
+
+The Client API connects to a Datomic peer server. It requires the peer-server endpoint, access key, secret, and database name.
+
+```yaml
+datomic:
+  adapter: datomic
+  uri: datomic:dev://localhost:4334/app_dev
+  client_endpoint: localhost:8998
+  access_key: chronicle-dev
+  secret: chronicle-dev-secret
+```
+
+### JRuby Peer API
+
+The Peer API connects directly to the transactor. Select it with `transport: peer`.
+
+```yaml
+datomic:
+  adapter: datomic
+  uri: datomic:dev://localhost:4334/app_dev
+  transport: peer
+```
+
+The included Compose examples mount the Datomic distribution at `/opt/datomic`.
+Chronicle loads `peer-*.jar` from the distribution root and its dependencies from
+`lib/*.jar`. Set `DATOMIC_HOME` when the distribution is installed elsewhere.
+The Peer jar is not inside `lib`: for Datomic Pro 1.0.7705 it is
+`/opt/datomic/peer-1.0.7705.jar`, corresponding to Maven artifact
+`com.datomic:peer:1.0.7705`. Alternatively, resolve that artifact and its runtime
+dependencies onto the application JVM classpath. Startup raises an error if
+`datomic.Peer` cannot be resolved or `Peer.connect` returns no connection.
+
+## Model Integration
+
+Include `Chronicle::Model` and declare the attributes stored in Datomic:
+
+```ruby
+class DatomicRecord < ApplicationRecord
+  self.abstract_class = true
+
+  connects_to database: { writing: :datomic, reading: :datomic }
+end
+
+class HistoricalRecord < DatomicRecord
+  include Chronicle::Model
+
+  datomic_attribute :event_name, :string
+  datomic_attribute :user_id, :integer, index: true
+  datomic_attribute :payload, :string
+end
+```
+
+`connects_to` must be declared on an abstract Active Record class. Rails 8 rejects it on a concrete model. Keep SQLite-backed models on `ApplicationRecord` and inherit Datomic-backed models from the abstract Datomic base.
+
+`Chronicle::Model` also provides `to_datoms`, `datomic_entity_id`, and model-level `.as_of` and `.since` query entry points.
+
+## Schema and Migrations
+
+Generate a Datomic migration:
+
+```bash
+bin/rails generate chronicle:migration create_historical_records \
+  event_name:string user_id:integer:index
+```
+
+A generated migration uses the Chronicle table definition:
+
+```ruby
+class CreateHistoricalRecords < ActiveRecord::Migration[8.1]
+  def change
+    create_datomic_schema :historical_record do |table|
+      table.string :event_name
+      table.integer :user_id, index: true
+      table.timestamps
+    end
+  end
+end
+```
+
+Run it with:
+
+```bash
+bin/rails db:migrate
+```
+
+## Time Travel
+
+Datomic never overwrites a fact. Each transaction produces a new database value and a transaction time. Chronicle exposes that history through relation scopes:
+
+```ruby
+past = HistoricalRecord.as_of(2.hours.ago).where(user_id: 42)
+recent = HistoricalRecord.since(10040).where(event_name: "login")
+```
+
+The transport applies `as_of` and `since` to the Datomic database snapshot before it executes the query.
+
+## Cross-Database Transactions
+
+`Chronicle::TransactionCoordinator` coordinates a Datomic write and a relational write. If the relational operation fails, it sends compensating retractions to Datomic and raises `Chronicle::TransactionError`.
+
+```ruby
+Chronicle::TransactionCoordinator.transaction do |transaction|
+  transaction.datomic(record.to_datoms)
+  transaction.postgres do
+    AuditLog.create!(datomic_basis_t: transaction.basis_t)
+  end
+end
+```
+
+## Examples
+
+The repository contains three Rails applications. They are excluded from the published gem.
+
+| Example | Ruby | Datomic API | Port | Purpose |
+| --- | --- | --- | ---: | --- |
+| `news_feed` | CRuby | REST | 3001 | Publish stories and inspect revision history. |
+| `wallet` | JRuby 10 | Client API | 3000 | Record deposits and withdrawals over time. |
+| `animal_tracker` | JRuby 10 | Peer API | 3002 | Record coordinates and draw the historical path on a map. |
+| `cross_store` | CRuby | REST + SQLite | 3003 | Reference a Datomic customer from a SQLite purchase and benchmark coordinated writes. |
+
+The Compose stack downloads and installs Datomic inside the Datomic container. It runs the transactor, peer server, REST service, and all four applications:
+
+```bash
+cd examples
+docker compose up --build
+```
+
+Then open:
+
+- `http://localhost:3000` for the wallet.
+- `http://localhost:3001` for the news feed.
+- `http://localhost:3002` for the animal tracker.
+- `http://localhost:3003` for the cross-store example.
+
+The Datomic peer server listens on port `8998`. The REST service listens on port `8001`. The transactor uses ports `4334` and `4335`.
+
+Run the cross-store benchmark with:
+
+```bash
+docker compose -f examples/docker-compose.yml exec cross_store \
+  bundle exec ruby benchmark/cross_store_benchmark.rb
+```
+
+## Development
+
+Run the full local validation:
+
+```bash
+bundle exec rake quality
+```
+
+This runs RuboCop and RSpec. The tracked pre-commit hook runs the same checks:
+
+```bash
+git config core.hooksPath .githooks
+```
+
+The CI workflow runs RuboCop, RSpec, and uploads SimpleCov results to Codecov.
+
+## Release Contents
+
+The gem contains only `lib/`, `README.md`, `CHANGELOG.md`, and `LICENSE.txt`. It excludes specs, CI configuration, examples, the Gemfile, the Rakefile, and the gemspec.
+
+Build the package with:
+
+```bash
+gem build chronicle.gemspec
+```
+
+## Support Notes
+
+- The CRuby REST transport and the JRuby Client API transport use different Datomic endpoints.
+- The JRuby Peer API requires the Datomic distribution jars and a JVM.
+- The Docker examples use Datomic Pro distribution downloads. Review Datomic licensing and distribution terms before use.
+- JRuby and Datomic containers are not required to run the CRuby unit test suite.
+
+## Special Thanks
+
+- Thanks to the creators of [Diametric](https://github.com/relevance/diametric), it was the spark of inspiration for this project.
+
+## License
+
+Chronicle is available under the MIT License.

data/lib/active_chronicle.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_support/all'
+
+require_relative 'chronicle/version'
+require_relative 'chronicle/resilience'
+require_relative 'chronicle/transport'
+require_relative 'chronicle/connection_adapters/datomic_adapter'
+require_relative 'chronicle/datalog/compiler'
+require_relative 'chronicle/datalog/optimizer'
+require_relative 'chronicle/relation'
+require_relative 'chronicle/hydrator'
+require_relative 'chronicle/model'
+require_relative 'chronicle/schema'
+require_relative 'chronicle/transaction_coordinator'
+
+require_relative 'chronicle/railtie' if defined?(Rails::Railtie)
+
+module Chronicle
+  class Error < StandardError; end
+  class ConnectionError < Error; end
+  class TransactionError < Error; end
+  class SchemaError < Error; end
+  class CircuitBreakerError < Error; end
+
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def reset_configuration!
+      self.configuration = Configuration.new
+    end
+  end
+
+  class Configuration
+    attr_accessor :uri, :client_endpoint, :secret, :pool_size,
+                  :max_retries, :retry_base_delay, :retry_max_delay,
+                  :circuit_breaker_threshold, :circuit_breaker_cooldown
+
+    def initialize
+      @pool_size = 5
+      @max_retries = 5
+      @retry_base_delay = 0.1
+      @retry_max_delay = 2.0
+      @circuit_breaker_threshold = 5
+      @circuit_breaker_cooldown = 10.0
+    end
+  end
+end

data/lib/chronicle/connection_adapters/datomic_adapter.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class DatomicAdapter < AbstractAdapter
+      ADAPTER_NAME = 'Datomic'
+
+      class << self
+        def quote_column_name(name)
+          "\"#{name.to_s.gsub('"', '""')}\""
+        end
+
+        def quote_table_name(name)
+          name.to_s.split('.').map { |part| quote_column_name(part) }.join('.')
+        end
+      end
+
+      attr_reader :transport
+
+      def initialize(config = {})
+        super
+        @config = config
+        @transport = Chronicle::Transport.build(config)
+        @transport.connect!
+      end
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def quote_column_name(name)
+        "\"#{name.to_s.gsub('"', '""')}\""
+      end
+
+      def quote_table_name(name)
+        name.to_s.split('.').map { |part| quote_column_name(part) }.join('.')
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def supports_ddl_transactions?
+        false
+      end
+
+      def tables(_name = nil)
+        datomic_models.map(&:table_name).uniq
+      end
+
+      alias data_sources tables
+
+      def data_source_exists?(name)
+        tables.include?(name.to_s)
+      end
+
+      alias table_exists? data_source_exists?
+
+      def primary_keys(table_name)
+        data_source_exists?(table_name) ? ['id'] : []
+      end
+
+      def column_definitions(table_name)
+        model = ActiveRecord::Base.descendants.find { |klass| klass.table_name == table_name.to_s }
+        attributes = model.respond_to?(:datomic_attributes) ? model.datomic_attributes : {}
+        attributes.keys.unshift(:id).uniq.map do |name|
+          type = name == :id ? :bigint : attributes.dig(name, :type)
+          type = :datetime if type == :instant
+          column_type = %i[integer bigint].include?(type) ? ActiveRecord::Type.lookup(:integer, limit: 8) : ActiveRecord::Type.lookup(type || :value)
+          ActiveRecord::ConnectionAdapters::Column.new(name.to_s, column_type, nil)
+        end
+      end
+
+      def new_column_from_field(_table_name, field, _definitions)
+        return field if field.is_a?(ActiveRecord::ConnectionAdapters::Column)
+
+        ActiveRecord::ConnectionAdapters::Column.new(field.to_s, ActiveRecord::Type::Value.new, nil)
+      end
+
+      # Executes a Datalog query or raw datom query
+      def execute(query, name = nil)
+        log(query.to_s, name || 'DATOMIC') do
+          db_snapshot = @transport.db
+          @transport.q(query, db_snapshot)
+        end
+      end
+
+      # Standard Active Record exec_query interface
+      def exec_query(query, name = 'DATOMIC', binds = [], prepare: false, async: false, time_travel: nil, **_options)
+        log(query.to_s, name) do
+          db_snapshot = @transport.db(
+            as_of: time_travel&.dig(:as_of),
+            since: time_travel&.dig(:since)
+          )
+
+          raw_results = @transport.q(query, db_snapshot, *binds)
+          format_results(raw_results)
+        end
+      end
+
+      # High-level query interface returning ActiveRecord::Result
+      def select_all(relation_or_query, name = nil, binds = [], prepare: false, async: false, time_travel: nil, **_options)
+        if relation_or_query.respond_to?(:to_datalog)
+          query_data = relation_or_query.to_datalog
+          exec_query(query_data[:query], name, query_data[:bindings], time_travel:)
+        elsif relation_or_query.is_a?(Hash) && relation_or_query[:query]
+          exec_query(relation_or_query[:query], name, relation_or_query[:bindings] || [], time_travel:)
+        else
+          exec_query(relation_or_query, name, binds, time_travel:)
+        end
+      end
+
+      def ensure_model_schema(model_class)
+        return if !model_class.respond_to?(:datomic_attributes) || model_class.datomic_attributes.empty?
+
+        namespace = model_class.table_name.singularize
+        attributes = model_class.datomic_attributes.dup
+        if model_class.respond_to?(:record_timestamps) && model_class.record_timestamps
+          attributes[:created_at] ||= { type: :instant, options: {} }
+          attributes[:updated_at] ||= { type: :instant, options: {} }
+        end
+        schema_datoms = attributes.map do |attribute, definition|
+          type = datomic_type(definition[:type])
+          raise Chronicle::SchemaError, "Unsupported Datomic attribute type: #{definition[:type]}" unless type
+
+          options = definition[:options] || {}
+          datom = Chronicle::Schema.create_attribute(namespace, attribute, type, options)
+          datom[':db/index'] = true if options[:index]
+          datom[':db/unique'] = ":db.unique/#{options[:unique]}" if %i[identity value].include?(options[:unique])
+          datom.transform_values { |value| value.is_a?(String) && value.start_with?(':') ? value.to_sym : value }
+        end
+        @transport.transact(schema_datoms)
+      end
+
+      # Transacts new or updated entities into Datomic
+      def insert(model_or_statement, attributes_or_name = nil, *args, **options)
+        if model_or_statement.is_a?(Arel::InsertManager)
+          statement = model_or_statement.ast
+          table_name = statement.relation.name
+          model_class = ActiveRecord::Base.descendants.find { |klass| klass.table_name == table_name }
+          values = statement.values.expr.first
+          attributes = statement.columns.zip(values).to_h do |column, value|
+            normalized_value = value.respond_to?(:value) ? value.value : value
+            normalized_value = nil if normalized_value.is_a?(ActiveModel::Type::Value)
+            [column.name, normalized_value]
+          end
+          entity_id = insert_entity(model_class, attributes)
+          returning = options[:returning]
+          primary_key = args[0]
+          return returning.map { |column| column.to_s == primary_key.to_s ? entity_id : attributes[column.to_s] } if returning
+
+          return entity_id
+        end
+
+        insert_entity(model_or_statement, attributes_or_name)
+      end
+
+      def insert_entity(model_class, attributes)
+        ensure_model_schema(model_class)
+        namespace = model_class.table_name.singularize
+        temp_id = attributes['id'] || attributes[:id] || 'chronicle_temp_id'
+
+        datoms = attributes.map do |k, v|
+          next if k.to_s == 'id' || v.nil?
+
+          [:'db/add', temp_id, :":#{namespace}/#{k}", v]
+        end.compact
+
+        tx_result = @transport.transact(datoms)
+        tempids = tx_result&.dig(:tempids) || tx_result&.dig('tempids') || {}
+        tempids[temp_id] || tempids[temp_id.to_sym] || temp_id
+      end
+
+      # Updates existing entity attributes
+      def update(model_or_statement, entity_id_or_name = nil, attributes = nil)
+        if model_or_statement.is_a?(Arel::UpdateManager)
+          statement = model_or_statement.ast
+          table_name = statement.relation.name
+          model_class = ActiveRecord::Base.descendants.find { |klass| klass.table_name == table_name }
+          entity_id = statement.wheres.filter_map do |predicate|
+            next unless predicate.is_a?(Arel::Nodes::Equality) && predicate.left.name.to_s == 'id'
+
+            value = predicate.right
+            value.respond_to?(:value) ? value.value : value
+          end.first
+          values = statement.values.to_h do |assignment|
+            [assignment.left.expr.name, assignment.right.value]
+          end
+          update_entity(model_class, entity_id, values)
+          return 1
+        end
+
+        update_entity(model_or_statement, entity_id_or_name, attributes)
+      end
+
+      def update_entity(model_class, entity_id, attributes)
+        ensure_model_schema(model_class)
+        namespace = model_class.table_name.singularize
+
+        datoms = attributes.map do |k, v|
+          next if k.to_s == 'id'
+
+          [:'db/add', entity_id, :":#{namespace}/#{k}", v]
+        end.compact
+
+        @transport.transact(datoms)
+      end
+
+      # Retracts an entity entirely from current database state
+      def delete(statement_or_entity_id, *_args)
+        if statement_or_entity_id.is_a?(Arel::DeleteManager)
+          statement = statement_or_entity_id.ast
+          table_name = statement.relation.name
+          model_class = ActiveRecord::Base.descendants.find { |klass| klass.table_name == table_name }
+          entity_id = statement.wheres.filter_map do |predicate|
+            next unless predicate.is_a?(Arel::Nodes::Equality) && predicate.left.name.to_s == 'id'
+
+            value = predicate.right
+            value.respond_to?(:value) ? value.value : value
+          end.first
+          return delete_entity(model_class, entity_id)
+        end
+
+        delete_entity(nil, statement_or_entity_id)
+      end
+
+      def delete_entity(_model_class, entity_id)
+        datoms = [[:'db/retractEntity', entity_id]]
+        @transport.transact(datoms)
+        1
+      end
+
+      def active?
+        @transport.connected?
+      end
+
+      def reconnect!
+        @transport.connect!
+      end
+
+      def disconnect!
+        @transport.disconnect!
+      end
+
+      private
+
+      def datomic_models
+        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+      end
+
+      def datomic_type(type)
+        {
+          string: 'string', integer: 'long', bigint: 'long', float: 'double', boolean: 'boolean',
+          instant: 'instant', datetime: 'instant', ref: 'ref', uuid: 'uuid', bytes: 'bytes', uri: 'uri'
+        }[type.to_sym]
+      end
+
+      def format_results(raw_results)
+        return ActiveRecord::Result.new([], []) if raw_results.blank?
+
+        if raw_results.first.is_a?(Array)
+          cols = (0...raw_results.first.size).map { |i| "col_#{i}" }
+          ActiveRecord::Result.new(cols, raw_results)
+        elsif raw_results.first.is_a?(Hash)
+          cols = raw_results.first.keys.map(&:to_s)
+          rows = raw_results.map(&:values)
+          ActiveRecord::Result.new(cols, rows)
+        else
+          ActiveRecord::Result.new(['value'], raw_results.map { |v| [v] })
+        end
+      end
+    end
+  end
+end
+
+# Register adapter with ActiveRecord
+if defined?(ActiveRecord::ConnectionAdapters) && ActiveRecord::ConnectionAdapters.respond_to?(:register)
+  ActiveRecord::ConnectionAdapters.register('datomic', 'ActiveRecord::ConnectionAdapters::DatomicAdapter',
+                                            'chronicle/connection_adapters/datomic_adapter')
+end