kaal-activerecord 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a7ad9284b605c193a77c6f998fc3f8d38b309075801bc25bad95f8b5d835a027
+  data.tar.gz: 671a2dfd4e3ea39ea43889c57258b6b0030170449bb63603d86a51c735e870fc
+SHA512:
+  metadata.gz: e5af0962d3d26f4b0e36835744adb1c2ee206c1e7bf95520e429d8ec7952a233cdb560d456b5e9fa9fd2e32ecfe32935498d0457428165c955180441d7b52fc5
+  data.tar.gz: 9d94b680eb0217568aa310fa48a070288f69eac29797d4912b8d8e1157de783d805965166b7b59e7d909dd0151709b6279b14975c8a11fa8cc89ec7f0fbbdd60

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Codevedas Inc. and the Kaal Authors
+
+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,76 @@
+# Kaal::ActiveRecord
+
+Active Record-backed datastore adapter for Kaal.
+
+`kaal-activerecord` depends on `kaal` and owns the Active Record persistence layer:
+
+- Active Record models for Kaal tables
+- Active Record-backed definition registry
+- Active Record-backed dispatch registry
+- SQLite table-lock adapter
+- PostgreSQL advisory-lock adapter
+- MySQL named-lock adapter
+- Rails-friendly migration templates
+
+## Install
+
+Plain Ruby:
+
+```ruby
+gem 'kaal'
+gem 'kaal-activerecord'
+```
+
+Rails applications normally use `kaal-rails`, which already depends on this gem.
+
+## Usage
+
+SQLite in plain Ruby:
+
+```ruby
+require 'kaal'
+require 'kaal/active_record'
+
+Kaal::ActiveRecord::ConnectionSupport.configure!(
+  adapter: 'sqlite3',
+  database: 'db/kaal.sqlite3'
+)
+
+Kaal.configure do |config|
+  config.backend = Kaal::ActiveRecord::DatabaseAdapter.new
+  config.scheduler_config_path = 'config/scheduler.yml'
+end
+```
+
+PostgreSQL in plain Ruby:
+
+```ruby
+config.backend = Kaal::ActiveRecord::PostgresAdapter.new
+```
+
+MySQL in plain Ruby:
+
+```ruby
+config.backend = Kaal::ActiveRecord::MySQLAdapter.new
+```
+
+Use this gem directly when you want Active Record-backed SQL outside Rails. For Rails apps, use `kaal-rails`.
+
+## Tables
+
+The Active Record adapter persists against:
+
+- `kaal_definitions`
+- `kaal_dispatches`
+- `kaal_locks`
+
+`kaal_locks` is used for SQLite. PostgreSQL and MySQL rely on advisory or named locks and persist definitions and dispatches without a dedicated locks table.
+
+## Development
+
+```bash
+bin/rspec-unit
+bin/rspec-e2e sqlite
+bin/rubocop
+bin/reek
+```

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'bundler/setup'
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+require 'bundler/gem_tasks'

data/lib/kaal/active_record/base_record.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Shared abstract ApplicationRecord class for Kaal tables.
+    class ApplicationRecord < ::ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    # Shared abstract Active Record base class for Kaal tables.
+    class BaseRecord < ApplicationRecord
+      self.abstract_class = true
+    end
+  end
+end

data/lib/kaal/active_record/connection_support.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Establishes and reuses the Active Record connection for adapter models.
+    module ConnectionSupport
+      CONFIGURE_MUTEX = Mutex.new
+
+      module_function
+
+      def configure!(connection = nil)
+        return BaseRecord unless connection
+
+        CONFIGURE_MUTEX.synchronize do
+          current_config = current_connection_config
+          target_config = normalize_connection_config(connection)
+          return BaseRecord if configs_match?(current_config, target_config)
+
+          BaseRecord.establish_connection(connection)
+        end
+        BaseRecord
+      end
+
+      def normalize_connection_config(connection)
+        config = extract_connection_config(connection)
+        return connection unless config
+
+        config.each_with_object({}) do |(key, value), normalized|
+          normalized_key = key.to_sym
+          normalized[normalized_key] = normalize_connection_value(normalized_key, value)
+        end
+      end
+
+      def current_connection_config
+        db_config = BaseRecord.connection_db_config
+        normalize_connection_config(extract_connection_config(db_config))
+      rescue ::ActiveRecord::ConnectionNotEstablished
+        nil
+      end
+
+      def extract_connection_config(connection)
+        case connection
+        when Hash
+          connection
+        when String
+          { url: connection }
+        else
+          config = connection.configuration_hash
+          url = begin
+            connection.url
+          rescue NoMethodError
+            nil
+          end
+          url ? config.merge(url: url) : config
+        end
+      rescue NoMethodError
+        nil
+      end
+
+      def normalize_connection_value(key, value)
+        case key
+        when :adapter
+          value.to_s.downcase
+        when :port
+          integer_like?(value) ? value.to_i : value
+        else
+          value
+        end
+      end
+
+      def integer_like?(value)
+        value.is_a?(Integer) || value.to_s.match?(/\A\d+\z/)
+      end
+
+      def configs_match?(current_config, target_config)
+        return true if current_config == target_config
+
+        current_url = current_config.is_a?(Hash) ? current_config[:url] : nil
+        target_url = target_config.is_a?(Hash) ? target_config[:url] : nil
+        !!(current_url && target_url && current_url == target_url)
+      end
+    end
+  end
+end

