database-core 0.1.0

data/lib/database/v3/query_runner.rb

@@ -0,0 +1,163 @@
+module Database::V3
+
+  class QueryRunner
+
+    def self.query models_query
+
+      models_values = setup_query(models_query)
+
+      remove_keys(models_query, models_values)
+
+      models_values = setup_values(models_values)
+
+      models_values
+    end
+
+    def self.setup_query models_query
+
+      models_values = { "rows" => {} }
+
+      models_query.each do |model, query|
+
+        QueryModel.build_parents(model, query)
+        QueryModel.build_children(model, query)
+
+        sql = QueryModel.build(model, query)
+
+        values = ActiveRecord::Base.connection.exec_query(sql).map(&:as_json)
+
+        if query["rows"]
+
+          sql = QueryModel.build_count(model, query)
+
+          rows = ActiveRecord::Base.connection.exec_query(sql).first.as_json
+
+          models_values["rows"].merge!(rows)
+        end
+
+        if values.present?
+
+          setup_relation values, query["parents"], true
+          setup_relation values, query["children"], false
+        end
+
+        models_values[model] = values
+      end
+
+      models_values
+    end
+
+    def self.setup_relation parents, models_query, relation
+
+      return unless models_query.present?
+
+      setup_relation_query(parents, models_query, relation)
+      setup_relation_value(parents, models_query, relation)
+    end
+
+    def self.setup_relation_query parents, models_query, relation
+
+      models_query.each do |model, query|
+
+        next if query["key"].nil?
+
+        foreign_key = relation ? "id" : query["key"]
+        primary_key = relation ? query["key"] : "id"
+
+        keys = parents.map{ |parent| parent[primary_key] }.uniq.compact
+
+        next if keys.empty?
+
+        query["and"] = {} if query["and"].nil?
+
+        if query["and"][foreign_key]
+          query["and"][foreign_key]["in"] ?
+            query["and"][foreign_key]["in"] << keys :
+            query["and"][foreign_key]["in"] = keys
+        else
+          query["and"][foreign_key] = { "in" => keys }
+        end
+      end
+    end
+
+    def self.setup_relation_value parents, models_query, relation
+
+      models_values = setup_query(models_query)
+
+      parents.each do |parent|
+
+        models_query.each do |model, query|
+
+          next if query["key"].nil?
+
+          foreign_key = relation ? "id" : query["key"]
+          primary_key = relation ? query["key"] : "id"
+
+          values = models_values[model].select{ |value| value[foreign_key] == parent[primary_key] }
+
+          parent[model] = relation ? values.first : values
+        end
+      end
+    end
+
+    def self.setup_values target
+
+      if target.is_a?(Integer)
+        return target > 2**32 ? target.to_s : target
+      end
+
+      if target.is_a?(Array)
+        return target.map { |value| setup_values(value) }
+      end
+
+      if target.is_a?(Hash)
+        return target.transform_values { |value| setup_values(value) }
+      end
+
+      if target.is_a?(String)
+        unless [Encoding::US_ASCII, Encoding::UTF_8].include?(target.encoding)
+          return target.bytes.to_a
+        end
+      end
+
+      target
+    end
+
+    def self.remove_keys models_query, models_values
+
+      models_query&.each do |model, query|
+
+        if models_values[model].is_a?(Array)
+          models_values[model].each do |value|
+            remove_key query, value
+          end
+        end
+
+        if models_values[model].is_a?(Hash)
+          value = models_values[model]
+          remove_key query, value
+        end
+      end
+    end
+
+    def self.remove_key query, value
+
+      columns = query["columns"]&.map{ |column| column.is_a?(Hash) ? column["alias"] : column }
+
+      value.keys.each do |key|
+
+        next if columns.include?(key)
+
+        next if query["parents"]&.key?(key)
+        next if query["children"]&.key?(key)
+
+        value.delete(key)
+      end
+
+      remove_keys query["parents"], value
+      remove_keys query["children"], value
+    end
+
+  end
+
+end

data/lib/database/v3/sanitize.rb

@@ -0,0 +1,19 @@
+module Database::V3
+
+  RULE = /[^a-zA-Z0-9_]/.freeze
+
+  class Sanitize
+
+    def self.target params
+
+      params.to_s.gsub(RULE, "")
+    end
+
+    def self.array params
+
+      ActiveRecord::Base.sanitize_sql_array(params)
+    end
+
+  end
+
+end

data/lib/database/v3/update_model.rb

@@ -0,0 +1,30 @@
+module Database::V3
+
+  class UpdateModel
+
+    def self.build model, params
+
+      model = Sanitize.target(model)
+
+      columns = build_columns(params).join(", ")
+
+      output = ["UPDATE `#{model}` SET #{columns}"]
+
+      WhereModel.build(output, params)
+
+      output.join(" ")
+    end
+
+    def self.build_columns params
+
+      params["columns"].map do |column, value|
+
+        column = Sanitize.target(column)
+
+        Sanitize.array(["`#{column}` = ?", value])
+      end
+    end
+
+  end
+
+end

data/lib/database/v3/update_runner.rb

@@ -0,0 +1,20 @@
+module Database::V3
+
+  class UpdateRunner
+
+    def self.update input
+
+      input.each do |model, payload|
+
+        Array.wrap(payload).each do |item|
+
+          sql = UpdateModel.build(model, item)
+
+          ActiveRecord::Base.connection.execute(sql)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/database/v3/where_model.rb

