graphql-rails-api 0.9.1 → 0.9.3.pre.fix

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1751d6f6ae5edf98341bdf30a149cd8aa9ab4dbcb0a627cb25c380cfe15c676
-  data.tar.gz: 90c9dc17368d908efb70a8ee55837c3d6b117709762c006eaee18ddcd3a820ff
+  metadata.gz: 28fb07b00c4ddc6fab6260937a8ab6b5edd025ae6703ab2334a3fba30e56619c
+  data.tar.gz: 5991b8d3475a620d0c4a0a6106795b8559123cfc65faf6f9cb3a5f44292778ec
 SHA512:
-  metadata.gz: 98cd97012f608dea85e6a5417a4d1ab83ddf3cdae9a51473a014a3c4d45769ce928301a9e57ab32a9c65a76df5e3687cead2046e57a829da18a1309ecfc7ff06
-  data.tar.gz: d297e02228b4a00c81a9f29eef88c92da12a23698e9e2dc3aa9eab52c3ccf97a471c04aa134d9cb11bb516bc1d2446464ba9b69b8cc0be8d1f84d465deaa2a91
+  metadata.gz: 95f60329781d38bf3275a24617868a2baa0fa82812fb4ecd5b79c36f45bbc9ad69a8f98270c797d76df384719417a60fb27a6cd31350c5fb1baa1ceecaae9ceb
+  data.tar.gz: 9c76d727e713a14110ea7e77314f446d5c996719abacd228f05202c8c1b7f379e9c1bdb2e67bdc6173bcfc2a6a84a704de6e32d60dd4155f68f769619aaeb822

data/README.md

