forest_admin_agent 1.0.0.pre.beta.22 → 1.0.0.pre.beta.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5714273d6e7144f00eb531b7a93d0e908698bd1dac7984dc47affd15a7514f6
-  data.tar.gz: 3b47af0daae4bc4e02b944f0d21be13aa18fe5e7abb9bfcfa03f2ea3272028bd
+  metadata.gz: 5366fcae628c5d313080f3218e187b1b5754b884d7e8cc38c85b905b4268e35e
+  data.tar.gz: b4778e1a8f354b96b9ce0be00afae2d3688b0565d73026be0b3c0e89425a7aaf
 SHA512:
-  metadata.gz: 93044527fdfb1a06f49408044479258b1cccb6af15c8025cf26310f01c684ae6b5c4657bd25496eb69d911eaa77daae83ec82ec551469bd15cacea61a3b46687
-  data.tar.gz: f93863c6d28342854e2e453795bca3c3892c6a09c0d91a44fcb42fae57b107c17f6daa3e9694d04e0862bb46e1f95ff2d14f04c199ab0c2a5436434ca5090ca4
+  metadata.gz: 1e150b17814b1d3d7bdf2a25cb4b9cfa9b88a80e29593a4307b452b5096d733360f264e4034da11e835c0c1c24534ea1b84feb7c0e4658dfd0f689ff3b9494bc
+  data.tar.gz: e626ef0f2022abc05884b5a529d77269c72bc2c8aa45f3e2d6484021fdd590fe6fc0fce8fdba30869a3ca18c434aad4a2ce614222096ad7e4bf4589848b6c191

data/forest_admin_agent.gemspec

@@ -34,6 +34,7 @@ admin work on any Ruby application."
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency "deepsort", "~> 0.4.5"
   spec.add_dependency "dry-container", "~> 0.11"
   spec.add_dependency "faraday", "~> 2.7"
   spec.add_dependency "filecache", "~> 1.0"

data/lib/forest_admin_agent/builder/agent_factory.rb

@@ -14,26 +14,31 @@ module ForestAdminAgent
       def setup(options)
         @options = options
         @has_env_secret = options.to_h.key?(:env_secret)
-        @customizer = ForestAdminDatasourceToolkit::Datasource.new
+        @customizer = ForestAdminDatasourceCustomizer::DatasourceCustomizer.new
         build_container
         build_cache
         build_logger
       end
 
-      def add_datasource(datasource)
-        datasource.collections.each_value { |collection| @customizer.add_collection(collection) }
+      def add_datasource(datasource, options = {})
+        @customizer.add_datasource(datasource, options)
+
         self
       end
 
+      def customize_collection(name, handle)
+        @customizer.customize_collection(name, handle)
+      end
+
       def build
-        @container.register(:datasource, @customizer)
+        @container.register(:datasource, @customizer.datasource)
         send_schema
       end
 
       def send_schema(force: false)
         return unless @has_env_secret
 
-        schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@customizer)
+        schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@customizer.datasource)
         schema_is_know = @container.key?(:schema_file_hash) &&
                          @container.resolve(:schema_file_hash).get('value') == schema[:meta][:schemaFileHash]
 
@@ -63,9 +68,7 @@ module ForestAdminAgent
         return unless @has_env_secret
 
         cache = @container.resolve(:cache)
-        cache.get_or_set 'config' do
-          @options.to_h
-        end
+        cache.set('config', @options.to_h)
       end
 
       def build_logger

data/lib/forest_admin_agent/http/router.rb

@@ -9,6 +9,7 @@ module ForestAdminAgent
           # api_charts_routes,
           System::HealthCheck.new.routes,
           Security::Authentication.new.routes,
+          Charts::Charts.new.routes,
           Resources::Count.new.routes,
           Resources::Delete.new.routes,
           Resources::List.new.routes,

data/lib/forest_admin_agent/routes/abstract_authenticated_route.rb

@@ -14,7 +14,7 @@ module ForestAdminAgent
         record = args[:params][:data][:attributes]
 
         args[:params][:data][:relationships]&.map do |field, value|
-          schema = @collection.fields[field]
+          schema = @collection.schema[:fields][field]
 
           record[schema.foreign_key] = value['data'][schema.foreign_key_target] if schema.type == 'ManyToOne'
         end

data/lib/forest_admin_agent/routes/abstract_related_route.rb

