database-core 0.1.0

data/lib/database/v2/query.rb

@@ -0,0 +1,121 @@
+module Database::V2
+
+  class Query
+
+    def self.build table, query
+
+      output = []
+
+      build_select output, query
+
+      output << "FROM `#{table}`"
+
+      build_where output, query
+      build_order output, query
+      build_limit output, query
+      build_offset output, query
+
+      output.join " "
+    end
+
+    def self.build_select output, query
+
+      columns = []
+
+      build_keys columns, query
+
+      unless query["columns"].nil?
+        columns.concat query["columns"]
+      end
+
+      if columns.empty?
+        output << "SELECT *"
+      end
+
+      unless columns.empty?
+        columns.map!{ |column| "`#{column}`" }
+        output << "SELECT #{columns.join ","}"
+      end
+    end
+
+    def self.build_where output, query
+
+      where_rules = []
+
+      unless query["where_and"].nil?
+        where_rules << Wherer.build(query["where_and"]).join(" AND ")
+      end
+
+      unless query["where_or"].nil?
+        where_rules << Wherer.build(query["where_and"]).join(" OR ")
+      end
+
+      unless where_rules.empty?
+        output << "WHERE #{where_rules.join(" AND ")}"
+      end
+    end
+
+    def self.build_order output, query
+
+      order = []
+
+      unless query["order"].nil?
+        query["order"].each do |key, value|
+          order << "`#{key}` #{value}"
+        end
+      end
+
+      unless order.empty?
+        order = order.join ","
+        output << "ORDER BY #{order}"
+      end
+    end
+
+    def self.build_limit output, query
+
+      unless query["limit"].nil?
+        output << "LIMIT #{query["limit"]}"
+      end
+    end
+
+    def self.build_offset output, query
+
+      unless query["offset"].nil?
+        output << "OFFSET #{query["offset"]}"
+      end
+    end
+
+    def self.build_keys output, query
+
+      unless query["has_one_key"].nil?
+        unless output.include? "id"
+          output << "id"
+        end
+      end
+
+      unless query["has_many"].nil?
+        unless output.include? "id"
+          output << "id"
+        end
+      end
+
+      unless query["has_many_key"].nil?
+        unless output.include? query["has_many_key"]
+          output << query["has_many_key"]
+        end
+      end
+
+      unless query["has_one"].nil?
+        query["has_one"].each do |table, query|
+          unless query["has_one_key"].nil?
+            unless output.include? query["has_one_key"]
+              output << query["has_one_key"]
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/database/v2/query_runner.rb