@@ -0,0 +1,144 @@
+module Database::V3
+
+  class WhereModel
+
+    OPERATORS = {
+
+      "="     => "=",
+      "!="    => "!=",
+      "<>"    => "<>",
+      ">"     => ">",
+      "<"     => "<",
+      ">="    => ">=",
+      "<="    => "<=",
+      "in"    => "IN",
+      "like"  => "LIKE",
+      "!in"   => "NOT IN",
+      "!like" => "NOT LIKE",
+    }
+
+    def self.build output, query
+
+      where = []
+
+      where << query["and"].to_h.map{ |key, value| build_scopes(" AND ", key, value) }.compact_blank.join(" AND ")
+
+      where << query["or"].to_h.map{ |key, value| build_scopes(" OR ", key, value) }.compact_blank.join(" OR ")
+
+      where = where.compact_blank.join(" AND ")
+
+      return unless where.present?
+
+      output << "WHERE #{where}"
+    end
+
+    def self.build_scopes scope, column, rules
+
+      if rules.is_a? FalseClass
+
+        return build_rules(column, "=", rules)
+      end
+
+      if rules.is_a? TrueClass
+
+        return build_rules(column, "=", rules)
+      end
+
+      if rules.is_a? Numeric
+
+        return build_rules(column, "=", rules)
+      end
+
+      if rules.is_a? String
+
+        return build_rules(column, "contains", rules)
+      end
+
+      output = build_scope(scope, column, rules)
+
+      output.present? ? "(#{output})" : ""
+    end
+
+    def self.build_scope scope, column, rules
+
+      case column
+      when "and"
+        return rules.map{ |key, value| build_scopes(" AND ", key, value) }.compact_blank.join(" AND ")
+      when "or"
+        return rules.map{ |key, value| build_scopes(" OR ", key, value) }.compact_blank.join(" OR ")
+      else
+        return rules.map{ |key, value| build_rules(column, key, value) }.compact_blank.join(scope)
+      end
+    end
+
+    def self.build_rules column, operator, value
+
+      case operator
+      when "and"
+        return build_scopes(" AND ", column, value)
+      when "or"
+        return build_scopes(" OR ", column, value)
+      else
+        return build_rule(column, operator, value)
+      end
+    end
+
+    def self.build_rule column, operator, value
+
+      return "" if value.is_a? NilClass
+
+      column = Sanitize.target(column)
+
+      if operator == "null"
+
+        value = value ? " " : " NOT "
+
+        return "`#{column}` IS#{value}NULL"
+      end
+
+      if operator == "last"
+        return Sanitize.array(["`#{column}` LIKE ?", "%#{value}"])
+      end
+
+      if operator == "first"
+        return Sanitize.array(["`#{column}` LIKE ?", "#{value}%"])
+      end
+
+      if operator == "contains"
+        return Sanitize.array(["`#{column}` LIKE ?", "%#{value}%"])
+      end
+
+      operator = get_operator(operator)
+
+      if value.is_a? Numeric
+        return Sanitize.array(["`#{column}` #{operator} ?", value])
+      end
+
+      if value.is_a? String
+        return Sanitize.array(["`#{column}` #{operator} ?", value])
+      end
+
+      if value.is_a? Array
+        return Sanitize.array(["`#{column}` #{operator} (?)", value])
+      end
+
+      if value.is_a? Hash
+
+        value = value.map{ |model, query| QueryModel.build(model, query) }
+
+        value = value.map{ |value| "(#{value})" }.join(" UNION ")
+      end
+
+      "`#{column}` #{operator} #{value}"
+    end
+
+    def self.get_operator operator
+
+      return OPERATORS[operator] if OPERATORS.key?(operator)
+
+      raise KeyError, operator
+    end
+
+  end
+
+end

data/lib/database/version.rb

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

data/lib/database.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "database/version"
+
+Dir[File.join(__dir__, "database/**/*.rb")].sort.each do |file|
+  require file
+end

data/sig/database.rbs

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

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: database-core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tiago da Silva
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: A comprehensive Ruby library providing database abstraction and management
+  features, making it easier to interact with various databases.
+email:
+- tyagoy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/database.rb
+- lib/database/v1/query.rb
+- lib/database/v1/query_runner.rb
+- lib/database/v2/query.rb
+- lib/database/v2/query_runner.rb
+- lib/database/v2/wherer.rb
+- lib/database/v3/delete_model.rb
+- lib/database/v3/delete_runner.rb
+- lib/database/v3/insert_model.rb
+- lib/database/v3/insert_runner.rb
+- lib/database/v3/policy_model.rb
+- lib/database/v3/policy_runner.rb
+- lib/database/v3/query_model.rb
+- lib/database/v3/query_runner.rb
+- lib/database/v3/sanitize.rb
+- lib/database/v3/update_model.rb
+- lib/database/v3/update_runner.rb
+- lib/database/v3/where_model.rb
+- lib/database/version.rb
+- sig/database.rbs
+homepage: https://rubygems.org/gems/database
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://rubygems.org/gems/database
+  source_code_uri: https://github.com/tyagoy/database-core
+  changelog_uri: https://github.com/tyagoy/database-core/blob/main/CHANGELOG.md
+post_install_message:
+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.4.10
+signing_key:
+specification_version: 4
+summary: A simple Ruby library for database abstraction and management.
+test_files: []