dorm 0.1.0

data/lib/dorm/repository.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module Dorm
+  # Metaprogramming module to generate repository methods
+  module Repository
+    module_function
+
+    def for(data_class, table_name: nil, validations: {})
+      table_name ||= pluralize(data_class.name.downcase)
+
+      Module.new do
+        extend self
+
+        # Store metadata about this repository
+        define_singleton_method(:data_class) { data_class }
+        define_singleton_method(:table_name) { table_name }
+        define_singleton_method(:validations) { validations }
+        define_singleton_method(:columns) { data_class.members }
+        define_singleton_method(:db_columns) { columns - [:id] }
+
+        # Helper method to get the correct placeholder syntax for the current adapter
+        define_singleton_method(:placeholder) do |index|
+          case Database.adapter
+          when :postgresql
+            "$#{index}"
+          when :sqlite3
+            '?'
+          else
+            '?'
+          end
+        end
+
+        # Helper method to generate placeholders for multiple values
+        define_singleton_method(:placeholders) do |count, start_index: 1|
+          case Database.adapter
+          when :postgresql
+            (start_index...(start_index + count)).map { |i| "$#{i}" }
+          when :sqlite3
+            Array.new(count, '?')
+          else
+            Array.new(count, '?')
+          end
+        end
+
+        # Helper method to handle RETURNING clause differences
+        define_singleton_method(:returning_clause) do |column = 'id'|
+          case Database.adapter
+          when :postgresql
+            "RETURNING #{column}"
+          when :sqlite3
+            "RETURNING #{column}"
+          else
+            "RETURNING #{column}"
+          end
+        end
+
+        # Helper method to check if result is empty (adapter-specific)
+        define_singleton_method(:result_empty?) do |result|
+          case Database.adapter
+          when :postgresql
+            result.ntuples == 0
+          when :sqlite3
+            result.empty?
+          else
+            result.empty?
+          end
+        end
+
+        # Generate standard CRUD methods
+        # Find by ID
+        define_singleton_method(:find) do |id|
+          Result.try do
+            result = Database.query("SELECT * FROM #{table_name} WHERE id = #{placeholder(1)}", [id])
+            raise 'Record not found' if result_empty?(result)
+
+            row_to_data(result[0])
+          end
+        end
+
+        # Find all records
+        define_singleton_method(:find_all) do
+          Result.try do
+            result = Database.query("SELECT * FROM #{table_name} ORDER BY id")
+            result.map { |row| row_to_data(row) }
+          end
+        end
+
+        # Create new record
+        define_singleton_method(:create) do |attrs|
+          Result.try do
+            validate_attrs(attrs)
+
+            now = Time.now
+            attrs_with_timestamps = attrs.merge(created_at: now, updated_at: now)
+
+            # Ensure we don't have an id in the attributes for creation
+            attrs_with_timestamps.delete(:id) if attrs_with_timestamps.key?(:id)
+
+            record = data_class.new(id: nil, **attrs_with_timestamps)
+
+            columns_list = db_columns.join(', ')
+            placeholder_list = placeholders(db_columns.length).join(', ')
+            values = db_columns.map { |col| serialize_value(record.send(col)) }
+
+            result = Database.query(
+              "INSERT INTO #{table_name} (#{columns_list}) VALUES (#{placeholder_list}) #{returning_clause}",
+              values
+            )
+
+            # Handle different return formats
+            id_value = case Database.adapter
+                       when :postgresql
+                         result[0]['id'].to_i
+                       when :sqlite3
+                         result[0]['id'].to_i
+                       else
+                         result[0]['id'].to_i
+                       end
+
+            record.with(id: id_value)
+          end
+        end
+
+        # Update existing record
+        define_singleton_method(:update) do |record|
+          Result.try do
+            raise 'Cannot update record without id' unless record.id
+
+            updated_record = record.with(updated_at: Time.now)
+
+            set_clauses = db_columns.map.with_index(1) { |col, i| "#{col} = #{placeholder(i)}" }.join(', ')
+            values = db_columns.map { |col| serialize_value(updated_record.send(col)) }
+            values << updated_record.id
+
+            id_placeholder = placeholder(db_columns.length + 1)
+            result = Database.query(
+              "UPDATE #{table_name} SET #{set_clauses} WHERE id = #{id_placeholder} #{returning_clause}",
+              values
+            )
+
+            raise 'Record not found' if result_empty?(result)
+
+            updated_record
+          end
+        end
+
+        # Save (create or update)
+        define_singleton_method(:save) do |record|
+          if record.id
+            update(record)
+          else
+            attrs = record.to_h
+            attrs.delete(:id) # Remove id key if present
+            create(attrs)
+          end
+        end
+
+        # Delete record
+        define_singleton_method(:delete) do |record|
+          Result.try do
+            raise 'Cannot delete record without id' unless record.id
+
+            result = Database.query(
+              "DELETE FROM #{table_name} WHERE id = #{placeholder(1)} #{returning_clause}",
+              [record.id]
+            )
+            raise 'Record not found' if result_empty?(result)
+
+            record
+          end
+        end
+
+        # Query methods
+        # Where with predicate
+        define_singleton_method(:where) do |predicate|
+          find_all.map { |records| records.select(&predicate) }
+        end
+
+        # Find by attributes
+        define_singleton_method(:find_by) do |**attrs|
+          Result.try do
+            conditions = attrs.keys.map.with_index(1) { |key, i| "#{key} = #{placeholder(i)}" }.join(' AND ')
+            values = attrs.values.map { |val| serialize_value(val) }
+
+            result = Database.query("SELECT * FROM #{table_name} WHERE #{conditions}", values)
+            raise 'Record not found' if result_empty?(result)
+
+            row_to_data(result[0])
+          end
+        end
+
+        # Find all by attributes
+        define_singleton_method(:find_all_by) do |**attrs|
+          Result.try do
+            conditions = attrs.keys.map.with_index(1) { |key, i| "#{key} = #{placeholder(i)}" }.join(' AND ')
+            values = attrs.values.map { |val| serialize_value(val) }
+
+            result = Database.query("SELECT * FROM #{table_name} WHERE #{conditions}", values)
+            result.map { |row| row_to_data(row) }
+          end
+        end
+
+        # Count records
+        define_singleton_method(:count) do
+          Result.try do
+            result = Database.query("SELECT COUNT(*) as count FROM #{table_name}")
+            case Database.adapter
+            when :postgresql
+              result[0]['count'].to_i
+            when :sqlite3
+              result[0]['count'].to_i
+            else
+              result[0]['count'].to_i
+            end
+          end
+        end
+
+        # Validation method
+        define_singleton_method(:validate_attrs) do |attrs|
+          validations.each do |field, rules|
+            value = attrs[field]
+
+            if rules[:required] && (value.nil? || (value.respond_to?(:empty?) && value.empty?) || (value.respond_to?(:strip) && value.strip.empty?))
+              raise ValidationError, "#{field} is required"
+            end
+
+            if rules[:format] && value && !value.match?(rules[:format])
+              raise ValidationError, "#{field} has invalid format"
+            end
+
+            if rules[:length] && value && !rules[:length].include?(value.length)
+              raise ValidationError, "#{field} length must be #{rules[:length]}"
+            end
+
+            if rules[:range] && value && !rules[:range].include?(value)
+              raise ValidationError, "#{field} must be in range #{rules[:range]}"
+            end
+          end
+        end
+
+        # Helper methods
+        define_singleton_method(:row_to_data) do |row|
+          attrs = {}
+          columns.each do |col|
+            attrs[col] = deserialize_value(col, row[col.to_s])
+          end
+          data_class.new(**attrs)
+        end
+
+        define_singleton_method(:serialize_value) do |value|
+          case value
+          when Time
+            case Database.adapter
+            when :postgresql
+              value # PostgreSQL handles Time objects natively
+            when :sqlite3
+              value.to_s # SQLite needs string representation
+            else
+              value.to_s
+            end
+          when true, false
+            case Database.adapter
+            when :postgresql
+              value # PostgreSQL handles booleans natively
+            when :sqlite3
+              value ? 1 : 0 # SQLite uses integers for booleans
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+
+        define_singleton_method(:deserialize_value) do |column, value|
+          return nil if value.nil?
+
+          case column
+          when :id, :user_id, :post_id, :comment_id
+            value.to_i
+          when :created_at, :updated_at
+            case Database.adapter
+            when :postgresql
+              # PostgreSQL might return Time objects or strings
+              value.is_a?(Time) ? value : Time.parse(value.to_s)
+            when :sqlite3
+              Time.parse(value.to_s)
+            else
+              Time.parse(value.to_s)
+            end
+          when /.*_id$/
+            value.to_i
+          when :published, :active, :approved
+            # Handle boolean fields
+            case Database.adapter
+            when :postgresql
+              # PostgreSQL returns actual booleans or 't'/'f' strings
+              case value
+              when true, 't', 'true', '1', 1
+                true
+              when false, 'f', 'false', '0', 0
+                false
+              else
+                !!value
+              end
+            when :sqlite3
+              # SQLite returns integers for booleans
+              case value
+              when 1, '1', 'true', true
+                true
+              when 0, '0', 'false', false
+                false
+              else
+                !!value
+              end
+            else
+              !!value
+            end
+          else
+            value
+          end
+        end
+      end
+    end
+
+    def pluralize(word)
+      # Simple pluralization - could be enhanced with inflector gem
+      case word
+      when /y$/
+        word.sub(/y$/, 'ies')
+      when /s$/, /x$/, /z$/, /ch$/, /sh$/
+        word + 'es'
+      else
+        word + 's'
+      end
+    end
+  end
+end

