apiql 0.4.8 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f23382bfe0c9946640a70754b0111d109267e24a00b23e675d16f2d5f5685938
-  data.tar.gz: d0fa0b8295cc1184b408e9817f7ba052b881abbefdab93533000af4d3fa1ea3c
+  metadata.gz: 50c3aec2e1f759145b3e6bf73e6bb9e810793360bf9c08aaec98095a83fa42c4
+  data.tar.gz: 331b529d03c24fc189ab17f1b9d9d7144a53c21b22812434ed116a602b927c6f
 SHA512:
-  metadata.gz: e795fba519ff01d1b7e21ed99f1e8f58619600249a5cd03b57b3b8acba407799c43fd2170dfb0d45d7b1ce6e18754caf23bd6c44ef28579dc571b2d644b52c17
-  data.tar.gz: a39ea52e53d9a8299fbaa0ae359ed25fa77112c0405279b1fa0cdbd089483d81894bf132466d197c32cee6c08415207a90c3d7763bec228258cfce9ff681db19
+  metadata.gz: 2249d7fb31711753c4db8dcd9ae711ba490bf587e99529f078e233b96de7f4827e3d01f920dc069382c172b2d98eed362a4f82b24a537d1776499445cbac0171
+  data.tar.gz: 332296fa978d1fa1e68dfe3e3e852f5e91cd3da8ed8dc344e368454572273a6a6988d4197d1454b1dbb51199f220158b623ef2f2049fb737740b3cb8d7fe88f0

data/README.md

@@ -6,37 +6,12 @@ It compiles requests into Hashes for faster rendering.
 
 It automatically detects nested entities and eager-loads them for faster DB access!
 
-Define your responder (requested methods):
-
-```ruby
-class UserAPIQL < ::APIQL
-  def me
-    authorize! :show, ::User
-
-    current_user
-  end
-
-  def authenticate(email, password)
-    user = ::User.find_by(email)
-    user.authenticate(password)
-
-    user
-  end
-
-  def logout
-    current_user&.logout
-
-    :ok
-  end
-end
-
-```
 In controller or Grape API endpoint, handler of POST /apiql method (or any other, see below APIQL.endpoint):
 
 ```ruby
 def apiql
   schema = APIQL.cache(params)
-  UserAPIQL.new(self, :session, :current_user, :params).render(schema)
+  APIQL.new(self, :session, :current_user, :params).render(schema)
 end
 
 ```
@@ -46,12 +21,41 @@ Define presenters for your models:
 
 ```ruby
 class User < ApplicationRecord
+  after_commit { APIQL.drop_cache(self) }
+
   class Entity < ::APIQL::Entity
     attributes :full_name, :email, :token, :role, :roles # any attributes, methods or associations
 
     def token # if defined, method will be called instead of attribute
       object.token if object == current_user # directly access to current_user from context
     end
+
+    def roles
+      APIQL.cacheable([object, roles], :roles, expires_in: 3600) do
+        roles.pluck(:name).join(', ')
+      end
+    end
+
+    class << self
+      def me
+        authorize! :show, ::User
+
+        current_user
+      end
+
+      def authenticate(email, password)
+        user = ::User.find_by(email)
+        user.authenticate(password)
+
+        user
+      end
+
+      def logout
+        current_user&.logout
+
+        :ok
+      end
+    end
   end
 
   has_many :roles
@@ -59,6 +63,14 @@ class User < ApplicationRecord
   ...
 end
 
+class Role < ApplicationRecord
+  after_commit { APIQL.drop_cache(self) }
+
+  class Entity < ::APIQL::Entity
+    attributes :id, :name
+  end
+end
+
 ```
 # JS:
 