@@ -0,0 +1,100 @@
+module Database::V2
+
+  class QueryRunner
+
+    def self.query models_query
+
+      models_values = {}
+
+      models_query.each do |model, query|
+
+        sql = Query.build(model, query)
+
+        values = ActiveRecord::Base.connection.exec_query(sql).map(&:as_json)
+
+        if values.present?
+
+          setup_relation values, query["has_one"], true
+          setup_relation values, query["has_many"], false
+        end
+
+        models_values[model] = values
+      end
+
+      serialize(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["has_one_key"].nil? && relation == true
+        next if query["has_many_key"].nil? && relation == false
+
+        foreign_key = relation ? "id" : query["has_many_key"]
+        primary_key = relation ? query["has_one_key"] : "id"
+
+        keys = parents.map{ |parent| parent[primary_key] }.uniq.compact
+
+        next if keys.empty?
+
+        query["in_value"] = {} if query["in_value"].nil?
+
+        if query["in_value"][foreign_key]
+          query["in_value"][foreign_key] << keys
+          query["in_value"][foreign_key].flatten
+        else
+          query["in_value"][foreign_key] = keys
+        end
+      end
+    end
+
+    def self.setup_relation_value parents, models_query, relation
+
+      models_values = query(models_query)
+
+      parents.each do |parent|
+
+        models_query.each do |model, query|
+
+          next if query["has_one_key"].nil? && relation == true
+          next if query["has_many_key"].nil? && relation == false
+
+          foreign_key = relation ? "id" : query["has_many_key"]
+          primary_key = relation ? query["has_one_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.serialize(target)
+
+      case target
+      when Integer
+        target > 2**32 ? target.to_s : target
+      when String
+        encodings = [Encoding::US_ASCII, Encoding::UTF_8]
+        encodings.include?(target.encoding) ? target : target.bytes.to_a
+      when Array
+        target.map { |value| serialize(value) }
+      when Hash
+        target.transform_values { |value| serialize(value) }
+      else
+        target
+      end
+    end
+
+  end
+
+end

data/lib/database/v2/wherer.rb

@@ -0,0 +1,62 @@
+module Database::V2
+
+  class Wherer
+
+    def self.build query
+
+      where_rules = []
+
+      unless query["bigger"].nil?
+        query["bigger"].each do |key, value|
+          where_rules << "`#{key}` = #{value}"
+        end
+      end
+
+      unless query["smaller"].nil?
+        query["smaller"].each do |key, value|
+          where_rules << "`#{key}` = #{value}"
+        end
+      end
+
+      unless query["different"].nil?
+        query["different"].each do |key, value|
+          where_rules << "`#{key}` = #{value}"
+        end
+      end
+
+      unless query["equal"].nil?
+        query["equal"].each do |key, value|
+          where_rules << "`#{key}` = #{value}"
+        end
+      end
+
+      unless query["in_query"].nil?
+        query["in_query"].each do |key, value|
+          value.each do |table, query|
+            query = Query.build table, query
+            where_rules << "`#{key}` IN (#{query})"
+          end
+        end
+      end
+
+      unless query["in_value"].nil?
+        query["in_value"].each do |key, value|
+          unless value.empty?
+            value = value.join ","
+            where_rules << "`#{key}` IN (#{value})"
+          end
+        end
+      end
+
+      unless query["like"].nil?
+        query["like"].each do |key, value|
+          where_rules << "`#{key}` LIKE '#{value}'"
+        end
+      end
+
+      where_rules
+    end
+
+  end
+
+end

data/lib/database/v3/delete_model.rb

@@ -0,0 +1,18 @@
+module Database::V3
+
+  class DeleteModel
+
+    def self.build model, params
+
+      model = Sanitize.target(model)
+
+      output = ["DELETE FROM `#{model}`"]
+
+      WhereModel.build(output, params)
+
+      output.join(" ")
+    end
+
+  end
+
+end

data/lib/database/v3/delete_runner.rb

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

data/lib/database/v3/insert_model.rb

@@ -0,0 +1,33 @@
+module Database::V3
+
+  class InsertModel
+
+    def self.build model, params
+
+      model = Sanitize.target(model)
+
+      datetime = Time.current.utc.strftime("%Y-%m-%d %H:%M:%S")
+
+      params["columns"]["created_at"] = datetime
+      params["columns"]["updated_at"] = datetime
+
+      columns = build_columns(params).join(", ")
+
+      values = build_values(params).join(", ")
+
+      "INSERT INTO `#{model}` (#{columns}) VALUES (#{values})"
+    end
+
+    def self.build_columns params
+
+      params["columns"].keys.map{ |column| "`#{Sanitize.target(column)}`" }
+    end
+
+    def self.build_values params
+
+      params["columns"].values.map{ |value| Sanitize.array(["?", value]) }
+    end
+
+  end
+
+end

data/lib/database/v3/insert_runner.rb

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

data/lib/database/v3/policy_model.rb

@@ -0,0 +1,29 @@
+module Database::V3
+
+  class PolicyModel
+
+    def initialize permissions, overrides
+
+      @permissions = permissions
+
+      @overrides = overrides
+    end
+
+    def permit? model, params, permission
+
+      override = @overrides.dig(model)
+
+      return @permissions.dig(permission) unless override
+
+      params_columns = params.dig("columns").to_a
+
+      override_columns = override.dig("columns").to_a
+
+      return @permissions.dig(permission) unless (params_columns - override_columns).empty?
+
+      override.dig("permissions", permission)
+    end
+
+  end
+
+end

data/lib/database/v3/policy_runner.rb

@@ -0,0 +1,23 @@
+module Database::V3
+
+  class PolicyRunner
+
+    def initialize permissions, overrides
+
+      @policy_model = PolicyModel.new(permissions, overrides)
+    end
+
+    def permit? input, permission
+
+      input.all? do |model, payload|
+
+        Array.wrap(payload).all? do |item|
+
+          @policy_model.permit?(model, item, permission)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/database/v3/query_model.rb

@@ -0,0 +1,126 @@
+module Database::V3
+
+  class QueryModel
+
+    def self.build model, query
+
+      model = Sanitize.target(model)
+
+      columns = build_columns(query)
+
+      output = ["SELECT #{columns} FROM `#{model}`"]
+
+      WhereModel.build(output, query)
+
+      build_order(output, query)
+      build_limit(output, query)
+      build_offset(output, query)
+
+      output.join(" ")
+    end
+
+    def self.build_count model, query
+
+      model = Sanitize.target(model)
+
+      output = ["SELECT COUNT(id) AS `#{model}` FROM `#{model}`"]
+
+      WhereModel.build(output, query)
+
+      output.join(" ")
+    end
+
+    def self.build_children model, query
+
+      children = query["children"]
+
+      return unless children.present?
+
+      children.each do |_model, value|
+
+        value["key"] = "#{model.singularize}_id" if value["key"].nil?
+
+        value["keys"] = [] if value["keys"].nil?
+
+        value["keys"] << value["key"] unless value["keys"].include? value["key"]
+      end
+
+      query["keys"] = [] if query["keys"].nil?
+
+      query["keys"] << "id" unless query["keys"].include? "id"
+    end
+
+    def self.build_parents _model, query
+
+      parents = query["parents"]
+
+      return unless parents.present?
+
+      parents.each do |model, value|
+
+        value["key"] = "#{model.singularize}_id" if value["key"].nil?
+
+        query["keys"] = [] if query["keys"].nil?
+
+        query["keys"] << value["key"] unless query["keys"].include? value["key"]
+
+        value["keys"] = [] if value["keys"].nil?
+
+        value["keys"] << "id" unless value["keys"].include? "id"
+      end
+    end
+
+    def self.build_columns query
+
+      columns = query["columns"].to_a + query["keys"].to_a
+
+      columns = columns.uniq.map{ |column| column.is_a?(Hash) ? build_function(column) : "`#{column}`" }.join(",")
+
+      columns.present? ? columns : "*"
+    end
+
+    def self.build_function function
+
+      function_name = function["function"].upcase
+
+      params = function["params"].map{ |param| param.is_a?(Hash) ? build_function(param) : "`#{param}`" }.join(", ")
+
+      function_call = "#{function_name}(#{params})"
+
+      function["alias"] ? "#{function_call} AS `#{function['alias']}`" : function_call
+    end
+
+    def self.build_order output, query
+
+      order = query["order"]
+
+      return unless order.present?
+
+      order = order.map{ |key, value| "`#{key}` #{value}" }.join(",")
+
+      return unless order.present?
+
+      output << "ORDER BY #{order}"
+    end
+
+    def self.build_limit output, query
+
+      limit = query["limit"].to_i
+
+      return if limit.zero?
+
+      output << "LIMIT #{limit}"
+    end
+
+    def self.build_offset output, query
+
+      offset = query["offset"].to_i
+
+      return if offset.zero?
+
+      output << "OFFSET #{offset}"
+    end
+
+  end
+
+end