fastapi 0.1.25 → 0.1.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6257aad18a7f5ccf31fd70bcb267a3976b83518
-  data.tar.gz: 81a7955417c82b41deafc611138a1fe606d20d4f
+  metadata.gz: 5478a368c91cfadee25770397b95a7b24865166f
+  data.tar.gz: 6362f9b6f08b3f0111ae69e3ac5695c4bf96cc8e
 SHA512:
-  metadata.gz: db70059eb226331aa57f6964612d7fde14e64b47671950882c2408ec1c0730740fa7fc60540f832ec713a449547727446fc715d32662bfc98f895b3f1f09681c
-  data.tar.gz: d0a9bfffd1eed2b65288bcaad6eb01331e573df1932923e75d0b9d6d679c19b70ce5a065f852291c50b1fce4132259bab8e488a3aa921802ed635f54421a22d8
+  metadata.gz: da97e14f324c2772288c78626102adb6ce2fb9b0a4db07d678a5b3dbd24fd80a77bfb9d5e573322c81646868481e0d03e84d0d23ccb38535d5d1e75f83dfd01f
+  data.tar.gz: f885f7f223dfea56a927167c38acd8cea4b45e1b2166671f1cce6eeab8b28daaa60e98053bec391f917b073619f0ade693ec6d0233fc0a955405c66a8b5d060d

data/lib/fastapi.rb

@@ -1,27 +1,24 @@
 require 'oj'
-require 'fastapi/active_record_extension.rb'
+require 'fastapi/active_record_extension'
 
 class FastAPI
 
-  @@result_types = {
-    single: 0,
-    multiple: 1,
-  }
-
-  @@api_comparator_list = [
-    'is',
-    'not',
-    'gt',
-    'gte',
-    'lt',
-    'lte',
-    'in',
-    'not_in',
-    'contains',
-    'icontains',
-    'is_null',
-    'not_null',
-  ]
+  @@result_types = { single: 0, multiple: 1 }
+
+  @@api_comparator_list = %w(
+    is
+    not
+    gt
+    gte
+    lt
+    lte
+    in
+    not_in
+    contains
+    icontains
+    is_null
+    not_null
+  )
 
   def initialize(model)
     @model = model
@@ -40,11 +37,9 @@ class FastAPI
   # @param fields [Array] an array containing fields to whitelist for the SQL query. Can also pass in fields as arguments.
   # @return [FastAPI] the current instance
   def whitelist(fields = [])
-
-    @whitelist_fields.concat fields
+    @whitelist_fields.concat(fields)
 
     self
-
   end
 
   # Create and execute an optimized SQL query based on specified filters
@@ -53,27 +48,13 @@ class FastAPI
   # @param meta [Hash] a hash containing custom metadata
   # @return [FastAPI] the current instance
   def filter(filters = {}, meta = {}, safe = false)
-
     result = fastapi_query(filters, safe)
 
-    metadata = {}
-
-    meta.each do |key, value|
-      metadata[key] = value
-    end
-
-    metadata[:total] = result[:total]
-    metadata[:offset] = result[:offset]
-    metadata[:count] = result[:count]
-    metadata[:error] = result[:error]
-
-    @metadata = metadata
-    @data = result[:data]
-
+    @metadata    = meta.merge(result.slice(:total, :offset, :count, :error))
+    @data        = result[:data]
     @result_type = @@result_types[:multiple]
 
     self
-
   end
 
   # Create and execute an optimized SQL query based on specified filters.
@@ -83,11 +64,7 @@ class FastAPI
   # @param meta [Hash] a hash containing custom metadata
   # @return [FastAPI] the current instance
   def safe_filter(filters = {}, meta = {})
-
     filter(filters, meta, true)
-
-    self
-
   end
 
   # Create and execute an optimized SQL query based on specified object id.
@@ -97,15 +74,13 @@ class FastAPI
   # @param meta [Hash] a hash containing custom metadata
   # @return [FastAPI] the current instance
   def fetch(id, meta = {})
+    filter({ id: id }, meta)
 
-    filter({id: id}, meta)
-
-    if @metadata[:total] == 0
-      @metadata[:error] = {message: @model.to_s + ' id does not exist'}
+    if @metadata[:total].zero?
+      @metadata[:error] = { message: "#{@model} id does not exist" }
     end
 
     self
-
   end
 
   # Returns the data from the most recently executed `filter` or `fetch` call.
@@ -140,10 +115,7 @@ class FastAPI
   #
   # @return [Hash] available data and metadata
   def to_hash
-    {
-      meta: @metadata,
-      data: @data
-    }
+    { meta: @metadata, data: @data }
   end
 
   # Intended to return the final API response
@@ -157,24 +129,11 @@ class FastAPI
   #
   # @return [String] JSON data and metadata
   def spoof(data = [], meta = {})
+    meta[:total]  ||= data.count
+    meta[:count]  ||= data.count
+    meta[:offset] ||= 0
 
-    if not meta.has_key? :total
-      meta[:total] = data.count
-    end
-
-    if not meta.has_key? :offset
-      meta[:offset] = 0
-    end
-
-    if not meta.has_key? :count
-      meta[:count] = data.count
-    end
-
-    Oj.dump({
-      meta: meta,
-      data: data
-    }, mode: :compat)
-
+    Oj.dump({ meta: meta, data: data }, mode: :compat)
   end
 
   # Returns a JSONified string representing a rejected API response with invalid fields parameters