@@ -4,8 +4,8 @@ module ForestAdminAgent
       def build(args = {})
         super
 
-        relation = @collection.fields[args[:params]['relation_name']]
-        @child_collection = @datasource.collection(relation.foreign_collection)
+        relation = @collection.schema[:fields][args[:params]['relation_name']]
+        @child_collection = @datasource.get_collection(relation.foreign_collection)
       end
     end
   end

data/lib/forest_admin_agent/routes/abstract_route.rb

@@ -8,7 +8,7 @@ module ForestAdminAgent
 
       def build(args)
         @datasource = ForestAdminAgent::Facades::Container.datasource
-        @collection = @datasource.collection(args[:params]['collection_name'])
+        @collection = @datasource.get_collection(args[:params]['collection_name'])
       end
 
       def routes

data/lib/forest_admin_agent/routes/charts/charts.rb

@@ -0,0 +1,214 @@
+require 'jsonapi-serializers'
+require 'active_support/inflector'
+
+module ForestAdminAgent
+  module Routes
+    module Charts
+      class Charts < AbstractAuthenticatedRoute
+        include ForestAdminAgent::Builder
+        include ForestAdminAgent::Utils
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+        include ForestAdminDatasourceToolkit::Components::Charts
+
+        attr_reader :filter
+
+        FORMAT = {
+          Day: '%d/%m/%Y',
+          Week: 'W%W-%Y',
+          Month: '%b %y',
+          Year: '%Y'
+        }.freeze
+
+        def setup_routes
+          add_route('forest_chart', 'post', '/stats/:collection_name', lambda { |args|
+                                                                         handle_request(args)
+                                                                       })
+          self
+        end
+
+        def handle_request(args = {})
+          build(args)
+          @permissions.can_chart?(args[:params])
+          @args = args
+          self.type = args[:params][:type]
+          @filter = Filter.new(
+            condition_tree: ConditionTreeFactory.intersect(
+              [
+                @permissions.get_scope(@collection),
+                ForestAdminAgent::Utils::QueryStringParser.parse_condition_tree(
+                  @collection, args
+                )
+              ]
+            )
+          )
+
+          inject_context_variables
+
+          { content: Serializer::ForestChartSerializer.serialize(send(:"make_#{@type}")) }
+        end
+
+        private
+
+        def type=(type)
+          chart_types = %w[Value Objective Pie Line Leaderboard]
+          unless chart_types.include?(type)
+            raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Invalid Chart type #{type}"
+          end
+
+          @type = type.downcase
+        end
+
+        def inject_context_variables
+          user = @permissions.get_user_data(@caller.id)
+          team = @permissions.get_team(@caller.rendering_id)
+
+          context_variables = ForestAdminAgent::Utils::ContextVariables.new(team, user,
+                                                                            @args[:params][:contextVariables])
+          return unless @args[:params][:filter]
+
+          @filter = @filter.override(condition_tree: ContextVariablesInjector.inject_context_in_filter(
+            @filter.condition_tree, context_variables
+          ))
+        end
+
+        def make_value
+          value = compute_value(@filter)
+          previous_value = nil
+          is_and_aggregator = @filter.condition_tree&.try(:aggregator) == 'And'
+          with_count_previous = @filter.condition_tree&.some_leaf(&:use_interval_operator)
+
+          if with_count_previous && !is_and_aggregator
+            previous_value = compute_value(FilterFactory.get_previous_period_filter(@filter, @caller.timezone))
+          end
+
+          ValueChart.new(value, previous_value)
+        end
+
+        def make_objective
+          ObjectiveChart.new(compute_value(@filter))
+        end
+
+        def make_pie
+          group_field = @args[:params][:groupByFieldName]
+          aggregation = Aggregation.new(
+            operation: @args[:params][:aggregator],
+            field: @args[:params][:aggregateFieldName],
+            groups: group_field ? [{ field: group_field }] : []
+          )
+
+          result = @collection.aggregate(@caller, @filter, aggregation)
+
+          PieChart.new(result.map { |row| { key: row[:group][group_field], value: row[:value] } })
+        end
+
+        def make_line
+          group_by_field_name = @args[:params][:groupByFieldName]
+          time_range = @args[:params][:timeRange]
+          filter_only_with_values = @filter.override(
+            condition_tree: ConditionTree::ConditionTreeFactory.intersect(
+              [
+                @filter.condition_tree,
+                ConditionTree::Nodes::ConditionTreeLeaf.new(group_by_field_name, ConditionTree::Operators::PRESENT)
+              ]
+            )
+          )
+          rows = @collection.aggregate(
+            @caller,
+            filter_only_with_values,
+            Aggregation.new(
+              operation: @args[:params][:aggregator],
+              field: @args[:params][:aggregateField],
+              groups: [{ field: group_by_field_name, operation: time_range }]
+            )
+          )
+
+          values = {}
+          rows.each { |row| values[row[:group][group_by_field_name]] = row[:value] }
+          dates = values.keys.sort
+          current = dates[0]
+          last = dates.last
+          result = []
+          while current <= last
+            result << {
+              label: current.strftime(FORMAT[time_range.to_sym]),
+              values: { value: values[current] || 0 }
+            }
+            current += 1.send(time_range.downcase.pluralize.to_sym)
+          end
+
+          LineChart.new(result)
+        end
+
+        def make_leaderboard
+          field = @collection.schema[:fields][@args[:params][:relationshipFieldName]]
+
+          if field && field.type == 'OneToMany'
+            inverse = ForestAdminDatasourceToolkit::Utils::Collection.get_inverse_relation(
+              @collection,
+              @args[:params][:relationshipFieldName]
+            )
+            if inverse
+              collection = field.foreign_collection
+              filter = @filter.nest(inverse)
+              aggregation = Aggregation.new(
+                operation: @args[:params][:aggregator],
+                field: @args[:params][:aggregateFieldName],
+                groups: [{ field: "#{inverse}:#{@args[:params][:labelFieldName]}" }]
+              )
+            end
+          end
+
+          if field && field.type == 'ManyToMany'
+            origin = ForestAdminDatasourceToolkit::Utils::Collection.get_through_origin(
+              @collection,
+              @args[:params][:relationshipFieldName]
+            )
+            target = ForestAdminDatasourceToolkit::Utils::Collection.get_through_target(
+              @collection,
+              @args[:params][:relationshipFieldName]
+            )
+            if origin && target
+              collection = field.through_collection
+              filter = @filter.nest(origin)
+              aggregation = Aggregation.new(
+                operation: @args[:params][:aggregator],
+                field: @args[:params][:aggregateFieldName] ? "#{target}:#{@args[:params][:aggregateFieldName]}" : nil,
+                groups: [{ field: "#{origin}:#{@args[:params][:labelFieldName]}" }]
+              )
+            end
+          end
+
+          if collection && filter && aggregation
+            rows = @datasource.get_collection(collection).aggregate(
+              @caller,
+              filter,
+              aggregation,
+              @args[:params][:limit]
+            )
+
+            result = rows.map do |row|
+              {
+                key: row[:group][aggregation.groups[0][:field]],
+                value: row[:value]
+              }
+            end
+
+            return LeaderboardChart.new(result)
+          end
+
+          raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
+                'Failed to generate leaderboard chart: parameters do not match pre-requisites'
+        end
+
+        def compute_value(filter)
+          aggregation = Aggregation.new(operation: @args[:params][:aggregator],
+                                        field: @args[:params][:aggregateFieldName])
+          result = @collection.aggregate(@caller, filter, aggregation)
+
+          result[0][:value] || 0
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/routes/resources/count.rb

