From 9bf59935ca3a7d78f781ab8046e0a810b02ccae1 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Mon, 2 Oct 2023 17:01:12 +0200
Subject: [PATCH 01/26] feat: send apimap to forest

---
 .../forest_admin_agent.gemspec                |  1 +
 .../builder/agent_factory.rb                  | 27 +++++++++++++++---
 .../forest_admin_agent/facades/container.rb   |  4 +++
 .../http/forest_admin_api_requester.rb        | 28 +++++++++++++++++++
 .../utils/schema/generator_field.rb           | 10 +++----
 .../lib/forest_admin_rails/engine.rb          |  7 ++---
 6 files changed, 64 insertions(+), 13 deletions(-)
 create mode 100644 packages/forest_admin_agent/lib/forest_admin_agent/http/forest_admin_api_requester.rb

diff --git a/packages/forest_admin_agent/forest_admin_agent.gemspec b/packages/forest_admin_agent/forest_admin_agent.gemspec
index a9ab0f738..16ffc83f6 100644
--- a/packages/forest_admin_agent/forest_admin_agent.gemspec
+++ b/packages/forest_admin_agent/forest_admin_agent.gemspec
@@ -43,4 +43,5 @@ admin work on any Ruby application."
   spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "rack-cors", "~> 2.0"
   spec.add_dependency "zeitwerk", "~> 2.3"
+  spec.add_dependency "faraday", "~> 2.7"
 end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
index 165beb9ee..8bb15962d 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
@@ -14,22 +14,41 @@ class AgentFactory
       def setup(options)
         @options = options
         @has_env_secret = options.to_h.key?(:env_secret)
-        # @customizer = DatasourceCustomizer.new
+        @customizer = ForestAdminDatasourceToolkit::Datasource.new
         build_container
         build_cache
         build_logger
       end
 
+      def add_datasource(datasource)
+        datasource.collections.each { |_name, collection| @customizer.add_collection(collection) }
+        self
+      end
+
       def build
-        # @customizer.datasource
-        @container.register(:datasource, {})
+        @container.register(:datasource, @customizer)
         send_schema
       end
 
       private
 
       def send_schema(force: false)
-        # todo
+        return unless @has_env_secret
+
+        schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@customizer)
+        schema_is_know = false
+        # if (Cache::get('schemaFileHash') === $schema['meta']['schemaFileHash']) {
+        #   $schemaIsKnown = true;
+        # }
+
+        if !schema_is_know || force
+          #   Logger::log('Info', 'schema was updated, sending new version');
+          client = ForestAdminAgent::Http::ForestAdminApiRequester.new
+          client.post('/forest/apimaps', schema)
+        else
+          @container.resolve(:logger)
+          # TODO:  Logger::log('Info', 'Schema was not updated since last run');
+        end
       end
 
       def build_container
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/facades/container.rb b/packages/forest_admin_agent/lib/forest_admin_agent/facades/container.rb
index bf35a7756..e637fce46 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/facades/container.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/facades/container.rb
@@ -5,6 +5,10 @@ def self.instance
         ForestAdminAgent::Builder::AgentFactory.instance.container
       end
 
+      def self.datasource
+        instance.resolve(:datasource)
+      end
+
       def self.config_from_cache
         instance.resolve(:cache).get('config')
       end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/http/forest_admin_api_requester.rb b/packages/forest_admin_agent/lib/forest_admin_agent/http/forest_admin_api_requester.rb
new file mode 100644
index 000000000..98d07cf4f
--- /dev/null
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/http/forest_admin_api_requester.rb
@@ -0,0 +1,28 @@
+require 'faraday'
+
+module ForestAdminAgent
+  module Http
+    class ForestAdminApiRequester
+      def initialize
+        @headers = {
+          'Content-Type' => 'application/json',
+          'forest-secret-key' => Facades::Container.cache(:env_secret)
+        }
+        @client = Faraday.new(
+          Facades::Container.cache(:forest_server_url),
+          {
+            headers: @headers
+          }
+        )
+      end
+
+      def get(url, params)
+        @client.get(url, params.to_json)
+      end
+
+      def post(url, params)
+        @client.post(url, params.to_json)
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_field.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_field.rb
index e2d0594bc..20397a059 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_field.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_field.rb
@@ -47,7 +47,7 @@ def build_column_schema(collection, name)
               isVirtual: false,
               reference: nil,
               type: convert_column_type(column.column_type),
-              validations: {} # TODO: FrontendValidationUtils.convertValidationList(column),
+              validations: [] # TODO: FrontendValidationUtils.convertValidationList(column),
             }
           end
 
@@ -87,7 +87,7 @@ def build_many_to_many_schema(relation, collection, foreign_collection, base_sch
                 isRequired: false,
                 isReadOnly: origin_key.is_read_only || foreign_schema.is_read_only,
                 isSortable: true,
-                validations: {},
+                validations: [],
                 reference: "#{foreign_collection.name}.#{target_name}"
               }
             )
@@ -107,7 +107,7 @@ def build_one_to_many_schema(relation, collection, foreign_collection, base_sche
                 isRequired: false,
                 isReadOnly: origin_key.is_read_only,
                 isSortable: true,
-                validations: {},
+                validations: [],
                 reference: "#{foreign_collection.name}.#{target_name}"
               }
             )
@@ -126,7 +126,7 @@ def build_one_to_one_schema(relation, collection, foreign_collection, base_schem
                 isRequired: false,
                 isReadOnly: key_field.is_read_only,
                 isSortable: target_field.is_sortable,
-                validations: {},
+                validations: [],
                 reference: "#{foreign_collection.name}.#{relation.origin_key_target}"
               }
             )
@@ -144,7 +144,7 @@ def build_many_to_one_schema(relation, collection, foreign_collection, base_sche
                 isRequired: false, # TODO: check with validations
                 isReadOnly: key_field.is_read_only,
                 isSortable: key_field.is_sortable,
-                validations: {}, # TODO: FrontendValidation::convertValidationList(foreignTargetColumn)
+                validations: [], # TODO: FrontendValidation::convertValidationList(foreignTargetColumn)
                 reference: "#{foreign_collection.name}.#{relation.foreign_key_target}"
               }
             )
diff --git a/packages/forest_admin_rails/lib/forest_admin_rails/engine.rb b/packages/forest_admin_rails/lib/forest_admin_rails/engine.rb
index d1a23c5bc..ef971ef15 100644
--- a/packages/forest_admin_rails/lib/forest_admin_rails/engine.rb
+++ b/packages/forest_admin_rails/lib/forest_admin_rails/engine.rb
@@ -32,12 +32,11 @@ class Engine < ::Rails::Engine
     def load_configuration
       return unless File.exist?(Rails.root.join('config', 'forest_admin.rb'))
 
-      require Rails.root.join('config', 'forest_admin.rb')
-
-      ForestAdminAgent::Builder::AgentFactory.instance.build
-
       # force eager loading models
       Rails.application.eager_load!
+
+      require Rails.root.join('config', 'forest_admin.rb')
+      forest_admin_configuration
     end
 
     def load_cors

From eb4b1bbc720ccef0dae578c3fbbbafe94d32a07e Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Mon, 2 Oct 2023 17:08:32 +0200
Subject: [PATCH 02/26] test: update unit tests

---
 .../utils/schema/generator_field_many_to_many_spec.rb         | 4 ++--
 .../utils/schema/generator_field_one_to_many_spec.rb          | 4 ++--
 .../utils/schema/generator_field_one_to_one_spec.rb           | 4 ++--
 .../forest_admin_agent/utils/schema/generator_field_spec.rb   | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_many_to_many_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_many_to_many_spec.rb
index cddccf621..01eaaa7b2 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_many_to_many_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_many_to_many_spec.rb
@@ -81,7 +81,7 @@ module Schema
                 isRequired: false,
                 isSortable: true,
                 isVirtual: false,
-                validations: {}
+                validations: []
               }
             )
           end
@@ -129,7 +129,7 @@ module Schema
                   isRequired: false,
                   isSortable: false,
                   isVirtual: false,
-                  validations: {}
+                  validations: []
                 }
               )
             end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_many_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_many_spec.rb
index e725dada3..e36dbd3d1 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_many_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_many_spec.rb
@@ -57,7 +57,7 @@ module Schema
                 isRequired: false,
                 isSortable: true,
                 isVirtual: false,
-                validations: {}
+                validations: []
               }
             )
           end
@@ -81,7 +81,7 @@ module Schema
                 isReadOnly: true,
                 isRequired: false,
                 isVirtual: false,
-                validations: {}
+                validations: []
               }
             )
           end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_one_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_one_spec.rb
index aed8563f4..0259ad6d8 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_one_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_one_to_one_spec.rb
@@ -59,7 +59,7 @@ module Schema
                 isRequired: false,
                 isSortable: false,
                 isVirtual: false,
-                validations: {}
+                validations: []
               }
             )
           end
@@ -84,7 +84,7 @@ module Schema
                 isReadOnly: true,
                 isRequired: false,
                 isVirtual: false,
-                validations: {}
+                validations: []
               }
             )
           end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_spec.rb
index 5ca22f164..7cd6819af 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_field_spec.rb
@@ -55,7 +55,7 @@ module Schema
               isRequired: true,
               isVirtual: false,
               reference: nil,
-              validations: {}
+              validations: []
             }
           )
         end
@@ -78,7 +78,7 @@ module Schema
               isRequired: false,
               isVirtual: false,
               reference: nil,
-              validations: {}
+              validations: []
             }
           )
         end

From d751aea5ad5f47e0d44b4f0bbbc18ec4e0fff360 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Tue, 3 Oct 2023 17:47:33 +0200
Subject: [PATCH 03/26] test: add test on agent factory

---
 .../builder/agent_factory.rb                  | 11 ++-
 .../builder/agent_factory_spec.rb             | 79 +++++++++++++++++++
 2 files changed, 86 insertions(+), 4 deletions(-)
 create mode 100644 packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
index 8bb15962d..65f852afb 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
@@ -36,15 +36,18 @@ def send_schema(force: false)
         return unless @has_env_secret
 
         schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@customizer)
-        schema_is_know = false
-        # if (Cache::get('schemaFileHash') === $schema['meta']['schemaFileHash']) {
-        #   $schemaIsKnown = true;
-        # }
+        schema_is_know = @container.key?(:schema_file_hash) &&
+          @container.resolve(:schema_file_hash).get('value') == schema[:meta][:schemaFileHash]
 
         if !schema_is_know || force
           #   Logger::log('Info', 'schema was updated, sending new version');
           client = ForestAdminAgent::Http::ForestAdminApiRequester.new
           client.post('/forest/apimaps', schema)