@@ -192,7 +151,7 @@ class FastAPI
           fields: fields
         }
       },
-      data: [],
+      data: []
     }, mode: :compat)
   end
 
@@ -210,878 +169,533 @@ class FastAPI
           message: message.to_s
         }
       },
-      data: [],
+      data: []
     }, mode: :compat)
   end
 
   private
 
-    def fastapi_query(filters = {}, safe = false)
-
-      if (not ActiveRecord::ConnectionAdapters.constants.include? :PostgreSQLAdapter or
-      not ActiveRecord::Base.connection.instance_of? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-        raise 'Fast API only supports PostgreSQL at this time'
-      end
-
-      offset = 0
-      count = 500
-      order = nil
-
-      if filters.has_key? :__offset
-        offset = filters[:__offset].to_i
-        filters.delete(:__offset)
-      end
-
-      if filters.has_key? :__count
-        count = [1, [500, filters[:__count].to_i].min].max
-        filters.delete(:__count)
-      end
-
-      begin
-        prepared_data = api_generate_sql(filters, offset, count, safe)
-      rescue Exception => error
-        return {
-          data: [],
-          total: 0,
-          count: 0,
-          offset: offset,
-          error: {message: error.message}
-        }
-      end
+  def clamp(value, min, max)
+    [min, value, max].sort[1]
+  end
 
-      model_lookup = {}
-      prepared_data[:models].each do |key, model|
-        columns_hash = model.columns_hash
-        model_lookup[key] = {
-          model: model,
-          fields: model.fastapi_fields_sub,
-          types: model.fastapi_fields_sub.map { |field| (columns_hash.has_key? field.to_s) ? columns_hash[field.to_s].type : nil },
-        }
-      end
+  def error(offset, message)
+    { data: [], total: 0, count: 0, offset: offset, error: { message: message } }
+  end
 
-      error = nil
-
-      begin
-        count_result = ActiveRecord::Base.connection.execute(prepared_data[:count_query])
-        result = ActiveRecord::Base.connection.execute(prepared_data[:query])
-      rescue
-        return {
-          data: [],
-          total: 0,
-          count: 0,
-          offset: offset,
-          error: {message: 'Query failed'}
-        }
-      end
+  def fastapi_query(filters = {}, safe = false)
 
-      total_size = count_result.values().size > 0 ? count_result.values()[0][0].to_i : 0
+    unless ActiveRecord::ConnectionAdapters.constants.include?(:PostgreSQLAdapter) &&
+        ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+      fail 'FastAPI only supports PostgreSQL at this time.'
+    end
 
-      start = Time.now()
+    offset = filters.delete(:__offset).try(:to_i) || 0
+    cnt    = filters.delete(:__count).try(:to_i) || 500
+    count  = clamp(cnt, 1, 500)
 
-      fields = result.fields()
-      rows = result.values()
+    begin
+      prepared_data = api_generate_sql(filters, offset, count, safe)
+    rescue StandardError => exception
+      return error(offset, exception.message)
+    end
 
-      dataset = Array.new(rows.size)
+    model_lookup = prepared_data[:models].each_with_object({}) do |(key, model), lookup|
+      columns = model.columns_hash
+      lookup[key] = {
+        model: model,
+        fields: model.fastapi_fields_sub,
+        types: model.fastapi_fields_sub.map { |field| columns[field.to_s].try(:type) }
+      }
+    end
 
-      rows.each_with_index do |row, index|
-        currow = {}
-        row.each_with_index do |val, key_index|
+    begin
+      count_result = ActiveRecord::Base.connection.execute(prepared_data[:count_query])
+      result = ActiveRecord::Base.connection.execute(prepared_data[:query])
+    rescue
+      error(offset, 'Query failed')
+    end
 
-          field = fields[key_index]
-          split_index = field.rindex('__')
+    total_size = count_result.values.size > 0 ? count_result.values[0][0].to_i : 0
 
-          if field[0..7] == '__many__'
+    fields = result.fields
+    rows   = result.values
 
-            field = field[8..-1]
-            field_sym = field.to_sym
-            model = model_lookup[field_sym]
+    dataset = rows.each_with_object([]) do |row, data|
+      datum = row.each_with_object({}).with_index do |(val, current), index|
+        field = fields[index]
+        split_index = field.rindex('__')
 
-            currow[field_sym] = parse_many(
-              val,
-              model_lookup[field_sym][:fields],
-              model_lookup[field_sym][:types]
-            )
+        if field[0..7] == '__many__'
 
-          elsif split_index
+          field     = field[8..-1]
+          field_sym = field.to_sym
+          model     = model_lookup[field_sym]
 
-            obj_name = field[0..split_index - 1].to_sym
-            field = field[split_index + 2..-1]
-            model = model_lookup[obj_name][:model]
+          current[field_sym] = parse_many(val, model[:fields], model[:types])
 
-            if !(currow.has_key? obj_name)
-              currow[obj_name] = {}
-            end
+        elsif split_index
 
-            currow[obj_name][field.to_sym] = api_convert_type(
-              val,
-              model.columns_hash[field].type,
-              (model.columns_hash[field].respond_to?('array') and model.columns_hash[field].array)
-            )
+          obj_name = field[0..split_index - 1].to_sym
+          field    = field[split_index + 2..-1]
+          model    = model_lookup[obj_name][:model]
 
-          elsif @model.columns_hash[field]
+          current[obj_name] ||= {}
 
-            currow[field.to_sym] = api_convert_type(
-              val,
-              @model.columns_hash[field].type,
-              (@model.columns_hash[field].respond_to?('array') and @model.columns_hash[field].array)
-            )
+          current[obj_name][field.to_sym] = api_convert_type(val,
+            model.columns_hash[field].type,
+            (model.columns_hash[field].respond_to?('array') && model.columns_hash[field].array))
 
-          end
+        elsif @model.columns_hash[field]
 
+          current[field.to_sym] = api_convert_type(val,
+            @model.columns_hash[field].type,
+            (@model.columns_hash[field].respond_to?('array') && @model.columns_hash[field].array))
         end
-
-        dataset[index] = currow
-
       end
-
-      my_end = Time.now()
-
-      # puts dataset.size.to_s + '-length array parsed in ' + (my_end - start).to_s
-
-      {
-        data: dataset,
-        total: total_size,
-        count: dataset.size,
-        offset: offset,
-        error: nil
-      }
-
+      data << datum
     end
+    { data: dataset, total: total_size, count: dataset.size, offset: offset, error: nil }
+  end
 
-    # the two following methods are very similar, can reuse
-
-    def parse_postgres_array(str)
-
-      unless str.is_a? String
-        return []
+  def parse_many(str, fields, types)
+    Oj.load(str).map do |row|
+      row.values.each_with_object({}).with_index do |(value, values), index|
+        values[fields[index]] = api_convert_type(value, types[index])
       end
+    end
+  end
 
-      i = 0
-      len = str.length
-
-      values = []
-
-      i = str.index('{')
-
-      return values unless i
+  def api_comparison(comparator, value, field, type, is_array)
+    field_string = is_array ? "ANY(#{field})" : field
 
-      i = i + 1
+    if comparator == 'is'
 
-      while i < len
+      ActiveRecord::Base.connection.quote(value.to_s) + ' = ' + field_string
 
-        c = str[i]
+    elsif comparator == 'not'
 
-        if c == '}'
+      ActiveRecord::Base.connection.quote(value.to_s) + ' <> ' + field_string
 
-          break
+    elsif comparator == 'gt'
 
-        elsif c == '"'
+      ActiveRecord::Base.connection.quote(value.to_s) + ' < ' + field_string
 
-          i += 1
-          nextIndex = str.index('"', i)
+    elsif comparator == 'gte'
 
-          while str[nextIndex - 1] == '\\'
+      ActiveRecord::Base.connection.quote(value.to_s) + ' <= ' + field_string
 
-            j = 1
-            while str[nextIndex - j] == '\\'
-              j += 1
-            end
+    elsif comparator == 'lt'
 
-            if j & 1 == 1
-              break
-            end
+      ActiveRecord::Base.connection.quote(value.to_s) + ' > ' + field_string
 
-            nextIndex = str.index('"', nextIndex + 1)
+    elsif comparator == 'lte'
 
-          end
+      ActiveRecord::Base.connection.quote(value.to_s) + ' >= ' + field_string
 
-          values.push str[i...nextIndex]
+    elsif comparator == 'in' || comparator == 'not_in'
 
-          i = nextIndex + 1
+      unless value.is_a?(Array)
 
+        if value.is_a?(Range)
+          value = value.to_a
         else
-
-          if c == ','
-
-            values.push nil
-            i += 1
-            next
-
-          end
-
-          parensIndex = str.index('}', i)
-          nextIndex = str.index(',', i)
-
-          if nextIndex.nil? or nextIndex > parensIndex
-
-            values.push str[i...parensIndex]
-            break
-
-          end
-
-          values.push str[i...nextIndex]
-
-          i = nextIndex + 1
-
+          value = [value.to_s]
         end
-
       end
 
-      return values
-
-    end
-
-    def parse_many(str, fields = [], types = [])
-
-      unless str.is_a? String
-        return []
-      end
-
-      rows = []
-      cur_row = {}
-      entry_index = 0
-
-      i = 0
-      len = str.length
-
-      i = str.index('(')
-
-      if not i
-        return rows
-      end
-
-      i = i + 1
-
-      while i < len
-
-        c = str[i]
-
-        if c == ')'
-
-          rows << cur_row
-          cur_row = {}
-          entry_index = 0
-          i = i + 3
-
-        elsif c == '"'
-
-          i = i + 1
-          nextIndex = str.index('"', i)
-
-          while str[nextIndex - 1] == '\\'
-
-            j = 1
-            while str[nextIndex - j] == '\\'
-              j = j + 1
-            end
-
-            if j & 1 == 1
-              break
-            end
-
-            nextIndex = str.index('"', nextIndex + 1)
-
-          end
-
-          cur_row[fields[entry_index]] = api_convert_type(str[i...nextIndex], types[entry_index])
+      if is_array
 
-          entry_index = entry_index + 1
+        type_convert = {
+          boolean: '::boolean',
+          integer: '::integer',
+          float: '::float',
+          string: '::varchar'
+        }[type]
 
-          i = nextIndex + 1
-
-        elsif c == ','
-
-          i = i + 1
-          cur_row[fields[entry_index]] = nil
-          entry_index = entry_index + 1
+        type_convert = '::text' if type.nil?
 
+        if comparator == 'in'
+          'ARRAY[' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ']' + type_convert + '[] && ' + field
         else
+          'NOT ARRAY[' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ']' + type_convert + '[] && ' + field
+        end
+      else
 
-          parensIndex = str.index(')', i)
-          nextIndex = str.index(',', i)
+        if comparator == 'in'
+          field + ' IN(' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ')'
+        else
+          field + ' NOT IN(' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ')'
+        end
+      end
 
-          if nextIndex.nil? or nextIndex > parensIndex
-            nextIndex = parensIndex
-          end
+    elsif comparator == 'contains'
 
-          if i == nextIndex
-            cur_row[fields[entry_index]] = nil
-          else
-            cur_row[fields[entry_index]] = api_convert_type(str[i...nextIndex], types[entry_index])
-          end
+      field_string + ' LIKE \'%\' || ' + ActiveRecord::Base.connection.quote(value.to_s) + ' || \'%\''
 
-          entry_index = entry_index + 1
+    elsif comparator == 'icontains'
 
-          if nextIndex == parensIndex
-            rows << cur_row
-            cur_row = {}
-            entry_index = 0
-            i = nextIndex + 3
-          else
-            i = nextIndex + 1
-          end
+      field_string + ' ILIKE \'%\' || ' + ActiveRecord::Base.connection.quote(value.to_s) + ' || \'%\''
 
-        end
+    elsif comparator == 'is_null'
 
-      end
+      "#{field_string} IS NULL"
 
-      rows
+    elsif comparator == 'not_null'
 
+      "#{field_string} IS NOT NULL"
     end
+  end
 
+  def api_convert_type(val, type, is_array = false)
+    if val && is_array
+      Oj.load(val).map { |inner_value| api_convert_value(inner_value, type) }
+    else
+      api_convert_value(val, type)
+    end
+  end
 
-    def api_comparison(comparator, value, field, type, is_array)
-
-      unless is_array
-        field_string = field
+  def api_convert_value(val, type)
+    if val
+      case type
+      when :integer
+        val.to_i
+      when :float
+        val.to_f
+      when :boolean
+        { 't' => true, 'f' => false }[val]
       else
-        field_string = 'ANY(' + field + ')'
+        val
       end
+    end
+  end
 
-      if comparator == 'is'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' = ' + field_string
-
-      elsif comparator == 'not'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' <> ' + field_string
-
-      elsif comparator == 'gt'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' < ' + field_string
-
-      elsif comparator == 'gte'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' <= ' + field_string
-
-      elsif comparator == 'lt'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' > ' + field_string
-
-      elsif comparator == 'lte'
-
-        ActiveRecord::Base.connection.quote(value.to_s) + ' >= ' + field_string
-
-      elsif comparator == 'in' or comparator == 'not_in'
-
-        if not value.is_a? Array
-
-          if value.is_a? Range
-            value = value.to_a
-          else
-            value = [value.to_s]
-          end
-
-        end
-
-        if is_array
+  def parse_filters(filters, safe = false, model = nil)
 
-          type_convert = {
-            boolean: '::boolean',
-            integer: '::integer',
-            float: '::float'
-          }[type]
+    self_obj = model ? model : @model
+    self_string_table = model ? "__#{model.to_s.tableize}" : @model.to_s.tableize
 
-          type_convert = '::text' if type.nil?
+    filters = filters.clone.symbolize_keys
+    # if we're at the top level...
+    if model.nil?
 
-          if comparator == 'in'
-            'ARRAY[' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ']' + type_convert + '[] && ' + field
-          else
-            'NOT ARRAY[' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ']' + type_convert + '[] && ' + field
-          end
-
-        else
+      if safe
+        filters.each do |key, value|
+          found_index = key.to_s.rindex('__')
+          key_root = found_index ? key.to_s[0..found_index].to_sym : key
 
-          if comparator == 'in'
-            field + ' IN(' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ')'
-          else
-            field + ' NOT IN(' + (value.map { |val| ActiveRecord::Base.connection.quote(val.to_s) }).join(',') + ')'
+          if [:__order, :__offset, :__count].exclude?(key) && self_obj.fastapi_filters_whitelist.exclude?(key_root)
+            fail %(Filter "#{key}" not supported.)
           end
-
         end
-
-      elsif comparator == 'contains'
-
-        field_string + ' LIKE \'%\' || ' + ActiveRecord::Base.connection.quote(value.to_s) + ' || \'%\''
-
-      elsif comparator == 'icontains'
-
-        field_string + ' ILIKE \'%\' || ' + ActiveRecord::Base.connection.quote(value.to_s) + ' || \'%\''
-
-      elsif comparator == 'is_null'
-
-        'NULL = ' + field_string
-
-      elsif comparator == 'not_null'
-
-        'NOT NULL = ' + field_string
-
       end
 
+      filters = @model.fastapi_filters.clone.merge(filters)
     end
 
-    def api_convert_type(val, type, is_array = false)
+    params = filters.has_key?(:__params) ? [*filters.delete(:__params)] : []
+    filters[:__order] ||= [:created_at, :DESC]
 
-      return api_convert_value(val, type) unless is_array
+    filters.each do |key, value|
 
-      return parse_postgres_array(val).map { |inner_value| api_convert_value(inner_value, type) }
+      next if [:__order, :__offset, :__count, :__params].include?(key)
 
-    end
+      found_index = key.to_s.rindex('__')
+      key_root = found_index.nil? ? key : key.to_s[0...found_index].to_sym
 
-    def api_convert_value(val, type)
-
-      if not val.nil?
-        if type == :integer
-          val = val.to_i
-        elsif type == :float
-          val = val.to_f
-        elsif type == :boolean
-          val = {
-            't' => true,
-            'f' => false
-          }[val]
+      if !self_obj.column_names.include?(key_root.to_s)
+        if !model.nil? || !(@model.reflect_on_all_associations(:has_many).map(&:name).include?(key_root)   ||
+                            @model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key_root) ||
+                            @model.reflect_on_all_associations(:has_one).map(&:name).include?(key_root))
+          fail %(Filter "#{key}" not supported)
         end
       end