data/lib/dorm/result.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Dorm
+  # Result monad using Data - inspired by dry-monads
+  module Result
+    Success = Data.define(:value) do
+      def success? = true
+      def failure? = false
+
+      def bind(&block)
+        block.call(value)
+      rescue StandardError => e
+        Failure.new(error: e.message)
+      end
+
+      def map(&block)
+        Success.new(value: block.call(value))
+      rescue StandardError => e
+        Failure.new(error: e.message)
+      end
+
+      def value_or(default = nil)
+        value
+      end
+    end
+
+    Failure = Data.define(:error) do
+      def success? = false
+      def failure? = true
+
+      def bind(&block)
+        self
+      end
+
+      def map(&block)
+        self
+      end
+
+      def value_or(default = nil)
+        default
+      end
+    end
+
+    # Add aliases to instance methods by reopening the Data classes
+    Success.class_eval do
+      alias_method :fmap, :map
+    end
+
+    Failure.class_eval do
+      alias_method :fmap, :map
+    end
+
+    module_function
+
+    def success(value)
+      Success.new(value: value)
+    end
+
+    def failure(error)
+      Failure.new(error: error)
+    end
+
+    def try(&block)
+      success(block.call)
+    rescue StandardError => e
+      failure(e.message)
+    end
+
+    # Combine multiple Results
+    def combine(*results)
+      failures = results.select(&:failure?)
+      return failure(failures.map(&:error).join(', ')) unless failures.empty?
+
+      success(results.map(&:value))
+    end
+  end
+end

