db_config 0.0.1 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a0734804344d2c70d69cb5527ee0e76b0e25e08133bce0e1d0815075934d61e
-  data.tar.gz: b34981648d8a394fb52c9bdb0e6743dae46beabcd73f4bff15ad53fa587a19aa
+  metadata.gz: 5d5c54735150023b281a43c825dac7af70b17ff1f80ab1f5e38adf732b87f178
+  data.tar.gz: 3afc236097de31e5f932fdfcdc5399ec1cc26fa0e16068b654a272f7b6179591
 SHA512:
-  metadata.gz: 29775d4ddaeb1d94b9f217b92d3b1db973a9601ee61697bd20cb187275fa847f358a40b1541b54f7b93b52a0a6e7f67f27fc6b78efdca506a338682005d7ab68
-  data.tar.gz: f03919cf0ed1539754d00c9dab98048d4c63f3b9b832aafec5a949415dac6f7b3199088f69802d42934fbdaaf46ed2f42f975688d2bcdc8df1aaf1affdf3f1f8
+  metadata.gz: eda9e948efb6464e99541ed0e58a3cd7539e9491347075922a08f10aa006ce16f563dba38bce0a3370e09964e6e5c2a9576c3be9e7b3a31ec7cccf41505bd9dc
+  data.tar.gz: d211e5e4b58798e88dbfad1c02b1e402d1e4baf9417af1ebbca0c357175d571435e7d8eae94bc8e920321631e2b968f530da242b40d2aba4452f169d8fff0803

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Paul Bob
+
+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,235 @@
+# DBConfig
+
+Database-backed configuration store for Rails with automatic type conversion, default values, and high-performance eager loading.
+
+## Features
+
+- **Type-safe storage**: Auto-detects and converts strings, integers, floats, booleans, arrays, hashes, and nil
+
+- **Eager loading**: Cache frequently accessed configs for near-zero database overhead
+- **Simple API**: `get`/`read`, `get!`, `set`/`write`, `update`, `delete`, `exist?`, `fetch` methods
+
+## Installation & Setup
+
+```ruby
+# Gemfile
+gem "db_config"
+```
+
+```bash
+bundle install
+```
+```bash
+rails generate db_config:install
+```
+```bash
+rails db:migrate
+```
+
+## Avo Integration
+
+> [!TIP]
+> If you're using [Avo](https://avohq.io), this gem ships with a pre-configured resource out of the box that should be visible on the menu as "Configurations". If you're using Avo Pro with a custom menu, you can render the resource using:
+> ```ruby
+> resource :db_config
+> ```
+
+## Usage
+
+### Set any data type - auto-detected and preserved
+```ruby
+DBConfig.set(:max_users, 1000)
+DBConfig.write(:site_title, "My App") # write is an alias for set
+DBConfig.set(:enabled, true)
+DBConfig.set(:rate, 0.05)
+DBConfig.set(:tags, ["ruby", "rails"])
+DBConfig.set(:config, {api: "https://api.example.com", timeout: 30})
+DBConfig.set(:feature, nil)
+```
+
+### Get with type preservation
+```ruby
+DBConfig.get(:max_users)    # => 1000 (Integer)
+DBConfig.read(:enabled)     # => true (Boolean) - alias for get
+
+# Get missing config (safe - returns nil)
+DBConfig.get(:missing_key)                # => nil
+
+# Get missing config with get! (raises error)
+DBConfig.get!(:missing_key)               # => raises DBConfig::NotFoundError
+
+# Check if a config exists
+DBConfig.exist?(:page_size)               # => true or false
+
+# Fetch with block - stores block result if key doesn't exist
+DBConfig.fetch(:page_size) { 25 }         # => 25 (stores if not found)
+
+# Use || operator for fallback values
+DBConfig.get(:page_size) || 25            # => 25 if :page_size not set
+
+```
+
+### Exception Handling
+
+```ruby
+# Strict get - raises exception if not found
+begin
+  value = DBConfig.get!(:api_token)
+rescue DBConfig::NotFoundError => e
+  Rails.logger.warn "Missing config: #{e.message}"
+  value = "default_token"
+end
+```
+
+### Managing Configurations
+
+```ruby
+# Update configurations with type safety
+DBConfig.set(:max_users, 1000)                              # Set value and type to Integer
+DBConfig.update(:max_users, value: 500)                     # Update value keeping same type
+
+DBConfig.set(:site_enabled, "true")                         # Set value and type to String
+DBConfig.update(:site_enabled, type: "Boolean")             # Convert "true" string to boolean true
+
+DBConfig.set(:cache_ttl, 3600)                              # Set value and type to Integer
+DBConfig.update(:cache_ttl, value: 4600, eager_load: true)  # Update value and enable eager loading
+
+DBConfig.delete(:old_setting)                               # => true if deleted, false if not found
+```
+
+### ⚡ Eager Loading
+
+> [!NOTE]
+> Eager loaded configs are cached per request and automatically synced when changed
+
+```ruby
+# Mark configs for eager loading (loaded once per request, cached)
+DBConfig.set(:api_key, "secret123")
+DBConfig.update(:api_key, eager_load: true)   # Enable eager loading
+
+# Now served from cache (no database query)
+DBConfig.get(:api_key)                         # Served from cache
+
+DBConfig.update(:api_key, eager_load: false)  # Disable eager loading
+```
+
+> [!TIP]
+> **Good for**: API keys, site settings, frequently accessed configs
+> **Avoid**: Rarely used configs, large data, user-specific settings
+
+## Supported Types
+
+Auto-detects and preserves: String, Integer, Float, Boolean, Array, Hash, nil
+
+```ruby
+# All types preserved exactly
+DBConfig.set(:string, "hello")           # => "hello" (String)
+DBConfig.set(:integer, 42)               # => 42 (Integer)
+DBConfig.set(:float, 3.14)               # => 3.14 (Float)
+DBConfig.set(:boolean, true)             # => true (Boolean)
+DBConfig.set(:array, [1, 2, 3])          # => [1, 2, 3] (Array)
+DBConfig.set(:hash, {a: 1})              # => {a: 1} (Hash)
+DBConfig.set(:null, nil)                 # => nil (NilClass)
+```
+
+## API Reference
+
+### Reading Methods
+| Method | Description | Raises Errors | Example |
+|--------|-------------|---------------|---------|
+| `get(key)` | Safe retrieval, returns nil if not found | No | `DBConfig.get(:api_key)` |
+| `get!(key)` | Strict retrieval | Yes, NotFoundError | `DBConfig.get!(:api_key)` |
+| `read(key)` | Alias for get() | No | `DBConfig.read(:api_key)` |
+| `exist?(key)` | Check if key exists | No | `DBConfig.exist?(:api_key)` |
+| `fetch(key, &block)` | Get or store block result | No | `DBConfig.fetch(:size) { 25 }` |
+
+**Fallback Pattern:**
+Use the `||` operator to provide fallback values when keys don't exist:
+
+```ruby
+# Recommended pattern for fallback values
+page_size = DBConfig.get(:page_size) || 25
+```
+
+### Writing Methods
+| Method | Description | Example |
+|--------|-------------|---------|
+| `set(key, value)` | Store configuration | `DBConfig.set(:api_key, "secret")` |
+| `write(key, value)` | Alias for set() | `DBConfig.write(:api_key, "secret")` |
+| `update(key, **options)` | Update existing config | `DBConfig.update(:key, value: 42)` |
+| `delete(key)` | Remove configuration | `DBConfig.delete(:old_key)` |
+
+### Method Details
+
+#### `DBConfig.fetch(key, &block)`
+Gets the value if it exists, or executes the block and stores the result if it doesn't.
+
+```ruby
+# If key exists, returns existing value (block not executed)
+DBConfig.set(:api_timeout, 30)
+timeout = DBConfig.fetch(:api_timeout) { 60 }    # => 30 (existing value)
+
+# If key doesn't exist, executes block and stores result
+cache_size = DBConfig.fetch(:cache_size) { 100 } # => 100 (stores 100)
+cache_size = DBConfig.fetch(:cache_size) { 200 } # => 100 (returns stored value)
+
+# Works with any data type
+features = DBConfig.fetch(:features) { ["feature1", "feature2"] }
+config = DBConfig.fetch(:api_config) { {endpoint: "api.com", timeout: 30} }
+
+# Returns nil if no block given and key doesn't exist
+DBConfig.fetch(:missing_key)  # => nil
+```
+
+#### `DBConfig.update(key, **options)`
+Updates configuration entry with intelligent type conversion and validation.
+
+**Parameters:**
+- `key` (Symbol/String) - Configuration key (must exist)
+- `**options` - Keyword arguments for updates:
+  - `value: Any` - New value to store (with type compatibility checking)
+  - `type: String` - Target type for conversion ("String", "Integer", "Float", "Boolean", "Array", "Hash", "NilClass")
+  - `eager_load: Boolean` - Enable/disable eager loading
+
+**Returns:** The updated value in its final type
+
+**Type Compatibility:**
+- When updating `value`: New values can change type automatically (e.g., "hello" → 42 changes String to Integer)
+- When updating `type`: Only compatible conversions are allowed (e.g., "123" → Integer, "hello" → Integer fails)
+- Incompatible type conversions raise `ArgumentError` with detailed message
+
+**Examples:**
+```ruby
+# Update value (can change type automatically)
+DBConfig.set(:config_value, "hello")
+DBConfig.update(:config_value, value: 42)    # String → Integer (automatic)
+
+# Change type explicitly (requires compatibility)
+DBConfig.set(:enabled, "true")              # "true" is set as a string
+DBConfig.update(:enabled, type: "Boolean")  # "true" → true (compatible conversion)
+
+# Update multiple attributes
+DBConfig.update(:cache_size, value: 1000, eager_load: true)
+
+# Examples from the specification
+DBConfig.update(:key, eager_load: true)
+DBConfig.update(:key, type: "Boolean")      # Only works if current value is compatible
+DBConfig.update(:key, eager_load: true, value: true)  # ✅ Always works
+
+# Fails only on incompatible TYPE conversions (not value updates)
+DBConfig.set(:username, "admin")
+DBConfig.update(:username, type: "Integer")  # ❌ Fails: "admin" can't become Integer
+DBConfig.update(:username, value: 123)       # ✅ Works: new value can be any type
+```
+
+**Raises:**
+- `DBConfig::NotFoundError` if key doesn't exist
+- `ArgumentError` for invalid types or incompatible conversions
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/avo-hq/db_config.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/app/avo/resources/db_config.rb