-
-      val
-
     end
 
-    def parse_filters(filters, safe = false, model = nil)
 
-      self_obj = model.nil? ? @model : model
-      self_string_table = model.nil? ? @model.to_s.tableize : '__' + model.to_s.tableize
+    filter_array = []
+    filter_has_many = {}
+    filter_belongs_to = {}
 
-      filters = filters.clone().symbolize_keys
-      # if we're at the top level...
-      if model.nil?
-
-        if safe
-          filters.each do |key, value|
-            found_index = key.to_s.rindex('__')
-            key_root = found_index.nil? ? key : key.to_s[0...found_index].to_sym
-            if not [:__order, :__offset, :__count].include? key and not self_obj.fastapi_filters_whitelist.include? key_root
-              raise 'Filter "' + key.to_s + '" not supported'
-            end
-          end
-        end
-
-        all_filters = @model.fastapi_filters.clone()
-
-        filters.each do |field, value|
-          all_filters[field.to_sym] = value
-        end
-
-        filters = all_filters
-
-      end
-
-      if not filters.has_key? :__order
-        filters[:__order] = [:created_at, :DESC]
-      end
+    order = nil
+    order_has_many = {}
+    order_belongs_to = {}
 
-      params = []
+    # get the order first
 
-      if filters.has_key? :__params
-        params = filters[:__params]
-        filters.delete :__params
-      end
+    if filters.has_key?(:__order)
 