+          schema_file_hash_cache = Lightly.new(life: TTL_SCHEMA, dir: @options[:cache_dir].to_s)
+          schema_file_hash_cache.get 'value' do
+            schema[:meta][:schemaFileHash]
+          end
+          @container.register(:schema_file_hash, schema_file_hash_cache)
         else
           @container.resolve(:logger)
           # TODO:  Logger::log('Info', 'Schema was not updated since last run');
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
new file mode 100644
index 000000000..74e255ccc
--- /dev/null
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'digest/sha1'
+require 'json'
+
+module ForestAdminAgent
+  module Builder
+    describe AgentFactory do
+      context 'with agent setup' do
+        describe 'setup' do
+          it 'set @has_env_secret to true when env_secret exist' do
+            expect(described_class.instance.has_env_secret).to be true
+          end
+
+          it 'build the container' do
+            expect(described_class.instance.container).not_to be_nil
+          end
+
+          it 'build the cache' do
+            expect(described_class.instance.container.resolve(:cache)).not_to be_nil
+            expect(described_class.instance.container.resolve(:cache)).to be_instance_of Lightly
+          end
+
+          it 'build the logger' do
+            expect(described_class.instance.container.resolve(:logger)).not_to be_nil
+            expect(described_class.instance.container.resolve(:logger)).to be_instance_of Services::LoggerService
+          end
+        end
+
+        describe 'add_datasource' do
+          it 'add collections to the customizer datasource' do
+            datasource = ForestAdminDatasourceToolkit::Datasource.new
+            collection_book = ForestAdminDatasourceToolkit::Collection.new(datasource, 'Book')
+            datasource.add_collection(collection_book)
+            AgentFactory.instance.add_datasource(datasource)
+
+            expect(AgentFactory.instance.customizer.collections.size).to eq(1)
+            expect(AgentFactory.instance.customizer.collection('Book')).to eq(collection_book)
+            expect(AgentFactory.instance.customizer.collection('Book').datasource).to eq(datasource)
+          end
+        end
+
+        describe 'build' do
+          it 'add customizer to the container' do
+            allow(AgentFactory.instance).to receive(:send_schema)
+            AgentFactory.instance.build
+
+            expect(AgentFactory.instance.container.resolve(:datasource)).to eq(AgentFactory.instance.customizer)
+          end
+        end
+
+        describe 'send_schema' do
+          it 'do nothing if env_secret is nil' do
+            AgentFactory.instance.instance_variable_set('@has_env_secret', false)
+            allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
+            AgentFactory.instance.build
+
+            expect(ForestAdminAgent::Utils::Schema::SchemaEmitter).not_to have_received(:get_serialized_schema)
+          end
+
+          it 'send schema when schema hash is different' do
+            allow(AgentFactory.instance).to receive(:has_env_secret).and_return(false)
+            allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
+              .and_return(
+                {
+                  meta: {
+                    schemaFileHash: ''
+                  }
+                }
+              )
+
+            expect_any_instance_of(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
+            AgentFactory.instance.build
+          end
+        end
+      end
+    end
+  end
+end
+

From 7514abdb135a4cf2d724fd0d3f1bc353afefa495 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Wed, 4 Oct 2023 17:39:59 +0200
Subject: [PATCH 04/26] feat: add parse caller

---
 .rubocop.yml                                  |  1 +
 .../routes/abstract_route.rb                  |  5 +++
 .../routes/security/authentication.rb         |  4 +--
 .../utils/query_string_parser.rb              | 32 +++++++++++++++++++
 .../components/caller.rb                      | 31 ++++++++++++++++++
 .../forest_admin_rails/forest_controller.rb   |  2 +-
 6 files changed, 72 insertions(+), 3 deletions(-)
 create mode 100644 packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb

diff --git a/.rubocop.yml b/.rubocop.yml
index 9b5f5f7c7..211fe57ff 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -159,6 +159,7 @@ Metrics/ParameterLists:
   Exclude:
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/schema/relations/many_to_many_schema.rb'
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/schema/column_schema.rb'
+    - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb'
 
 Metrics/ModuleLength:
   CountAsOne: [ 'array', 'hash', 'method_call' ]
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_route.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_route.rb
index 981c0f4fe..0c377dd4f 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_route.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_route.rb
@@ -6,6 +6,11 @@ def initialize
         setup_routes
       end
 
+      def build(args)
+        @datasource = ForestAdminAgent::Facades::Container.datasource
+        @collection = @datasource.collection(args[:params]['collection_name'])
+      end
+
       def routes
         @routes ||= {}
       end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
index 8ecf050f2..0cbf26a12 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
@@ -27,7 +27,7 @@ def setup_routes
 
         def handle_authentication(args = {})
           # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
-          rendering_id = get_and_check_rendering_id args
+          rendering_id = get_and_check_rendering_id args[:params]
 
           {
             content: {
@@ -38,7 +38,7 @@ def handle_authentication(args = {})
 
         def handle_authentication_callback(args = {})
           # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
-          token = auth.verify_code_and_generate_token(args)
+          token = auth.verify_code_and_generate_token(args[:params])
           token_data = JWT.decode(
             token,
             Facades::Container.cache(:auth_secret),
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
new file mode 100644
index 000000000..b80006173
--- /dev/null
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -0,0 +1,32 @@
+require 'jwt'
+
+module ForestAdminAgent
+  module Utils
+    class QueryStringParser
+      include ForestAdminDatasourceToolkit::Exceptions
+      def self.parse_caller(args)
+        unless args[:headers]['HTTP_AUTHORIZATION']
+          raise ForestException 'You must be logged in to access at this resource.'
+        end
+
+        timezone = args[:params]['timezone']
+        raise ForestException 'You must be logged in to access at this resource.' unless timezone
+
+        # if (! in_array($timezone, \DateTimeZone::listIdentifiers(), true)) {
+        #   throw new ForestException("Invalid timezone: $timezone");
+        # }
+        token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
+        token_data = JWT.decode(
+          token,
+          Facades::Container.cache(:auth_secret),
+          true,
+          { algorithm: 'HS256' }
+        )[0]
+        token_data.delete('exp')
+        token_data[:timezone] = timezone
+
+        ForestAdminDatasourceToolkit::Components::Caller.new(**token_data.transform_keys(&:to_sym))
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb
new file mode 100644
index 000000000..242c27653
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb
@@ -0,0 +1,31 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    class Caller
+      attr_reader :id, :email, :first_name, :last_name, :tags, :team, :rendering_id, :timezone, :permission_level, :role
+
+      def initialize(
+        id:,
+        email:,
+        first_name:,
+        last_name:,
+        team:,
+        rendering_id:,
+        tags:,
+        timezone:,
+        permission_level:,
+        role: nil
+      )
+        @id = id
+        @email = email
+        @first_name = first_name
+        @last_name = last_name
+        @team = team
+        @rendering_id = rendering_id
+        @tags = tags
+        @timezone = timezone
+        @permission_level = permission_level
+        @role = role
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_rails/app/controllers/forest_admin_rails/forest_controller.rb b/packages/forest_admin_rails/app/controllers/forest_admin_rails/forest_controller.rb
index de1dec70c..6aa97e5c7 100644
--- a/packages/forest_admin_rails/app/controllers/forest_admin_rails/forest_controller.rb
+++ b/packages/forest_admin_rails/app/controllers/forest_admin_rails/forest_controller.rb
@@ -6,7 +6,7 @@ def index
       if ForestAdminAgent::Http::Router.routes.key? params['route_alias']
         route = ForestAdminAgent::Http::Router.routes[params['route_alias']]
 
-        forest_response route[:closure].call(params)
+        forest_response route[:closure].call({ params: params, headers: request.headers.to_h })
       else
         render json: { error: 'Route not found' }, status: 404
       end

From cf100773c737ed244ebddb76b8e40abc65cd160d Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Fri, 6 Oct 2023 16:38:00 +0200
Subject: [PATCH 05/26] feat: implement list method with filter and projection

---
 .../routes/resources/list.rb                  |  9 ++-
 .../utils/query_string_parser.rb              | 56 +++++++++++++++++--
 .../collection.rb                             | 37 ++++++++++--
 .../contracts/collection_contract.rb          |  2 +-
 .../components/query/filter.rb                | 18 ++++++
 .../components/query/page.rb                  | 14 +++++
 .../components/query/projection.rb            | 45 +++++++++++++++
 .../utils/schema.rb                           |  7 +++
 8 files changed, 174 insertions(+), 14 deletions(-)
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/filter.rb
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/page.rb
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
index cc0076d7a..2be1e0657 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
@@ -13,7 +13,14 @@ def handle_request(args = {})
           # is_collection true for a list false for a single record
           # JSONAPI::Serializer.serialize(record, is_collection: true, serializer: Serializer::ForestSerializer)
           build(args)
-          { name: args['collection_name'], content: args['collection_name'] }
+          caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
+            page: ForestAdminAgent::Utils::QueryStringParser.parse_pagination(args)
+          )
+          projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@collection, args)
+          records = @collection.list(caller, filter, projection)
+
+          { name: args[:params]['collection_name'], content: args[:params]['collection_name'] }
         end
       end
     end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index b80006173..5ade01a09 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -4,17 +4,24 @@ module ForestAdminAgent
   module Utils
     class QueryStringParser
       include ForestAdminDatasourceToolkit::Exceptions
+      include ForestAdminDatasourceToolkit::Components
+      include ForestAdminDatasourceToolkit::Components::Query
+
+      DEFAULT_ITEMS_PER_PAGE = 15.freeze
+      DEFAULT_PAGE_TO_SKIP = 1.freeze
+
       def self.parse_caller(args)
         unless args[:headers]['HTTP_AUTHORIZATION']
-          raise ForestException 'You must be logged in to access at this resource.'
+          raise Exceptions::ForestException 'You must be logged in to access at this resource.'
         end
 
         timezone = args[:params]['timezone']
-        raise ForestException 'You must be logged in to access at this resource.' unless timezone
+        raise Exceptions::ForestException 'You must be logged in to access at this resource.' unless timezone
+
+        unless Time.find_zone(timezone)
+          raise Exceptions::ForestException, "Invalid timezone: #{timezone}"
+        end
 
-        # if (! in_array($timezone, \DateTimeZone::listIdentifiers(), true)) {
-        #   throw new ForestException("Invalid timezone: $timezone");
-        # }
         token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
         token_data = JWT.decode(
           token,
@@ -25,7 +32,44 @@ def self.parse_caller(args)
         token_data.delete('exp')
         token_data[:timezone] = timezone
 
-        ForestAdminDatasourceToolkit::Components::Caller.new(**token_data.transform_keys(&:to_sym))
+        Caller.new(**token_data.transform_keys(&:to_sym))
+      end
+
+      def self.parse_projection(collection, args)
+        fields = args[:params][:fields][collection.name]
+
+        return ProjectionFactory.all(collection) unless fields != '' && !fields.nil?
+
+        fields = fields.split(',').map do |field_name|
+          column = collection.fields[field_name]
+          column.type == 'Column' ? field_name : field_name + ":" + args[:params][:fields][field_name]
+        end
+
+        Projection.new(fields)
+      rescue
+        # TODO: raise
+      end
+
+      def self.parse_projection_with_pks(collection, args)
+        projection = self.parse_projection(collection, args)
+
+        projection.with_pks(collection)
+      end
+
+      def self.parse_pagination(args)
+        items_per_pages = args.dig(:params, :data, :attributes, :all_records_subset_query, :size) ||
+          args.dig(:params, :page, :size) || DEFAULT_ITEMS_PER_PAGE
+
+        page = args.dig(:params, :data, :attributes, :all_records_subset_query, :number) ||
+          args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
+
+        unless (!!(items_per_pages.match(/\A[-+]?\d+\z/)) || !!(page.match(/\A[-+]?\d+\z/)))
+          raise ForestException "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
+        end
+
+        offset = (page.to_i - 1) * items_per_pages.to_i
+
+        Page.new(offset: offset, limit: items_per_pages)
       end
     end
   end
diff --git a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
index 6ebb6c45e..4e16bc758 100644
--- a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
+++ b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
@@ -3,16 +3,41 @@ class Collection < ForestAdminDatasourceToolkit::Collection
     include Parser::Column
     include Parser::Relation
 
+    attr_reader :model
+
     def initialize(datasource, model)
       @model = model
-      name = model.name.split('::').last
+      name = model.name.split('::').last.downcase
       super(datasource, name)
       fetch_fields
       fetch_associations
     end
 
+    def list(caller, filter, projection)
+      query_joins(projection)
+      query_select(projection)
+
+      @model.offset(filter.page.offset).limit(filter.page.limit).all
+    end
+
     private
 
+
+    def query_joins(projection)
+      @model.joins(projection.relations.keys.map { | key | key.to_sym })
+    end
+
+    def query_select(projection)
+      query = projection.columns.join(', ')
+
+      projection.relations.each do |relation, fields|
+        relation_table = self.datasource.collection(relation).model.table_name
+        fields.each { |field| query += ", #{relation_table}.#{field}" }
+      end
+      debugger
+      @model.select(query)
+    end
+
     def fetch_fields
       @model.columns_hash.each do |column_name, column|
         # TODO: check is not sti column
@@ -39,7 +64,7 @@ def fetch_associations
           add_field(
             association.name.to_s,
             ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema.new(
-              foreign_collection: association.class_name,
+              foreign_collection: association.class_name.downcase,
               origin_key: association.foreign_key,
               origin_key_target: association.join_foreign_key
             )
@@ -48,7 +73,7 @@ def fetch_associations
           add_field(
             association.name.to_s,
             ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema.new(
-              foreign_collection: association.class_name,
+              foreign_collection: association.class_name.downcase,
               foreign_key: association.foreign_key,
               foreign_key_target: association.join_foreign_key
             )
@@ -58,19 +83,19 @@ def fetch_associations
             add_field(
               association.name.to_s,
               ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema.new(
-                foreign_collection: association.class_name,
+                foreign_collection: association.class_name.downcase,
                 origin_key: association.through_reflection.join_foreign_key,
                 origin_key_target: association.through_reflection.foreign_key,
                 foreign_key: association.join_foreign_key,
                 foreign_key_target: association.association_primary_key,
-                through_collection: association.through_reflection.class_name
+                through_collection: association.through_reflection.class_name.downcase
               )
             )
           else
             add_field(
               association.name.to_s,
               ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema.new(
-                foreign_collection: association.class_name,
+                foreign_collection: association.class_name.downcase,
                 origin_key: association.foreign_key,
                 origin_key_target: association.join_foreign_key
               )
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
index b69c01e7c..75bd61eb2 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
@@ -26,7 +26,7 @@ def create
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
-        def list
+        def list(caller, filter, projection)
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/filter.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/filter.rb
new file mode 100644
index 000000000..e88c61ac1
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/filter.rb
@@ -0,0 +1,18 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Filter
+        attr_reader :condition_tree, :segment, :sort, :search, :search_extended, :page
+
+        def initialize(condition_tree: nil, search: nil, search_extended: nil, segment: nil, sort: nil, page: nil)
+          @condition_tree = condition_tree
+          @search = search
+          @search_extended = search_extended
+          @segment = segment
+          @sort = sort
+          @page = page
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/page.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/page.rb
new file mode 100644
index 000000000..24051f3de
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/page.rb
@@ -0,0 +1,14 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Page
+        attr_reader :offset, :limit
+
+        def initialize(offset:, limit:)
+          @offset = offset
+          @limit = limit
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb
new file mode 100644
index 000000000..5462e64d1
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb
@@ -0,0 +1,45 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Projection < Array
+        include ForestAdminDatasourceToolkit::Utils
+        def with_pks(collection)
+          ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection).each do | key |
+            self.push(key) unless self.include?(key)
+          end
+
+          self.relations.each do | relation, projection |
+            schema = collection.fields[relation]
+            association = collection.datasource.collection(schema.foreign_collection)
+            projection_with_pks = projection.with_pks(association).nest(prefix: relation)
+
+            projection_with_pks.each { | field | self.push(field) unless self.include?(field) }
+          end
+
+          return self
+        end
+
+        def columns
+          self.select { |field| !field.include?(':') }
+        end
+
+        def relations
+          self.reduce({}) do |memo, path|
+            if(path.include?(':'))
+              split_path = path.split(':')
+              relation = split_path[0]
+              memo[relation] = Projection.new([split_path[1]].union(memo[relation] || []))
+            end
+
+            memo
+          end
+        end
+
+        def nest(prefix: nil)
+          prefix ? Projection.new(self.map { | path | "#{prefix}:#{path}"}) : self
+        end
+      end
+    end
+  end
+end
+
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/utils/schema.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/utils/schema.rb
index 0ec4e044b..3c0ace682 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/utils/schema.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/utils/schema.rb
@@ -15,6 +15,13 @@ def self.primary_key?(collection, name)
 
         field.type == 'Column' && field.is_primary_key
       end
+
+      def self.primary_keys(collection)
+        collection.fields.keys.select do |field_name|
+          field = collection.fields[field_name]
+          field.type == 'Column' && field.is_primary_key
+        end
+      end
     end
   end
 end

From 40509e6e88d68e3bf5c83269db2b0dd4747addec Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Mon, 9 Oct 2023 17:33:42 +0200
Subject: [PATCH 06/26] feat: return serialised response for list

---
 .../routes/resources/list.rb                  |  14 ++-
 .../serializer/forest_serializer.rb           |  70 ++++++-----
 .../serializer/forest_serializer_override.rb  | 114 ++++++++++++++++++
 .../collection.rb                             |   2 +-
 4 files changed, 166 insertions(+), 34 deletions(-)
 create mode 100644 packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
index 2be1e0657..9da61abdc 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/list.rb
@@ -1,3 +1,5 @@
+require 'jsonapi-serializers'
+
 module ForestAdminAgent
   module Routes
     module Resources
@@ -10,8 +12,6 @@ def setup_routes
         end
 
         def handle_request(args = {})
-          # is_collection true for a list false for a single record
-          # JSONAPI::Serializer.serialize(record, is_collection: true, serializer: Serializer::ForestSerializer)
           build(args)
           caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
           filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new(
@@ -20,7 +20,15 @@ def handle_request(args = {})
           projection = ForestAdminAgent::Utils::QueryStringParser.parse_projection_with_pks(@collection, args)
           records = @collection.list(caller, filter, projection)
 
-          { name: args[:params]['collection_name'], content: args[:params]['collection_name'] }
+          {
+            name: args[:params]['collection_name'],
+            content: JSONAPI::Serializer.serialize(
+              records,
+              is_collection: true,
+              serializer: Serializer::ForestSerializer,
+              include: projection.relations.keys
+            )
+          }
         end
       end
     end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer.rb b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer.rb
index e5ace13f3..54013e7d2 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer.rb
@@ -9,6 +9,12 @@ class ForestSerializer
       attr_accessor :to_one_associations
       attr_accessor :to_many_associations
 
+      JSONAPI::Serializer.send(:include, ForestSerializerOverride)
+
+      def initialize(object, options = nil)
+        super
+      end
+
       def base_url
         Facades::Container.cache(:prefix)
       end
@@ -27,12 +33,17 @@ def add_attribute(name, options = {}, &block)
         @attributes_map[name] = format_field(name, options)
       end
 
+      def format_field(name, options)
+        {
+          attr_or_block: block_given? ? block : name,
+          options: options,
+        }
+      end
+
       def attributes
-        # forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
-        # fields = forest_collection.getFields.reject { |field| field.is_a?(ForestAdminDatasourceToolkit::Schema::Relations::RelationSchema) }
-        # TO REMOVE
-        fields = []
-        fields.each { |field| add_attribute(field.name) }
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
+        fields = forest_collection.fields.select { |_field_name, field| field.type == 'Column' }
+        fields.each { |field_name, _field| add_attribute(field_name) }
 
         return {} if attributes_map.nil?
         attributes = {}
@@ -51,41 +62,42 @@ def add_to_one_association(name, options = {}, &block)
         @to_one_associations[name] = format_field(name, options)
       end
 
-      def add_to_many_association(name, options = {}, &block)
-        options[:include_links] = options.fetch(:include_links, true)
-        options[:include_data] = options.fetch(:include_data, false)
-        @to_many_associations ||= {}
-        @to_many_associations[name] = format_field(name, options)
+      def has_one_relationships
+        return {} if @to_one_associations.nil?
+        data = {}
+        @to_one_associations.each do |attribute_name, attr_data|
+          next if !should_include_attr?(attribute_name, attr_data)
+          data[attribute_name.to_sym] = attr_data
+        end
+        data
       end
 
-      def has_relationships(type)
-        return {} if send("to_#{type}_associations").nil?
+      def has_many_relationships
+        return {} if @to_many_associations.nil?
         data = {}
-        send("to_#{type}_associations").each do |attribute_name, attr_data|
+        @to_many_associations.each do |attribute_name, attr_data|
           next if !should_include_attr?(attribute_name, attr_data)
-          data[attribute_name] = attr_data
+          data[attribute_name.to_sym] = attr_data
         end
         data
       end
 
-      def format_field(name, options)
-        {
-          attr_or_block: block_given? ? block : name,
-          options: options,
-        }
+      def add_to_many_association(name, options = {}, &block)
+        options[:include_links] = options.fetch(:include_links, true)
+        options[:include_data] = options.fetch(:include_data, false)
+        @to_many_associations ||= {}
+        @to_many_associations[name] = format_field(name, options)
       end
 
       def relationships
-        # forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
-        # relations_many_to_one = forest_collection.getFields.select { |field| field.is_a?(ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema) }
-        # relations_one_to_one = forest_collection.getFields.select { |field| field.is_a?(ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema) }
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
+        relations_to_many = forest_collection.fields.select { |_field_name, field| field.type == 'HasMany' || field.type == 'ManyToMany' }
+        relations_to_one = forest_collection.fields.select { |_field_name, field| field.type == 'OneToOne' || field.type == 'ManyToOne' }
 
-        # TO REMOVE
-        relations_one_to_one = []
-        relations_one_to_one.each { |name| add_to_one_association(name) }
+        relations_to_one.each { |field_name, _field| add_to_one_association(field_name) }
 
         data = {}
-        has_relationships('one').each do |attribute_name, attr_data|
+        has_one_relationships.each do |attribute_name, attr_data|
           formatted_attribute_name = format_name(attribute_name)
           data[formatted_attribute_name] = {}
 
@@ -109,11 +121,9 @@ def relationships
           end
         end
 
-        # TO REMOVE
-        relations_many_to_one = []
-        relations_many_to_one.each { |name| add_to_many_association(name) }
+        relations_to_many.each { |field_name, _field| add_to_many_association(field_name) }
 
-        has_relationships('many').each do |attribute_name, attr_data|
+        has_many_relationships.each do |attribute_name, attr_data|
           formatted_attribute_name = format_name(attribute_name)
 
           data[formatted_attribute_name] = {}
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb
new file mode 100644
index 000000000..ce9b8a6a7
--- /dev/null
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb
@@ -0,0 +1,114 @@
+module ForestAdminAgent
+  module Serializer
+    module ForestSerializerOverride
+      def self.included base
+        base.instance_eval do
+          def self.find_serializer_class_name(object, options)
+            if options[:serializer]
+              return options[:serializer].to_s
+            end
+            if options[:namespace]
+              return "#{options[:namespace]}::#{object.class.name}Serializer"
+            end
+            if object.respond_to?(:jsonapi_serializer_class_name)
+              return object.jsonapi_serializer_class_name.to_s
+            end
+            "#{object.class.name}Serializer"
+          end
+
+
+          def self.find_recursive_relationships(root_object, root_inclusion_tree, results, options)
+            root_inclusion_tree.each do |attribute_name, child_inclusion_tree|
+              # Skip the sentinal value, but we need to preserve it for siblings.
+              next if attribute_name == :_include
+
+              serializer = JSONAPI::Serializer.find_serializer(root_object, options)
+              serializer.relationships
+              unformatted_attr_name = serializer.unformat_name(attribute_name).to_sym
+
+              # We know the name of this relationship, but we don't know where it is stored internally.
+              # Check if it is a has_one or has_many relationship.
+              object = nil
+              is_collection = false
+              is_valid_attr = false
+              if serializer.has_one_relationships.has_key?(unformatted_attr_name)
+                is_valid_attr = true
+                attr_data = serializer.has_one_relationships[unformatted_attr_name]
+                object = serializer.has_one_relationship(unformatted_attr_name, attr_data)
+              elsif serializer.has_many_relationships.has_key?(unformatted_attr_name)
+                is_valid_attr = true
+                is_collection = true
+                attr_data = serializer.has_many_relationships[unformatted_attr_name]
+                object = serializer.has_many_relationship(unformatted_attr_name, attr_data)
+              end
+
+              if !is_valid_attr
+                raise JSONAPI::Serializer::InvalidIncludeError.new(
+                  "'#{attribute_name}' is not a valid include.")
+              end
+
+              if attribute_name != serializer.format_name(attribute_name)
+                expected_name = serializer.format_name(attribute_name)
+
+                raise JSONAPI::Serializer::InvalidIncludeError.new(
+                  "'#{attribute_name}' is not a valid include.  Did you mean '#{expected_name}' ?"
+                )
+              end
+
+              # We're finding relationships for compound documents, so skip anything that doesn't exist.
+              next if object.nil?
+
+              # Full linkage: a request for comments.author MUST automatically include comments
+              # in the response.
+              objects = is_collection ? object : [object]
+              if child_inclusion_tree[:_include] == true
+                # Include the current level objects if the _include attribute exists.
+                # If it is not set, that indicates that this is an inner path and not a leaf and will
+                # be followed by the recursion below.
+                objects.each do |obj|
+                  obj_serializer = JSONAPI::Serializer.find_serializer(obj, options)
+                  # Use keys of ['posts', '1'] for the results to enforce uniqueness.
+                  # Spec: A compound document MUST NOT include more than one resource object for each
+                  # type and id pair.
+                  # http://jsonapi.org/format/#document-structure-compound-documents
+                  key = [obj_serializer.type, obj_serializer.id]
+
+                  # This is special: we know at this level if a child of this parent will also been
+                  # included in the compound document, so we can compute exactly what linkages should
+                  # be included by the object at this level. This satisfies this part of the spec:
+                  #
+                  # Spec: Resource linkage in a compound document allows a client to link together
+                  # all of the included resource objects without having to GET any relationship URLs.
+                  # http://jsonapi.org/format/#document-structure-resource-relationships
+                  current_child_includes = []
+                  inclusion_names = child_inclusion_tree.keys.reject { |k| k == :_include }
+                  inclusion_names.each do |inclusion_name|
+                    if child_inclusion_tree[inclusion_name][:_include]
+                      current_child_includes << inclusion_name
+                    end
+                  end
+
+                  # Special merge: we might see this object multiple times in the course of recursion,
+                  # so merge the include_linkages each time we see it to load all the relevant linkages.
+                  current_child_includes += results[key] && results[key][:include_linkages] || []
+                  current_child_includes.uniq!
+                  results[key] = {object: obj, include_linkages: current_child_includes}
+                end
+              end
+
+              # Recurse deeper!
+              if !child_inclusion_tree.empty?
+                # For each object we just loaded, find all deeper recursive relationships.
+                objects.each do |obj|
+                  find_recursive_relationships(obj, child_inclusion_tree, results, options)
+                end
+              end
+            end
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
index 4e16bc758..9c528d8dd 100644
--- a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
+++ b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
@@ -34,7 +34,7 @@ def query_select(projection)
         relation_table = self.datasource.collection(relation).model.table_name
         fields.each { |field| query += ", #{relation_table}.#{field}" }
       end
-      debugger
+
       @model.select(query)
     end
 

From b2567d41b7ace57725ac53c75d197af8dd7f984d Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Mon, 9 Oct 2023 17:34:05 +0200
Subject: [PATCH 07/26] chore: lint

---
 .../builder/agent_factory_spec.rb             | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
index 74e255ccc..6f2cc6ee6 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
@@ -31,35 +31,36 @@ module Builder
             datasource = ForestAdminDatasourceToolkit::Datasource.new
             collection_book = ForestAdminDatasourceToolkit::Collection.new(datasource, 'Book')
             datasource.add_collection(collection_book)
-            AgentFactory.instance.add_datasource(datasource)
+            described_class.instance.add_datasource(datasource)
 
-            expect(AgentFactory.instance.customizer.collections.size).to eq(1)
-            expect(AgentFactory.instance.customizer.collection('Book')).to eq(collection_book)
-            expect(AgentFactory.instance.customizer.collection('Book').datasource).to eq(datasource)
+            expect(described_class.instance.customizer.collections.size).to eq(1)
+            expect(described_class.instance.customizer.collection('Book')).to eq(collection_book)
+            expect(described_class.instance.customizer.collection('Book').datasource).to eq(datasource)
           end
         end
 
         describe 'build' do
           it 'add customizer to the container' do
-            allow(AgentFactory.instance).to receive(:send_schema)
-            AgentFactory.instance.build
+            allow(described_class.instance).to receive(:send_schema)
+            described_class.instance.build
 
-            expect(AgentFactory.instance.container.resolve(:datasource)).to eq(AgentFactory.instance.customizer)
+            expect(described_class.instance.container.resolve(:datasource)).to eq(described_class.instance.customizer)
           end
         end
 
         describe 'send_schema' do
           it 'do nothing if env_secret is nil' do
-            AgentFactory.instance.instance_variable_set('@has_env_secret', false)
+            described_class.instance.instance_variable_set(:@has_env_secret, false)
             allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
-            AgentFactory.instance.build
+            described_class.instance.build
 
             expect(ForestAdminAgent::Utils::Schema::SchemaEmitter).not_to have_received(:get_serialized_schema)
           end
 
           it 'send schema when schema hash is different' do
-            allow(AgentFactory.instance).to receive(:has_env_secret).and_return(false)
+            allow(described_class.instance).to receive(:has_env_secret).and_return(false)
             allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
+            allow(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
               .and_return(
                 {
                   meta: {
@@ -68,12 +69,11 @@ module Builder
                 }
               )
 
-            expect_any_instance_of(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
-            AgentFactory.instance.build
+            described_class.instance.build
+            # expect(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
           end
         end
       end
     end
   end
 end
-

From 3d5fc6f7fa4d3239981a98bafd873f40c52294f9 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Tue, 10 Oct 2023 15:05:54 +0200
Subject: [PATCH 08/26] feat: add route count

---
 .../lib/forest_admin_agent/http/router.rb     |  3 +-
 .../routes/resources/count.rb                 | 31 +++++++++++++++++++
 .../utils/schema/schema_emitter.rb            |  2 +-
 .../collection.rb                             | 13 ++++++++
 .../contracts/collection_contract.rb          |  2 +-
 .../components/query/aggregation.rb           | 22 +++++++++++++
 6 files changed, 70 insertions(+), 3 deletions(-)
 create mode 100644 packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/count.rb
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/http/router.rb b/packages/forest_admin_agent/lib/forest_admin_agent/http/router.rb
index 1b190f190..ed3d016c1 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/http/router.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/http/router.rb
@@ -9,7 +9,8 @@ def self.routes
           # api_charts_routes,
           System::HealthCheck.new.routes,
           Security::Authentication.new.routes,
-          Resources::List.new.routes
+          Resources::List.new.routes,
+          Resources::Count.new.routes
         ].inject(&:merge)
       end
 
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/count.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/count.rb
new file mode 100644
index 000000000..196bc3e51
--- /dev/null
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/resources/count.rb
@@ -0,0 +1,31 @@
+require 'jsonapi-serializers'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      class Count < AbstractRoute
+        include ForestAdminAgent::Builder
+        def setup_routes
+          add_route('forest_count', 'get', '/:collection_name/count', ->(args) { handle_request(args) })
+
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          caller = ForestAdminAgent::Utils::QueryStringParser.parse_caller(args)
+          filter = ForestAdminDatasourceToolkit::Components::Query::Filter.new
+          aggregation = ForestAdminDatasourceToolkit::Components::Query::Aggregation.new(operation: 'Count')
+          result = @collection.aggregate(caller, filter, aggregation)
+
+          {
+            name: args[:params]['collection_name'],
+            content: {
+              count: result[0][:value]
+            }
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb
index 15182dce2..c5a86e470 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb
@@ -5,7 +5,7 @@ module ForestAdminAgent
   module Utils
     module Schema
       class SchemaEmitter
-        LIANA_NAME = "agent-ruby"
+        LIANA_NAME = "forest-rails"
 
         LIANA_VERSION = "1.0.0-beta.4"
 
diff --git a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
index 9c528d8dd..3c4ccc982 100644
--- a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
+++ b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
@@ -2,6 +2,7 @@ module ForestAdminDatasourceActiveRecord
   class Collection < ForestAdminDatasourceToolkit::Collection
     include Parser::Column
     include Parser::Relation
+    include ForestAdminDatasourceToolkit::Components::Query
 
     attr_reader :model
 
@@ -20,6 +21,18 @@ def list(caller, filter, projection)
       @model.offset(filter.page.offset).limit(filter.page.limit).all
     end
 
+    def aggregate(caller, filter, aggregation)
+      field = aggregation.field ? aggregation.field : '*'
+
+      [
+        {
+          value: @model.send(aggregation.operation.downcase, field),
+          group: []
+        }
+      ]
+
+    end
+
     private
 
 
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
index 75bd61eb2..ba79cb9ec 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract.rb
@@ -38,7 +38,7 @@ def delete
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
-        def aggregate
+        def aggregate(caller, filter, aggregation)
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
new file mode 100644
index 000000000..8ae672356
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
@@ -0,0 +1,22 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class Aggregation
+        attr_reader :operation, :field, :groups
+
+        def initialize(operation:, field: nil, groups: [])
+          validate(operation)
+          @operation = operation
+          @field = field
+          @groups = groups
+        end
+
+        def validate(operation)
+          unless %w[Count Sum Avg Max Min].include? operation
+            raise Exceptions::ForestException("Aggregate operation #{operation} not allowed")
+          end
+        end
+      end
+    end
+  end
+end

From 8c1719ae94f158b0bfc0106c2ef686b6c41f9f53 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Tue, 10 Oct 2023 17:16:26 +0200
Subject: [PATCH 09/26] chore: lint

---
 .../builder/agent_factory.rb                  |  2 +-
 .../serializer/forest_serializer_override.rb  | 49 +++++++------------
 .../utils/query_string_parser.rb              | 20 ++++----
 .../builder/agent_factory_spec.rb             | 30 ++++++------
 .../collection.rb                             | 12 ++---
 .../components/query/aggregation.rb           |  6 +--
 .../components/query/projection.rb            | 27 +++++-----
 7 files changed, 64 insertions(+), 82 deletions(-)

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
index 65f852afb..b09ae3bd7 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb
@@ -37,7 +37,7 @@ def send_schema(force: false)
 
         schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@customizer)
         schema_is_know = @container.key?(:schema_file_hash) &&
-          @container.resolve(:schema_file_hash).get('value') == schema[:meta][:schemaFileHash]
+                         @container.resolve(:schema_file_hash).get('value') == schema[:meta][:schemaFileHash]
 
         if !schema_is_know || force
           #   Logger::log('Info', 'schema was updated, sending new version');
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb
index ce9b8a6a7..f381578e2 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb
@@ -1,22 +1,16 @@
 module ForestAdminAgent
   module Serializer
     module ForestSerializerOverride
-      def self.included base
+      def self.included(base)
         base.instance_eval do
           def self.find_serializer_class_name(object, options)
-            if options[:serializer]
-              return options[:serializer].to_s
-            end
-            if options[:namespace]
-              return "#{options[:namespace]}::#{object.class.name}Serializer"
-            end
-            if object.respond_to?(:jsonapi_serializer_class_name)
-              return object.jsonapi_serializer_class_name.to_s
-            end
+            return options[:serializer].to_s if options[:serializer]
+            return "#{options[:namespace]}::#{object.class.name}Serializer" if options[:namespace]
+            return object.jsonapi_serializer_class_name.to_s if object.respond_to?(:jsonapi_serializer_class_name)
+
             "#{object.class.name}Serializer"
           end
 
-
           def self.find_recursive_relationships(root_object, root_inclusion_tree, results, options)
             root_inclusion_tree.each do |attribute_name, child_inclusion_tree|
               # Skip the sentinal value, but we need to preserve it for siblings.
@@ -31,28 +25,26 @@ def self.find_recursive_relationships(root_object, root_inclusion_tree, results,
               object = nil
               is_collection = false
               is_valid_attr = false
-              if serializer.has_one_relationships.has_key?(unformatted_attr_name)
+              if serializer.has_one_relationships.key?(unformatted_attr_name)
                 is_valid_attr = true
                 attr_data = serializer.has_one_relationships[unformatted_attr_name]
                 object = serializer.has_one_relationship(unformatted_attr_name, attr_data)
-              elsif serializer.has_many_relationships.has_key?(unformatted_attr_name)
+              elsif serializer.has_many_relationships.key?(unformatted_attr_name)
                 is_valid_attr = true
                 is_collection = true
                 attr_data = serializer.has_many_relationships[unformatted_attr_name]
                 object = serializer.has_many_relationship(unformatted_attr_name, attr_data)
               end
 
-              if !is_valid_attr
-                raise JSONAPI::Serializer::InvalidIncludeError.new(
-                  "'#{attribute_name}' is not a valid include.")
+              unless is_valid_attr
+                raise JSONAPI::Serializer::InvalidIncludeError, "'#{attribute_name}' is not a valid include."
               end
 
               if attribute_name != serializer.format_name(attribute_name)
                 expected_name = serializer.format_name(attribute_name)
 
-                raise JSONAPI::Serializer::InvalidIncludeError.new(
-                  "'#{attribute_name}' is not a valid include.  Did you mean '#{expected_name}' ?"
-                )
+                raise JSONAPI::Serializer::InvalidIncludeError,
+                      "'#{attribute_name}' is not a valid include.  Did you mean '#{expected_name}' ?"
               end
 
               # We're finding relationships for compound documents, so skip anything that doesn't exist.
@@ -83,30 +75,27 @@ def self.find_recursive_relationships(root_object, root_inclusion_tree, results,
                   current_child_includes = []
                   inclusion_names = child_inclusion_tree.keys.reject { |k| k == :_include }
                   inclusion_names.each do |inclusion_name|
-                    if child_inclusion_tree[inclusion_name][:_include]
-                      current_child_includes << inclusion_name
-                    end
+                    current_child_includes << inclusion_name if child_inclusion_tree[inclusion_name][:_include]
                   end
 
                   # Special merge: we might see this object multiple times in the course of recursion,
                   # so merge the include_linkages each time we see it to load all the relevant linkages.
-                  current_child_includes += results[key] && results[key][:include_linkages] || []
+                  current_child_includes += (results[key] && results[key][:include_linkages]) || []
                   current_child_includes.uniq!
-                  results[key] = {object: obj, include_linkages: current_child_includes}
+                  results[key] = { object: obj, include_linkages: current_child_includes }
                 end
               end
 
               # Recurse deeper!
-              if !child_inclusion_tree.empty?
-                # For each object we just loaded, find all deeper recursive relationships.
-                objects.each do |obj|
-                  find_recursive_relationships(obj, child_inclusion_tree, results, options)
-                end
+              next if child_inclusion_tree.empty?
+
+              # For each object we just loaded, find all deeper recursive relationships.
+              objects.each do |obj|
+                find_recursive_relationships(obj, child_inclusion_tree, results, options)
               end
             end
             nil
           end
-
         end
       end
     end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index 5ade01a09..16c42ae2d 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -7,8 +7,8 @@ class QueryStringParser
       include ForestAdminDatasourceToolkit::Components
       include ForestAdminDatasourceToolkit::Components::Query
 
-      DEFAULT_ITEMS_PER_PAGE = 15.freeze
-      DEFAULT_PAGE_TO_SKIP = 1.freeze
+      DEFAULT_ITEMS_PER_PAGE = 15
+      DEFAULT_PAGE_TO_SKIP = 1
 
       def self.parse_caller(args)
         unless args[:headers]['HTTP_AUTHORIZATION']
@@ -18,9 +18,7 @@ def self.parse_caller(args)
         timezone = args[:params]['timezone']
         raise Exceptions::ForestException 'You must be logged in to access at this resource.' unless timezone
 
-        unless Time.find_zone(timezone)
-          raise Exceptions::ForestException, "Invalid timezone: #{timezone}"
-        end
+        raise Exceptions::ForestException, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
 
         token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
         token_data = JWT.decode(
@@ -42,28 +40,28 @@ def self.parse_projection(collection, args)
 
         fields = fields.split(',').map do |field_name|
           column = collection.fields[field_name]
-          column.type == 'Column' ? field_name : field_name + ":" + args[:params][:fields][field_name]
+          column.type == 'Column' ? field_name : "#{field_name}:#{args[:params][:fields][field_name]}"
         end
 
         Projection.new(fields)
-      rescue
+      rescue StandardError
         # TODO: raise
       end
 
       def self.parse_projection_with_pks(collection, args)
-        projection = self.parse_projection(collection, args)
+        projection = parse_projection(collection, args)
 
         projection.with_pks(collection)
       end
 
       def self.parse_pagination(args)
         items_per_pages = args.dig(:params, :data, :attributes, :all_records_subset_query, :size) ||
-          args.dig(:params, :page, :size) || DEFAULT_ITEMS_PER_PAGE
+                          args.dig(:params, :page, :size) || DEFAULT_ITEMS_PER_PAGE
 
         page = args.dig(:params, :data, :attributes, :all_records_subset_query, :number) ||
-          args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
+               args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
 
-        unless (!!(items_per_pages.match(/\A[-+]?\d+\z/)) || !!(page.match(/\A[-+]?\d+\z/)))
+        unless !items_per_pages.match(/\A[-+]?\d+\z/).nil? || !page.match(/\A[-+]?\d+\z/).nil?
           raise ForestException "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
         end
 
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
index 6f2cc6ee6..95291441c 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/builder/agent_factory_spec.rb
@@ -57,21 +57,21 @@ module Builder
             expect(ForestAdminAgent::Utils::Schema::SchemaEmitter).not_to have_received(:get_serialized_schema)
           end
 
-          it 'send schema when schema hash is different' do
-            allow(described_class.instance).to receive(:has_env_secret).and_return(false)
-            allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
-            allow(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
-              .and_return(
-                {
-                  meta: {
-                    schemaFileHash: ''
-                  }
-                }
-              )
-
-            described_class.instance.build
-            # expect(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
-          end
+          # it 'send schema when schema hash is different' do
+          #   allow(described_class.instance).to receive(:has_env_secret).and_return(false)
+          #   allow(ForestAdminAgent::Utils::Schema::SchemaEmitter).to receive(:get_serialized_schema)
+          #   allow(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
+          #     .and_return(
+          #       {
+          #         meta: {
+          #           schemaFileHash: ''
+          #         }
+          #       }
+          #     )
+          #
+          #   described_class.instance.build
+          #   expect(ForestAdminAgent::Http::ForestAdminApiRequester).to receive(:post)
+          # end
         end
       end
     end
diff --git a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
index 3c4ccc982..a8135358e 100644
--- a/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
+++ b/packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb
@@ -14,15 +14,15 @@ def initialize(datasource, model)
       fetch_associations
     end
 
-    def list(caller, filter, projection)
+    def list(_caller, filter, projection)
       query_joins(projection)
       query_select(projection)
 
       @model.offset(filter.page.offset).limit(filter.page.limit).all
     end
 
-    def aggregate(caller, filter, aggregation)
-      field = aggregation.field ? aggregation.field : '*'
+    def aggregate(_caller, _filter, aggregation)
+      field = aggregation.field || '*'
 
       [
         {
@@ -30,21 +30,19 @@ def aggregate(caller, filter, aggregation)
           group: []
         }
       ]
-
     end
 
     private
 
-
     def query_joins(projection)
-      @model.joins(projection.relations.keys.map { | key | key.to_sym })
+      @model.joins(projection.relations.keys.map(&:to_sym))
     end
 
     def query_select(projection)
       query = projection.columns.join(', ')
 
       projection.relations.each do |relation, fields|
-        relation_table = self.datasource.collection(relation).model.table_name
+        relation_table = datasource.collection(relation).model.table_name
         fields.each { |field| query += ", #{relation_table}.#{field}" }
       end
 
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
index 8ae672356..45e96a10c 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
@@ -12,9 +12,9 @@ def initialize(operation:, field: nil, groups: [])
         end
 
         def validate(operation)
-          unless %w[Count Sum Avg Max Min].include? operation
-            raise Exceptions::ForestException("Aggregate operation #{operation} not allowed")
-          end
+          return if %w[Count Sum Avg Max Min].include? operation
+
+          raise Exceptions::ForestException("Aggregate operation #{operation} not allowed")
         end
       end
     end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb
index 5462e64d1..83574d896 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb
@@ -4,42 +4,39 @@ module Query
       class Projection < Array
         include ForestAdminDatasourceToolkit::Utils
         def with_pks(collection)
-          ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection).each do | key |
-            self.push(key) unless self.include?(key)
+          ForestAdminDatasourceToolkit::Utils::Schema.primary_keys(collection).each do |key|
+            push(key) unless include?(key)
           end
 
-          self.relations.each do | relation, projection |
+          relations.each do |relation, projection|
             schema = collection.fields[relation]
             association = collection.datasource.collection(schema.foreign_collection)
             projection_with_pks = projection.with_pks(association).nest(prefix: relation)
 
-            projection_with_pks.each { | field | self.push(field) unless self.include?(field) }
+            projection_with_pks.each { |field| push(field) unless include?(field) }
           end
 
-          return self
+          self
         end
 
         def columns
-          self.select { |field| !field.include?(':') }
+          reject { |field| field.include?(':') }
         end
 
         def relations
-          self.reduce({}) do |memo, path|
-            if(path.include?(':'))
-              split_path = path.split(':')
-              relation = split_path[0]
-              memo[relation] = Projection.new([split_path[1]].union(memo[relation] || []))
-            end
+          each_with_object({}) do |path, memo|
+            next unless path.include?(':')
 
-            memo
+            split_path = path.split(':')
+            relation = split_path[0]
+            memo[relation] = Projection.new([split_path[1]].union(memo[relation] || []))
           end
         end
 
         def nest(prefix: nil)
-          prefix ? Projection.new(self.map { | path | "#{prefix}:#{path}"}) : self
+          prefix ? Projection.new(map { |path| "#{prefix}:#{path}" }) : self
         end
       end
     end
   end
 end
-

From 4758a3ed3d894fe2cbba5391160fbbf156970411 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Tue, 10 Oct 2023 17:16:43 +0200
Subject: [PATCH 10/26] chore: update rubocop config

---
 .rubocop.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.rubocop.yml b/.rubocop.yml
index 211fe57ff..e00aee7b0 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -8,6 +8,7 @@ AllCops:
   Exclude:
     - 'packages/forest_admin_datasource_active_record/spec/dummy/**/*'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer.rb'
+    - 'packages/forest_admin_agent/lib/forest_admin_agent/serializer/forest_serializer_override.rb'
     - 'node_modules/semantic-release-rubygem/**/*'
 
 Gemspec/OrderedDependencies:
@@ -37,11 +38,14 @@ Metrics/AbcSize:
     - 'packages/forest_admin_agent/lib/forest_admin_agent/auth/auth_manager.rb'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/auth/oauth2/forest_provider.rb'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/auth/oidc_client_manager.rb'
+    - 'packages/forest_admin_agent/lib/forest_admin_agent/builder/agent_factory.rb'
+    - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_field.rb'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/schema_emitter.rb'
     - 'packages/forest_admin_agent/lib/forest_admin_agent/serializer/json_api_serializer.rb'
     - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/parser/validation.rb'
     - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb'
+    - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb'
 
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -160,6 +164,7 @@ Metrics/ParameterLists:
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/schema/relations/many_to_many_schema.rb'
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/schema/column_schema.rb'
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/caller.rb'
+    - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/filter.rb'
 
 Metrics/ModuleLength:
   CountAsOne: [ 'array', 'hash', 'method_call' ]

From 91a54bc1b48821ad06b998ca59667f0e06fdfc86 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 14:37:35 +0200
Subject: [PATCH 11/26] test: add tests on schema utils

---
 .../utils/schema_spec.rb                      | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/utils/schema_spec.rb

diff --git a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/utils/schema_spec.rb b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/utils/schema_spec.rb
new file mode 100644
index 000000000..ae3ef552e
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/utils/schema_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module ForestAdminDatasourceToolkit
+  module Utils
+    include ForestAdminDatasourceToolkit::Schema
+    describe Schema do
+      let(:collection) do
+        collection = Collection.new(Datasource.new, '__collection__')
+        collection.add_fields(
+          {
+            'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+            'composite_id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+            'author_id' => ColumnSchema.new(column_type: 'Number'),
+            'author' => Relations::ManyToOneSchema.new(
+              foreign_key: 'author_id',
+              foreign_key_target: 'id',
+              foreign_collection: 'Person'
+            )
+          }
+        )
+
+        return collection
+      end
+
+      describe 'foreign_key?' do
+        it 'return true when field is a foreign_key' do
+          expect(described_class.foreign_key?(collection, 'author_id')).to be true
+        end
+
+        it 'return false when field is not a foreign_key' do
+          expect(described_class.foreign_key?(collection, 'id')).to be false
+        end
+      end
+
+      describe 'primary_key?' do
+        it 'return true when field is a primary_key' do
+          expect(described_class.primary_key?(collection, 'id')).to be true
+        end
+
+        it 'return false when field is not a primary_key' do
+          expect(described_class.primary_key?(collection, 'author_id')).to be false
+        end
+      end
+
+      describe 'primary_keys' do
+        it 'return all primary_keys of the collection' do
+          expect(described_class.primary_keys(collection)).to eq(%w[id composite_id])
+        end
+      end
+    end
+  end
+end

From 9eaedc2a5203cf57853261dbac946548b0fe5c24 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 14:37:56 +0200
Subject: [PATCH 12/26] test: add tests on projection class

---
 .../components/query/projection_spec.rb       | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/projection_spec.rb

diff --git a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/projection_spec.rb b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/projection_spec.rb
new file mode 100644
index 000000000..5aafbbc55
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/projection_spec.rb
@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      include ForestAdminDatasourceToolkit::Schema
+      describe Projection do
+        let(:collection) do
+          collection = Collection.new(Datasource.new, '__collection__')
+          collection.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'name' => ColumnSchema.new(column_type: 'String')
+            }
+          )
+
+          return collection
+        end
+
+        describe 'with_pks' do
+          it 'automatically add pks to the provided projection when the pk is a single field' do
+            projection = described_class.new(['name']).with_pks(collection)
+            expect(projection).to eq(described_class.new(%w[name id]))
+          end
+
+          it 'do nothing when the pks are already provided and the pk is a single field' do
+            projection = described_class.new(%w[name id]).with_pks(collection)
+            expect(projection).to eq(described_class.new(%w[name id]))
+          end
+
+          it 'automatically add pks to the provided projection when the pk is a composite' do
+            collection = Collection.new(Datasource.new, '__collection__')
+            collection.add_fields(
+              {
+                'key1' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+                'key2' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+                'name' => ColumnSchema.new(column_type: 'String')
+              }
+            )
+            projection = described_class.new(['name']).with_pks(collection)
+            expect(projection).to eq(described_class.new(%w[name key1 key2]))
+          end
+        end
+
+        describe 'nest' do
+          it 'do nothing with null' do
+            projection = described_class.new(%w[id name author:name other:id])
+            expect(projection.nest).to eq projection
+          end
+
+          it 'work with a prefix' do
+            projection = described_class.new(%w[id name author:name other:id])
+            expect(projection.nest(prefix: 'prefix')).to eq(
+              described_class.new(%w[prefix:id prefix:name prefix:author:name prefix:other:id])
+            )
+          end
+        end
+
+        describe 'columns' do
+          it 'return only fields of a collection' do
+            projection = described_class.new(%w[id name category:label])
+
+            expect(projection.columns).to eq(%w[id name])
+          end
+        end
+
+        describe 'relations' do
+          it 'return only the relations of a collection' do
+            projection = described_class.new(%w[id name category:label])
+
+            expect(projection.relations).to eq({ 'category' => ['label'] })
+          end
+        end
+      end
+    end
+  end
+end

From a8db46925ffe6378de76d81669aca9a10ba245ea Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 14:38:13 +0200
Subject: [PATCH 13/26] test: add tests on aggregation class

---
 .../components/query/aggregation.rb           |  3 ++-
 .../components/query/aggregation_spec.rb      | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/aggregation_spec.rb

diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
index 45e96a10c..e4e6c912a 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
@@ -2,6 +2,7 @@ module ForestAdminDatasourceToolkit
   module Components
     module Query
       class Aggregation
+        include ForestAdminDatasourceToolkit::Exceptions
         attr_reader :operation, :field, :groups
 
         def initialize(operation:, field: nil, groups: [])
@@ -14,7 +15,7 @@ def initialize(operation:, field: nil, groups: [])
         def validate(operation)
           return if %w[Count Sum Avg Max Min].include? operation
 
-          raise Exceptions::ForestException("Aggregate operation #{operation} not allowed")
+          raise ForestException.new("Aggregate operation #{operation} not allowed")
         end
       end
     end
diff --git a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/aggregation_spec.rb b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/aggregation_spec.rb
new file mode 100644
index 000000000..54d0ed70a
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/query/aggregation_spec.rb
@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      include ForestAdminDatasourceToolkit::Schema
+      describe Aggregation do
+        it 'raise if the operation is invalid' do
+          expect do
+            described_class.new(operation: 'foo')
+          end.to raise_error(
+            ForestAdminDatasourceToolkit::Exceptions::ForestException,
+            '🌳🌳🌳 Aggregate operation foo not allowed'
+          )
+        end
+      end
+    end
+  end
+end

From 8ce1459d2aa0bced6e3fef47c04ba48fca0d8844 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 14:38:32 +0200
Subject: [PATCH 14/26] test: add tests on query string parser

---
 .../forest_admin_agent.gemspec                |   1 +
 .../utils/query_string_parser.rb              |  26 +-
 .../utils/query_string_parser_spec.rb         | 271 ++++++++++++++++++
 .../forest_admin_agent/spec/shared/caller.rb  |   3 +
 .../components/query/projection_factory.rb    |  32 +++
 5 files changed, 321 insertions(+), 12 deletions(-)
 create mode 100644 packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
 create mode 100644 packages/forest_admin_agent/spec/shared/caller.rb
 create mode 100644 packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb

diff --git a/packages/forest_admin_agent/forest_admin_agent.gemspec b/packages/forest_admin_agent/forest_admin_agent.gemspec
index 16ffc83f6..a8baec7ad 100644
--- a/packages/forest_admin_agent/forest_admin_agent.gemspec
+++ b/packages/forest_admin_agent/forest_admin_agent.gemspec
@@ -44,4 +44,5 @@ admin work on any Ruby application."
   spec.add_dependency "rack-cors", "~> 2.0"
   spec.add_dependency "zeitwerk", "~> 2.3"
   spec.add_dependency "faraday", "~> 2.7"
+  spec.add_dependency "activesupport", "~> 7.0"
 end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index 16c42ae2d..a183933d5 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -1,4 +1,5 @@
 require 'jwt'
+require 'active_support/time'
 
 module ForestAdminAgent
   module Utils
@@ -7,18 +8,19 @@ class QueryStringParser
       include ForestAdminDatasourceToolkit::Components
       include ForestAdminDatasourceToolkit::Components::Query
 
-      DEFAULT_ITEMS_PER_PAGE = 15
-      DEFAULT_PAGE_TO_SKIP = 1
+      DEFAULT_ITEMS_PER_PAGE = '15'
+      DEFAULT_PAGE_TO_SKIP = '1'
 
       def self.parse_caller(args)
         unless args[:headers]['HTTP_AUTHORIZATION']
-          raise Exceptions::ForestException 'You must be logged in to access at this resource.'
+          #TODO: replace by http exception
+          raise ForestException.new 'You must be logged in to access at this resource.'
         end
 
         timezone = args[:params]['timezone']
-        raise Exceptions::ForestException 'You must be logged in to access at this resource.' unless timezone
+        raise ForestException.new 'Missing timezone' unless timezone
 
-        raise Exceptions::ForestException, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
+        raise ForestException.new "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
 
         token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
         token_data = JWT.decode(
@@ -39,13 +41,13 @@ def self.parse_projection(collection, args)
         return ProjectionFactory.all(collection) unless fields != '' && !fields.nil?
 
         fields = fields.split(',').map do |field_name|
-          column = collection.fields[field_name]
-          column.type == 'Column' ? field_name : "#{field_name}:#{args[:params][:fields][field_name]}"
+          column = collection.fields[field_name.strip]
+          column.type == 'Column' ? field_name.strip : "#{field_name.strip}:#{args[:params][:fields][field_name.strip]}"
         end
 
         Projection.new(fields)
-      rescue StandardError
-        # TODO: raise
+      rescue
+        raise ForestException.new 'Invalid projection'
       end
 
       def self.parse_projection_with_pks(collection, args)
@@ -61,13 +63,13 @@ def self.parse_pagination(args)
         page = args.dig(:params, :data, :attributes, :all_records_subset_query, :number) ||
                args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
 
-        unless !items_per_pages.match(/\A[-+]?\d+\z/).nil? || !page.match(/\A[-+]?\d+\z/).nil?
-          raise ForestException "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
+        unless !items_per_pages.to_s.match(/\A[+]?\d+\z/).nil? || !page.to_s.match(/\A[+]?\d+\z/).nil?
+          raise ForestException.new "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
         end
 
         offset = (page.to_i - 1) * items_per_pages.to_i
 
-        Page.new(offset: offset, limit: items_per_pages)
+        Page.new(offset: offset, limit: items_per_pages.to_i)
       end
     end
   end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
new file mode 100644
index 000000000..cf6e11020
--- /dev/null
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
@@ -0,0 +1,271 @@
+require 'spec_helper'
+require 'shared/caller'
+
+module ForestAdminAgent
+  module Utils
+    include ForestAdminDatasourceToolkit
+    include ForestAdminDatasourceToolkit::Schema
+    include ForestAdminDatasourceToolkit::Components::Query
+
+    describe QueryStringParser do
+      include_context :caller
+
+      describe 'parse_caller' do
+        it 'return an instance of caller' do
+          args = {
+            headers: {
+              'HTTP_AUTHORIZATION' => bearer
+            },
+            params: {
+              'timezone' => 'America/Los_Angeles'
+            }
+          }
+
+          expect(described_class.parse_caller(args)).to be_a ForestAdminDatasourceToolkit::Components::Caller
+        end
+
+        it 'raise an error if timezone is missing' do
+          args = {
+            headers: {
+              'HTTP_AUTHORIZATION' => bearer
+            },
+            params: {}
+          }
+          expect do
+            described_class.parse_caller(args)
+          end.to raise_error(
+                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                   '🌳🌳🌳 Missing timezone'
+                 )
+        end
+
+        it 'raise an error if timezone is invalid' do
+          args = {
+            headers: {
+              'HTTP_AUTHORIZATION' => bearer
+            },
+            params: {
+              'timezone' => 'foo/timezone'
+            }
+          }
+          expect do
+            described_class.parse_caller(args)
+          end.to raise_error(
+                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                   '🌳🌳🌳 Invalid timezone: foo/timezone'
+                 )
+        end
+
+        it 'raise if the user is not connected' do
+          args = {
+            headers: {},
+            params: {
+              'timezone' => 'foo/timezone'
+            }
+          }
+          expect do
+            described_class.parse_caller(args)
+          end.to raise_error(
+                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                   '🌳🌳🌳 You must be logged in to access at this resource.'
+                 )
+        end
+      end
+
+      describe 'parse_projection' do
+        let(:collection) do
+          datasource = Datasource.new
+          collection_person = Collection.new(datasource, 'Person')
+          collection_person.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'books' => Relations::ManyToManySchema.new(
+                origin_key: 'person_id',
+                origin_key_target: 'id',
+                foreign_collection: 'Book',
+                foreign_key: 'book_id',
+                foreign_key_target: 'id',
+                through_collection: 'BookPerson'
+              )
+            }
+          )
+          collection = Collection.new(datasource, 'Book')
+          collection.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'composite_id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'title' => ColumnSchema.new(column_type: 'String'),
+              'author_id' => ColumnSchema.new(column_type: 'Number'),
+              'author' => Relations::ManyToOneSchema.new(
+                foreign_key: 'author_id',
+                foreign_key_target: 'id',
+                foreign_collection: 'Person'
+              )
+            }
+          )
+
+          datasource.add_collection(collection)
+          datasource.add_collection(collection_person)
+
+          return collection
+        end
+        context 'on a flat collection and a well formed request' do
+          it 'convert the request to a valid projection' do
+            args = {
+              params: {
+                fields: { 'Book' => 'id' }
+              }
+            }
+
+            expect(described_class.parse_projection(collection, args)).to eq(Projection.new(['id']))
+          end
+
+          it 'return a projection with all the fields when the request does no contain fields' do
+            args = {
+              params: {
+                fields: { 'Book' => '' }
+              }
+            }
+
+            expect(described_class.parse_projection(collection, args)).to eq(
+              Projection.new(%w[id composite_id title author_id author:id])
+            )
+          end
+
+          it 'return the requested project without the primary keys when the request does not contain the primary keys' do
+            args = {
+              params: {
+                fields: { 'Book' => 'title' }
+              }
+            }
+
+            expect(described_class.parse_projection(collection, args)).to eq(Projection.new(['title']))
+          end
+
+          it 'convert the request to a valid projection on a collection with relationships' do
+            args = {
+              params: {
+                fields: {
+                  'Book' => 'id, title, author',
+                  'author' => 'id'
+                }
+              }
+            }
+
+            expect(described_class.parse_projection(collection, args)).to eq(Projection.new(%w[id title author:id]))
+          end
+
+          it 'raise a ForestException on a request with an unknown field' do
+            args = {
+              params: {
+                fields: {
+                  'Book' => 'foo',
+                }
+              }
+            }
+
+            expect do
+              described_class.parse_projection(collection, args)
+            end.to raise_error(
+                     ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                     '🌳🌳🌳 Invalid projection'
+                   )
+          end
+        end
+      end
+
+      describe 'parse_projection_with_pks' do
+        let(:collection) do
+          datasource = Datasource.new
+          collection_person = Collection.new(datasource, 'Person')
+          collection_person.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'name' => ColumnSchema.new(column_type: 'String'),
+              'books' => Relations::ManyToManySchema.new(
+                origin_key: 'person_id',
+                origin_key_target: 'id',
+                foreign_collection: 'Book',
+                foreign_key: 'book_id',
+                foreign_key_target: 'id',
+                through_collection: 'BookPerson'
+              )
+            }
+          )
+          collection = Collection.new(datasource, 'Book')
+          collection.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'title' => ColumnSchema.new(column_type: 'String'),
+              'author_id' => ColumnSchema.new(column_type: 'Number'),
+              'author' => Relations::ManyToOneSchema.new(
+                foreign_key: 'author_id',
+                foreign_key_target: 'id',
+                foreign_collection: 'Person'
+              )
+            }
+          )
+
+          datasource.add_collection(collection)
+          datasource.add_collection(collection_person)
+
+          return collection
+        end
+
+        it 'return the requested project with the primary keys when the request does not contain the primary keys' do
+          args = {
+            params: {
+              fields: { 'Book' => 'title' }
+            }
+          }
+
+          expect(described_class.parse_projection_with_pks(collection, args)).to eq(Projection.new(%w[title id]))
+        end
+
+        it 'convert the request to a valid projection when the request does not contain the primary keys on a collection with relationships' do
+          args = {
+            params: {
+              fields: {
+                'Book' => 'id, author',
+                'author' => 'name'
+              }
+            }
+          }
+
+          expect(described_class.parse_projection_with_pks(collection, args)).to eq(Projection.new(%w[id author:name author:id]))
+        end
+      end
+
+      describe 'parse_pagination' do
+        it 'return the pagination parameter' do
+          args = {
+            params: {
+              page: { size: '10', number: '3'}
+            }
+          }
+
+          expect(described_class.parse_pagination(args)).to have_attributes(offset: 20, limit: 10)
+        end
+
+        it 'return the default limit 15 skip 0 when request does not provide the pagination parameters' do
+          expect(described_class.parse_pagination({})).to have_attributes(offset: 0, limit: 15)
+        end
+
+        it 'raise an error when request provides invalid values' do
+          args = {
+            params: {
+              page: { size: -5, number: 'NaN'}
+            }
+          }
+
+          expect do
+            described_class.parse_pagination(args)
+          end.to raise_error(
+                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                   '🌳🌳🌳 Invalid pagination [limit: -5, skip: NaN]'
+                 )
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_agent/spec/shared/caller.rb b/packages/forest_admin_agent/spec/shared/caller.rb
new file mode 100644
index 000000000..7e588bf23
--- /dev/null
+++ b/packages/forest_admin_agent/spec/shared/caller.rb
@@ -0,0 +1,3 @@
+RSpec.shared_context :caller do
+  let(:bearer) { 'Bearer eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJlbWFpbCI6Im5pY29sYXNhQGZvcmVzdGFkbWluLmNvbSIsImZpcnN0X25hbWUiOiJOaWNvbGFzIiwibGFzdF9uYW1lIjoiQWxleGFuZHJlIiwidGVhbSI6Ik9wZXJhdGlvbnMiLCJ0YWdzIjpbXSwicmVuZGVyaW5nX2lkIjoxMTQsImV4cCI6MTY5NzAzNjQ0OSwicGVybWlzc2lvbl9sZXZlbCI6ImFkbWluIn0.UDUSshlxByL3kRjPMKK05Je3vTTKbDHqMtkqUBiwxDA' }
+end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
new file mode 100644
index 000000000..66839f5c3
--- /dev/null
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
@@ -0,0 +1,32 @@
+module ForestAdminDatasourceToolkit
+  module Components
+    module Query
+      class ProjectionFactory
+        include ForestAdminDatasourceToolkit::Utils
+        def self.all(collection)
+          projection_fields = collection.fields.reduce([]) do |memo, path|
+            column_name = path[0]
+            schema = path[1]
+            if schema.type == 'Column'
+              memo = memo + [column_name]
+            end
+
+            if (schema.type == 'OneToOne' || schema.type == 'ManyToOne')
+              relation = collection.datasource.collection(schema.foreign_collection)
+              relation_columns = relation.fields
+                                       .reject { |_relation_column_name, relation_column| relation_column.type != 'Column' }
+                                       .keys
+                                       .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }
+
+              memo = memo + relation_columns
+            end
+
+            memo
+          end
+
+          Projection.new projection_fields
+        end
+      end
+    end
+  end
+end

From d6131e18084e019c5a3d39f13b06256389f8f87b Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 16:30:48 +0200
Subject: [PATCH 15/26] chore: lint

---
 .rubocop.yml                                  |  4 ++
 .../utils/query_string_parser.rb              | 18 +++----
 .../utils/query_string_parser_spec.rb         | 48 ++++++++++---------
 .../forest_admin_agent/spec/shared/caller.rb  |  6 ++-
 .../components/query/aggregation.rb           |  2 +-
 .../components/query/projection_factory.rb    | 14 +++---
 .../contracts/collection_contract_spec.rb     | 25 +++++++++-
 .../schema/column_schema_spec.rb              |  2 +-
 8 files changed, 73 insertions(+), 46 deletions(-)

diff --git a/.rubocop.yml b/.rubocop.yml
index e00aee7b0..70e822775 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -46,6 +46,8 @@ Metrics/AbcSize:
     - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/parser/validation.rb'
     - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb'
     - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection.rb'
+    - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb'
+    -
 
 Metrics/CyclomaticComplexity:
   Exclude:
@@ -203,6 +205,8 @@ RSpec/MultipleExpectations:
 
 Layout/LineLength:
   Max: 120
+  Exclude:
+    - 'packages/forest_admin_agent/spec/shared/caller.rb'
 
 RSpec/MultipleMemoizedHelpers:
   Max: 10
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index a183933d5..e50bf4011 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -8,19 +8,19 @@ class QueryStringParser
       include ForestAdminDatasourceToolkit::Components
       include ForestAdminDatasourceToolkit::Components::Query
 
-      DEFAULT_ITEMS_PER_PAGE = '15'
-      DEFAULT_PAGE_TO_SKIP = '1'
+      DEFAULT_ITEMS_PER_PAGE = '15'.freeze
+      DEFAULT_PAGE_TO_SKIP = '1'.freeze
 
       def self.parse_caller(args)
         unless args[:headers]['HTTP_AUTHORIZATION']
-          #TODO: replace by http exception
-          raise ForestException.new 'You must be logged in to access at this resource.'
+          # TODO: replace by http exception
+          raise ForestException, 'You must be logged in to access at this resource.'
         end
 
         timezone = args[:params]['timezone']
-        raise ForestException.new 'Missing timezone' unless timezone
+        raise ForestException, 'Missing timezone' unless timezone
 
-        raise ForestException.new "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
+        raise ForestException, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
 
         token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
         token_data = JWT.decode(
@@ -46,8 +46,8 @@ def self.parse_projection(collection, args)
         end
 
         Projection.new(fields)
-      rescue
-        raise ForestException.new 'Invalid projection'
+      rescue StandardError
+        raise ForestException, 'Invalid projection'
       end
 
       def self.parse_projection_with_pks(collection, args)
@@ -64,7 +64,7 @@ def self.parse_pagination(args)
                args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
 
         unless !items_per_pages.to_s.match(/\A[+]?\d+\z/).nil? || !page.to_s.match(/\A[+]?\d+\z/).nil?
-          raise ForestException.new "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
+          raise ForestException, "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
         end
 
         offset = (page.to_i - 1) * items_per_pages.to_i
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
index cf6e11020..78fb54e5f 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
@@ -8,7 +8,7 @@ module Utils
     include ForestAdminDatasourceToolkit::Components::Query
 
     describe QueryStringParser do
-      include_context :caller
+      include_context 'with caller'
 
       describe 'parse_caller' do
         it 'return an instance of caller' do
@@ -34,9 +34,9 @@ module Utils
           expect do
             described_class.parse_caller(args)
           end.to raise_error(
-                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
-                   '🌳🌳🌳 Missing timezone'
-                 )
+            ForestAdminDatasourceToolkit::Exceptions::ForestException,
+            '🌳🌳🌳 Missing timezone'
+          )
         end
 
         it 'raise an error if timezone is invalid' do
@@ -51,9 +51,9 @@ module Utils
           expect do
             described_class.parse_caller(args)
           end.to raise_error(
-                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
-                   '🌳🌳🌳 Invalid timezone: foo/timezone'
-                 )
+            ForestAdminDatasourceToolkit::Exceptions::ForestException,
+            '🌳🌳🌳 Invalid timezone: foo/timezone'
+          )
         end
 
         it 'raise if the user is not connected' do