@@ -0,0 +1,121 @@
+class Avo::Resources::DbConfig < Avo::BaseResource
+  self.model_class = ::DBConfig::Record
+  self.title = :key
+  self.search = {
+    query: -> {
+      query.ransack(
+        key_cont: q,
+        id_cont: q,
+        value_cont: q,
+        value_type_cont: q,
+        eager_load_cont: q,
+        m: "or"
+      ).result(distinct: false)
+    },
+    item: -> {
+      {
+        title: "",
+        description: "Key: <strong>#{record.key}</strong> <br> Value: <strong>#{record.value}</strong> <br> Type: <strong>#{record.value_type}</strong> <br> Eager Load: <strong>#{record.eager_load}</strong>".html_safe
+      }
+    }
+  }
+
+  self.description = -> {
+    base = if view.form?
+      "If you're not familiar with DBConfig, please refer to the <a href='https://github.com/avo-hq/db_config' target='_blank'>DBConfig</a> documentation.".html_safe
+    elsif view.index?
+      "This is used to manage the <a href='https://github.com/avo-hq/db_config' target='_blank'>DBConfig</a> configurations.<br>Search is performed on all fields.".html_safe
+    end
+
+    if view.new?
+      base += "<br>This is a new configuration. Please fill in the key and the type values and click the 'Save' button.<br>
+      You'll be able to edit the value on the next page.".html_safe
+    end
+
+    base
+  }
+
+  VALUE_TYPE_CONVERSIONS = {
+    "String" => :text,
+    "Integer" => :number,
+    "Boolean" => :boolean,
+    "Hash" => :code,
+    "Array" => :text,
+    "Float" => :number
+  }
+
+  def fields
+    field :id, as: :id
+    field :key
+
+    if record.present?
+      field :value, as: VALUE_TYPE_CONVERSIONS[record.value_type], update_using: ->{
+        return value unless record.value_type == "Boolean"
+
+        case value
+        when "1"
+          "true"
+        when "0"
+          "false"
+        else
+          value
+        end
+      }, visible: -> { !resource.view.new? }
+    else
+      field :value, visible: -> { !resource.view.new? }
+    end
+
+    field :value_type,
+      as: :select,
+      name: "Type",
+      options: DBConfig::Record::VALUE_TYPES, disabled: -> { record.persisted? },
+      help: -> {
+        return if !record.persisted?
+
+        path, data = Avo::Resources::DbConfig::ForceChangeType.link_arguments(resource: resource)
+
+        "Can't change the type of a configuration that has already been set.<br>
+        Click #{link_to("here", path, data: data).html_safe} to force the type change."
+      }
+
+    field :eager_load, as: :boolean
+  end
+
+  def self.plural_name
+    "Configurations"
+  end
+
+  def self.singular_name
+    "Configuration"
+  end
+
+  class ForceChangeType < Avo::BaseAction
+    self.name = "Force Change Type"
+    self.message = "Are you sure you want to change the type of this configuration?<br>
+    This will reset the type to the selected type and will remove the current value."
+    self.confirm_button_label = "Force Change"
+    self.cancel_button_label = "Cancel"
+    self.visible = -> {
+      resource.view.form? && resource.record&.persisted?
+    }
+
+    def fields
+      field :value_type, as: :select, options: DBConfig::Record::VALUE_TYPES
+    end
+
+    DEFAULT_VALUE_TYPES = {
+      "String" => "",
+      "Integer" => 0,
+      "Float" => 0.0,
+      "Boolean" => false,
+      "Array" => [],
+      "Hash" => {},
+      "NilClass" => nil
+    }
+
+    def handle(query:, fields:, **)
+      query.first.update!(value_type: fields[:value_type], value: DEFAULT_VALUE_TYPES[fields[:value_type]])
+      succeed "Type changed successfully."
+    end
+  end
+end