@@ -1,46 +1,87 @@
-# GraphqlRailsApi
+# Graphql Rails Api
+`graphql-rails-api` is a wrapper around [graphql-ruby](https://graphql-ruby.org/) for rails application. It describes easily your graphql API in a domain driven design way.
 
-`graphql-rails-api` is a gem that provides generators to describe easily your graphql API in a domain driven design way.
+The main purpose of this gem is to earn time providing:
+- A normalized code architecture by mapping graphql resources to the active record models
+- A global graphql service to directly perform crud mutations
+- A set of generators to create or modify graphql resource and active record model at the same time
 
-Need any help or wanna talk with me about it on discord : Poilon#5412
+### Notes
+Only postgresql adapter is maintained.
+Only model using uuid as identifier are compatible with generated migrations right now.
+A model User will be created during installation.
 
 ## Installation
 
-Create a rails app via
-```
-rails new project-name --api --database=postgresql
-cd project-name
-bundle
-rails db:create
-```
-
-Add these lines to your application's Gemfile:
+Add the gem to your application's Gemfile:
 ```ruby
 gem 'graphql-rails-api'
 ```
 
-And then execute:
+Download and install the gem:
 ```bash
 $ bundle
 $ rails generate graphql_rails_api:install
 ```
 
+### Options
+The following options to the `graphql_rails_api:install` command are available:
+
+
 To disable PostgreSQL uuid extension, add the option `--no-pg-uuid`
 
 To disable ActionCable websocket subscriptions, add the option `--no-action-cable-subs`
 
 To disable Apollo compatibility, add the option `--no-apollo-compatibility`
 
-Automatically, `post '/graphql', to: 'graphql#execute'` will be added to your `config/route.rb`
-To avoid this, you can just add the option `--no-generate-graphql-route`
+To avoid the addition of a new post '/graphql' route , add the option `--no-generate-graphql-route`
 
-# Usage
+## Get Started
 
-## Resources generation
+Generate a new active record model with its graphql type and input type.
+```bash
+$ rails generate graphql_resource city name:string
+```
+Reboot the rails server, and you're good to go!
 
+Now You can perform crud mutation on resources:
 ```bash
-$ rails generate graphql_resource resource_name field1:string field2:float belongs_to:other_resource_name has_many:other_resources_name many_to_many:other_resources_name
+curl -X POST http://localhost:3000/graphql \
+  -H "content-type: application/json"      \
+  -d '{ "query":"mutation($name: String) { create_city(city: { name: $name }) { name } }", "variables": {"name":"Paris"} }'
+
+=> {"data":{"create_city":{"name":"Paris"}}}
 ```
+You can perform queries as well:
+```bash
+curl -X POST http://localhost:3000/graphql \
+  -H "content-type: application/json"       \
+  -d '{ "query": "{ cities { name } }" }'
+
+=> {"data":{"cities":[ {"name":"Paris"} ] } }
+```
+
+## Generators
+
+```bash
+$ rails generate graphql_resource computer code:string price:integer power_bench:float belongs_to:user has_many:hard_drives many_to_many:tags
+```
+
+
+This line will create the data migration, the model and the graphql type of the Computer resource.
+
+It will automatically add `has_many :computers` to the User model
+
+It will add a `computer_id` to the `HardDrive` model, and
+
+respectively the `has_many :hard_drives` and `belongs_to :computer` to the `Computer` and `HardDrive` models.
+
+The `many_to_many` option will make the `has_many through` association and create the join table between tag and computer.
+
+All of these relations will be propagated to the graphql types.
+
+### Options
+
 
 To disable migration generation, add the option `--no-migration`
 
@@ -54,40 +95,236 @@ To disable graphql-type generation, add the option `--no-graphql-type`
 
 To disable graphql-input-type generation, add the option `--no-graphql-input-type`
 
-To disable propagation (has_many creating the id in the other table, many to many creating the join table, and apply to the graphql types), add the option `--no-propagation`
-
-I made the choice of migrate automatically after generating a resource, to avoid doing it each time.
-You can of course disable the automatic migrate by adding the option `--no-migrate`
+To disable propagation (has_many creating the id in the other table, many to many creating the join table and apply to the graphql types), add the option `--no-propagation`
+To avoid running migrations after a resource generation, add the option `--no-migrate`
 
-## On generating resources
 
+### Note on enum
+The library handle enum with an integer column in the model table. Enum is defined into the active record model.
+Example:
 ```bash
-$ rails generate graphql_resource computer code:string price:integer power_bench:float belongs_to:user has_many:hard_drives many_to_many:tags
+$ rails generate graphql_resource house energy_grade:integer belongs_to:user belongs_to:city
+```
+house.rb
+```ruby
+class House < ApplicationRecord
+  belongs_to :city
+  belongs_to :user
+  enum energy_grade: {
+    good: 0,
+    average: 1,
+    bad: 2,
+  }
+end
 ```
 
-This line will create the data migration, the model and the graphql type of the Computer resource.
+## About queries
+3 types of queries are available.
 
-It will automatically add `has_many :computers` to the User model
+show query:
+```gql
+query($id: String!) {
+  city(id: $id) {
+    id
+  }
+}
+```
+index query:
+A max number of 1000 results are return.
+```gql
+query($page: String, per_page: String, $filter: String, $order_by: String) {
+  cities {
+    id
+  }
+}
+```
+index query with pagination: Add the suffix `paginated_` to any index query to use pagination
+```gql
+query($page: String, per_page: String, $filter: String, $order_by: String) {
+  paginated_cities {
+    id
+  }
+}
+```
 
-It will add a `computer_id` to the `HardDrive` model, and
-respectively the `has_many :hard_drives` and `belongs_to :computer` to the `Computer` and `HardDrive` models.
+### Filter query results
+`filter` is a not required string argument used to filter data based on conditions made on active record model fields.
+You can use :
+- parenthesis : `()`
+- Logical operators : `&&` , `||`
+- Comparaisons operators : `==`, `!=`, `===`, `!==`, `>`, `<`, `>=`, `<=`
 
-The `many_to_many` option will make the `has_many through` association and create the join table between tag and computer.
+The operators `===` and `!==` are used to perform case sensitive comparaisons on string fields
+Example:
+The following model is generated
+```
+rails generate graphql_resource house \
+  street:string        \
+  number:integer       \
+  price:float          \
+  energy_grade:integer \
+  principal:boolean    \
+  belongs_to:user      \
+  belongs_to:city
+```
+The following filter values can be used:
+```ruby
+"street != 'candlewood lane'"
+"street !== 'Candlewood Lane'"
+"number <= 50"
+"price != 50000"
+"build_at <= '#{DateTime.now - 2.years}'"
+"user.email == 'jason@gmail.com'"
+"city.name != 'Berlin'"
+"street != 'candlewood lane' && (city.name != 'Berlin' || user.email == 'jason@gmail.com')"
+```
 
-All of these relations will be propagated to the graphql types.
+### Order query result argument
+`order_by` is a non mandatory string argument used to order the returned data.
+With the model above the following order_by values can be used:
+```ruby
+"street DESC"
+"number ASC"
+"user.email ASC"
+```
+## About mutations
+The graphql-rails-api application service can handle 5 types of mutation on generated models.
+
+create mutation:
+```gql
+mutation($name: String!) {
+  create_city(
+    city: {
+      name: $name
+    }
+  ) {
+    id
+  }
+}
+```
 
+update mutation:
+```gql
+mutation($id: String!, $name: String) {
+  update_city(
+    id: $id
+    city: {
+      name: $name
+    }
+  ) {
+    id
+    name
+  }
+}
+```
 
+destroy mutation:
+```gql
+mutation($id: String!) {
+  destroy_city(id: $id) {
+    id
+  }
+}
+```
 
-## Graphql API example
+bulk_create mutation:
+```gql
+mutation($cities: [CityInputType]!) {
+  bulk_create_city(cities: $cities) {
+    id
+  }
+}
+```
 
-Example of a backend API: https://github.com/Poilon/graphql-rails-api-example
+bulk_update:
+```gql
+mutation($cities: [CityInputType]!) {
+  bulk_update_city(cities: $cities) {
+    id
+  }
+}
+```
 
+You can override the default application service for all mutation by defining your own method into the corresponding graphql service:
 
+Example:
+
+app/graphql/cities/service.rb
+```ruby
+module Cities
+  class Service < ApplicationService
+    def create
+      return graphql_error('Forbidden') if params[:name] == 'Forbidden city'
+
+      super
+    end
+  end
+end
+```
+## Custom mutation resource services
+
+To defined your own custom mutation create a file to defined the mutation type and define the correponding methods.
+
+Example:
+
+app/graphql/cities/mutations/custom.rb
+```ruby
+Cities::Mutations::Custom = GraphQL::Field.define do
+  description 'Im a custom mutation'
+  type Cities::Type
+
+  argument :id, !types.String
+  argument :name, !types.String
+
+  resolve ApplicationService.call(:city, :custom)
+end
+```
+
+app/graphql/cities/service.rb
+```ruby
+module Cities
+  class Service < ApplicationService
+    def custom
+      ...
+    end
+  end
+end
+```
+
+## TODO
+
+- Clean error management : catching on raise ... no unexpected json blabla
+- Query type
+	- remove me type
+	- add paginated_resource types
+- Logging on generators actions
+- Don't create model user if it exists
+- Config variable for max number of result (Per page on query)
+- Handle id type != uuid (generated migration)
+- Filter:
+	- handle association multiple level
+- Order
+	- handle order on multiple field
+	- handle order on association multiple level
+	- case sensitivity on order by string / text
+- Write Spec to test visible_for
+- Write Spec to test filter order and visible for together
+- Write spec to test installation and generators
+- Documentation about user authentication and scope
+  - describe authenticated_user
+  - describe visible_for
+  - describe writable_by
+
+## Graphql API example
+
+Example of a backend API: https://github.com/Poilon/graphql-rails-api-example
 
 ## Contributing
 
 You can post any issue, and contribute by making pull requests.
 Don't hesitate, even the shortest pull request is great help. <3
 
+Need any help or wanna talk with me on discord : Poilon#5412
+
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -8,10 +8,10 @@ module GraphqlRailsApi
 
     def generate_files
       @app_name = File.basename(Rails.root.to_s).underscore
-      
+
       folder = 'app/graphql/'
       FileUtils.mkdir_p(folder) unless File.directory?(folder)
-       
+
       write_uuid_extensions_migration
 
       write_service
@@ -22,9 +22,7 @@ module GraphqlRailsApi
 
       write_controller
 
-      write_websocket_models
-      write_websocket_connection
-      write_subscriptions_channel
+      system 'rails g graphql_resource user first_name:string last_name:string email:string'
 
       write_application_record_methods
       write_initializer
@@ -34,12 +32,6 @@ module GraphqlRailsApi
 
     private
 
-    def write_websocket_models
-      system 'rails g graphql_resource user first_name:string last_name:string email:string'
-      system 'rails g graphql_resource websocket_connection belongs_to:user connection_identifier:string'
-      system 'rails g graphql_resource subscribed_query belongs_to:websocket_connection result_hash:string query:string'
-    end
-
     def write_route
       route_file = File.read('config/routes.rb')
       return if route_file.include?('graphql')
@@ -49,8 +41,7 @@ module GraphqlRailsApi
         route_file.gsub(
           "Rails.application.routes.draw do\n",
           "Rails.application.routes.draw do\n" \
-          "  post '/graphql', to: 'graphql#execute'\n" \
-          "  mount ActionCable.server => '/cable'\n"
+          "  post '/graphql', to: 'graphql#execute'\n"
         )
       )
     end