-      if not params.is_a? Array and not params.is_a? Hash
-        params = [params]
-      end
+      value = filters.delete(:__order)
 
-      filters.each do |key, value|
+      order = value.clone()
 
-        if [:__order, :__offset, :__count, :__params].include? key
-          next
+      if order.is_a?(String)
+        order = order.split(',')
+        if order.size < 2
+          order << 'ASC'
         end
-
-        found_index = key.to_s.rindex('__')
-        key_root = found_index.nil? ? key : key.to_s[0...found_index].to_sym
-
-        if not self_obj.column_names.include? key_root.to_s
-          if not model.nil? or not (
-            @model.reflect_on_all_associations(:has_many).map(&:name).include? key_root or
-            @model.reflect_on_all_associations(:belongs_to).map(&:name).include? key_root or
-            @model.reflect_on_all_associations(:has_one).map(&:name).include? key_root
-          )
-            raise 'Filter "' + key.to_s + '" not supported'
-          end
+      elsif order.is_a?(Array)
+        order = order.map { |v| v.to_s }
+        while order.size < 2
+          order << ''
         end
-
+      else
+        order = ['', '']
       end
 
+      order[1] = 'ASC' if ['ASC', 'DESC'].exclude?(order[1])
 
-      filter_array = []
-      filter_has_many = {}
-      filter_belongs_to = {}
-
-      order = nil
-      order_has_many = {}
-      order_belongs_to = {}
-
-      # get the order first
+      if model.nil? && @model.fastapi_custom_order.has_key?(order[0].to_sym)
 