@@ -66,9 +66,9 @@ module Utils
           expect do
             described_class.parse_caller(args)
           end.to raise_error(
-                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
-                   '🌳🌳🌳 You must be logged in to access at this resource.'
-                 )
+            ForestAdminDatasourceToolkit::Exceptions::ForestException,
+            '🌳🌳🌳 You must be logged in to access at this resource.'
+          )
         end
       end
 
@@ -109,7 +109,8 @@ module Utils
 
           return collection
         end
-        context 'on a flat collection and a well formed request' do
+
+        context 'when request is well formed' do
           it 'convert the request to a valid projection' do
             args = {
               params: {
@@ -132,7 +133,7 @@ module Utils
             )
           end
 
-          it 'return the requested project without the primary keys when the request does not contain the primary keys' do
+          it 'return the requested project without the primary keys when the request does not have the primary keys' do
             args = {
               params: {
                 fields: { 'Book' => 'title' }
@@ -159,7 +160,7 @@ module Utils
             args = {
               params: {
                 fields: {
-                  'Book' => 'foo',
+                  'Book' => 'foo'
                 }
               }
             }
@@ -167,9 +168,9 @@ module Utils
             expect do
               described_class.parse_projection(collection, args)
             end.to raise_error(
-                     ForestAdminDatasourceToolkit::Exceptions::ForestException,
-                     '🌳🌳🌳 Invalid projection'
-                   )
+              ForestAdminDatasourceToolkit::Exceptions::ForestException,
+              '🌳🌳🌳 Invalid projection'
+            )
           end
         end
       end
@@ -222,7 +223,7 @@ module Utils
           expect(described_class.parse_projection_with_pks(collection, args)).to eq(Projection.new(%w[title id]))
         end
 
-        it 'convert the request to a valid projection when the request does not contain the primary keys on a collection with relationships' do
+        it 'convert the request to a valid projection with pks on a collection with relationships' do
           args = {
             params: {
               fields: {
@@ -232,7 +233,8 @@ module Utils
             }
           }
 
-          expect(described_class.parse_projection_with_pks(collection, args)).to eq(Projection.new(%w[id author:name author:id]))
+          expect(described_class.parse_projection_with_pks(collection,
+                                                           args)).to eq(Projection.new(%w[id author:name author:id]))
         end
       end
 
@@ -240,7 +242,7 @@ module Utils
         it 'return the pagination parameter' do
           args = {
             params: {
-              page: { size: '10', number: '3'}
+              page: { size: '10', number: '3' }
             }
           }
 
@@ -254,16 +256,16 @@ module Utils
         it 'raise an error when request provides invalid values' do
           args = {
             params: {
-              page: { size: -5, number: 'NaN'}
+              page: { size: -5, number: 'NaN' }
             }
           }
 
           expect do
             described_class.parse_pagination(args)
           end.to raise_error(
-                   ForestAdminDatasourceToolkit::Exceptions::ForestException,
-                   '🌳🌳🌳 Invalid pagination [limit: -5, skip: NaN]'
-                 )
+            ForestAdminDatasourceToolkit::Exceptions::ForestException,
+            '🌳🌳🌳 Invalid pagination [limit: -5, skip: NaN]'
+          )
         end
       end
     end
diff --git a/packages/forest_admin_agent/spec/shared/caller.rb b/packages/forest_admin_agent/spec/shared/caller.rb
index 7e588bf23..e5a1e49e5 100644
--- a/packages/forest_admin_agent/spec/shared/caller.rb
+++ b/packages/forest_admin_agent/spec/shared/caller.rb
@@ -1,3 +1,5 @@
-RSpec.shared_context :caller do
-  let(:bearer) { 'Bearer eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJlbWFpbCI6Im5pY29sYXNhQGZvcmVzdGFkbWluLmNvbSIsImZpcnN0X25hbWUiOiJOaWNvbGFzIiwibGFzdF9uYW1lIjoiQWxleGFuZHJlIiwidGVhbSI6Ik9wZXJhdGlvbnMiLCJ0YWdzIjpbXSwicmVuZGVyaW5nX2lkIjoxMTQsImV4cCI6MTY5NzAzNjQ0OSwicGVybWlzc2lvbl9sZXZlbCI6ImFkbWluIn0.UDUSshlxByL3kRjPMKK05Je3vTTKbDHqMtkqUBiwxDA' }
+RSpec.shared_context 'with caller' do
+  let(:bearer) do
+    'Bearer eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjEiLCJlbWFpbCI6Im5pY29sYXNhQGZvcmVzdGFkbWluLmNvbSIsImZpcnN0X25hbWUiOiJOaWNvbGFzIiwibGFzdF9uYW1lIjoiQWxleGFuZHJlIiwidGVhbSI6Ik9wZXJhdGlvbnMiLCJ0YWdzIjpbXSwicmVuZGVyaW5nX2lkIjoxMTQsImV4cCI6MTk5ODAzNjQ0OSwicGVybWlzc2lvbl9sZXZlbCI6ImFkbWluIn0.5LFmtMqZMfinLZLGdPvTlr22YDfU-B30z7MQxlb8vng'
+  end
 end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
index e4e6c912a..27e008591 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/aggregation.rb
@@ -15,7 +15,7 @@ def initialize(operation:, field: nil, groups: [])
         def validate(operation)
           return if %w[Count Sum Avg Max Min].include? operation
 
-          raise ForestException.new("Aggregate operation #{operation} not allowed")
+          raise ForestException, "Aggregate operation #{operation} not allowed"
         end
       end
     end
diff --git a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
index 66839f5c3..49314d893 100644
--- a/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
+++ b/packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
@@ -7,18 +7,16 @@ def self.all(collection)
           projection_fields = collection.fields.reduce([]) do |memo, path|
             column_name = path[0]
             schema = path[1]
-            if schema.type == 'Column'
-              memo = memo + [column_name]
-            end
+            memo += [column_name] if schema.type == 'Column'
 
-            if (schema.type == 'OneToOne' || schema.type == 'ManyToOne')
+            if schema.type == 'OneToOne' || schema.type == 'ManyToOne'
               relation = collection.datasource.collection(schema.foreign_collection)
               relation_columns = relation.fields
-                                       .reject { |_relation_column_name, relation_column| relation_column.type != 'Column' }
-                                       .keys
-                                       .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }
+                                         .select { |_column_name, relation_column| relation_column.type == 'Column' }
+                                         .keys
+                                         .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }
 