@@ -91,25 +82,13 @@ module GraphqlRailsApi
     all
   end
 
-  def self.broadcast_queries
-    WebsocketConnection.all.each do |wsc|
-      wsc.subscribed_queries.each do |sq|
-        result = #{@app_name.camelize}Schema.execute(sq.query, context: { current_user: wsc.user })
-        hex = Digest::SHA1.hexdigest(result.to_s)
-        next if sq.result_hash == hex
 
-        sq.update_attributes(result_hash: hex)
-        SubscriptionsChannel.broadcast_to(wsc, query: sq.query, result: result.to_s)
-      end
-    end
-  end
-
-        STRING
-      )
-    end
+  STRING
+  )
+end
 
     def write_require_application_rb
-      write_at('config/application.rb', 5, "require 'graphql/hydrate_query'\nrequire 'rkelly'\n")
+      write_at('config/application.rb', 5, "require 'graphql/hydrate_query'\nrequire 'rkelly'\nrequire 'graphql'\n")
     end
 
     def write_uuid_extensions_migration
@@ -121,8 +100,7 @@ module GraphqlRailsApi
           class UuidPgExtensions < ActiveRecord::Migration[5.2]
 
             def change
-              execute 'CREATE EXTENSION "pgcrypto" SCHEMA pg_catalog;'
-              execute 'CREATE EXTENSION "uuid-ossp" SCHEMA pg_catalog;'
+              enable_extension 'pgcrypto'
             end
 
           end