-      if filters.has_key? :__order
+        order[0] = @model.fastapi_custom_order[order[0].to_sym].gsub('self.', self_string_table + '.')
 
-        value = filters[:__order]
-
-        order = value.clone()
-
-        if order.is_a? String
-          order = order.split(',')
-          if order.size < 2
-            order << 'ASC'
-          end
-        elsif order.is_a? Array
-          order = order.map { |v| v.to_s }
-          while order.size < 2
-            order << ''
-          end
+        if params.is_a?(Array)
+          order[0].gsub!(/\$params\[([\w-]+)\]/) { ActiveRecord::Base.connection.quote(params[Regexp.last_match[1].to_i].to_s) }
         else
-          order = ['', '']
+          order[0].gsub!(/\$params\[([\w-]+)\]/) { ActiveRecord::Base.connection.quote(params[Regexp.last_match[1]].to_s) }
         end
 
-        if not ['ASC', 'DESC'].include? order[1]
-          order[1] = 'ASC'
-        end
-
-        if model.nil? and @model.fastapi_custom_order.has_key? order[0].to_sym
-
-          order[0] = @model.fastapi_custom_order[order[0].to_sym].gsub('self.', self_string_table + '.')
-
-          if params.is_a? Array
-
-            order[0] = order[0].gsub(/\$params\[([\w\d_-]+)\]/) { ActiveRecord::Base.connection.quote(params[Regexp.last_match[1].to_i].to_s) }
-
-          else
-
-            order[0] = order[0].gsub(/\$params\[([\w\d_-]+)\]/) { ActiveRecord::Base.connection.quote(params[Regexp.last_match[1]].to_s) }
-
-          end
-
-          order[0] = '(' + order[0] + ')'
-          order = order.join(' ')
+        order[0] = "(#{order[0]})"
+        order = order.join(' ')
+      else
 
+        if self_obj.column_names.exclude?(order[0])
+          order = nil
         else