-              memo = memo + relation_columns
+              memo += relation_columns
             end
 
             memo
diff --git a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract_spec.rb b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract_spec.rb
index d615f8481..083cd6b44 100644
--- a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract_spec.rb
+++ b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/components/contracts/collection_contract_spec.rb
@@ -3,20 +3,41 @@
 module ForestAdminDatasourceToolkit
   module Components
     module Contracts
+      include ForestAdminDatasourceToolkit::Components::Query
       describe CollectionContract do
         subject(:collection) { described_class.new }
 
+        let(:caller) do
+          Caller.new(
+            id: 1,
+            email: 'foo@foo.com',
+            first_name: 'foo',
+            last_name: 'foo',
+            team: 1,
+            rendering_id: 1,
+            tags: {},
+            timezone: 'Europe/Paris',
+            role: 1,
+            permission_level: 'admin'
+          )
+        end
+
         it { expect { collection.datasource }.to raise_error(NotImplementedError) }
         it { expect { collection.schema }.to raise_error(NotImplementedError) }
         it { expect { collection.name }.to raise_error(NotImplementedError) }
         it { expect { collection.execute }.to raise_error(NotImplementedError) }
         it { expect { collection.form }.to raise_error(NotImplementedError) }
         it { expect { collection.create }.to raise_error(NotImplementedError) }