data/app/controllers/avo/db_configs_controller.rb

@@ -0,0 +1,7 @@
+# This controller has been generated to enable Rails' resource routes.
+# More information on https://docs.avohq.io/3.0/controllers.html
+class Avo::DbConfigsController < Avo::ResourcesController
+  def after_create_path
+    edit_resource_path(record: @record, resource: @resource)
+  end
+end

data/lib/db_config/current.rb

@@ -0,0 +1,9 @@
+module DBConfig
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :cached_records, default: {}
+
+    def load_eager_configs!
+      self.cached_records = DBConfig::Record.where(eager_load: true).index_by(&:key)
+    end
+  end
+end

data/lib/db_config/middleware.rb

@@ -0,0 +1,15 @@
+module DBConfig
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Load eager configs for this request
+      DBConfig::Current.load_eager_configs!
+
+      # Continue with the request
+      @app.call(env)
+    end
+  end
+end

data/lib/db_config/railtie.rb

@@ -0,0 +1,40 @@
+require "rails/railtie"
+require "db_config/middleware"
+
+module DBConfig
+  class Railtie < ::Rails::Railtie
+    railtie_name :db_config
+
+    def self.root
+      @root ||= Pathname.new(File.expand_path('../..', __dir__))
+    end
+
+    rake_tasks do
+      load "tasks/db_config_tasks.rake"
+    end
+
+    generators do
+      require "generators/db_config/install/install_generator"
+    end
+
+    initializer "db_config.load_app_instance_data" do |app|
+      # This can be used for any setup that needs to happen after Rails is loaded
+    end
+
+    initializer "db_config.autoload" do |app|
+      if defined?(Avo)
+        db_config_app_directory = DBConfig::Railtie.root.join("app/avo").to_s
+        db_config_avo_controllers_directory = DBConfig::Railtie.root.join("app/controllers/avo").to_s
+
+        ActiveSupport::Dependencies.autoload_paths.delete(db_config_app_directory)
+
+        Rails.autoloaders.main.push_dir(db_config_app_directory, namespace: Avo)
+        Rails.autoloaders.main.push_dir(db_config_avo_controllers_directory, namespace: Avo)
+      end
+    end
+
+    initializer "db_config.add_middleware" do |app|
+      app.middleware.use DBConfig::Middleware
+    end
+  end
+end