-
-          if not self_obj.column_names.include? order[0]
-
-            order = nil
-
-          else
-
-            order[0] = self_string_table + '.' + order[0]
-            order = order.join(' ')
-
-          end
-
+          order[0] = "#{self_string_table}.#{order[0]}"
+          order = order.join(' ')
         end
-
-        filters.delete :__order
-
       end
+    end
 
-      if filters.size > 0
-
-        filters.each do |key, value|
-
-          field = key.to_s
-
-          if field.rindex('__').nil?
-
-            comparator = 'is'
+    if filters.size > 0
 
-          else
+      filters.each do |key, data|
+        field = key.to_s
 
-            comparator = field[(field.rindex('__') + 2)..-1]
-            field = field[0...field.rindex('__')]
+        if field.rindex('__').nil?
+          comparator = 'is'
+        else
 
-            if not @@api_comparator_list.include? comparator
-              next # skip dis bro
-            end
+          comparator = field[(field.rindex('__') + 2)..-1]
+          field = field[0...field.rindex('__')]
 
+          if @@api_comparator_list.exclude?(comparator)
+            next # skip dis bro
           end
+        end
 
-          if model.nil? and (self_obj.reflect_on_all_associations(:has_many).map(&:name).include? key)
+        if model.nil? && self_obj.reflect_on_all_associations(:has_many).map(&:name).include?(key)
 
-            filter_result = parse_filters(value, safe, field.singularize.classify.constantize)
-            # puts filter_result
-            filter_has_many[key] = filter_result[:main]
-            order_has_many[key] = filter_result[:main_order]
+          filter_result        = parse_filters(data, safe, field.singularize.classify.constantize)
+          filter_has_many[key] = filter_result[:main]
+          order_has_many[key]  = filter_result[:main_order]
 
-          elsif model.nil? and (self_obj.reflect_on_all_associations(:belongs_to).map(&:name).include? key or
-            self_obj.reflect_on_all_associations(:has_one).map(&:name).include? key)
+        elsif model.nil? && (self_obj.reflect_on_all_associations(:belongs_to).map(&:name).include?(key) ||
+          self_obj.reflect_on_all_associations(:has_one).map(&:name).include?(key))
 
-            filter_result = parse_filters(value, safe, field.singularize.classify.constantize)
-            # puts filter_result
-            filter_belongs_to[key] = filter_result[:main]
-            order_belongs_to[key] = filter_result[:main_order]
+          filter_result          = parse_filters(data, safe, field.singularize.classify.constantize)
+          filter_belongs_to[key] = filter_result[:main]
+          order_belongs_to[key]  = filter_result[:main_order]
 
-          elsif self_obj.column_names.include? field
+        elsif self_obj.column_names.include?(field)
 
-            base_field = self_string_table + '.' + field
-            field_string = base_field
-            is_array = false
+          base_field   = "#{self_string_table}.#{field}"
+          field_string = base_field
+          is_array     = false
 
-            if self_obj.columns_hash[field].respond_to?('array') and self_obj.columns_hash[field].array == true
+          if self_obj.columns_hash[field].respond_to?('array') && self_obj.columns_hash[field].array == true
+            field_string = "ANY(#{field_string})"
+            is_array = true
+          end
 
-              field_string = 'ANY(' + field_string + ')'
-              is_array = true
+          if self_obj.columns_hash[field].type == :boolean
 
+            # if data is not a boolean
+            if !!data != data
+              data = ['f', 'false'].include?(data) ? false : true
             end
 
-            if self_obj.columns_hash[field].type == :boolean
-
-              if !!value != value
-
-                bool_lookup = {
-                  't' => true,
-                  'f' => false,
-                  'true' => true,
-                  'false' => false
-                }
-
-                value = value.to_s.downcase
-
-                if bool_lookup.has_key? value
-                  value = bool_lookup[value]
-                else
-                  value = true
-                end
-
-              end
-
-              if !!value == value
-
-                if comparator == 'is'
-                  filter_array << value.to_s.upcase + ' = ' + field_string
-                elsif comparator == 'not'
-                  filter_array << 'NOT ' + value.to_s.upcase + ' = ' + field_string
-                end
-
-              end
-
-            elsif value == nil and comparator != 'is_null' and comparator != 'not_null'
-
-              if comparator == 'is'
-                filter_array << 'NULL = ' + field_string
-              elsif comparator == 'not'
-                filter_array << 'NOT NULL = ' + field_string
-              end
-
-            elsif value.is_a? Range and comparator == 'is'
-
-              filter_array << ActiveRecord::Base.connection.quote(value.first.to_s) + ' <= ' + field_string
-              filter_array << ActiveRecord::Base.connection.quote(value.last.to_s) + ' >= ' + field_string
-
-            else
-
-              filter_array << api_comparison(comparator, value, base_field, self_obj.columns_hash[field].type, is_array)
+            if comparator == 'is'
+              filter_array << "#{data.to_s.upcase} = #{field_string}"
+            elsif comparator == 'not'
+              filter_array << "NOT #{data.to_s.upcase} = #{field_string}"
+            end
 
+          elsif data == nil && comparator != 'is_null' && comparator != 'not_null'
+            if comparator == 'is'
+              filter_array << "#{field_string} IS NULL"
+            elsif comparator == 'not'
+              filter_array << "#{field_string} IS NOT NULL"
             end
 
