forest_admin_datasource_toolkit 1.0.0.pre.beta.23 → 1.0.0.pre.beta.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786b58c3bc21c7187d7a95025aae6229de6c04bac42549cede55f060be797d86
-  data.tar.gz: 477ffdc3ed1eba5e5240e641741f9f7cbd311373e35594438ccc452584a75830
+  metadata.gz: a6db15a9f9827fdef57eb3a018ec0c3a9851a5ab131f26b38d2792fc12cb897d
+  data.tar.gz: 83ed4a24c607297af411ec2bbeacf739bb2c9f5c6b611343885a7237abb1deb6
 SHA512:
-  metadata.gz: 46282da2e6d7221c853d234d382a3712a4fcb0e0340c06f93ba97f2a9ca26967a0adc0e153e6b904dfe39c4aaadcb31ffe0a3731ae6a097e3520120dbdaa0e16
-  data.tar.gz: 52c33562da9679ea958fec285158dc6c12f5fb7ff9a3076f2724951bae500e99debb10925a562add7daeab4d749102494b46c6a33eaaaee22e54c5fb4c861984
+  metadata.gz: 2169823cdaa62b57be4fbef2cbd5986c4576d43ea063425ab741a9abd58af0b83b17881cad854f1e2ec6a3fe8de1006e589842fa6cfe052394252748e4d4ad53
+  data.tar.gz: fbc3374aefaeda605d14e882e9a988142d9a5e43c3d147546bbd1cfa17c6978429f953367e9588c02d47684146c41a32f664887d4d30205cbc228698654f3d0b

data/lib/forest_admin_datasource_toolkit/collection.rb

@@ -1,6 +1,6 @@
 module ForestAdminDatasourceToolkit
   class Collection < Components::Contracts::CollectionContract
-    attr_accessor :fields, :segments
+    attr_accessor :segments
 
     attr_reader :actions,
                 :charts,
@@ -17,13 +17,17 @@ module ForestAdminDatasourceToolkit
       @datasource = datasource
       @name = name
       @native_driver = native_driver
-      @fields = {}
-      @schema = {}
-      @fields = {}
+      @schema = {
+        fields: {}
+      }
       @actions = {}
       @segments = {}
       @charts = {}
       @searchable = false
+      @countable = false
+    end
+
+    def enable_count
       @countable = true
     end
 
@@ -35,10 +39,14 @@ module ForestAdminDatasourceToolkit
       @searchable
     end
 
+    def fields
+      @schema[:fields]
+    end
+
     def add_field(name, field)
-      raise Exceptions::ForestException, "Field #{name} already defined in collection" if @fields.key?(name)
+      raise Exceptions::ForestException, "Field #{name} already defined in collection" if @schema[:fields].key?(name)
 
-      @fields[name] = field
+      @schema[:fields][name] = field
     end
 
     def add_fields(fields)

data/lib/forest_admin_datasource_toolkit/components/contracts/datasource_contract.rb

@@ -10,7 +10,7 @@ module ForestAdminDatasourceToolkit
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 
-        def collection(name)
+        def get_collection(name)
           raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
         end
 

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/condition_tree_factory.rb

@@ -22,7 +22,7 @@ module ForestAdminDatasourceToolkit
             raise ForestException, 'Collection must have at least one primary key' if primary_key_names.empty?
 
             primary_key_names.each do |name|
-              operators = collection.fields[name].filter_operators
+              operators = collection.schema[:fields][name].filter_operators
               unless operators.include?(Operators::EQUAL) || operators.include?(Operators::IN)
                 raise ForestException, "Field '#{name}' must support operators: ['Equal', 'In']"
               end

data/lib/forest_admin_datasource_toolkit/components/query/condition_tree/transforms/times.rb

@@ -54,15 +54,15 @@ module ForestAdminDatasourceToolkit
             def self.previous_interval(duration)
               interval(
                 lambda { |now|
-                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send("beginning_of_#{duration}")
+                  duration == 'quarter' ? now.prev_quarter : (now - 1.send(duration)).send(:"beginning_of_#{duration}")
                 },
-                ->(now) { now.send("beginning_of_#{duration}") }
+                ->(now) { now.send(:"beginning_of_#{duration}") }
               )
             end
 
             def self.previous_interval_to_date(duration)
               interval(
-                ->(now) { now.send("beginning_of_#{duration}") },
+                ->(now) { now.send(:"beginning_of_#{duration}") },
                 ->(now) { now }
               )
             end

data/lib/forest_admin_datasource_toolkit/components/query/filter_factory.rb