data/lib/db_config/record.rb

@@ -0,0 +1,38 @@
+module DBConfig
+  class Record < ActiveRecord::Base
+    self.table_name_prefix = "db_config_"
+
+    VALUE_TYPES = %w[String Integer Float Boolean Array Hash NilClass]
+
+    validates :key, presence: true, uniqueness: true
+    validates :value_type, presence: true, inclusion: {in: VALUE_TYPES}
+    validates :eager_load, inclusion: {in: [true, false]}
+
+    # Sync cache automatically on any changes
+    after_save :sync_cache
+    after_destroy :sync_cache
+
+    def self.ransackable_attributes(auth_object = nil)
+      authorizable_ransackable_attributes
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      authorizable_ransackable_associations
+    end
+
+    private
+
+    def sync_cache
+      # Only sync if Current attributes are available (i.e., in a request context)
+      return unless defined?(DBConfig::Current)
+
+      if destroyed?
+        # Remove from cache if destroyed
+        DBConfig::Current.cached_records.delete(key)
+      else
+        # Update cache with current record
+        DBConfig::Current.cached_records[key] = self
+      end
+    end
+  end
+end

data/lib/db_config/version.rb

@@ -0,0 +1,3 @@
+module DBConfig
+  VERSION = "0.1.9"
+end