@@ -74,13 +86,13 @@ APIQL.endpoint = "/apiql"
 
 authenticate(email, password) {
   apiql(`
-    logout()
+    User.logout()
 
-    authenticate(email, password) {
+    User.authenticate(email, password) {
       token
     }
 
-    me {
+    User.me {
       email full_name role token
 
       roles {
@@ -98,7 +110,7 @@ authenticate(email, password) {
 
 logout() {
   apiql(`
-    logout
+    User.logout
   `)
   .then(response => {
   })
@@ -110,11 +122,11 @@ you can call methods on entities:
 
 ```javascript
   apiql(`
-    authenticate(email, password) {
+    User.authenticate(email, password) {
       token
     }
 
-    user: me.reload {
+    user: User.me.reload {
       email full_name role token
 
       roles(filter) {
@@ -157,20 +169,69 @@ class APIQL
 end
 ```
 
-you can add CRUD methods for your models:
+CRUD methods available for all models:
 
-```ruby
-class UserAPIQL < ::APIQL
-  model ::User
-  model ::Role
-end
+```js
+  apiql(`
+    User.create(user)
+  `, {
+    user: {
+      email: this.email,
+      full_name: this.full_name
+    }
+  })
+  .then(response => {
+    ...
+  })
+
+  apiql(`
+    User.find(id) {
+      id email full_name
+    }
+  `, {
+    id: this.id
+  })
+  .then(response => {
+    ...
+  })
+
+  apiql(`
+    User.all {
+      id email full_name
+    }
+  `)
+  .then(response => {
+    ...
+  })
+
+  apiql(`
+    User.update(id, user)
+  `, {
+    id: this.id,
+    user: {
+      email: this.email,
+      full_name: this.full_name
+    }
+  })
+  .then(response => {
+    ...
+  })
+
+  apiql(`
+    User.destroy(id)
+  `, {
+    id: this.id
+  })
+  .then(response => {
+    ...
+  })
 ```
 
 or mount methods from external modules:
 
 ```ruby
-class UserAPIQL < ::APIQL
-  mount ::Services::User # all methouds could be called with "user" prefix like "user.logout()"
+class APIQL < ::APIQL
+  mount ::Services::User # all methods could be called with "user" prefix like "user.logout()"
   mount ::Services::Common, as: '' # all methods could be called without prefixes
   mount ::Services::Employer, as: 'dashboard" # all methods could be called with specified prefix
 end

data/apiql.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'apiql'
-  spec.version       = '0.4.8'
+  spec.version       = '1.0.5'
   spec.authors       = ['Dmitry Silchenko']
   spec.email         = ['dmitry@desofto.com']
 

data/assets/javascripts/apiql.js

@@ -1,9 +1,11 @@
 const APIQL = {
   on_error: null,
   endpoint: '',
+  CSRFToken: '',
+  http: null,
 
   hash: function(s) {
-    let hash = 0, i, chr
+    var hash = 0, i, chr
     if(s.length === 0) return hash
     for(i = 0; i < s.length; i++) {
       chr   = s.charCodeAt(i)
@@ -13,6 +15,35 @@ const APIQL = {
     return hash
   },
 
+  post: function(endpoint, data) {
+    return new Promise(function(resolve, reject) {
+      var http = new XMLHttpRequest()
+      http.open("POST", endpoint, true)
+      if(APIQL.CSRFToken.length > 0) {
+        http.setRequestHeader("X-CSRF-Token", APIQL.CSRFToken)
+      }
+      http.setRequestHeader("Content-Type", "application/json;charset=UTF-8")
+      http.onload = function() {
+        APIQL.http = http
+
+        if(http.status >= 200 && http.status < 300) {
+          resolve({
+            status: http.status,
+            body: JSON.parse(http.responseText),
+            http: http
+          })
+        } else {
+          reject({
+            status: http.status,
+            body: JSON.parse(http.responseText),
+            http: http
+          })
+        }
+      }
+      http.send(JSON.stringify(data))
+    })
+  },
+
   call: function(schema, params, form) {
     if(!params) params = {}
     if(!form) form = null
@@ -35,11 +66,10 @@ const APIQL = {
         params.apiql = APIQL.hash(schema)
       }
 
-      Vue.http.post(APIQL.endpoint, form || params)
+      APIQL.post(APIQL.endpoint, form || params)
       .then(function(response) {
         resolve(response.body)
-      })
-      .catch(function(response) {
+      }, function(response) {
         if(response.status == 401 && APIQL.on_error) {
           APIQL.on_error(response)
           return
@@ -53,11 +83,10 @@ const APIQL = {
           params.apiql_request = schema
         }
 
-        Vue.http.post(APIQL.endpoint, form || params)
+        APIQL.post(APIQL.endpoint, form || params)
         .then(function(response) {
           resolve(response.body)
-        })
-        .catch(function(response) {
+        }, function(response) {
           if(APIQL.on_error) {
             APIQL.on_error(response)
           } else {

data/lib/apiql.rb

@@ -2,7 +2,7 @@ class APIQL
   module Rails
     class Engine < ::Rails::Engine
       initializer 'apiql.assets' do |app|
-        app.config.assets.paths << root.join('assets', 'javascripts').to_s
+        app.config.assets.paths << root.join('assets', 'javascripts').to_s if app.config.respond_to? :assets
       end
     end
   end
@@ -14,69 +14,6 @@ class APIQL
     end
   end
 
-  module CRUD
-    def model(klass)
-      define_method "#{klass.name.pluralize.underscore}" do |page = nil, page_size = 10|
-        authorize! :read, klass
-
-        if page.present?
-          {
-            total: klass.count,
-            items: klass.eager_load(eager_load).offset(page * page_size).limit(page_size)
-          }
-        else
-          klass.eager_load(eager_load).all
-        end
-      end
-
-      define_method "#{klass.name.underscore}" do |id|
-        item = klass.eager_load(eager_load).find(id)
-
-        authorize! :read, item
-
-        item
-      end
-
-      define_method "#{klass.name.underscore}.create" do |params|
-        authorize! :create, klass
-
-        klass_entity = "#{klass.name}::Entity".constantize
-
-        if klass_entity.respond_to?(:create_params, params)
-          params = klass_entity.send(:create_params, params)
-        elsif klass_entity.respond_to?(:params, params)
-          params = klass_entity.send(:params, params)
-        end
-
-        klass.create!(params)
-      end
-
-      define_method "#{klass.name.underscore}.update" do |id, params|
-        item = klass.find(id)
-
-        authorize! :update, item
-
-        klass_entity = "#{klass.name}::Entity".constantize
-
-        if klass_entity.respond_to?(:update_params, params)
-          params = klass_entity.send(:update_params, params)
-        elsif klass_entity.respond_to?(:params, params)
-          params = klass_entity.send(:params, params)
-        end
-
-        item.update!(params)
-      end
-
-      define_method "#{klass.name.underscore}.destroy" do |id|
-        item = klass.find(id)
-
-        authorize! :destroy, item
-
-        item.destroy!
-      end
-    end
-  end
-
   class Error < StandardError; end
   class CacheMissed < StandardError; end
 
@@ -84,8 +21,6 @@ class APIQL
   delegate :authorize!, to: :@context
 
   class << self
-    include ::APIQL::CRUD
-
     def mount(klass, as: nil)
       as ||= klass.name.split('::').last.underscore
       as += '.' if as.present?
@@ -106,18 +41,34 @@ class APIQL
 
       if request.present?
         request = compile(request)
-        redis&.set("api-ql-cache-#{request_id}", request.to_json)
+        ::Rails.cache.write("api-ql-cache-#{request_id}", JSON.generate(request), expires_in: 31*24*60*60)
         @@cache[request_id] = request
         @@cache = {} if(@@cache.count > 1000)
       else
         request = @@cache[request_id]
-        request ||= JSON.parse(redis.get("api-ql-cache-#{request_id}")) rescue nil
+        request ||= JSON.parse(::Rails.cache.fetch("api-ql-cache-#{request_id}")) rescue nil
         raise CacheMissed unless request.present? && request.is_a?(::Array)
       end
 
       request
     end
 
+    def cacheable(dependencies, attr, expires_in: 31*24*60*60)
+      dependencies = dependencies.flatten.map { |obj| [obj.class.name, obj.id] }
+      name = ['api-ql-cache', dependencies, attr].flatten.join('-')
+      begin
+        raise if expires_in <= 0
+        JSON.parse(::Rails.cache.fetch(name))
+      rescue
+        (block_given? ? yield : nil).tap { |data| expires_in > 0 && ::Rails.cache.write(name, JSON.generate(data), expires_in: expires_in) }
+      end
+    end
+
+    def drop_cache(obj)
+      return unless ::Rails.cache.respond_to? :delete_if
+      ::Rails.cache.delete_if { |k, v| k =~ /api-ql.*-#{obj.class.name}-#{obj.id}-.*/ }
+    end
+
     def simple_class?(value)
       value.nil? ||
         value.is_a?(TrueClass) || value.is_a?(FalseClass) ||
@@ -151,15 +102,6 @@ class APIQL
 
     private
 
-    def redis
-      @redis ||=
-        begin
-          ::Redis.new(host: 'localhost')
-        rescue
-          nil
-        end
-    end
-
     def compile(schema)
       result = []
 
@@ -201,7 +143,7 @@ class APIQL
 
           ptr = pool.pop
         elsif pool.any?
-          if reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s*)?(?<name>[\w\.]+)(\((?<params>.*?)\))?(?<rest>.*)\z/m)
+          if reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s*)?(?<name>[\w\.\:\!\?]+)(\((?<params>.*?)\))?(?<rest>.*)\z/m)
             schema = reg[:rest]
 
             key = reg[:alias].present? ? "#{reg[:alias]}: #{reg[:name]}" : reg[:name]
@@ -213,7 +155,7 @@ class APIQL
           else
             raise Error, schema
           end
-        elsif reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s*)?(?<name>[\w\.]+)(\((?<params>((\w+)(\s*\,\s*\w+)*))?\))?\s*\{(?<rest>.*)\z/m)
+        elsif reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>((\w+)(\s*\,\s*\w+)*))?\))?\s*\{(?<rest>.*)\z/m)
           schema = reg[:rest]
 
           key = "#{reg[:alias] || reg[:name]}: #{reg[:name]}(#{reg[:params]})"
@@ -221,7 +163,7 @@ class APIQL
           pool.push(ptr)
 
           ptr = push_key.call(key, true)
-        elsif reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s*)?(?<name>[\w\.]+)(\((?<params>((\w+)(\s*\,\s*\w+)*))?\))?\s*\n?(?<rest>.*)\z/m)
+        elsif reg = schema.match(/\A\s*((?<alias>[\w\.]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>((\w+)(\s*\,\s*\w+)*))?\))?\s*\n?(?<rest>.*)\z/m)
           schema = reg[:rest]
 
           key = "#{reg[:alias] || reg[:name]}: #{reg[:name]}(#{reg[:params]})"
@@ -255,7 +197,7 @@ class APIQL
     schema.each do |call|
       if call.is_a? ::Hash
         call.each do |function, sub_schema|
-          reg = function.match(/\A((?<alias>[\w\.\!]+):\s*)?(?<name>[\w\.\!]+)(\((?<params>.*?)\))?\z/)
+          reg = function.match(/\A((?<alias>[\w\.\:\!\?]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>.*?)\))?\z/)
           raise Error, function unless reg.present?
 
           name = reg[:alias] || reg[:name]
@@ -263,9 +205,11 @@ class APIQL
           params = @context.parse_params(reg[:params].presence)
 
           @eager_load = APIQL::eager_loads(sub_schema)
-          data = public_send(function, *params)
+
+          data = call_function(function, *params)
+
           if @eager_load.present? && !data.is_a?(::Hash) && !data.is_a?(::Array)
-            if data.respond_to?(:eager_load)
+            if data.respond_to?(:includes)
               data = data.includes(eager_load)
             elsif data.respond_to?(:id)
               data = data.class.includes(eager_load).find(data.id)
@@ -281,7 +225,7 @@ class APIQL
           end
         end
       else
-        reg = call.match(/\A((?<alias>[\w\.\!]+):\s*)?(?<name>[\w\.\!]+)(\((?<params>.*?)\))?\z/)
+        reg = call.match(/\A((?<alias>[\w\.\:\!\?]+):\s+)?(?<name>[\w\.\:\!\?]+)(\((?<params>.*?)\))?\z/)
         raise Error, call unless reg.present?
 
         name = reg[:alias] || reg[:name]
@@ -289,7 +233,9 @@ class APIQL
         params = @context.parse_params(reg[:params].presence)
 
         @eager_load = []
-        data = public_send(function, *params)
+
+        data = call_function(function, *params)
+
         if data.is_a? Array
           if data.any? { |item| !APIQL::simple_class?(item) }
             data = nil
@@ -313,11 +259,112 @@ class APIQL
 
   private
 
+  def call_function(name, *params)
+    if respond_to?(name) && (methods - Object.methods).include?(name.to_sym)
+      public_send(name, *params)
+    else
+      o = nil
+
+      names = name.split('.')
+      names.each_with_index do |name, index|
+        if o.nil?
+          o = "#{name}::Entity".constantize
+          o.instance_variable_set('@context', @context)
+          o.instance_variable_set('@eager_load', @eager_load)
+          @context.inject_delegators(self)
+        elsif o.superclass == ::APIQL::Entity || o.superclass.superclass == ::APIQL::Entity
+          if o.respond_to?(name) && (o.methods - Object.methods).include?(name.to_sym)
+            o =
+              if index == names.count - 1
+                o.public_send(name, *params)
+              else
+                o.public_send(name)
+              end
+          else
+            o = nil
+            break
+          end
+        else
+          objects = o
+          o = "#{o.name}::Entity".constantize
+          if o.respond_to?(name) && (o.methods - Object.methods).include?(name.to_sym)
+            o.instance_variable_set("@objects", objects)
+            o.instance_variable_set('@context', @context)
+            o.instance_variable_set('@eager_load', @eager_load)
+            @context.inject_delegators(self)
+            o =
+              if index == names.count - 1
+                o.public_send(name, *params)
+              else
+                o.public_send(name)
+              end
+          else
+            o = nil
+            break
+          end
+        end
+      end
+
+      o
+    end
+  end
+
   class Entity
     delegate :authorize!, to: :@context
 
     class << self
-      attr_reader :apiql_attributes
+      def all
+        authorize! :read, @apiql_entity_class
+
+        @apiql_entity_class.eager_load(eager_load).all
+      end
+
+      def find(id)
+        item = @apiql_entity_class.eager_load(eager_load).find(id)
+
+        authorize! :read, item
+
+        item
+      end
+
+      def create(params)
+        authorize! :create, @apiql_entity_class
+
+        if respond_to?(:create_params, params)
+          params = create_params(params)
+        elsif respond_to?(:params, params)
+          params = self.params(params)
+        end
+
+        @apiql_entity_class.create!(params)
+      end
+
+      def update(id, params)
+        item = @apiql_entity_class.find(id)
+
+        authorize! :update, item
+
+        if respond_to?(:update_params, params)
+          params = update_params(params)
+        elsif respond_to?(:params, params)
+          params = self.params(params)
+        end
+
+        item.update!(params)
+      end
+
+      def destroy(id)
+        item = @apiql_entity_class.find(id)
+
+        authorize! :destroy, item
+
+        item.destroy!
+      end
+
+      private
+
+      attr_reader :apiql_attributes, :objects
+      delegate :authorize!, to: :@context, private: true
 
       def inherited(child)
         super
@@ -328,6 +375,10 @@ class APIQL
 
         child.instance_eval do
           @apiql_attributes = attributes
+
+          names = child.name.split('::')
+          return unless names.last == 'Entity'
+          @apiql_entity_class = names[0..-2].join('::').constantize
         end
       end
 
@@ -335,6 +386,14 @@ class APIQL
         @apiql_attributes ||= []
         @apiql_attributes += attrs.map(&:to_sym)
       end
+
+      def eager_load
+        result = @eager_load
+
+        @eager_load = []
+
+        result
+      end
     end
 
     attr_reader :object
@@ -354,7 +413,7 @@ class APIQL
       schema.each do |field|
         if field.is_a? Hash
           field.each do |field, sub_schema|
-            reg = field.match(/\A((?<alias>[\w\.\!]+):\s*)?(?<name>[\w\.\!]+)(\((?<params>.*?)\))?\z/)
+            reg = field.match(/\A((?<alias>[\w\.\!\?]+):\s*)?(?<name>[\w\.\!\?]+)(\((?<params>.*?)\))?\z/)
             raise Error, field unless reg.present?
 
             name = reg[:alias] || reg[:name]
@@ -368,7 +427,7 @@ class APIQL
             end
           end
         else
-          reg = field.match(/\A((?<alias>[\w\.\!]+):\s*)?(?<name>[\w\.\!]+)(\((?<params>.*?)\))?\z/)
+          reg = field.match(/\A((?<alias>[\w\.\!\?]+):\s*)?(?<name>[\w\.\!\?]+)(\((?<params>.*?)\))?\z/)
           raise Error, field unless reg.present?
 
           name = reg[:alias] || reg[:name]
@@ -396,20 +455,31 @@ class APIQL
       names = field.split('.')
       if names.count > 1
         o = nil
-        names.each do |field|
+        names.each_with_index do |field, index|
           if o.nil?
             return unless field.to_sym.in? self.class.apiql_attributes
 
-            if respond_to? field
-              o = public_send(field, *params)
+            if respond_to?(field) && (methods - Object.methods).include?(name.to_sym)
+              o = public_send(field)
             else
-              o = object.public_send(field, *params)
+              o = object.public_send(field)
             end
 
             break if o.nil?
           else
-            if o.respond_to? field
-              o = o.public_send(field, *params)
+            objects = o
+            o = "#{o.name}::Entity".constantize
+            o.instance_variable_set("@objects", objects)
+            o.instance_variable_set('@context', @context)
+            o.instance_variable_set('@eager_load', @eager_load)
+            @context.inject_delegators(self)
+
+            if o.respond_to?(field) && (o.methods - Object.methods).include?(name.to_sym)
+              if index == names.count - 1
+                o = o.public_send(field, *params)
+              else
+                o = o.public_send(field)
+              end
             else
               o = nil
               break
@@ -419,9 +489,9 @@ class APIQL
 
         o
       else
-        return unless field.to_sym.in? self.class.apiql_attributes
+        return unless field.to_sym.in? self.class.send(:apiql_attributes)
 
-        if respond_to? field
+        if respond_to?(field) && (methods - Object.methods).include?(name.to_sym)
           public_send(field, *params)
         else
           object.public_send(field, *params)
@@ -473,10 +543,10 @@ class APIQL
 
       field.split('.').each do |name|
         if o.nil?
-          o = object[name.to_sym]
+          o = object[name.to_sym] || object[name.to_s]
           break if o.nil?
         else
-          if o.respond_to? name
+          if o.respond_to?(name) && (o.methods - Object.methods).include?(name.to_sym)
             o = o.public_send(name)
           else
             o = nil
@@ -504,6 +574,7 @@ class APIQL
 
     def inject_delegators(target)
       @fields.each do |field|
+        next if target.respond_to?(field)
         target.class_eval do
           delegate field, to: :@context
         end
@@ -537,11 +608,7 @@ class APIQL
         begin
           "#{value.class.name}::Entity".constantize.new(value, self).render(schema)
         rescue StandardError
-          if ::Rails.env.development?
-            raise
-          else
-            nil
-          end
+          raise
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: apiql
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 1.0.5
 platform: ruby
 authors:
 - Dmitry Silchenko
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-11-07 00:00:00.000000000 Z
+date: 2022-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,7 +69,7 @@ homepage: https://github.com/desofto/apiql
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,9 +84,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Implementation of the API language similar to GraphQL for Ruby on Rails
 test_files: []