+          elsif data.is_a?(Range) && comparator == 'is'
+            filter_array << "#{ActiveRecord::Base.connection.quote(data.first.to_s)} <= #{field_string}"
+            filter_array << "#{ActiveRecord::Base.connection.quote(data.last.to_s)} >= #{field_string}"
+          else
+            filter_array << api_comparison(comparator, data, base_field, self_obj.columns_hash[field].type, is_array)
           end
-
         end
-
       end
+    end
 
-      {
-        main: filter_array,
-        main_order: order,
-        has_many: filter_has_many,
-        has_many_order: order_has_many,
-        belongs_to: filter_belongs_to,
-        belongs_to_order: order_belongs_to
-      }
+    {
+      main: filter_array,
+      main_order: order,
+      has_many: filter_has_many,
+      has_many_order: order_has_many,
+      belongs_to: filter_belongs_to,
+      belongs_to_order: order_belongs_to
+    }
+  end
 
-    end
+  def api_generate_sql(filters, offset, count, safe = false)
 
-    def api_generate_sql(filters, offset, count, safe = false)
+    filters = parse_filters(filters, safe)
 
-      filters = parse_filters(filters, safe)
+    belongs  = []
+    has_many = []
 
-      fields = []
-      belongs = []
-      has_many = []
+    model_lookup = {}
 
-      model_lookup = {}
+    filter_fields = []
+    filter_fields.concat(@model.fastapi_fields)
+    filter_fields.concat(@whitelist_fields)
 
-      filter_fields = []
-      filter_fields.concat @model.fastapi_fields
-      filter_fields.concat @whitelist_fields
+    fields = filter_fields.each_with_object([]) do |field, field_list|
+      if @model.reflect_on_all_associations(:belongs_to).map(&:name).include?(field)
+        class_name = @model.reflect_on_association(field).options[:class_name]
 
-      filter_fields.each do |field|
+        if class_name
+          model = class_name.constantize
+        else
+          model = field.to_s.classify.constantize
+        end
 
-        if (@model.reflect_on_all_associations(:belongs_to).map(&:name).include? field or
-          @model.reflect_on_all_associations(:has_one).map(&:name).include? field)
+        model_lookup[field] = model
+        belongs << { model: model, alias: field, type: :belongs_to }
 
-          class_name = @model.reflect_on_association(field).options[:class_name]
+      elsif @model.reflect_on_all_associations(:has_one).map(&:name).include?(field)
 
-          if class_name.nil?
-            model = field.to_s.classify.constantize
-          else
-            model = class_name.constantize
-          end
+        class_name = @model.reflect_on_association(field).options[:class_name]
 
-          model_lookup[field] = model
-          belongs << {model: model, alias: field}
+        if class_name
+          model = class_name.constantize
+        else
+          model = field.to_s.classify.constantize
+        end
 
-        elsif @model.reflect_on_all_associations(:has_many).map(&:name).include? field
+        model_lookup[field] = model
 
-          model = field.to_s.singularize.classify.constantize
-          model_lookup[field] = model
-          has_many << model
+        belongs << { model: model, alias: field, type: :has_one }
 
-        elsif @model.column_names.include? field.to_s
+      elsif @model.reflect_on_all_associations(:has_many).map(&:name).include?(field)
 
-          fields << field
+        model = field.to_s.singularize.classify.constantize
+        model_lookup[field] = model
+        has_many << model
 
-        end
+      elsif @model.column_names.include?(field.to_s)
 
+        field_list << field
       end
+    end
 
-      self_string = @model.to_s.tableize.singularize
-      self_string_table = @model.to_s.tableize
+    self_string = @model.to_s.tableize.singularize
+    self_string_table = @model.to_s.tableize
 
-      field_list = []
-      joins = []
+    # Base fields
+    field_list = fields.each_with_object([]) do |field, list|
+      if @model.columns_hash[field.to_s].array
+        list << "ARRAY_TO_JSON(#{self_string_table}.#{field}) AS #{field}"
+      else
+        list << "#{self_string_table}.#{field} AS #{field}"
+      end
+    end
 
-      # array_to_string: (ActiveRecord::Base.connection.instance_of? ActiveRecord::ConnectionAdapters::SQLite3Adapter) ? 'GROUP_CONCAT' : 'ARRAY_TO_STRING',
+    # Belongs fields (1 to 1)
+    joins = belongs.each_with_object([]) do |model_data, join_list|
 
-      # Base fields
-      fields.each do |field|
+      model_string_table       = model_data[:model].to_s.tableize
+      model_string_table_alias = model_data[:alias].to_s.pluralize
 
-        field_string = field.to_s
-        field_list << [
-          self_string_table,
-          '.',
-          field_string,
-          ' as ',
-          field_string
-        ].join('')
+      model_string_field  = model_data[:alias].to_s
+      singular_self_table = self_string_table.singularize
 
-      end
-
-      # Belongs fields (1 to 1)
-      belongs.each do |model_data|
-
-        model_string_table = model_data[:model].to_s.tableize
-        model_string_table_alias = model_data[:alias].to_s.pluralize
-
-        model_string_field = model_data[:alias].to_s
-
-        # fields
-        model_data[:model].fastapi_fields_sub.each do |field|
-          field_string = field.to_s
-          field_list << [
-            model_string_table_alias,
-            '.',
-            field_string,
-            ' as ',
-            model_string_field,
-            '__',
-            field_string
-          ].join('')
+      model_data[:model].fastapi_fields_sub.each do |field|
+        if model_data[:model].columns_hash[field.to_s].array
+          field_list << "ARRAY_TO_JSON(#{model_string_table_alias}.#{field}) AS #{model_string_field}__#{field}"
+        else
+          field_list << "#{model_string_table_alias}.#{field} AS #{model_string_field}__#{field}"
         end