@@ -26,7 +26,7 @@ module ForestAdminAgent
             return {
               name: args[:params]['collection_name'],
               content: {
-                count: result[0][:value]
+                count: result.empty? ? 0 : result[0][:value]
               }
             }
           end

data/lib/forest_admin_agent/routes/resources/related/associate_related.rb

@@ -62,7 +62,7 @@ module ForestAdminAgent
             origin_value = Collection.get_value(@collection, @caller, parent_id, id)
             record = { relation.origin_key => origin_value, relation.foreign_key => foreign_value }
 
-            through_collection = @datasource.collection(relation.through_collection)
+            through_collection = @datasource.get_collection(relation.through_collection)
             through_collection.create(@caller, record)
           end
         end

data/lib/forest_admin_agent/routes/resources/related/dissociate_related.rb

@@ -52,7 +52,7 @@ module ForestAdminAgent
           end
 
           def dissociate_or_delete_many_to_many(relation, relation_name, parent_id, is_delete_mode, filter)
-            through_collection = @datasource.collection(relation.through_collection)
+            through_collection = @datasource.get_collection(relation.through_collection)
 
             if is_delete_mode
               # Generate filters _BEFORE_ deleting stuff, otherwise things break.

data/lib/forest_admin_agent/routes/resources/related/update_related.rb