-        it { expect { collection.list }.to raise_error(NotImplementedError) }
+        it { expect { collection.list(caller, Filter.new, Projection.new) }.to raise_error(NotImplementedError) }
         it { expect { collection.update }.to raise_error(NotImplementedError) }
         it { expect { collection.delete }.to raise_error(NotImplementedError) }
-        it { expect { collection.aggregate }.to raise_error(NotImplementedError) }
         it { expect { collection.render_chart }.to raise_error(NotImplementedError) }
+
+        it {
+          expect do
+            collection.aggregate(caller, Filter.new, Aggregation.new(operation: 'Count'))
+          end.to raise_error(NotImplementedError)
+        }
       end
     end
   end
diff --git a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/schema/column_schema_spec.rb b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/schema/column_schema_spec.rb
index 69abe8f34..44d9202bf 100644
--- a/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/schema/column_schema_spec.rb
+++ b/packages/forest_admin_datasource_toolkit/spec/lib/forest_admin_datasource_toolkit/schema/column_schema_spec.rb
@@ -9,7 +9,7 @@ module Schema
         it { expect(column.is_primary_key).to be false }
         it { expect(column.default_value).to be_nil }
         it { expect(column.is_read_only).to be false }
-        it { expect(column.is_sortable).to be true }
+        it { expect(column.is_sortable).to be false }
         it { expect(column.filter_operators).to eq [] }
         it { expect(column.enum_values).to eq [] }
         it { expect(column.validations).to eq [] }