data/lib/db_config.rb

@@ -0,0 +1,293 @@
+require "db_config/version"
+require "db_config/railtie"
+require "db_config/record"
+require "db_config/current"
+require "json"
+
+module DBConfig
+  class NotFoundError < StandardError; end
+
+  class << self
+    def get(key)
+      record = get_record(key)
+      record ? convert_value(record.value, record.value_type) : nil
+    end
+
+    def get!(key)
+      record = get_record(key)
+
+      if record
+        convert_value(record.value, record.value_type)
+      else
+        raise NotFoundError, "DBConfig not found for key: #{key}"
+      end
+    end
+
+    def set(key, value)
+      value_str = serialize_value(value)
+      value_type = determine_type(value)
+      key = key.to_s
+
+      record = Current.cached_records[key] || DBConfig::Record.find_or_initialize_by(key:)
+
+      record.update!(
+        value: value_str,
+        value_type: value_type,
+        eager_load: record.eager_load || false
+      )
+
+      convert_value(record.value, record.value_type)
+    end
+
+    def delete(key)
+      key_str = key.to_s
+      record = DBConfig::Record.find_by(key: key_str)
+
+      if record
+        record.destroy!
+        true
+      else
+        false
+      end
+    end
+
+    def update(key, **kwargs)
+      key_str = key.to_s
+      record = get_record(key_str)
+      raise NotFoundError, "DBConfig not found for key: #{key}" unless record
+
+      # Extract current values
+      current_value = convert_value(record.value, record.value_type)
+      current_type = record.value_type
+
+      # Process updates
+      updates = {}
+
+      # Handle value update - new values can change type freely
+      if kwargs.key?(:value)
+        new_value = kwargs[:value]
+        new_type = determine_type(new_value)
+
+        updates[:value] = serialize_value(new_value)
+        updates[:value_type] = new_type
+      end
+
+      # Handle type update with compatibility check
+      if kwargs.key?(:type)
+        target_type = kwargs[:type]
+
+        # Validate target type
+        unless DBConfig::Record::VALUE_TYPES.include?(target_type)
+          raise ArgumentError, "Invalid type: #{target_type}. Must be one of: #{DBConfig::Record::VALUE_TYPES.join(", ")}"
+        end
+
+        # Check if current value can be converted to target type
+        unless value_convertible_to_type?(current_value, current_type, target_type)
+          raise ArgumentError, "Can't modify type because value \"#{current_value}\" doesn't support conversion from \"#{current_type}\" to \"#{target_type}\""
+        end
+
+        # Convert value to new type
+        converted_value = convert_value_to_type(current_value, current_type, target_type)
+        updates[:value] = serialize_value(converted_value)
+        updates[:value_type] = target_type
+      end
+
+      # Handle eager_load update
+      if kwargs.key?(:eager_load)
+        updates[:eager_load] = kwargs[:eager_load]
+      end
+
+      # Apply updates
+      record.update!(updates)
+
+      # Return the updated value in its new type
+      convert_value(record.value, record.value_type)
+    end
+
+    def exist?(key)
+      get_record(key) != nil
+    end
+
+    def fetch(key, &block)
+      record = get_record(key)
+
+      if record
+        convert_value(record.value, record.value_type)
+      elsif block_given?
+        # Execute block and store the result
+        value = yield
+        set(key, value)
+      end
+
+      # Return nil if key doesn't exist and no block given
+    end
+
+    # Aliases for convenience
+    alias_method :read, :get
+    alias_method :write, :set
+
+    private
+
+    # Get record from cache or database, returns nil if not found
+    def get_record(key)
+      key = key.to_s
+
+      Current.cached_records[key] || DBConfig::Record.find_by(key:)
+    end
+
+    def determine_type(value)
+      case value
+      when NilClass
+        "NilClass"
+      when String
+        "String"
+      when Integer
+        "Integer"
+      when Float
+        "Float"
+      when TrueClass, FalseClass
+        "Boolean"
+      when Array
+        "Array"
+      when Hash
+        "Hash"
+      else
+        "String"
+      end
+    end
+
+    def serialize_value(value)
+      case value
+      when NilClass
+        nil
+      when Array, Hash
+        JSON.generate(value)
+      else
+        value.to_s
+      end
+    end
+
+    def convert_value(value_str, value_type)
+      case value_type
+      when "NilClass"
+        nil
+      when "Boolean"
+        value_str == "true"
+      when "Integer"
+        value_str.to_i
+      when "Float"
+        value_str.to_f
+      when "Array"
+        JSON.parse(value_str)
+      when "Hash"
+        JSON.parse(value_str)
+      else
+        value_str
+      end
+    end
+
+    def types_compatible?(current_value, current_type, new_value, new_type)
+      # If types are the same, always compatible
+      return true if current_type == new_type
+
+      # Allow specific compatible conversions
+      case [current_type, new_type]
+      when ["Boolean", "String"], ["Integer", "String"], ["Float", "String"], ["NilClass", "String"]
+        true
+      when ["String", "Boolean"]
+        ["true", "false"].include?(current_value.to_s.downcase)
+      when ["String", "Integer"]
+        current_value.to_s.match?(/\A-?\d+\z/)
+      when ["String", "Float"]
+        current_value.to_s.match?(/\A-?\d*\.?\d+\z/)
+      when ["Integer", "Float"]
+        true
+      when ["Float", "Integer"]
+        current_value.to_f % 1 == 0  # Only if float is a whole number
+      when ["Boolean", "Integer"]
+        true  # true -> 1, false -> 0
+      when ["Integer", "Boolean"]
+        [0, 1].include?(current_value)
+      else
+        false
+      end
+    end
+
+    def value_convertible_to_type?(value, current_type, target_type)
+      # If types are the same, always convertible
+      return true if current_type == target_type
+
+      case target_type
+      when "String"
+        true  # Everything can be converted to string
+      when "Boolean"
+        case current_type
+        when "String"
+          ["true", "false", "1", "0"].include?(value.to_s.downcase)
+        when "Integer"
+          [0, 1].include?(value)
+        else
+          false
+        end
+      when "Integer"
+        case current_type
+        when "String"
+          value.to_s.match?(/\A-?\d+\z/)
+        when "Float"
+          value.to_f % 1 == 0
+        when "Boolean"
+          true
+        else
+          false
+        end
+      when "Float"
+        case current_type
+        when "String"
+          value.to_s.match?(/\A-?\d*\.?\d+\z/)
+        when "Integer", "Boolean"
+          true
+        else
+          false
+        end
+      else
+        false  # Array, Hash, NilClass conversions not supported
+      end
+    end
+
+    def convert_value_to_type(value, current_type, target_type)
+      return value if current_type == target_type
+
+      case target_type
+      when "String"
+        value.to_s
+      when "Boolean"
+        case current_type
+        when "String"
+          ["true", "1"].include?(value.to_s.downcase)
+        when "Integer"
+          value == 1
+        end
+      when "Integer"
+        case current_type
+        when "String"
+          value.to_i
+        when "Float"
+          value.to_i
+        when "Boolean"
+          value ? 1 : 0
+        end
+      when "Float"
+        case current_type
+        when "String"
+          value.to_f
+        when "Integer"
+          value.to_f
+        when "Boolean"
+          value ? 1.0 : 0.0
+        end
+      else
+        raise ArgumentError, "Conversion to #{target_type} not supported"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module DbConfig
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+      desc "Creates a DBConfig migration and shows usage information"
+
+      def copy_migration
+        migration_template "create_db_config.rb", File.join(db_migrate_path, "create_db_config.rb")
+      end
+
+      def show_usage
+        say ""
+        say "=" * 70
+        say "DB_CONFIG INSTALLATION COMPLETE", :green
+        say "=" * 70
+        say ""
+        say "Run the migration:"
+        say "  rails db:migrate", :yellow
+        say ""
+        say "Usage examples:", :green
+        say ""
+        say "  # Set different types of configuration values"
+        say "  DBConfig.set(:homepage_cta, 'Click here now!')", :cyan
+        say "  DBConfig.write(:max_users, 1000)  # alias for set", :cyan
+        say "  DBConfig.set(:maintenance_mode, false)", :cyan
+        say "  DBConfig.set(:allowed_countries, ['US', 'CA', 'UK'])", :cyan
+        say "  DBConfig.set(:api_config, { endpoint: 'api.com', timeout: 30 })", :cyan
+        say ""
+        say "  # Get configuration values (returns original data type)"
+        say "  DBConfig.get(:homepage_cta)", :cyan
+        say "  # => 'Click here now!'"
+        say "  DBConfig.read(:allowed_countries)  # alias for get", :cyan
+        say "  # => ['US', 'CA', 'UK']"
+        say ""
+        say "  # Check if configuration exists"
+        say "  DBConfig.exist?(:page_size)", :cyan
+        say "  # => true or false"
+        say ""
+        say "  # Fetch with block - stores block result if key doesn't exist"
+        say "  page_size = DBConfig.fetch(:page_size) { 25 }", :cyan
+        say "  debug_mode = DBConfig.fetch(:debug_mode) { false }", :cyan
+        say ""
+        say "  # Use || operator for fallback values"
+        say "  page_size = DBConfig.get(:page_size) || 25", :cyan
+        say "  admin_emails = DBConfig.get(:admin_emails) || []", :cyan
+        say ""
+
+        say "  # Enable/disable eager loading for a config"
+        say "  DBConfig.eager_load(:homepage_cta, true)", :cyan
+        say ""
+        say "  # Handle missing configs"
+        say "  begin"
+        say "    DBConfig.get(:missing_key)"
+        say "  rescue DBConfig::NotFoundError => e"
+        say "    puts e.message"
+        say "  end", :cyan
+        say ""
+        say "Supported data types: String, Integer, Float, Boolean, Array, Hash", :green
+        say ""
+        say "=" * 70
+      end
+
+      private
+
+      def db_migrate_path
+        configured_migrate_path || default_migrate_path
+      end
+
+      def configured_migrate_path
+        Rails.application.config.paths["db/migrate"]&.first
+      end
+
+      def default_migrate_path
+        Rails.root.join("db", "migrate")
+      end
+    end
+  end
+end