@@ -23,7 +23,7 @@ module ForestAdminAgent
             build(args)
             @permissions.can?(:edit, @collection)
 
-            relation = @collection.fields[args[:params]['relation_name']]
+            relation = @collection.schema[:fields][args[:params]['relation_name']]
             parent_id = Utils::Id.unpack_id(@collection, args[:params]['id'])
 
             linked_id = if (id = args.dig(:params, :data, :id))

data/lib/forest_admin_agent/routes/resources/store.rb

@@ -32,18 +32,18 @@ module ForestAdminAgent
 
         def link_one_to_one_relations(args, record)
           args[:params][:data][:relationships]&.map do |field, value|
-            schema = @collection.fields[field]
-            if schema.type == 'OneToOne'
-              id = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
-              foreign_collection = @datasource.collection(schema.foreign_collection)
-              # Load the value that will be used as origin_key
-              origin_value = record[schema.origin_key_target]
+            schema = @collection.schema[:fields][field]
+            next unless schema.type == 'OneToOne'
 
-              # update new relation (may update zero or one records).
-              condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [id])
-              filter = Filter.new(condition_tree: condition_tree)
-              foreign_collection.update(@caller, filter, { schema.origin_key => origin_value })
-            end
+            id = Utils::Id.unpack_id(@collection, value['data']['id'], with_key: true)
+            foreign_collection = @datasource.get_collection(schema.foreign_collection)
+            # Load the value that will be used as origin_key
+            origin_value = record[schema.origin_key_target]
+
+            # update new relation (may update zero or one records).
+            condition_tree = ConditionTree::ConditionTreeFactory.match_records(foreign_collection, [id])
+            filter = Filter.new(condition_tree: condition_tree)
+            foreign_collection.update(@caller, filter, { schema.origin_key => origin_value })
           end
         end
       end

data/lib/forest_admin_agent/serializer/forest_chart_serializer.rb