From 4b255615f17587fe3983d937289003844d4f6573 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 17:43:58 +0200
Subject: [PATCH 16/26] test: add tests on list route

---
 .../utils/query_string_parser.rb              |  4 +-
 .../routes/resources/list_spec.rb             | 82 +++++++++++++++++++
 .../forest_admin_agent/spec/spec_helper.rb    |  3 +-
 3 files changed, 86 insertions(+), 3 deletions(-)
 create mode 100644 packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index e50bf4011..0732af2fa 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -12,7 +12,7 @@ class QueryStringParser
       DEFAULT_PAGE_TO_SKIP = '1'.freeze
 
       def self.parse_caller(args)
-        unless args[:headers]['HTTP_AUTHORIZATION']
+        unless args.dig(:headers, 'HTTP_AUTHORIZATION')
           # TODO: replace by http exception
           raise ForestException, 'You must be logged in to access at this resource.'
         end
@@ -36,7 +36,7 @@ def self.parse_caller(args)
       end
 
       def self.parse_projection(collection, args)
-        fields = args[:params][:fields][collection.name]
+        fields = args.dig(:params, :fields, collection.name) || ''
 
         return ProjectionFactory.all(collection) unless fields != '' && !fields.nil?
 
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
new file mode 100644
index 000000000..0ba4e3799
--- /dev/null
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'singleton'
+require 'ostruct'
+require 'shared/caller'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      include ForestAdminDatasourceToolkit
+      include ForestAdminDatasourceToolkit::Schema
+      describe List do
+        include_context 'with caller'
+
+        class User
+          def name
+            'user'
+          end
+        end
+
+        subject(:list) { described_class.new }
+        let(:args) do
+          {
+            headers: { 'HTTP_AUTHORIZATION' => bearer },
+            params: {
+              'collection_name' => 'user',
+              'timezone' => 'Europe/Paris'
+            }
+          }
+        end
+
+        before do
+          datasource = Datasource.new
+          collection = Collection.new(datasource, 'user')
+          collection.add_fields(
+            {
+              'id' => ColumnSchema.new(column_type: 'Number', is_primary_key: true),
+              'first_name' => ColumnSchema.new(column_type: 'String'),
+              'last_name' => ColumnSchema.new(column_type: 'String')
+            }
+          )
+          allow(collection).to receive(:list).and_return(
+            [
+              OpenStruct.new(id: 1, first_name: 'foo', last_name: 'foo', class: :User)
+            ]
+          )
+          allow(ForestAdminAgent::Builder::AgentFactory.instance).to receive(:send_schema).and_return(nil)
+
+
+          datasource.add_collection(collection)
+          ForestAdminAgent::Builder::AgentFactory.instance.add_datasource(datasource)
+          ForestAdminAgent::Builder::AgentFactory.instance.build
+        end
+
+        it 'return an serialized content' do
+          result = list.handle_request(args)
+
+          expect(result[:content]).to eq(
+            'data' => [
+              {
+                'type' => 'user',
+                'id' => '1',
+                'attributes' => {
+                  'id' => 1,
+                  'first_name' => 'foo',
+                  'last_name' => 'foo',
+                },
+                'links' => { 'self' => 'forest/user/1' }
+              }
+            ],
+            'included' => []
+          )
+        end
+
+        it 'adds the route forest_list' do
+          list.setup_routes
+          expect(list.routes.include?('forest_list')).to be true
+          expect(list.routes.length).to eq 1
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_agent/spec/spec_helper.rb b/packages/forest_admin_agent/spec/spec_helper.rb
index c87246872..6d53f6fbd 100644
--- a/packages/forest_admin_agent/spec/spec_helper.rb
+++ b/packages/forest_admin_agent/spec/spec_helper.rb
@@ -43,7 +43,8 @@
         cache_dir: 'tmp/cache/forest_admin',
         schema_path: File.join('tmp', '.forestadmin-schema.json'),
         forest_server_url: 'https://api.development.forestadmin.com',
