hadouken-json 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3f7db7ba69d3b1b011d3c3473d8f8ed062b7db7d81c7e2dd0b579f0fa6aa71ac
+  data.tar.gz: 76bdcafe07baa2e145dda9bc628cfa3c3b95e957e7db14fe496d2c942dd24093
+SHA512:
+  metadata.gz: fd3597acf4b95916dbd9784ba5c55acf423e18086d29a84210ab40f73e904af48936a8f264be588bef2842d1bf4d8e44581ee3e6b435877cb4fdbf3d3c7104f3
+  data.tar.gz: 1c40b20ad5176b88b7b8b173136e057e9f59a06b71c96144b72b575337b26f1b77344cb9cc8bf46ce32b4abe3dcbaea67e7dcd7c96e842c7f157bddbf6bdce0b

data/lib/hadouken/decorator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Hadouken::Decorator
+  attr_accessor :relation
+  class << self 
+    def columns(column_names, *args)
+      @@column_names = column_names.is_a?(Array) ? column_names.map(&:to_s) : []
+      @@mapping = args[0].is_a?(Hash) ? args[0] : {}
+      
+      fail "Please specify column names for #{self.class}" if @@column_names.empty?
+      fail "Please specify mapping of a columns for #{self.class}" if @@mapping.empty?
+    end
+  end
+
+  def initialize(relation)
+    @relation = relation
+  end
+
+  def valid?
+    @@column_names.present?
+  end
+
+  def join_sql
+    "LEFT OUTER JOIN \"#{table_name}\" ON #{join_condition}"
+  end
+
+  def columns_sql
+    columns_to_exclude = (@@mapping.keys+@@mapping.values).map(&:to_s)
+    (@@column_names - columns_to_exclude).map do |column|
+      "\"#{table_name}\".\"#{column.downcase}\" AS #{column}"
+    end
+  end
+
+  def data
+    fail "#{self.class} does not implement #data"
+  end
+
+  def data_table_sql
+    "WITH #{table_name}(#{@@column_names.join(', ')}) AS ( VALUES #{values_sql} ) "
+  end
+
+
+  private
+
+  def join_condition
+    @@mapping.map { |decorator_column, relation_column|
+      "\"#{@relation.table_name}\".\"#{relation_column}\" = \"#{table_name}\".\"#{decorator_column}\""
+    }.join(' AND ')
+  end
+
+  def sanitize(value)
+    ActiveRecord::Base::sanitize_sql(value)
+  end
+
+  def values_sql
+    values.map { |vals| "(#{vals.map{|v| "'#{sanitize(v)}'"}.join(', ') })"  }.join(', ')
+  end
+
+  def values
+    data.present? ? data : [ @@column_names.map{|_| ''} ]
+  end
+
+  def table_name
+    self.class.name.underscore
+  end
+end

data/lib/hadouken/json.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Hadouken::Json
+  include ::Virtus.model
+  attribute :relation, Hadouken::Virtus::ActiveRecordRelation
+
+  def self.call(*args)
+    new(*args).call
+  end
+
+  def call
+    execute_query array_of(structure)
+  end
+
+  protected
+  
+  def array_of(json_schema, *args)
+    options = args[0] || {}
+
+    Hadouken::SqlBuilder.call(
+      main_class: relation.klass,
+      scope: options[:for],
+      schema: json_schema,
+      decorator: (options[:decorate_with].is_a?(Hadouken::Decorator) ? options[:decorate_with] : nil)
+    )
+  end
+
+  private
+
+  def execute_query(sql_query)
+    ActiveRecord::Base.connection.execute(sql_query).values.first.first
+  end
+  
+end

data/lib/hadouken/sql_builder.rb