data/lib/generators/db_config/install/templates/create_db_config.rb

@@ -0,0 +1,15 @@
+class CreateDbConfig < ActiveRecord::Migration<%= "[#{ActiveRecord::Migration.current_version}]" if ActiveRecord::Migration.respond_to?(:current_version) %>
+  def change
+    create_table :db_config_records do |t|
+      t.string :key, null: false
+      t.string :value
+      t.string :value_type, null: false, default: "String"
+      t.boolean :eager_load, null: false, default: false
+
+      t.timestamps null: false
+    end
+
+    add_index :db_config_records, :key, unique: true
+    add_index :db_config_records, :eager_load
+  end
+end

data/lib/tasks/db_config_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :db_config do
+#   # Task goes here
+# end

metadata

@@ -1,43 +1,93 @@
 --- !ruby/object:Gem::Specification
 name: db_config
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.9
 platform: ruby
 authors:
-- Adrian
-- Paul
-autorequire: 
+- Paul Bob
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-01 00:00:00.000000000 Z
+date: 2026-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: avo
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0.pre.dev.2
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0.pre.dev.2
-description: Visit https://avohq.io/ to get more information about this gem.
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: |
+  DBConfig provides a powerful, database-backed configuration store for Rails applications.
+  Store and retrieve configuration values dynamically with automatic type detection and conversion
+  (strings, integers, floats, booleans, arrays, hashes, and nil). Features eager loading for
+  high-performance access to frequently used configs, a simple API (get/set/update/delete),
+  and seamless integration with Avo admin panels.
+
+  See https://github.com/avo-hq/db_config for full documentation and usage examples.
 email:
-- adrian@adrianthedev.com
 - paul.ionut.bob@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: https://avohq.io/
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/avo/resources/db_config.rb
+- app/controllers/avo/db_configs_controller.rb
+- lib/db_config.rb
+- lib/db_config/current.rb
+- lib/db_config/middleware.rb
+- lib/db_config/railtie.rb
+- lib/db_config/record.rb
+- lib/db_config/version.rb
+- lib/generators/db_config/install/install_generator.rb
+- lib/generators/db_config/install/templates/create_db_config.rb
+- lib/tasks/db_config_tasks.rake
+homepage: https://github.com/avo-hq/db_config
 licenses:
-- Commercial
-metadata: {}
-post_install_message: 
+- MIT
+metadata:
+  homepage_uri: https://github.com/avo-hq/db_config
+  source_code_uri: https://github.com/avo-hq/db_config
+  changelog_uri: https://github.com/avo-hq/db_config/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -53,7 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.22
-signing_key: 
+signing_key:
 specification_version: 4
-summary: Visit https://avohq.io/ to get more information about this gem.
+summary: Database-backed configuration store for Rails with automatic type conversion,
+  eager loading, and Avo integration
 test_files: []