@@ -141,70 +119,6 @@ module GraphqlRailsApi
       )
     end
 
-    def write_websocket_connection
-      File.write(
-        'app/channels/application_cable/connection.rb',
-        <<~'STRING'
-          module ApplicationCable
-            class Connection < ActionCable::Connection::Base
-
-              identified_by :websocket_connection
-
-              def connect
-                # Check authentication, and define current user
-                self.websocket_connection = WebsocketConnection.create(
-                  # user_id: current_user.id
-                )
-              end
-
-            end
-          end
-        STRING
-      )
-    end
-
-    def write_subscriptions_channel
-      File.write(
-        'app/channels/subscriptions_channel.rb',
-        <<~STRING
-          class SubscriptionsChannel < ApplicationCable::Channel
-
-            def subscribed
-              stream_for(websocket_connection)
-              websocket_connection.update_attributes(connection_identifier: connection.connection_identifier)
-              ci = ActionCable.server.connections.map(&:connection_identifier)
-              WebsocketConnection.all.each do |wsc|
-                wsc.destroy unless ci.include?(wsc.connection_identifier)
-              end
-            end
-
-            def subscribe_to_query(data)
-              websocket_connection.subscribed_queries.find_or_create_by(query: data['query'])
-              SubscriptionsChannel.broadcast_to(
-                websocket_connection,
-                query: data['query'],
-                result: #{@app_name.camelize}Schema.execute(data['query'], context: { current_user: websocket_connection.user })
-              )
-            end
-
-            def unsubscribe_to_query(data)
-              websocket_connection.subscribed_queries.find_by(query: data['query'])&.destroy
-            end
-
-            def unsubscribed
-              websocket_connection.destroy
-              ci = ActionCable.server.connections.map(&:connection_identifier)
-              WebsocketConnection.all.each do |wsc|
-                wsc.destroy unless ci.include?(wsc.connection_identifier)
-              end
-            end
-
-          end
-
-        STRING
-      )
-    end
-
     def write_controller
       File.write(
         'app/controllers/graphql_controller.rb',
@@ -219,7 +133,6 @@ module GraphqlRailsApi
                 context: { current_user: authenticated_user },
                 operation_name: params[:operationName]
               )