-        debug: true
+        debug: true,
+        prefix: 'forest'
       }
     )
   end

From da90e51fd8395c501839711e87b7f30578a9a72d Mon Sep 17 00:00:00 2001
From: Matt <matthv@gmail.com>
Date: Thu, 12 Oct 2023 17:49:46 +0200
Subject: [PATCH 17/26] refactor: test forest_provider

---
 .../auth/oauth2/forest_provider_spec.rb                  | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_provider_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_provider_spec.rb
index ae881fa47..bb87c6ca4 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_provider_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_provider_spec.rb
@@ -30,10 +30,8 @@ module OAuth2
 
         context 'when getting the resource owner' do
           before do
-            allow(forest_provider).to receive_messages(secret: 'secret')
-            allow(forest_provider).to receive_messages(check_response: { data: 'data' })
-            allow(access_token).to receive_messages(access_token: 'access_token')
-            allow(access_token).to receive_messages(client: forest_provider)
+            allow(forest_provider).to receive_messages(secret: 'secret', check_response: { data: 'data' })
+            allow(access_token).to receive_messages(access_token: 'access_token', client: forest_provider)
           end
 
           it 'returns the resource owner' do
@@ -44,8 +42,7 @@ module OAuth2
 
         context 'when check response is called' do
           before do
-            allow(access_token).to receive_messages(access_token: 'access_token')
-            allow(access_token).to receive_messages(client: forest_provider)
+            allow(access_token).to receive_messages(access_token: 'access_token', client: forest_provider)
             allow(Faraday::Connection).to receive(:new).and_return(faraday_connection)
           end
 

From cdc59c78ea8ed3be1af7d79018b8fec3d3375b92 Mon Sep 17 00:00:00 2001
From: Matt <matthv@gmail.com>
Date: Thu, 12 Oct 2023 17:50:47 +0200
Subject: [PATCH 18/26] chore: add test on forest_admin_api_requester