+      end
 
+      # fields
+      if model_data[:type] == :belongs_to
         # joins
-        joins << [
-          'LEFT JOIN',
-            model_string_table,
-          'AS',
-            model_string_table_alias,
-          'ON',
-            model_string_table_alias + '.id',
-            '=',
-            self_string_table + '.' + model_string_field + '_id'
-        ].join(' ')
-
+        join_list << "LEFT JOIN #{model_string_table} AS #{model_string_table_alias} " \
+                       "ON #{model_string_table_alias}.id = #{self_string_table}.#{model_string_field}_id"
+      elsif model_data[:type] == :has_one
+        join_list << "LEFT JOIN #{model_string_table} AS #{model_string_table_alias} " \
+                       "ON #{model_string_table_alias}.#{singular_self_table}_id = #{self_string_table}.id"
       end
+    end
 
-      # Many fields (Many to 1)
-      has_many.each do |model|
+    # Many fields (1 to many)
+    has_many.each do |model|
 
-        model_string = model.to_s.tableize.singularize
-        model_string_table = model.to_s.tableize
-        model_symbol = model_string_table.to_sym
+      model_string_table = model.to_s.tableize
+      model_symbol = model_string_table.to_sym
 
-        model_fields = []
+      model_fields = model.fastapi_fields_sub.each_with_object([]) do |field, m_fields|
+        m_fields << "__#{model_string_table}.#{field}"
+      end
 
-        model.fastapi_fields_sub.each do |field|
-          field_string = field.to_s
-          model_fields << [
-            '__' + model_string_table + '.' + field_string,
-            # 'as',
-            # field_string
-          ].join(' ')
+      if filters[:has_many].has_key?(model_symbol)
+        if filters[:has_many][model_symbol].count > 0
+          has_many_filters = "AND #{filters[:has_many][model_symbol].join(' AND ')}"
+        else
+          has_many_filters = nil
         end
 
-        has_many_filters = ''
-        has_many_order = ''
-        if filters[:has_many].has_key? model_symbol
-
-          if filters[:has_many][model_symbol].count > 0
-            has_many_filters = 'AND ' + filters[:has_many][model_symbol].join(' AND ')
-          end
-
-          if not filters[:has_many_order][model_symbol].nil?
-            has_many_order = 'ORDER BY ' + filters[:has_many_order][model_symbol]
-          end
-
+        if filters[:has_many_order][model_symbol]
+          has_many_order = "ORDER BY #{filters[:has_many_order][model_symbol]}"
+        else
+          has_many_filters = nil
         end
-
-        field_list << [
-          'ARRAY_TO_STRING(ARRAY(',
-            'SELECT',
-              'ROW(',
-              model_fields.join(', '),
-              ')',
-            'FROM',
-              model_string_table,
-              'as',
-              '__' + model_string_table,
-            'WHERE',
-              '__' + model_string_table + '.' + self_string + '_id IS NOT NULL',
-              'AND __' + model_string_table + '.' + self_string + '_id',
-              '=',
-              self_string_table + '.id',
-              has_many_filters,
-              has_many_order,
-          '), \',\')',
-          'as',
-          '__many__' + model_string_table
-        ].join(' ')
-
       end
 
-      filter_string = (filters[:main].size > 0 ? ('WHERE ' + filters[:main].join(' AND ')) : '')
-      order_string = (filters[:main_order].nil? ? '' : 'ORDER BY ' + filters[:main_order])
-
-      {
-        query: [
-          'SELECT',
-            field_list.join(', '),
-          'FROM',
-            self_string_table,
-          joins.join(' '),
-          filter_string,
-          order_string,
-          'LIMIT',
-            count.to_s,
-          'OFFSET',
-            offset.to_s,
-        ].join(' '),
-        count_query: [
-          'SELECT COUNT(id) FROM',
-            self_string_table,
-          filter_string
-        ].join(' '),
-        models: model_lookup
-      }
-
+      field_list << [
+        "ARRAY_TO_JSON(ARRAY(SELECT ROW(#{model_fields.join(', ')})",
+        "FROM #{model_string_table}",
+        "AS __#{model_string_table}",
+        "WHERE __#{model_string_table}.#{self_string}_id IS NOT NULL",
+        "AND __#{model_string_table}.#{self_string}_id",
+        "= #{self_string_table}.id",
+        has_many_filters,
+        has_many_order,
+        ")) AS __many__#{model_string_table}"
+      ].compact.join(' ')
     end
 
+    filter_string = filters[:main].size > 0 ? "WHERE #{filters[:main].join(' AND ')}" : nil
+    order_string  = filters[:main_order] ? "ORDER BY #{filters[:main_order]}" : nil
+
+    {
+      query: [
+        "SELECT #{field_list.join(', ')}",
+        "FROM #{self_string_table}",
+        joins.join(' '),
+        filter_string,
+        order_string,
+        "LIMIT #{count}",
+        "OFFSET #{offset}"
+      ].compact.join(' '),
+      count_query: [
+        "SELECT COUNT(id) FROM #{self_string_table}",
+        filter_string
+      ].compact.join(' '),
+      models: model_lookup
+    }
+  end
 end