-              ApplicationRecord.broadcast_queries
               render json: result
             end
 

data/lib/graphql/hydrate_query.rb

@@ -1,20 +1,24 @@
-require 'deep_pluck'
-require 'rkelly'
+require "deep_pluck"
+require "rkelly"
 
 module Graphql
   class HydrateQuery
-
     def initialize(model, context, order_by: nil, filter: nil, check_visibility: true, id: nil, user: nil, page: nil, per_page: nil)
       @context = context
       @filter = filter
       @order_by = order_by
       @model = model
-      @models = [model_name.singularize.camelize]
       @check_visibility = check_visibility
+
+      if id.present? && !valid_id?(id)
+        raise GraphQL::ExecutionError, "Invalid id: #{id}"
+      end
+
       @id = id
       @user = user
-      @page = page || 1
-      @per_page = per_page || 1000
+      @page = page&.to_i || 1
+      @per_page = per_page&.to_i || 1000
+      @per_page = 1000 if @per_page > 1000
     end
 
     def run
@@ -24,21 +28,24 @@ module Graphql
       else
         @model = @model.limit(@per_page)
         @model = @model.offset(@per_page * (@page - 1))
-        filter_and_order
+
+        transform_filter if @filter.present?
+        transform_order if @order_by.present?
+
         deep_pluck_to_structs(@context&.irep_node)
       end
     end
 
     def paginated_run
-      filter_and_order
+      transform_filter if @filter.present?
+      transform_order if @order_by.present?
 
-      @total = @model.length
+      @total = @model.count
       @model = @model.limit(@per_page)
       @model = @model.offset(@per_page * (@page - 1))
 