@@ -61,7 +61,7 @@ module ForestAdminDatasourceToolkit
           if relation.is_a?(OneToManySchema)
             origin_tree = Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value)
           else
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
             through_tree = ConditionTreeFactory.intersect([
                                                             Nodes::ConditionTreeLeaf.new(relation.origin_key, Operators::EQUAL, origin_value),
                                                             Nodes::ConditionTreeLeaf.new(relation.foreign_key, Operators::PRESENT)
@@ -86,8 +86,8 @@ module ForestAdminDatasourceToolkit
           unit = unit.downcase
           start = "beginning_of_#{unit}"
           end_ = "end_of_#{unit}"
-          start_period = Time.now.in_time_zone(timezone).send("prev_#{unit}").send(start)
-          end_period = Time.now.in_time_zone(timezone).send("prev_#{unit}").send(end_)
+          start_period = Time.now.in_time_zone(timezone).send(:"prev_#{unit}").send(start)
+          end_period = Time.now.in_time_zone(timezone).send(:"prev_#{unit}").send(end_)
 
           get_previous_condition_tree(field, start_period.to_datetime, end_period.to_datetime)
         end
@@ -104,13 +104,13 @@ module ForestAdminDatasourceToolkit
         end
 
         def self.make_through_filter(collection, id, relation_name, caller, base_foreign_filter)
-          relation = collection.fields[relation_name]
+          relation = collection.schema[:fields][relation_name]
           origin_value = Utils::Collection.get_value(collection, caller, id, relation.origin_key_target)
           foreign_relation = Utils::Collection.get_through_target(collection, relation_name)
 
           # Optimization for many to many when there is not search/segment (saves one query)
           if foreign_relation && base_foreign_filter.nestable?
-            foreign_key = collection.datasource.collection(relation.through_collection).fields[relation.foreign_key]
+            foreign_key = collection.datasource.get_collection(relation.through_collection).schema[:fields][relation.foreign_key]
             base_through_filter = base_foreign_filter.nest(foreign_relation)
             condition_tree = ConditionTreeFactory.intersect(
               [
@@ -129,7 +129,7 @@ module ForestAdminDatasourceToolkit
 
           # Otherwise we have no choice but to call the target collection so that search and segment
           # are correctly apply, and then match ids in the though collection.
-          target = collection.datasource.collection(relation.foreign_collection)
+          target = collection.datasource.get_collection(relation.foreign_collection)
           records = target.list(
             caller,
             make_foreign_filter(collection, id, relation_name, caller, base_foreign_filter),

data/lib/forest_admin_datasource_toolkit/components/query/projection.rb

@@ -9,8 +9,8 @@ module ForestAdminDatasourceToolkit
           end
 
           relations.each do |relation, projection|
-            schema = collection.fields[relation]
-            association = collection.datasource.collection(schema.foreign_collection)
+            schema = collection.schema[:fields][relation]
+            association = collection.datasource.get_collection(schema.foreign_collection)
             projection_with_pks = projection.with_pks(association).nest(prefix: relation)
 
             projection_with_pks.each { |field| push(field) unless include?(field) }

data/lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb

@@ -4,14 +4,14 @@ module ForestAdminDatasourceToolkit
       class ProjectionFactory
         include ForestAdminDatasourceToolkit::Utils
         def self.all(collection)
-          projection_fields = collection.fields.reduce([]) do |memo, path|
+          projection_fields = collection.schema[:fields].reduce([]) do |memo, path|
             column_name = path[0]
             schema = path[1]
             memo += [column_name] if schema.type == 'Column'
 
             if schema.type == 'OneToOne' || schema.type == 'ManyToOne'
-              relation = collection.datasource.collection(schema.foreign_collection)
-              relation_columns = relation.fields
+              relation = collection.datasource.get_collection(schema.foreign_collection)
+              relation_columns = relation.schema[:fields]
                                          .select { |_column_name, relation_column| relation_column.type == 'Column' }
                                          .keys
                                          .map { |relation_column_name| "#{column_name}:#{relation_column_name}" }

data/lib/forest_admin_datasource_toolkit/datasource.rb

@@ -8,7 +8,7 @@ module ForestAdminDatasourceToolkit
       @collections = {}
     end
 
-    def collection(name)
+    def get_collection(name)
       raise Exceptions::ForestException, "Collection #{name} not found." unless @collections.key? name
 
       @collections[name]

data/lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb

@@ -0,0 +1,110 @@
+module ForestAdminDatasourceToolkit
+  module Decorators
+    class CollectionDecorator < Collection
+      attr_reader :datasource, :child_collection, :last_schema
+
+      def initialize(child_collection, datasource)
+        super
+        @child_collection = child_collection
+        @datasource = datasource
+
+        # When the child collection invalidates its schema, we also invalidate ours.
+        # This is done like this, and not in the markSchemaAsDirty method, because we don't have
+        # a reference to parent collections from children.
+        return unless child_collection.is_a?(CollectionDecorator)
+
+        original_child_mark_schema_as_dirty = child_collection.mark_schema_as_dirty
+        child_collection.mark_schema_as_dirty = lambda {
+          # Call the original method (the child)
+          original_child_mark_schema_as_dirty.call(child_collection)
+
+          # Invalidate our schema (the parent)
+          mark_schema_as_dirty
+        }
+      end
+
+      def native_driver
+        # TODO
+      end
+
+      def schema
+        unless @last_schema
+          sub_schema = @child_collection.schema
+          @last_schema = refine_schema(sub_schema)
+        end
+
+        @last_schema
+      end
+
+      def name
+        @child_collection.name
+      end
+
+      def execute(caller, name, data, filter = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.execute(caller, name, data, refined_filter)
+      end
+
+      def get_form(caller, name, data = nil, filter = nil, metas = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.get_form(caller, name, data, refined_filter, metas)
+      end
+
+      def create(caller, data)
+        @child_collection.create(caller, data)
+      end
+
+      def list(caller, filter = nil, projection = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.list(caller, refined_filter, projection)
+      end
+
+      def update(caller, filter, patch)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.update(caller, refined_filter, patch)
+      end
+
+      def delete(caller, filter)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.delete(caller, refined_filter)
+      end
+
+      def aggregate(caller, filter, aggregation, limit = nil)
+        refined_filter = refine_filter(caller, filter)
+
+        @child_collection.aggregate(caller, refined_filter, aggregation, limit)
+      end
+
+      def render_chart(caller, name, record_id)
+        @child_collection.render_chart(caller, name, record_id)
+      end
+
+      protected
+
+      def mark_schema_as_dirty
+        @last_schema = nil
+      end
+
+      def refine_filter(_caller, filter = nil)
+        filter
+      end
+
+      def refine_schema(sub_schema)
+        sub_schema
+      end
+
+      private
+
+      def push_customization(customization)
+        @stack.queue_customization(customization)
+
+        self
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/decorators/datasource_decorator.rb

@@ -0,0 +1,28 @@
+module ForestAdminDatasourceToolkit
+  module Decorators
+    class DatasourceDecorator
+      def initialize(child_datasource, collection_decorator_class)
+        @child_datasource = child_datasource
+        @collection_decorator_class = collection_decorator_class
+        @decorators = {}
+      end
+
+      def collections
+        @child_datasource.collections.transform_values { |c| get_collection(c.name) }
+      end
+
+      def get_collection(name)
+        collection = @child_datasource.get_collection(name)
+        unless @decorators.key?(collection.name)
+          @decorators[collection.name] = @collection_decorator_class.new(collection, self)
+        end
+
+        @decorators[collection.name]
+      end
+
+      def render_chart(caller, name)
+        @child_datasource.render_chart(caller, name)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_toolkit/utils/collection.rb

@@ -7,10 +7,10 @@ module ForestAdminDatasourceToolkit
       include ForestAdminDatasourceToolkit::Exceptions
 
       def self.get_inverse_relation(collection, relation_name)
-        relation_field = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation_field.foreign_collection)
+        relation_field = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation_field.foreign_collection)
 
-        inverse = foreign_collection.fields.select do |_name, field|
+        inverse = foreign_collection.schema[:fields].select do |_name, field|
           field.is_a?(RelationSchema) &&
             field.foreign_collection == collection.name &&
             (
@@ -50,7 +50,7 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.get_field_schema(collection, field_name)
-        fields = collection.fields
+        fields = collection.schema[:fields]
         unless field_name.include?(':')
           raise ForestException, "Column not found #{collection.name}.#{field_name}" unless fields.key?(field_name)
 
@@ -67,7 +67,7 @@ module ForestAdminDatasourceToolkit
         end
 
         get_field_schema(
-          collection.datasource.collection(relation_schema.foreign_collection), field_name.split(':')[1..].join(':')
+          collection.datasource.get_collection(relation_schema.foreign_collection), field_name.split(':')[1..].join(':')
         )
       end
 
@@ -90,11 +90,11 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.get_through_target(collection, relation_name)
-        relation = collection.fields[relation_name]
+        relation = collection.schema[:fields][relation_name]
         raise ForestException, 'Relation must be many to many' unless relation.is_a?(ManyToManySchema)
 
-        through_collection = collection.datasource.collection(relation.through_collection)
-        through_collection.fields.select do |field_name, field|
+        through_collection = collection.datasource.get_collection(relation.through_collection)
+        through_collection.schema[:fields].select do |field_name, field|
           if field.is_a?(ManyToOneSchema) &&
              field.foreign_collection == relation.foreign_collection &&
              field.foreign_key == relation.foreign_key &&
@@ -107,11 +107,11 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.get_through_origin(collection, relation_name)
-        relation = collection.fields[relation_name]
+        relation = collection.schema[:fields][relation_name]
         raise ForestException, 'Relation must be many to many' unless relation.is_a?(ManyToManySchema)
 
-        through_collection = collection.datasource.collection(relation.through_collection)
-        through_collection.fields.select do |field_name, field|
+        through_collection = collection.datasource.get_collection(relation.through_collection)
+        through_collection.schema[:fields].select do |field_name, field|
           if field.is_a?(ManyToOneSchema) &&
              field.foreign_collection == collection.name &&
              field.foreign_key == relation.origin_key &&
@@ -124,14 +124,14 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.list_relation(collection, id, relation_name, caller, foreign_filter, projection)
-        relation = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation.foreign_collection)
+        relation = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
 
         if relation.is_a?(ManyToManySchema) && foreign_filter.nestable?
           foreign_relation = get_through_target(collection, relation_name)
 
           if foreign_relation
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
             records = through_collection.list(
               caller,
               FilterFactory.make_through_filter(collection, id, relation_name, caller, foreign_filter),
@@ -150,13 +150,13 @@ module ForestAdminDatasourceToolkit
       end
 
       def self.aggregate_relation(collection, id, relation_name, caller, foreign_filter, aggregation, limit = nil)
-        relation = collection.fields[relation_name]
-        foreign_collection = collection.datasource.collection(relation.foreign_collection)
+        relation = collection.schema[:fields][relation_name]
+        foreign_collection = collection.datasource.get_collection(relation.foreign_collection)
 
         if relation.is_a?(ManyToManySchema) && foreign_filter.nestable?
           foreign_relation = get_through_target(collection, relation_name)
           if foreign_relation
-            through_collection = collection.datasource.collection(relation.through_collection)
+            through_collection = collection.datasource.get_collection(relation.through_collection)
 
             return through_collection.aggregate(
               caller,

data/lib/forest_admin_datasource_toolkit/utils/schema.rb

@@ -2,33 +2,33 @@ module ForestAdminDatasourceToolkit
   module Utils
     class Schema
       def self.foreign_key?(collection, name)
-        field = collection.fields[name]
+        field = collection.schema[:fields][name]
 
         field.type == 'Column' &&
-          collection.fields.any? do |_key, relation|
+          collection.schema[:fields].any? do |_key, relation|
             relation.type == 'ManyToOne' && relation.foreign_key == name
           end
       end
 
       def self.primary_key?(collection, name)
-        field = collection.fields[name]
+        field = collection.schema[:fields][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]
+        collection.schema[:fields].keys.select do |field_name|
+          field = collection.schema[:fields][field_name]
           field.type == 'Column' && field.is_primary_key
         end
       end
 
       def self.get_to_many_relation(collection, relation_name)
-        unless collection.fields.key?(relation_name)
+        unless collection.schema[:fields].key?(relation_name)
           raise Exceptions::ForestException, "Relation #{relation_name} not found"
         end
 
-        relation = collection.fields[relation_name]
+        relation = collection.schema[:fields][relation_name]
 
         if relation.type != 'OneToMany' && relation.type != 'ManyToMany'
           raise Exceptions::ForestException,

data/lib/forest_admin_datasource_toolkit/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceToolkit
-  VERSION = "1.0.0-beta.23"
+  VERSION = "1.0.0-beta.24"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_toolkit
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.23
+  version: 1.0.0.pre.beta.24
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2023-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,6 +82,8 @@ files:
 - lib/forest_admin_datasource_toolkit/components/query/projection.rb
 - lib/forest_admin_datasource_toolkit/components/query/projection_factory.rb
 - lib/forest_admin_datasource_toolkit/datasource.rb
+- lib/forest_admin_datasource_toolkit/decorators/collection_decorator.rb
+- lib/forest_admin_datasource_toolkit/decorators/datasource_decorator.rb
 - lib/forest_admin_datasource_toolkit/exceptions/forest_exception.rb
 - lib/forest_admin_datasource_toolkit/schema/column_schema.rb
 - lib/forest_admin_datasource_toolkit/schema/primitive_type.rb