@@ -0,0 +1,19 @@
+require 'securerandom'
+
+module ForestAdminAgent
+  module Serializer
+    class ForestChartSerializer
+      def self.serialize(chart)
+        {
+          data: {
+            id: SecureRandom.uuid,
+            type: 'stats',
+            attributes: {
+              value: chart.serialize
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/serializer/forest_serializer.rb

@@ -41,8 +41,8 @@ module ForestAdminAgent
       end
 
       def attributes
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
-        fields = forest_collection.fields.select { |_field_name, field| field.type == 'Column' }
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(object.class.name.demodulize.underscore)
+        fields = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'Column' }
         fields.each { |field_name, _field| add_attribute(field_name) }
         return {} if attributes_map.nil?
         attributes = {}
@@ -104,9 +104,9 @@ module ForestAdminAgent
       end
 
       def relationships
-        forest_collection = ForestAdminAgent::Facades::Container.datasource.collection(object.class.name.demodulize.underscore)
-        relations_to_many = forest_collection.fields.select { |_field_name, field| field.type == 'OneToMany' || field.type == 'ManyToMany' }
-        relations_to_one = forest_collection.fields.select { |_field_name, field| field.type == 'OneToOne' || field.type == 'ManyToOne' }
+        forest_collection = ForestAdminAgent::Facades::Container.datasource.get_collection(object.class.name.demodulize.underscore)
+        relations_to_many = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToMany' || field.type == 'ManyToMany' }
+        relations_to_one = forest_collection.schema[:fields].select { |_field_name, field| field.type == 'OneToOne' || field.type == 'ManyToOne' }
 
         relations_to_one.each { |field_name, _field| add_to_one_association(field_name) }
 

data/lib/forest_admin_agent/services/permissions.rb

@@ -1,4 +1,5 @@
 require 'filecache'
+require 'deepsort'
 
 module ForestAdminAgent
   module Services
@@ -56,7 +57,7 @@ module ForestAdminAgent
       end
 
       def can_chart?(parameters)
-        attributes = sanitize_chart_parameters(parameters)
+        attributes = sanitize_chart_parameters(parameters.deep_symbolize_keys)
         hash_request = "#{attributes[:type]}:#{array_hash(attributes)}"
         is_allowed = get_chart_data(caller.rendering_id).include?(hash_request)
 
@@ -99,8 +100,6 @@ module ForestAdminAgent
       def get_scope(collection)
         permissions = get_scope_and_team_data(caller.rendering_id)
         scope = permissions[:scopes][collection.name.to_sym]
-        team = permissions[:team]
-        user = get_user_data(caller.id)
 
         return nil if scope.nil?
 
@@ -170,16 +169,21 @@ module ForestAdminAgent
       end
 
       def sanitize_chart_parameters(parameters)
-        # parameters = parameters.to_h
         parameters.delete(:timezone)
         parameters.delete(:collection)
         parameters.delete(:contextVariables)
+        # rails
+        parameters.delete(:route_alias)
+        parameters.delete(:controller)
+        parameters.delete(:action)
+        parameters.delete(:collection_name)
+        parameters.delete(:forest)
 
         parameters.select { |_, value| !value.nil? && value != '' }
       end
 
       def array_hash(data)
-        Digest::SHA1.hexdigest(data.sort.to_h.to_s)
+        Digest::SHA1.hexdigest(data.deep_sort.to_h.to_s)
       end
 
       def get_scope_and_team_data(rendering_id)
@@ -197,7 +201,7 @@ module ForestAdminAgent
       def permission_system?
         cache.get_or_set('forest.has_permission') do
           response = fetch('/liana/v4/permissions/environment')
-          { enable: !response.nil? }
+          { enable: response != true }
         end[:enable]
       end
 

data/lib/forest_admin_agent/utils/id.rb

@@ -11,7 +11,7 @@ module ForestAdminAgent
         end
 
         result = primary_keys.map.with_index do |pk_name, index|
-          field = collection.fields[pk_name]
+          field = collection.schema[:fields][pk_name]
           value = primary_key_values[index]
           casted_value = field.column_type == 'Number' ? value.to_i : value
           # TODO: call FieldValidator::validateValue($value, $field, $castedValue);

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -1,4 +1,5 @@
 require 'jwt'
+require 'active_support'
 require 'active_support/time'
 
 module ForestAdminAgent
@@ -56,7 +57,7 @@ module ForestAdminAgent
         return ProjectionFactory.all(collection) unless fields != '' && !fields.nil?
 
         fields = fields.split(',').map do |field_name|
-          column = collection.fields[field_name.strip]
+          column = collection.schema[:fields][field_name.strip]
           column.type == 'Column' ? field_name.strip : "#{field_name.strip}:#{args[:params][:fields][field_name.strip]}"
         end
 

data/lib/forest_admin_agent/utils/schema/generator_collection.rb

@@ -10,7 +10,7 @@ module ForestAdminAgent
             fields: build_fields(collection),
             icon: nil,
             integration: nil,
-            isReadOnly: collection.fields.all? { |_k, field| field.type != 'Column' || field.is_read_only },
+            isReadOnly: collection.schema[:fields].all? { |_k, field| field.type != 'Column' || field.is_read_only },
             isSearchable: true,
             isVirtual: false,
             name: collection.name,
@@ -21,7 +21,7 @@ module ForestAdminAgent
         end
 
         def self.build_fields(collection)
-          fields = collection.fields.select do |name, _field|
+          fields = collection.schema[:fields].select do |name, _field|
             !ForestAdminDatasourceToolkit::Utils::Schema.foreign_key?(collection, name) ||
               ForestAdminDatasourceToolkit::Utils::Schema.primary_key?(collection, name)
           end

data/lib/forest_admin_agent/utils/schema/generator_field.rb

@@ -10,7 +10,7 @@ module ForestAdminAgent
         }.freeze
 
         def self.build_schema(collection, name)
-          type = collection.fields[name].type
+          type = collection.schema[:fields][name].type
 
           case type
           when 'Column'
@@ -26,7 +26,7 @@ module ForestAdminAgent
           private
 
           def build_column_schema(collection, name)
-            column = collection.fields[name]
+            column = collection.schema[:fields][name]
             is_foreign_key = ForestAdminDatasourceToolkit::Utils::Schema.foreign_key?(collection, name)
 
             {
@@ -74,10 +74,10 @@ module ForestAdminAgent
 
           def build_many_to_many_schema(relation, collection, foreign_collection, base_schema)
             target_name = relation.foreign_key_target
-            target_field = foreign_collection.fields[target_name]
-            through_schema = collection.datasource.collection(relation.through_collection)
-            foreign_schema = through_schema.fields[relation.foreign_key]
-            origin_key = through_schema.fields[relation.origin_key]
+            target_field = foreign_collection.schema[:fields][target_name]
+            through_schema = collection.datasource.get_collection(relation.through_collection)
+            foreign_schema = through_schema.schema[:fields][relation.foreign_key]
+            origin_key = through_schema.schema[:fields][relation.origin_key]
 
             base_schema.merge(
               {
@@ -96,8 +96,8 @@ module ForestAdminAgent
 
           def build_one_to_many_schema(relation, collection, foreign_collection, base_schema)
             target_name = relation.origin_key_target
-            target_field = collection.fields[target_name]
-            origin_key = foreign_collection.fields[relation.origin_key]
+            target_field = collection.schema[:fields][target_name]
+            origin_key = foreign_collection.schema[:fields][relation.origin_key]
 
             base_schema.merge(
               {
@@ -115,8 +115,8 @@ module ForestAdminAgent
           end
 
           def build_one_to_one_schema(relation, collection, foreign_collection, base_schema)
-            target_field = collection.fields[relation.origin_key_target]
-            key_field = foreign_collection.fields[relation.origin_key]
+            target_field = collection.schema[:fields][relation.origin_key_target]
+            key_field = foreign_collection.schema[:fields][relation.origin_key]
 
             base_schema.merge(
               {
@@ -134,7 +134,7 @@ module ForestAdminAgent
           end
 
           def build_many_to_one_schema(relation, collection, foreign_collection, base_schema)
-            key_field = collection.fields[relation.foreign_key]
+            key_field = collection.schema[:fields][relation.foreign_key]
 
             base_schema.merge(
               {
@@ -152,8 +152,8 @@ module ForestAdminAgent
           end
 
           def build_relation_schema(collection, name)
-            relation = collection.fields[name]
-            foreign_collection = collection.datasource.collection(relation.foreign_collection)
+            relation = collection.schema[:fields][name]
+            foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
 
             relation_schema = {
               field: name,

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -7,7 +7,7 @@ module ForestAdminAgent
       class SchemaEmitter
         LIANA_NAME = "forest-rails"
 
-        LIANA_VERSION = "1.0.0-beta.22"
+        LIANA_VERSION = "1.0.0-beta.24"
 
         def self.get_serialized_schema(datasource)
           schema_path = Facades::Container.cache(:schema_path)

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.0.0-beta.22"
+  VERSION = "1.0.0-beta.24"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.22
+  version: 1.0.0.pre.beta.24
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-08 00:00:00.000000000 Z
+date: 2023-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,6 +25,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: deepsort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.5
 - !ruby/object:Gem::Dependency
   name: dry-container
   requirement: !ruby/object:Gem::Requirement
@@ -204,7 +218,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
-- CHANGELOG.md
 - README.md
 - Rakefile
 - forest_admin
@@ -229,6 +242,7 @@ files:
 - lib/forest_admin_agent/routes/abstract_authenticated_route.rb
 - lib/forest_admin_agent/routes/abstract_related_route.rb
 - lib/forest_admin_agent/routes/abstract_route.rb
+- lib/forest_admin_agent/routes/charts/charts.rb
 - lib/forest_admin_agent/routes/resources/count.rb
 - lib/forest_admin_agent/routes/resources/delete.rb
 - lib/forest_admin_agent/routes/resources/list.rb
@@ -242,6 +256,7 @@ files:
 - lib/forest_admin_agent/routes/resources/update.rb
 - lib/forest_admin_agent/routes/security/authentication.rb
 - lib/forest_admin_agent/routes/system/health_check.rb
+- lib/forest_admin_agent/serializer/forest_chart_serializer.rb
 - lib/forest_admin_agent/serializer/forest_serializer.rb
 - lib/forest_admin_agent/serializer/forest_serializer_override.rb
 - lib/forest_admin_agent/services/ip_whitelist.rb

data/CHANGELOG.md

@@ -1,5 +0,0 @@
-## [Unreleased]
-
-## [0.1.0] - 2023-08-28
-
-- Initial release