-      ::Rails.logger.info(@model.to_sql)
       OpenStruct.new(
-        data: deep_pluck_to_structs(@context&.irep_node&.typed_children&.values&.first.try(:[], 'data')),
+        data: deep_pluck_to_structs(@context&.irep_node&.typed_children&.values&.first.try(:[], "data")),
         total_count: @total,
         per_page: @per_page,
         page: @page
@@ -47,58 +54,251 @@ module Graphql
 
     private
 
-    def filter_and_order
-      if @filter
-        transformed_filter = transform_filter(@filter)
-        to_join = transformed_filter.split(/AND|OR|like|ilike/).map do |expression|
-          expression.strip.split(/!=|=|IS/).first.strip
-        end.select { |e| e.include?('.') }.map { |e| e.split('.').first }.map(&:to_sym)
-        to_join.reject { |j| j.to_s.pluralize.to_sym == @model.klass.to_s.pluralize.underscore.to_sym }.each do |j|
-          @model = @model.left_joins(j).distinct
+    def transform_order
+      return if @order_by.blank?
+
+      @order_by.split(",").each do |order|
+
+        sign = order.split(" ").last.downcase == "desc" ? "desc" : "asc"
+        column = order.split(" ").first.strip
+
+        if column.include?(".")
+          associated_model = column.split(".").first
+          accessor = column.split(".").last
+          assoc = get_assoc!(@model, associated_model)
+          field_type = get_field_type!(assoc.klass, accessor)
+          @model = @model.left_joins(associated_model.to_sym)
+          ordered_field = "#{associated_model.pluralize}.#{accessor}"
+        else
+          field_type = get_field_type!(@model, column)
+          ordered_field = "#{model_name.pluralize}.#{column}"
         end
-        transformed_filter = transformed_filter.split(/(AND|OR|like|ilike)/).map do |e|
-          arr = e.split(/(!=|=|IS)/)
-          if arr.first.include?('.')
-            arr.first.split('.').first.pluralize + '.' + arr.first.split('.').last + arr[1].to_s + arr[2].to_s
+
+        @model = if %i[string text].include?(field_type)
+          @model.order(Arel.sql("upper(#{ordered_field}) #{sign}"))
+        else
+          @model.order(Arel.sql("#{ordered_field} #{sign}"))
+        end
+      end
+    end
+
+    def transform_filter
+      return if @filter.blank?
+
+      ast = RKelly::Parser.new.parse(@filter)
+      exprs = ast.value
+      if exprs.count != 1
+        raise GraphQL::ExecutionError, "Invalid filter: #{@filter}, only one expression allowed"
+      end
+
+      @model = handle_node(exprs.first.value, @model)
+
+      if @need_distinct_results
+        @model = @model.distinct
+      end
+    rescue RKelly::SyntaxError => e
+      raise GraphQL::ExecutionError, "Invalid filter: #{e.message}"
+    end
+
+    def handle_node(node, model)
+      if node.instance_of?(RKelly::Nodes::ParentheticalNode)
+        handle_ParentheticalNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::LogicalAndNode)
+        handle_LogicalAndNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::LogicalOrNode)
+        handle_LogicalOrNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::NotEqualNode)
+        handle_NotEqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::EqualNode)
+        handle_EqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::StrictEqualNode)
+        handle_StrictEqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::NotStrictEqualNode)
+        handle_NotStrictEqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::GreaterOrEqualNode)
+        handle_GreaterOrEqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::LessOrEqualNode)
+        handle_LessOrEqualNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::LessNode)
+        handle_LessNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::GreaterNode)
+        handle_GreaterNode(node, model)
+      else
+        raise GraphQL::ExecutionError, "Invalid filter: #{node.class} unknown operator"
+      end
+    end
+
+    def handle_ParentheticalNode(node, model)
+      handle_node(node.value, model)
+    end
+
+    def handle_LogicalAndNode(node, model)
+      handle_node(node.left, model).and(handle_node(node.value, model))
+    end
+
+    def handle_LogicalOrNode(node, model)
+      handle_node(node.left, model).or(handle_node(node.value, model))
+    end
+
+    def handle_dot_accessor_node(node, model)
+      associated_model = node.left.value.value
+      accessor = node.left.accessor
+      assoc = get_assoc!(model, associated_model)
+      field_type = get_field_type!(assoc.klass, accessor)
+
+      if assoc.association_class == ActiveRecord::Associations::HasManyAssociation
+        @need_distinct_results = true
+      end
+
+      model = model.left_joins(associated_model.to_sym)
+      # field = "#{associated_model.pluralize}.#{accessor}"
+      value = value_from_node(node.value, field_type, accessor.to_sym, model)
+      [assoc.klass.arel_table[accessor], model, field_type, value]
+    end
+
+    def handle_resolve_node(node, model)
+      field = node.left.value
+      field_type = get_field_type!(model, field)
+      value = value_from_node(node.value, field_type, field.to_sym, model)
+      [model.klass.arel_table[field], model, field_type, value]
+    end
+
+    def handle_operator_node(node, model)
+      if node.left.instance_of?(RKelly::Nodes::DotAccessorNode)
+        handle_dot_accessor_node(node, model)
+      elsif node.left.instance_of?(RKelly::Nodes::ResolveNode)
+        handle_resolve_node(node, model)
+      else
+        raise GraphQL::ExecutionError, "Invalid left value: #{node.left.class}"
+      end
+    end
+
+    def value_from_node(node, sym_type, sym, model)
+      if node.instance_of?(RKelly::Nodes::StringNode)
+        val = node.value.gsub(/^'|'$|^"|"$/, "")
+        if sym_type == :datetime
+          DateTime.parse(val)
+        elsif sym_type == :date
+          Date.parse(val)
+        elsif sym_type == :integer
+          # Enums are handled here : We are about to compare a string with an integer column
+          # If the symbol and the value correspond to an existing enum into the model
+          if model.klass.defined_enums[sym.to_s]&.keys&.include?(val)
+            # return the corresponding enum value
+            model.klass.defined_enums[sym.to_s][val]
           else
-            arr.join
+            raise GraphQL::ExecutionError, "Invalid value: #{val}, compare a string with an integer column #{sym}"
           end
-        end.join
-        @model = @model.where(transformed_filter)
+        else
+          val
+        end
+      elsif node.instance_of?(RKelly::Nodes::NumberNode)
+        node.value
+      elsif node.instance_of?(RKelly::Nodes::TrueNode)
+        true
+      elsif node.instance_of?(RKelly::Nodes::FalseNode)
+        false
+      elsif node.instance_of?(RKelly::Nodes::NullNode)
+        nil
+      else
+        raise GraphQL::ExecutionError, "Invalid filter: #{node} unknown rvalue node"
       end