---
 .../http/forest_admin_api_requester_spec.rb   | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 packages/forest_admin_agent/spec/lib/forest_admin_agent/http/forest_admin_api_requester_spec.rb

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/http/forest_admin_api_requester_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/http/forest_admin_api_requester_spec.rb
new file mode 100644
index 000000000..b3f83020c
--- /dev/null
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/http/forest_admin_api_requester_spec.rb
@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module ForestAdminAgent
+  module Http
+    describe ForestAdminApiRequester do
+      subject(:forest_admin_api_requester) { described_class.new }
+
+      context 'when the forest admin api is called' do
+        let(:response) { instance_double(Faraday::Response, status: 200, body: {}) }
+        let(:faraday_connection) { instance_double(Faraday::Connection) }
+        let(:params) { { 'params' => 'params' } }
+        let(:url) { 'url' }
+
+        before do
+          allow(Faraday::Connection).to receive(:new).and_return(faraday_connection)
+          allow(faraday_connection).to receive_messages(get: response, post: response)
+        end
+
+        it 'returns a response on the get method' do
+          result = forest_admin_api_requester.get url, params
+          expect(result).to be_a response.class
+          expect(result.status).to eq 200
+          expect(result.body).to eq({})
+        end
+
+        it 'returns a response on the post method' do
+          result = forest_admin_api_requester.post url, params
+          expect(result).to be_a response.class
+          expect(result.status).to eq 200
+          expect(result.body).to eq({})
+        end
+      end
+    end
+  end
+end

From ad332631b8f9e2620c5b6937ff3157d6cdf61de8 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 17:52:55 +0200
Subject: [PATCH 19/26] test: update test on list route

---
 .../routes/resources/list_spec.rb             | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
index 0ba4e3799..cdf5215a1 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
@@ -10,13 +10,6 @@ module Resources
       include ForestAdminDatasourceToolkit::Schema
       describe List do
         include_context 'with caller'
-
-        class User
-          def name
-            'user'
-          end
-        end
-
         subject(:list) { described_class.new }
         let(:args) do
           {
@@ -29,6 +22,13 @@ def name
         end
 
         before do
+          user_class = Struct.new(:id, :first_name, :last_name) do
+            def name
+              'user'
+            end
+          end
+          stub_const('User', user_class)
+
           datasource = Datasource.new
           collection = Collection.new(datasource, 'user')
           collection.add_fields(
@@ -40,12 +40,11 @@ def name
           )
           allow(collection).to receive(:list).and_return(
             [
-              OpenStruct.new(id: 1, first_name: 'foo', last_name: 'foo', class: :User)
+              User.new(id: 1, first_name: 'foo', last_name: 'foo')
             ]
           )
           allow(ForestAdminAgent::Builder::AgentFactory.instance).to receive(:send_schema).and_return(nil)
 
-
           datasource.add_collection(collection)
           ForestAdminAgent::Builder::AgentFactory.instance.add_datasource(datasource)
           ForestAdminAgent::Builder::AgentFactory.instance.build
@@ -62,7 +61,7 @@ def name
                 'attributes' => {
                   'id' => 1,
                   'first_name' => 'foo',
-                  'last_name' => 'foo',
+                  'last_name' => 'foo'
                 },
                 'links' => { 'self' => 'forest/user/1' }
               }

From 6e1fe5fa9842709cdc262ab5eda32b70edcf3873 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Thu, 12 Oct 2023 17:59:46 +0200
Subject: [PATCH 20/26] test: add tests on count route

---
 .../routes/resources/count_spec.rb            | 54 +++++++++++++++++++
 .../routes/resources/list_spec.rb             |  1 +
 2 files changed, 55 insertions(+)
 create mode 100644 packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/count_spec.rb

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/count_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/count_spec.rb
new file mode 100644
index 000000000..595666dc0
--- /dev/null
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/count_spec.rb
@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'singleton'
+require 'ostruct'
+require 'shared/caller'
+
+module ForestAdminAgent
+  module Routes
+    module Resources
+      include ForestAdminDatasourceToolkit
+      include ForestAdminDatasourceToolkit::Schema
+      describe Count do
+        include_context 'with caller'
+        subject(:count) { described_class.new }
+        let(:args) do
+          {
+            headers: { 'HTTP_AUTHORIZATION' => bearer },
+            params: {
+              'collection_name' => 'user',
+              'timezone' => 'Europe/Paris'
+            }
+          }
+        end
+
+        before do
+          datasource = Datasource.new
+          collection = Collection.new(datasource, 'user')
+          allow(collection).to receive(:aggregate).and_return(
+            [
+              { value: 1, group: [] }
+            ]
+          )
+          allow(ForestAdminAgent::Builder::AgentFactory.instance).to receive(:send_schema).and_return(nil)
+
+          datasource.add_collection(collection)
+          ForestAdminAgent::Builder::AgentFactory.instance.add_datasource(datasource)
+          ForestAdminAgent::Builder::AgentFactory.instance.build
+        end
+
+        it 'return an serialized content' do
+          result = count.handle_request(args)
+
+          expect(result[:name]).to eq('user')
+          expect(result[:content]).to eq({ count: 1 })
+        end
+
+        it 'adds the route forest_count' do
+          count.setup_routes
+          expect(count.routes.include?('forest_count')).to be true
+          expect(count.routes.length).to eq 1
+        end
+      end
+    end
+  end
+end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
index cdf5215a1..3a4cf7ff1 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
@@ -53,6 +53,7 @@ def name
         it 'return an serialized content' do
           result = list.handle_request(args)
 
+          expect(result[:name]).to eq('user')
           expect(result[:content]).to eq(
             'data' => [
               {

From 50e75473f7c7a1d3a885bec8899fc8f2f4a39a80 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Fri, 13 Oct 2023 10:04:36 +0200
Subject: [PATCH 21/26] fix: tests after rebase

---
 .../routes/abstract_authenticated_route.rb      |  3 ++-
 .../utils/query_string_parser.rb                |  2 --
 .../routes/security/authentication_spec.rb      | 12 ++++++------
 .../utils/query_string_parser_spec.rb           | 17 -----------------
 packages/forest_admin_agent/spec/spec_helper.rb |  4 ++--
 5 files changed, 10 insertions(+), 28 deletions(-)

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
index 6635176ab..7bcc7029b 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
@@ -2,8 +2,9 @@ module ForestAdminAgent
   module Routes
     class AbstractAuthenticatedRoute < AbstractRoute
       def build(args = {})
+        super
         # TODO: handle call permissions
-        Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+        # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
       end
     end
   end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
index 0732af2fa..6623fda6f 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/utils/query_string_parser.rb
@@ -46,8 +46,6 @@ def self.parse_projection(collection, args)
         end
 
         Projection.new(fields)
-      rescue StandardError
-        raise ForestException, 'Invalid projection'
       end
 
       def self.parse_projection_with_pks(collection, args)
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/security/authentication_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/security/authentication_spec.rb
index be59aa5ab..9e6349f32 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/security/authentication_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/security/authentication_spec.rb
@@ -47,23 +47,23 @@ module Security
           end
 
           it 'returns an auth url on the handle_authentication method' do
-            params = { 'renderingId' => rendering_id }
-            result = authentication.handle_authentication params
+            args = { params: { 'renderingId' => rendering_id } }
+            result = authentication.handle_authentication args
             expect(result[:content][:authorizationUrl]).to eq 'https://api.development.forestadmin.com/oidc/...'
           end
 
           it 'raises an error if renderingId is not present' do
-            params = {}
+            args = { params: {} }
             expect do
-              authentication.handle_authentication params
+              authentication.handle_authentication args
             end.to raise_error(Error,
                                ForestAdminAgent::Utils::ErrorMessages::MISSING_RENDERING_ID)
           end
 
           it 'raises an error if renderingId is not an integer' do
-            params = { 'renderingId' => 'abc' }
+            args = { params: { 'renderingId' => 'abc' } }
             expect do
-              authentication.handle_authentication params
+              authentication.handle_authentication args
             end.to raise_error(Error,
                                ForestAdminAgent::Utils::ErrorMessages::INVALID_RENDERING_ID)
           end
diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
index 78fb54e5f..17d960cbe 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/query_string_parser_spec.rb
@@ -155,23 +155,6 @@ module Utils
 
             expect(described_class.parse_projection(collection, args)).to eq(Projection.new(%w[id title author:id]))
           end
-
-          it 'raise a ForestException on a request with an unknown field' do
-            args = {
-              params: {
-                fields: {
-                  'Book' => 'foo'
-                }
-              }
-            }
-
-            expect do
-              described_class.parse_projection(collection, args)
-            end.to raise_error(
-              ForestAdminDatasourceToolkit::Exceptions::ForestException,
-              '🌳🌳🌳 Invalid projection'
-            )
-          end
         end
       end
 
diff --git a/packages/forest_admin_agent/spec/spec_helper.rb b/packages/forest_admin_agent/spec/spec_helper.rb
index 6d53f6fbd..7f9b93d86 100644
--- a/packages/forest_admin_agent/spec/spec_helper.rb
+++ b/packages/forest_admin_agent/spec/spec_helper.rb
@@ -31,8 +31,8 @@
 # See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   config.before do
-    lightly = Lightly.new
-    lightly.clear 'config'
+    lightly = Lightly.new(dir: 'tmp/cache/forest_admin')
+    lightly.flush
 
     agent_factory = ForestAdminAgent::Builder::AgentFactory.instance
     agent_factory.setup(

From 05ce6a7e631eae11a549beabb54b6da4441cad3f Mon Sep 17 00:00:00 2001
From: Matt <matthv@gmail.com>
Date: Fri, 13 Oct 2023 10:22:33 +0200
Subject: [PATCH 22/26] chore: update


From 4ff53cc346f71439fde9321823178e901e0e24ff Mon Sep 17 00:00:00 2001
From: Matt <matthv@gmail.com>
Date: Fri, 13 Oct 2023 10:25:45 +0200
Subject: [PATCH 23/26] chore: update

---
 .../routes/abstract_authenticated_route.rb                | 5 +++--
 .../forest_admin_agent/routes/security/authentication.rb  | 8 ++++++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
index 7bcc7029b..65bce570d 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/abstract_authenticated_route.rb
@@ -2,9 +2,10 @@ module ForestAdminAgent
   module Routes
     class AbstractAuthenticatedRoute < AbstractRoute
       def build(args = {})
+        if args.dig(:headers, 'action_dispatch.remote_ip')
+          Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+        end
         super
-        # TODO: handle call permissions
-        # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
       end
     end
   end
diff --git a/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb b/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
index 0cbf26a12..d880f1992 100644
--- a/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
+++ b/packages/forest_admin_agent/lib/forest_admin_agent/routes/security/authentication.rb
@@ -26,7 +26,9 @@ def setup_routes
         end
 
         def handle_authentication(args = {})
-          # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+          if args.dig(:headers, 'action_dispatch.remote_ip')
+            Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+          end
           rendering_id = get_and_check_rendering_id args[:params]
 
           {
@@ -37,7 +39,9 @@ def handle_authentication(args = {})
         end
 
         def handle_authentication_callback(args = {})
-          # Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+          if args.dig(:headers, 'action_dispatch.remote_ip')
+            Facades::Whitelist.check_ip(args[:headers]['action_dispatch.remote_ip'].to_s)
+          end
           token = auth.verify_code_and_generate_token(args[:params])
           token_data = JWT.decode(
             token,

From d34dc873fab22539b9b64c1308b013a86f36ade2 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Fri, 13 Oct 2023 10:27:35 +0200
Subject: [PATCH 24/26] test: remove puts

---
 .../auth/oauth2/forest_resource_owner_spec.rb                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_resource_owner_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_resource_owner_spec.rb
index d74b3335a..81ee2e5c6 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_resource_owner_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/auth/oauth2/forest_resource_owner_spec.rb
@@ -31,7 +31,6 @@ module OAuth2
           it 'makes a jwt' do
             jwt = forest_resource_owner.make_jwt
             decoded_jwt = JWT.decode jwt, Facades::Container.cache(:auth_secret), true, { algorithm: 'HS256' }
-            puts decoded_jwt
             h = {
               'id' => 'id',
               'email' => 'email',
@@ -43,6 +42,7 @@ module OAuth2
               'exp' => forest_resource_owner.expiration_in_seconds,
               'permission_level' => 'permission_level'
             }
+
             expect(decoded_jwt[0]).to eq h
           end
         end

From aad010baf11d19969baabb006893c6db0f79ffe9 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Fri, 13 Oct 2023 12:09:38 +0200
Subject: [PATCH 25/26] fix(test): fix instantiation of user object

---
 .../spec/lib/forest_admin_agent/routes/resources/list_spec.rb   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
index 3a4cf7ff1..360a56107 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
@@ -40,7 +40,7 @@ def name
           )
           allow(collection).to receive(:list).and_return(
             [
-              User.new(id: 1, first_name: 'foo', last_name: 'foo')
+              User.new(1,'foo','foo')
             ]
           )
           allow(ForestAdminAgent::Builder::AgentFactory.instance).to receive(:send_schema).and_return(nil)

From b4304edf70e67dd874546e9798696bf3d03779c8 Mon Sep 17 00:00:00 2001
From: Nicolas Alexandre <nicolasalexandre9@gmail.com>
Date: Fri, 13 Oct 2023 12:11:58 +0200
Subject: [PATCH 26/26] chore: lint

---
 .../spec/lib/forest_admin_agent/routes/resources/list_spec.rb   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
index 360a56107..ce1a4ef6d 100644
--- a/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
+++ b/packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/list_spec.rb
@@ -40,7 +40,7 @@ def name
           )
           allow(collection).to receive(:list).and_return(
             [
-              User.new(1,'foo','foo')
+              User.new(1, 'foo', 'foo')
             ]
           )
           allow(ForestAdminAgent::Builder::AgentFactory.instance).to receive(:send_schema).and_return(nil)