@@ -0,0 +1,111 @@
+class Hadouken::SqlBuilder
+  include Virtus.model
+
+  attribute :main_class
+  attribute :scope
+  attribute :schema, Hash, default: {}
+  attribute :decorator, Hadouken::Decorator
+  def self.call(*args)
+    new(*args).call
+  end
+
+  def call
+    return json_build_object_sql(schema) if scope.nil?
+
+    @sql = ''
+    @relation = build_relation
+    apply_decorator if decorator&.valid?
+    @sql << @relation.select(*columns_to_select).to_sql.gsub(sample_id.to_s, primary_key)
+
+    "SELECT COALESCE(json_agg(a), '[]'::JSON ) FROM (#{@sql}) a"
+  end
+
+  private
+
+  def columns_to_select
+    columns = []
+    columns += static_columns.map { |field, value| "'#{value}' AS '#{field}' " }
+    columns += association_columns
+    columns += regular_columns.map { |field, column_name| "#{sanitize_column_name(column_name)} AS \"#{field}\"" } 
+    columns += decorator.columns_sql if decorator&.valid?
+    columns += nested_columns.map { |field, column_schema| "(#{sql_for(column_schema)}) AS \"#{field}\"" }
+  end
+
+
+  def json_build_object_sql(schema)
+    <<~EOQ
+      SELECT json_build_object(#{(
+        static_columns.map { |field, value| "'#{field}', '#{value}'"} +
+        regular_columns.map { |field, data| "'#{field}', (#{data})"} +
+        nested_columns.map {|field, column_schema| "'#{field}', (#{sql_for(column_schema)})" }
+      ).join(', ')})
+    EOQ
+  end
+
+  def apply_decorator
+    @sql << decorator.data_table_sql
+    @relation.joins!(decorator.join_sql)
+  end
+
+  def build_relation
+    fail 'Scope should be ActiveRecord::Relation or string' if [ActiveRecord::Relation, String].none? { |klass| scope.is_a?( klass ) }
+
+    scope.is_a?(ActiveRecord::Relation) ? scope : main_class.new(id: sample_id).instance_eval(scope)
+  end
+
+  def regular_columns
+    schema.extract!(*schema.select{ |_,v| v.is_a?(String) }.keys)
+          .inject({}) do |h, (field, column)|
+            col = (@relation&.klass&.column_names||[]).include?(column) ? [@relation.klass.table_name, column].join('.') : column
+            h.merge(field => col)
+          end
+  end
+
+  def nested_columns
+    schema.extract!(*schema.select{ |_,v| v.is_a?(Hash) }.keys)
+  end
+
+  def association_columns
+    belongs_to_associations = @relation.klass.reflections.select {|_, v| v.is_a?(ActiveRecord::Reflection::BelongsToReflection) }.keys
+    split_regex = /^[\.](?<association>#{belongs_to_associations.join('|')})[.]?(?<scope>.+?)[.](?<column>[^.]+)$/
+
+    cols = schema.extract!(*schema.select{ |_, v| v.to_s.starts_with?('.') }.keys)
+
+    cols.map do |json_field, relation_field|
+      s = relation_field.match(split_regex)
+      reflection = @relation.klass.reflections[s[:association]]
+      join_table_name = [reflection.table_name, reflection.object_id].join('_')
+      @relation.joins!(<<~EOQ
+          LEFT OUTER JOIN #{reflection.table_name} #{join_table_name}
+          ON "#{join_table_name}"."#{reflection.join_primary_key}" = "#{@relation.table_name}"."#{reflection.join_foreign_key}"
+        EOQ
+      )
+      # Scope can not be merged now because i need to do named joins
+      # @relation.merge!(reflection.klass.instance_eval(s[:scope])) if(s[:scope])
+      "\"#{join_table_name}\".\"#{s[:column]}\" AS \"#{json_field}\""
+    end
+    
+  end
+
+  def static_columns
+    schema.extract!(*schema.select{ |k,_| k.to_s.starts_with?('_') }.keys)
+          .inject({}) { |h, (k, v)| h.merge(k.to_s[1..-1] => v) }
+  end
+
+  def sql_for(json_schema)
+    self.class.call!(main_class: main_class, schema: json_schema, decorator: decorator)
+  end
+
+  def sample_id
+    @sample_id ||= Faker::Number.number(digits: 5)
+  end
+
+  def primary_key
+    "\"#{main_class.table_name}\".\"#{main_class.primary_key}\""
+  end
+
+  def sanitize_column_name(column_name)
+    column_name.scan(/[.]/).length <= 1 ? "\"#{column_name.split('.').join('"."')}\"" : "(#{column_name})"
+  end
+
+end

data/lib/hadouken/virtus/active_record_relation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hadouken
+  module Virtus
+    # Polymorphic class to use for coercing ActiveRecord models
+    class ActiveRecordRelation < ::Virtus::Attribute
+      def coerce(value)
+        # Raise an error if we got something other than a relation or array
+        fail ::Virtus::CoercionError.new(value.class, self) unless value.is_a?(ActiveRecord::Relation) || value.is_a?(Array)
+
+        value
+      end
+    end
+  end
+end

data/lib/hadouken-json.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'hadouken/virtus/active_record_relation'
+require 'hadouken/decorator'
+require 'hadouken/sql_builder'
+require 'hadouken/json'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: hadouken-json
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Roman Zaytsev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+description: ''
+email: gnemot@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hadouken-json.rb
+- lib/hadouken/decorator.rb
+- lib/hadouken/json.rb
+- lib/hadouken/sql_builder.rb
+- lib/hadouken/virtus/active_record_relation.rb
+homepage: https://github.com/nemot/hadouken-json
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: A tool to create a JSON response right inside of PostgreSQL 9.3+
+test_files: []