+    end
 
-      return unless @order_by
+    def sanitize_sql_like(value)
+      ActiveRecord::Base.sanitize_sql_like(value)
+    end
 
-      sign = @order_by.split(' ').last.downcase == 'desc' ? 'desc' : 'asc'
-      column = @order_by.split(' ').first
-      if column.include?('.')
-        @model = @model.left_joins(column.split('.').first.to_sym)
-        string_type = %i[string text].include?(
-          evaluate_model(@model, column.split('.').first).columns_hash[column.split('.').last]&.type
-        )
+    def handle_NotEqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
 
-        @to_select_to_add = if string_type
-                              "upper(#{column.split('.').first.pluralize}.#{column.split('.').last})"
-                            else
-                              column.split('.').first.pluralize + '.' + column.split('.').last
-                            end
-        @model = @model.select(@to_select_to_add)
-        column = "#{column.split('.').first.pluralize}.#{column.split('.').last}"
-        @model = @model.order(Arel.sql("#{string_type ? "upper(#{column})" : column} #{sign}"))
-      elsif @order_by
-        column = "upper(#{model_name}.#{column})" if %i[string text].include?(@model.columns_hash[column]&.type)
-        @model = @model.order("#{column} #{sign}")
+      if value.nil?
+        model.where.not(arel_field.eq(nil))
+      elsif type == :text || type == :string
+        model.where.not(arel_field.lower.matches(sanitize_sql_like(value.downcase)))
+      else
+        model.where.not(arel_field.eq(value))
       end
     end
 
-    def transform_filter(filter)
-      parsed_filter = RKelly::Parser.new.parse(filter.gsub('like', ' | '))&.to_ecma
-      return '' unless parsed_filter
+    def handle_NotStrictEqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
 
-      @model.klass.defined_enums.values.reduce(:merge)&.each { |k, v| parsed_filter.gsub!("= #{k}", "= #{v}") }
-      parsed_filter.gsub(' | ', ' ilike ').gsub('||', 'OR').gsub('&&', 'AND').gsub('===', '=').gsub('==', '=').gsub(
-        '!= null', 'IS NOT NULL'
-      ).gsub('= null', 'IS NULL').delete(';')
+      if value.nil?
+        model.where.not(arel_field.eq(nil))
+      elsif type == :text || type == :string
+        model.where.not(arel_field.matches(sanitize_sql_like(value), false, true))
+      else
+        model.where.not(arel_field.eq(value))
+      end
+    end
+
+    def handle_EqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+
+      if value.nil?
+        model.where(arel_field.eq(nil))
+      elsif type == :text || type == :string
+        model.where(arel_field.lower.matches(sanitize_sql_like(value.downcase)))
+      else
+        model.where(arel_field.eq(value))
+      end
+    end
+
+    def handle_StrictEqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+
+      if value.nil?
+        model.where(arel_field.eq(nil))
+      elsif type == :text || type == :string
+        model.where(arel_field.matches(sanitize_sql_like(value), false, true))
+      else
+        model.where(arel_field.eq(value))
+      end
+    end
+
+    def handle_GreaterOrEqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+      model.where(arel_field.gteq(value))
+    end
+
+    def handle_LessOrEqualNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+      model.where(arel_field.lteq(value))
+    end
+
+    def handle_LessNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+      model.where(arel_field.lt(value))
+    end
+
+    def handle_GreaterNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+      model.where(arel_field.gt(value))
+    end
+
+    def valid_id?(id)
+      valid_uuid?(id) || id.is_a?(Integer)
+    end
+
+    def valid_uuid?(id)
+      id.to_s.match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+    end
+
+    def get_assoc!(model, assoc_name)
+      assoc = model.reflect_on_association(assoc_name)
+      unless assoc.present?
+        raise GraphQL::ExecutionError, "Invalid filter: #{assoc_name} is not an association of #{model}"
+      end
+      assoc
+    end
+
+    def get_field_type!(model, field_name)
+      field = model.column_for_attribute(field_name.to_sym)
+      unless field.present?
+        raise GraphQL::ExecutionError, "Invalid filter: #{field_name} is not a field of #{model}"
+      end
+      field.type
     end
 
     def deep_pluck_to_structs(irep_node)
@@ -129,7 +329,7 @@ module Graphql
     def hash_to_array_of_hashes(hash, parent_class)
       return if parent_class.nil? || hash.nil?
 
-      hash['id'] = nil if hash['id'].blank?
+      hash["id"] = nil if hash["id"].blank?
       fetch_ids_from_relation(hash)
 
       hash.each_with_object([]) do |(k, v), arr|
@@ -137,18 +337,17 @@ module Graphql
         next arr << v if parent_class.new.attributes.key?(v)
 
         klass = evaluate_model(parent_class, k)
-        @models << klass.to_s unless @models.include?(klass.to_s)
-        arr << { k.to_sym => hash_to_array_of_hashes(v, klass) } if klass.present? && v.present?
+        arr << {k.to_sym => hash_to_array_of_hashes(v, klass)} if klass.present? && v.present?
       end
     end
 
     def fetch_ids_from_relation(hash)
-      hash.select { |k, _| k.ends_with?('_ids') }.each do |(k, _)|
-        collection_name = k.gsub('_ids', '').pluralize
+      hash.select { |k, _| k.ends_with?("_ids") }.each do |(k, _)|
+        collection_name = k.gsub("_ids", "").pluralize
         if hash[collection_name].blank?
-          hash[collection_name] = { 'id' => nil }
+          hash[collection_name] = {"id" => nil}
         else
-          hash[collection_name]['id'] = nil
+          hash[collection_name]["id"] = nil
         end
       end
     end
@@ -177,7 +376,7 @@ module Graphql
 
     def parse_fields(irep_node)
       fields = irep_node&.scoped_children&.values&.first
-      fields = fields['edges'].scoped_children.values.first['node']&.scoped_children&.values&.first if fields&.key?('edges')
+      fields = fields["edges"].scoped_children.values.first["node"]&.scoped_children&.values&.first if fields&.key?("edges")
       return if fields.blank?
 
       fields.each_with_object({}) do |(k, v), h|
@@ -186,8 +385,7 @@ module Graphql
     end
 
     def model_name
-      @model.class.to_s.split('::').first.underscore.pluralize
+      @model.class.to_s.split("::").first.underscore.pluralize
     end
-
   end
 end

data/lib/graphql/rails/api/config.rb

@@ -6,23 +6,22 @@ module Graphql
         include Singleton
 
         def self.query_resources
-          Dir.glob("#{File.expand_path('.')}/app/graphql/*/type.rb").map do |dir|
+          Dir.glob("#{::Rails.root}/app/graphql/*/type.rb").map do |dir|
             dir.split('/').last(2).first
           end
         end
 
         def self.mutation_resources
-          mutations = Dir.glob("#{File.expand_path('.')}/app/graphql/*/mutations/*.rb").reject do |e|
+          mutations = Dir.glob("#{::Rails.root}/app/graphql/*/mutations/*.rb").reject do |e|
             e.end_with?('type.rb', 'types.rb')
           end
           mutations = mutations.map { |e| e.split('/').last.gsub('.rb', '') }.uniq
           mutations.each_with_object({}) do |meth, h|
-            h[meth] = Dir.glob("#{File.expand_path('.')}/app/graphql/*/mutations/#{meth}.rb").map do |dir|
+            h[meth] = Dir.glob("#{::Rails.root}/app/graphql/*/mutations/#{meth}.rb").map do |dir|
               dir.split('/').last(3).first
             end
           end
         end
-
       end
     end
   end

data/lib/graphql/rails/api/version.rb

@@ -1,7 +1,7 @@
 module Graphql
   module Rails
     module Api
-      VERSION = '0.9.1'.freeze
+      VERSION = "0.9.3-fix".freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-api
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.3.pre.fix
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2023-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 1.12.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 1.12.13
 - !ruby/object:Gem::Dependency
   name: deep_pluck_with_authorization
   requirement: !ruby/object:Gem::Requirement
@@ -44,20 +50,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.4
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 5.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.4
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 5.1.4
 - !ruby/object:Gem::Dependency
   name: rkelly-remix
   requirement: !ruby/object:Gem::Requirement
@@ -110,11 +110,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Graphql rails api framework to create easily graphql api with rails