data/lib/dorm/version.rb

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

data/lib/dorm.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "dorm/version"
+require_relative "dorm/result"
+require_relative "dorm/database"
+require_relative "dorm/repository"
+require_relative "dorm/query_builder"
+require_relative "dorm/connection_pool"
+require_relative "dorm/functional_helpers"
+
+module Dorm
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ValidationError < Error; end
+  class RecordNotFoundError < Error; end
+
+  def self.configure(**options)
+    Database.configure(**options)
+  end
+
+  # Convenience method for creating repositories
+  def self.repository_for(data_class, **options)
+    Repository.for(data_class, **options)
+  end
+end

data/sig/Dorm.rbs

@@ -0,0 +1,4 @@
+module Dorm
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: dorm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ecnal
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: |
+  Dorm (Data ORM) is a lightweight, functional ORM built on Ruby's Data class.
+  Features immutable records, monadic error handling inspired by dry-monads,
+  and a functional programming approach to database operations.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- README.md
+- Rakefile
+- examples/connection_pool_example.rb
+- examples/query_builder_examples.rb
+- lib/dorm.rb
+- lib/dorm/connection_pool.rb
+- lib/dorm/database.rb
+- lib/dorm/functional_helpers.rb
+- lib/dorm/query_builder.rb
+- lib/dorm/repository.rb
+- lib/dorm/result.rb
+- lib/dorm/version.rb
+- sig/Dorm.rbs
+homepage: https://github.com/ecnal/dorm
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ecnal/dorm
+  source_code_uri: https://github.com/ecnal/dorm
+  changelog_uri: https://github.com/ecnal/dorm/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A functional ORM using Ruby's Data class with monadic error handling
+test_files: []