data/lib/kaal/active_record/database_adapter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal/backend/adapter'
+require 'kaal/backend/dispatch_logging'
+
+module Kaal
+  module ActiveRecord
+    # Table-backed lock adapter used for SQLite-style Active Record storage.
+    class DatabaseAdapter < Kaal::Backend::Adapter
+      include Kaal::Backend::DispatchLogging
+
+      def initialize(connection = nil, lock_model: LockRecord, dispatch_registry: nil, definition_registry: nil, namespace: nil)
+        super()
+        ConnectionSupport.configure!(connection)
+        @lock_model = lock_model
+        @dispatch_registry = dispatch_registry
+        @definition_registry = definition_registry
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= DispatchRegistry.new(namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= DefinitionRegistry.new
+      end
+
+      def acquire(key, ttl)
+        now = Time.now.utc
+        expires_at = now + ttl
+
+        2.times do |attempt|
+          cleanup_expired_locks if attempt.positive?
+
+          begin
+            @lock_model.create!(key: key, acquired_at: now, expires_at: expires_at)
+            log_dispatch_attempt(key)
+            return true
+          rescue ::ActiveRecord::RecordNotUnique
+            next
+          end
+        end
+
+        false
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "Database acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        @lock_model.where(key: key).delete_all.positive?
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "Database release failed for #{key}: #{e.message}"
+      end
+
+      def cleanup_expired_locks
+        @lock_model.where(expires_at: ...Time.now.utc).delete_all
+      end
+
+      private
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+
+    SQLiteAdapter = DatabaseAdapter
+  end
+end

data/lib/kaal/active_record/definition_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Active Record model for persisted scheduler definitions.
+    class DefinitionRecord < BaseRecord
+      self.table_name = 'kaal_definitions'
+    end
+  end
+end

data/lib/kaal/active_record/definition_registry.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'json'
+require 'kaal/definition/registry'
+require 'kaal/definition/persistence_helpers'
+
+module Kaal
+  module ActiveRecord
+    # Active Record-backed registry for scheduler definitions.
+    class DefinitionRegistry < Kaal::Definition::Registry
+      def initialize(connection: nil, model: DefinitionRecord)
+        super()
+        ConnectionSupport.configure!(connection)
+        @model = model
+      end
+
+      def upsert_definition(key:, cron:, enabled: true, source: 'code', metadata: {})
+        record = @model.find_or_initialize_by(key: key)
+        existing = record.persisted? ? { enabled: record.enabled, disabled_at: record.disabled_at } : nil
+        now = Time.now.utc
+        record.cron = cron
+        record.enabled = enabled
+        record.source = source
+        record.metadata = JSON.generate(metadata || {})
+        record.created_at ||= now
+        record.updated_at = now
+        record.disabled_at = Kaal::Definition::PersistenceHelpers.disabled_at_for(existing, enabled, now)
+        record.save!
+        normalize(record)
+      end
+
+      def remove_definition(key)
+        record = @model.find_by(key: key)
+        return nil unless record
+
+        normalized = normalize(record)
+        record.destroy!
+        normalized
+      end
+
+      def find_definition(key)
+        normalize(@model.find_by(key: key))
+      end
+
+      def all_definitions
+        @model.order(:key).map { |record| normalize(record) }
+      end
+
+      def enabled_definitions
+        @model.where(enabled: true).order(:key).map { |record| normalize(record) }
+      end
+
+      private
+
+      def normalize(record)
+        return nil unless record
+
+        normalize_definition_record(record)
+      end
+
+      def normalize_definition_record(record)
+        {
+          key: record.key,
+          cron: record.cron,
+          enabled: record.enabled ? true : false,
+          source: record.source,
+          metadata: Kaal::Definition::PersistenceHelpers.parse_metadata(record.metadata),
+          created_at: record.created_at,
+          updated_at: record.updated_at,
+          disabled_at: record.disabled_at
+        }
+      end
+    end
+  end
+end

data/lib/kaal/active_record/dispatch_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Active Record model for persisted dispatch audit entries.
+    class DispatchRecord < BaseRecord
+      self.table_name = 'kaal_dispatches'
+    end
+  end
+end

data/lib/kaal/active_record/dispatch_registry.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal/dispatch/registry'
+
+module Kaal
+  module ActiveRecord
+    # Active Record-backed registry for dispatch audit records.
+    class DispatchRegistry < Kaal::Dispatch::Registry
+      def initialize(connection: nil, model: DispatchRecord, namespace: nil)
+        super()
+        ConnectionSupport.configure!(connection)
+        @model = model
+        @namespace = namespace
+      end
+
+      def log_dispatch(key, fire_time, node_id, status = 'dispatched')
+        record = @model.find_or_initialize_by(key: namespaced_key(key), fire_time: fire_time)
+        record.dispatched_at = Time.now.utc
+        record.node_id = node_id
+        record.status = status
+        record.save!
+        normalize(record)
+      end
+
+      def find_dispatch(key, fire_time)
+        normalize(@model.find_by(key: namespaced_key(key), fire_time: fire_time))
+      end
+
+      def find_by_key(key)
+        query(key: namespaced_key(key))
+      end
+
+      def find_by_node(node_id)
+        query(node_id: node_id)
+      end
+
+      def find_by_status(status)
+        query(status: status)
+      end
+
+      def cleanup(recovery_window: 86_400)
+        cutoff_time = Time.now.utc - recovery_window
+        cleanup_scope.where(fire_time: ...cutoff_time).delete_all
+      end
+
+      private
+
+      def query(filters)
+        query_scope(filters).order(fire_time: :desc).map { |record| normalize(record) }
+      end
+
+      def namespaced_key(key)
+        "#{namespace_prefix}#{key}"
+      end
+
+      def normalize(record)
+        return nil unless record
+
+        {
+          key: strip_namespace(record.key),
+          fire_time: record.fire_time,
+          dispatched_at: record.dispatched_at,
+          node_id: record.node_id,
+          status: record.status
+        }
+      end
+
+      def strip_namespace(key)
+        key.delete_prefix(namespace_prefix)
+      end
+
+      def query_scope(filters)
+        relation = @model.where(filters)
+        return relation if filters.key?(:key)
+
+        namespace_scope(relation)
+      end
+
+      def cleanup_scope
+        namespace_scope(@model)
+      end
+
+      def namespace_scope(relation)
+        return relation if namespace_prefix.empty?
+
+        relation.where('key LIKE ?', "#{namespace_prefix}%")
+      end
+
+      def namespace_prefix
+        @namespace.to_s.empty? ? '' : "#{@namespace}:"
+      end
+    end
+  end
+end

data/lib/kaal/active_record/lock_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Active Record model for table-backed scheduler locks.
+    class LockRecord < BaseRecord
+      self.table_name = 'kaal_locks'
+    end
+  end
+end

data/lib/kaal/active_record/migration_templates.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    # Rails migration templates for Active Record-backed Kaal tables.
+    module MigrationTemplates
+      module_function
+
+      def for_backend(backend)
+        case backend.to_s
+        when 'sqlite'
+          {
+            '001_create_kaal_dispatches.rb' => dispatches_template,
+            '002_create_kaal_locks.rb' => locks_template,
+            '003_create_kaal_definitions.rb' => definitions_template('sqlite')
+          }
+        when 'postgres'
+          {
+            '001_create_kaal_dispatches.rb' => dispatches_template,
+            '002_create_kaal_definitions.rb' => definitions_template('postgres')
+          }
+        when 'mysql'
+          {
+            '001_create_kaal_dispatches.rb' => dispatches_template,
+            '002_create_kaal_definitions.rb' => definitions_template('mysql')
+          }
+        else
+          {}
+        end
+      end
+
+      def dispatches_template
+        <<~RUBY
+          class CreateKaalDispatches < ActiveRecord::Migration[7.1]
+            def change
+              create_table :kaal_dispatches do |t|
+                t.string :key, null: false
+                t.datetime :fire_time, null: false
+                t.datetime :dispatched_at, null: false
+                t.string :node_id, null: false
+                t.string :status, null: false, default: 'dispatched', limit: 50
+              end
+
+              add_index :kaal_dispatches, [:key, :fire_time], unique: true
+              add_index :kaal_dispatches, :key
+              add_index :kaal_dispatches, :node_id
+              add_index :kaal_dispatches, :status
+              add_index :kaal_dispatches, :fire_time
+            end
+          end
+        RUBY
+      end
+
+      def locks_template
+        <<~RUBY
+          class CreateKaalLocks < ActiveRecord::Migration[7.1]
+            def change
+              create_table :kaal_locks do |t|
+                t.string :key, null: false
+                t.datetime :acquired_at, null: false
+                t.datetime :expires_at, null: false
+              end
+
+              add_index :kaal_locks, :key, unique: true
+              add_index :kaal_locks, :expires_at
+            end
+          end
+        RUBY
+      end
+
+      def definitions_template(backend)
+        metadata_definition =
+          if backend == 'mysql'
+            't.text :metadata, null: false'
+          else
+            "t.text :metadata, null: false, default: '{}'"
+          end
+
+        <<~RUBY
+          class CreateKaalDefinitions < ActiveRecord::Migration[7.1]
+            def change
+              create_table :kaal_definitions do |t|
+                t.string :key, null: false
+                t.string :cron, null: false
+                t.boolean :enabled, null: false, default: true
+                t.string :source, null: false
+                #{metadata_definition}
+                t.datetime :disabled_at
+                t.datetime :created_at, null: false
+                t.datetime :updated_at, null: false
+              end
+
+              add_index :kaal_definitions, :key, unique: true
+              add_index :kaal_definitions, :enabled
+              add_index :kaal_definitions, :source
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/kaal/active_record/mysql_adapter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'digest'
+
+module Kaal
+  module ActiveRecord
+    # MySQL named-lock adapter paired with Active Record registries.
+    class MySQLAdapter < Kaal::Backend::Adapter
+      include Kaal::Backend::DispatchLogging
+
+      MAX_LOCK_NAME_LENGTH = 64
+
+      def initialize(connection = nil, dispatch_registry: nil, definition_registry: nil, namespace: nil)
+        super()
+        ConnectionSupport.configure!(connection)
+        @dispatch_registry = dispatch_registry
+        @definition_registry = definition_registry
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= DispatchRegistry.new(namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= DefinitionRegistry.new
+      end
+
+      def acquire(key, _ttl)
+        acquired = scalar('SELECT GET_LOCK(?, 0) AS lock_result', self.class.normalize_lock_name(key)) == 1
+        log_dispatch_attempt(key) if acquired
+        acquired
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "MySQL acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        scalar('SELECT RELEASE_LOCK(?) AS lock_result', self.class.normalize_lock_name(key)) == 1
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "MySQL release failed for #{key}: #{e.message}"
+      end
+
+      def self.normalize_lock_name(key)
+        return key if key.length <= MAX_LOCK_NAME_LENGTH
+
+        digest = Digest::SHA256.hexdigest(key)
+        prefix_length = MAX_LOCK_NAME_LENGTH - 17
+        "#{key[0...prefix_length]}:#{digest[0...16]}"
+      end
+
+      private
+
+      def scalar(sql, value)
+        result = BaseRecord.connection.exec_query(
+          BaseRecord.send(:sanitize_sql_array, [sql, value])
+        )
+        result.first.values.first
+      end
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+  end
+end

data/lib/kaal/active_record/postgres_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'digest'
+
+module Kaal
+  module ActiveRecord
+    # PostgreSQL advisory-lock adapter paired with Active Record registries.
+    class PostgresAdapter < Kaal::Backend::Adapter
+      include Kaal::Backend::DispatchLogging
+
+      SIGNED_64_MAX = 9_223_372_036_854_775_807
+      UNSIGNED_64_RANGE = 18_446_744_073_709_551_616
+
+      def initialize(connection = nil, dispatch_registry: nil, definition_registry: nil, namespace: nil)
+        super()
+        ConnectionSupport.configure!(connection)
+        @dispatch_registry = dispatch_registry
+        @definition_registry = definition_registry
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= DispatchRegistry.new(namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= DefinitionRegistry.new
+      end
+
+      def acquire(key, _ttl)
+        acquired = scalar('SELECT pg_try_advisory_lock(?) AS acquired', self.class.calculate_lock_id(key)) == true
+        log_dispatch_attempt(key) if acquired
+        acquired
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "PostgreSQL acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        scalar('SELECT pg_advisory_unlock(?) AS released', self.class.calculate_lock_id(key)) == true
+      rescue StandardError => e
+        raise Kaal::Backend::LockAdapterError, "PostgreSQL release failed for #{key}: #{e.message}"
+      end
+
+      def self.calculate_lock_id(key)
+        hash = Digest::MD5.digest(key).unpack1('Q>')
+        hash > SIGNED_64_MAX ? hash - UNSIGNED_64_RANGE : hash
+      end
+
+      private
+
+      def scalar(sql, value)
+        result = BaseRecord.connection.exec_query(
+          BaseRecord.send(:sanitize_sql_array, [sql, value])
+        )
+        result.first.values.first
+      end
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+  end
+end

data/lib/kaal/active_record/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'rails/railtie'
+
+module Kaal
+  module ActiveRecord
+    # Minimal Railtie so the adapter can integrate with Rails loading.
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/kaal/active_record/sqlite_adapter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal/active_record/database_adapter'

data/lib/kaal/active_record/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module ActiveRecord
+    VERSION = '0.3.0'
+  end
+end

data/lib/kaal/active_record.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'active_record'
+require 'kaal'
+require 'kaal/active_record/version'
+require 'kaal/active_record/railtie'
+require 'kaal/active_record/connection_support'
+require 'kaal/active_record/base_record'
+require 'kaal/active_record/definition_record'
+require 'kaal/active_record/dispatch_record'
+require 'kaal/active_record/lock_record'
+require 'kaal/active_record/definition_registry'
+require 'kaal/active_record/dispatch_registry'
+require 'kaal/active_record/database_adapter'
+require 'kaal/active_record/postgres_adapter'
+require 'kaal/active_record/mysql_adapter'
+require 'kaal/active_record/sqlite_adapter'
+require 'kaal/active_record/migration_templates'
+
+module Kaal
+  # Active Record-backed datastore adapter namespace for Kaal.
+  module ActiveRecord
+  end
+end

data/lib/tasks/kaal/active_record_tasks.rake

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# This file intentionally does not define any rake tasks for kaal-activerecord.

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: kaal-activerecord
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Nitesh Purohit
+- Codevedas Inc.
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kaal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: rails-i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: "    Kaal-ActiveRecord provides seamless integration of Kaal with ActiveRecord,
+  allowing you to use ActiveRecord models for scheduling and managing cron jobs in
+  a distributed environment.\n"
+email:
+- nitesh.purohit.it@gmail.com
+- team@codevedas.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/kaal/active_record.rb
+- lib/kaal/active_record/base_record.rb
+- lib/kaal/active_record/connection_support.rb
+- lib/kaal/active_record/database_adapter.rb
+- lib/kaal/active_record/definition_record.rb
+- lib/kaal/active_record/definition_registry.rb
+- lib/kaal/active_record/dispatch_record.rb
+- lib/kaal/active_record/dispatch_registry.rb
+- lib/kaal/active_record/lock_record.rb
+- lib/kaal/active_record/migration_templates.rb
+- lib/kaal/active_record/mysql_adapter.rb
+- lib/kaal/active_record/postgres_adapter.rb
+- lib/kaal/active_record/railtie.rb
+- lib/kaal/active_record/sqlite_adapter.rb
+- lib/kaal/active_record/version.rb
+- lib/tasks/kaal/active_record_tasks.rake
+homepage: https://github.com/Code-Vedas/kaal
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/Code-Vedas/kaal/issues
+  changelog_uri: https://github.com/Code-Vedas/kaal/blob/main/CHANGELOG.md
+  documentation_uri: https://kaal.codevedas.com
+  homepage_uri: https://github.com/Code-Vedas/kaal
+  source_code_uri: https://github.com/Code-Vedas/kaal.git
+  funding_uri: https://github.com/sponsors/Code-Vedas
+  support_uri: https://kaal.codevedas.com/support
+  rubygems_uri: https://rubygems.org/gems/kaal-activerecord
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: ActiveRecord integration for Kaal, a distributed cron scheduler for Ruby.
+test_files: []