forest_admin_datasource_customizer 1.0.0.pre.beta.21 → 1.0.0.pre.beta.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a57e523c5b7c53d6a40452a6f9ea21a7a1b858ab1a39a3f5cac3fe83ec93ec27
-  data.tar.gz: a6cf096f51d0ed6c12fa9787e69b74c75663f1eba63981822369ba41a73bd621
+  metadata.gz: 26154cad59202641c5e5b05438306ca77b63a79a764a8f65d4a31a0c7808c33f
+  data.tar.gz: 9e9bfab31439f364e7a0e3624001a952a6f51b670fb6677cbf00cfcb476006a8
 SHA512:
-  metadata.gz: ba6b15e85b6c7bd38cf9a32b26824b52c8078a33b0001add15942a042c8d5afd8fd4d7a3e21d742cdce700338a62f1a0b928d3d40ee8af171ae92acad415d02f
-  data.tar.gz: 9deebebbc665d471aa7450e23df9bd12df12d0333cca89aefa1cd3cabf710a755c0821ee944d41daa8ee1437b31ce5ddb90256f53b8be8f55cd1b819618a6b2d
+  metadata.gz: 601b7736694dbe374753c7b8c9d02563c7a7ea4e17fc1d0eb50964942953ebcdc6bed0c373fafe058fbaaa84e80171e685db8ed3d3a4612c7c82bbdfb81a3a84
+  data.tar.gz: d592ca27fb7c138fa7e347d8e99fcd09a55a914e959faa7824144441163ae306201733c6c35e284a953d803a1a3344c07ae003ad04e44c226b31f52d89544b99

data/forest_admin_datasource_customizer.gemspec

@@ -12,12 +12,12 @@ Gem::Specification.new do |spec|
   spec.summary      = "Ruby agent for Forest Admin."
   spec.description  = "Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
 admin work on any Ruby application."
-  spec.license = "MIT"
+  spec.license = "GPL-3.0"
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/ForestAdmin/agent-ruby"
-  spec.metadata["changelog_uri"] = "https://github.com/ForestAdmin/agent-ruby/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "https://github.com/ForestAdmin/agent-ruby/blob/main/CHANGELOG.md"
   spec.metadata["rubygems_mfa_required"] = "false"
 
   # Specify which files should be added to the gem when it is released.
@@ -34,5 +34,6 @@ admin work on any Ruby application."
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport", ">= 6.1"
+  spec.add_dependency 'marcel', '~> 1.0', '>= 1.0.4'
   spec.add_dependency "zeitwerk", "~> 2.3"
 end

data/lib/forest_admin_datasource_customizer/collection_customizer.rb

@@ -1,5 +1,6 @@
 module ForestAdminDatasourceCustomizer
   class CollectionCustomizer
+    include ForestAdminDatasourceToolkit::Validations
     attr_reader :datasource_customizer, :stack, :name
 
     def initialize(datasource_customizer, stack, name)
@@ -8,18 +9,304 @@ module ForestAdminDatasourceCustomizer
       @name = name
     end
 
+    def add_action(name, definition)
+      push_customization { @stack.action.get_collection(@name).add_action(name, definition) }
+    end
+
     def schema
-      @stack.datasource.get_collection(@name).schema
+      @stack.validation.get_collection(@name).schema
     end
 
     def collection
-      @stack.datasource.get_collection(@name)
+      @stack.validation.get_collection(@name)
     end
 
     def use(plugin, options = [])
-      push_customization(
-        -> { plugin.run(@datasource_customizer, self, options) }
-      )
+      push_customization { plugin.new.run(@datasource_customizer, self, options) }
+    end
+
+    def disable_count
+      push_customization { @stack.schema.get_collection(@name).override_schema(countable: false) }
+    end
+
+    def replace_search(definition)
+      push_customization { @stack.search.get_collection(@name).replace_search(definition) }
+    end
+
+    def add_field(name, definition)
+      push_customization do
+        collection_before_relations = @stack.early_computed.get_collection(@name)
+        collection_after_relations = @stack.late_computed.get_collection(@name)
+        can_be_computed_before_relations = definition.dependencies.all? do |field|
+          !ForestAdminDatasourceToolkit::Utils::Collection.get_field_schema(collection_before_relations, field).nil?
+        rescue StandardError
+          false
+        end
+
+        collection = can_be_computed_before_relations ? collection_before_relations : collection_after_relations
+
+        collection.register_computed(name, definition)
+      end
+    end
+
+    def emulate_field_operator(name, operator)
+      push_customization do
+        collection = if @stack.early_op_emulate.get_collection(@name).schema[:fields].key?(name)
+                       @stack.early_op_emulate.get_collection(@name)
+                     else
+                       @stack.late_op_emulate.get_collection(@name)
+                     end
+
+        collection.emulate_field_operator(name, operator)
+      end
+    end
+
+    def emulate_field_filtering(name)
+      push_customization do
+        collection = @stack.late_op_emulate.get_collection(@name)
+        field = collection.schema[:fields][name]
+
+        if field.column_type.is_a?(String)
+          operators = Rules.get_allowed_operators_for_column_type[field.column_type]
+
+          operators.each do |operator|
+            emulate_field_operator(name, operator) unless field.filter_operators&.include?(operator)
+          end
+        end
+      end
+    end
+
+    def replace_field_operator(name, operator, &replacer)
+      push_customization do
+        collection = if @stack.early_op_emulate.get_collection(@name).schema[:fields].key?(name)
+                       @stack.early_op_emulate.get_collection(@name)
+                     else
+                       @stack.late_op_emulate.get_collection(@name)
+                     end
+
+        collection.replace_field_operator(name, operator, &replacer)
+      end
+    end
+
+    # Add a many to one relation to the collection
+    # @param name name of the new relation
+    # @param foreign_collection name of the targeted collection
+    # @param options extra information about the relation
+    # @example
+    # books.add_many_to_one_relation('my_author', 'persons', { foreign_key: 'author_id' })
+    def add_many_to_one_relation(name, foreign_collection, options = {})
+      push_relation(name, {
+                      type: 'ManyToOne',
+                      foreign_collection: foreign_collection,
+                      foreign_key: options[:foreign_key],
+                      foreign_key_target: options[:foreign_key_target]
+                    })
+    end
+
+    # Add a one to many relation to the collection
+    # @param name name of the new relation
+    # @param foreign_collection name of the targeted collection
+    # @param options extra information about the relation
+    # @example
+    # persons.add_one_to_many_relation('written_books', 'books', { origin_key: 'author_id' })
+    def add_one_to_many_relation(name, foreign_collection, options = {})
+      push_relation(name, {
+                      type: 'OneToMany',
+                      foreign_collection: foreign_collection,
+                      origin_key: options[:origin_key],
+                      origin_key_target: options[:origin_key_target]
+                    })
+    end
+
+    # Add a one to one relation to the collection
+    # @param name name of the new relation
+    # @param foreign_collection name of the targeted collection
+    # @param options extra information about the relation
+    # @example
+    # persons.add_one_to_one_relation('best_friend', 'persons', { origin_key: 'best_friend_id' })
+    def add_one_to_one_relation(name, foreign_collection, options = {})
+      push_relation(name, {
+                      type: 'OneToOne',
+                      foreign_collection: foreign_collection,
+                      origin_key: options[:origin_key],
+                      origin_key_target: options[:origin_key_target]
+                    })
+    end
+
+    # Add a many to many relation to the collection
+    # @param name name of the new relation
+    # @param foreign_collection name of the targeted collection
+    # @param through_collection name of the intermediary collection
+    # @param options extra information about the relation
+    # @example
+    # dvds.add_many_to_many_relation('rentals_of_this_dvd', 'rentals', 'dvd_rentals', {
+    #  origin_key: 'dvd_id',
+    # foreign_key: 'rental_id'
+    # })
+    def add_many_to_many_relation(name, foreign_collection, through_collection, options = {})
+      push_relation(name, {
+                      type: 'ManyToMany',
+                      foreign_collection: foreign_collection,
+                      through_collection: through_collection,
+                      origin_key: options[:origin_key],
+                      origin_key_target: options[:origin_key_target],
+                      foreign_key: options[:foreign_key],
+                      foreign_key_target: options[:foreign_key_target]
+                    })
+    end
+
+    def add_external_relation(name, definition)
+      use(ForestAdminDatasourceCustomizer::Plugins::AddExternalRelation, { name: name }.merge(definition))
+    end
+
+    def import_field(name, definition)
+      use(ForestAdminDatasourceCustomizer::Plugins::ImportField, { name: name }.merge(definition))
+    end
+
+    # Add a new validator to the edition form of a given field
+    # @param name The name of the field
+    # @param operator The validator that you wish to add
+    # @param value A configuration value that the validator may need
+    # @example
+    # .add_field_validation('first_name', Operators::LONGER_THAN, 2)
+    def add_field_validation(name, operator, value = nil)
+      push_customization do
+        @stack.validation.get_collection(@name).add_validation(name, { operator: operator, value: value })
+      end
+    end
+
+    # Enable sorting on a specific field using emulation.
+    # As for all the emulation method, the field sorting will be done in-memory.
+    # @param name the name of the field to enable emulation on
+    # @example
+    # .emulate_field_sorting('fullName')
+    def emulate_field_sorting(name)
+      push_customization { @stack.sort.get_collection(@name).emulate_field_sorting(name) }
+    end
+
+    # Replace an implementation for the sorting.
+    # The field sorting will be done by the datasource.
+    # @param name the name of the field to enable sort
+    # @param equivalent_sort the sort equivalent
+    # @example
+    # .replace_field_sorting(
+    #   'fullName',
+    #   [
+    #     { field: 'firstName', ascending: true },
+    #     { field: 'lastName',  ascending: true },
+    #   ]
+    # )
+    def replace_field_sorting(name, equivalent_sort)
+      push_customization { @stack.sort.get_collection(@name).replace_field_sorting(name, equivalent_sort) }
+    end
+
+    # Remove fields from the exported schema (they will still be usable within the agent).
+    # @param names the names of the field or the relation
+    # @example
+    # .remove_field('fieldNameToRemove', 'relationNameToRemove')
+    def remove_field(*names)
+      push_customization do
+        collection = @stack.publication.get_collection(@name)
+        names.each { |name| collection.change_field_visibility(name, false) }
+      end
+    end
+
+    # Rename fields from the exported schema.
+    # @param current_name the current name of the field or the relation in a given collection
+    # @param new_name the new name of the field or the relation
+    # @example
+    # rename_field('currentFieldOrRelationName', 'newFieldOrRelationName')
+    def rename_field(current_name, new_name)
+      push_customization { @stack.rename_field.get_collection(@name).rename_field(current_name, new_name) }
+    end
+
+    # Replace the write behavior of a field.
+    # @param name the name of the field
+    # @param definition the function or a value to represent the write behavior
+    # @example
+    # .replace_field_writing('author_last_name') do
+    #   { 'author' => { 'last_name' => value } }
+    # end
+    def replace_field_writing(name, &definition)
+      push_customization { @stack.write.get_collection(@name).replace_field_writing(name, &definition) }
+    end
+
+    # Create a new API chart
+    # @param name name of the chart
+    # @param definition definition of the chart
+    # @example
+    # .add_chart('num_customers') do |context, result_builder|
+    #   return result_builder.distribution({
+    #     tomatoes: 10,
+    #     potatoes: 20,
+    #     carrots: 30,
+    #   });
+    # end
+    def add_chart(name, &definition)
+      push_customization { @stack.chart.get_collection(@name).add_chart(name, &definition) }
+    end
+
+    # Add a new hook handler to an action
+    # @param position Either if the hook is executed before or after the action
+    # @param type Type of action which should be hooked
+    # @param handler Callback that should be executed when the hook is triggered
+    # @example
+    # .add_hook('before', 'list') do |context|
+    #   # Do something before the list action
+    # end
+    def add_hook(position, type, &handler)
+      push_customization { @stack.hook.get_collection(@name).add_hook(position, type, handler) }
+    end
+
+    # Add a new segment on the collection.
+    # @param name the name of the segment
+    # @param definition a function used to generate a condition tree or a condition tree
+    # @example
+    # .add_segment(
+    #    'Wrote more than 2 books',
+    #   { field: 'booksCount', operator: 'GreaterThan', value: 2 }
+    # );
+    def add_segment(name, &definition)
+      push_customization { @stack.segment.get_collection(@name).add_segment(name, definition) }
+    end
+
+    # Choose how binary data should be transported to the GUI.
+    # By default, all fields are transported as 'datauri', with the exception of primary and foreign
+    # keys.
+    #
+    # Using 'datauri' allows to use the FilePicker widget, while 'hex' is more suitable for
+    # short binary data (for instance binary uuids).
+    #
+    # @param name the name of the field
+    # @param binary_mode either 'datauri' or 'hex'
+    # @example
+    # .replace_field_binary_mode('avatar', 'datauri');
+    def replace_field_binary_mode(name, binary_mode)
+      push_customization { @stack.binary.get_collection(@name).set_binary_mode(name, binary_mode) }
+    end
+
+    def override_create(&handler)
+      push_customization { @stack.override.get_collection(@name).add_create_handler(handler) }
+    end
+
+    def override_update(&handler)
+      push_customization { @stack.override.get_collection(@name).add_update_handler(handler) }
+    end
+
+    def override_delete(&handler)
+      push_customization { @stack.override.get_collection(@name).add_delete_handler(handler) }
+    end
+
+    private
+
+    def push_customization(&customization)
+      @stack.queue_customization(customization)
+
+      self
+    end
+
+    def push_relation(name, definition)
+      push_customization { @stack.relation.get_collection(@name).add_relation(name, definition) }
     end
   end
 end

data/lib/forest_admin_datasource_customizer/context/agent_customization_context.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Context
+    class AgentCustomizationContext
+      include ForestAdminDatasourceCustomizer::Context::RelaxedWrappers
+
+      attr_reader :caller
+
+      def initialize(datasource, caller)
+        @real_datasource = datasource
+        @caller = caller
+      end
+
+      def datasource
+        RelaxedDataSource.new(@real_datasource, @caller)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/context/collection_customization_context.rb

@@ -0,0 +1,15 @@
+module ForestAdminDatasourceCustomizer
+  module Context
+    class CollectionCustomizationContext < AgentCustomizationContext
+      include ForestAdminDatasourceCustomizer::Context::RelaxedWrappers
+      def initialize(collection, caller)
+        super(collection.datasource, caller)
+        @real_collection = collection
+      end
+
+      def collection
+        RelaxedCollection.new(@real_collection, @caller)
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/context/relaxed_wrappers/relaxed_collection.rb

@@ -0,0 +1,50 @@
+module ForestAdminDatasourceCustomizer
+  module Context
+    module RelaxedWrappers
+      class RelaxedCollection
+        include ForestAdminDatasourceToolkit::Components::Query
+
+        def initialize(collection, caller)
+          @collection = collection
+          @caller = caller
+        end
+
+        def native_driver
+          @collection.native_driver
+        end
+
+        def schema
+          @collection.schema
+        end
+
+        def execute(name, form_values = {}, filter = nil)
+          @collection.execute(@caller, name, form_values, filter)
+        end
+
+        def get_form(name, data = nil, filter = nil, metas = {})
+          @collection.get_form(@caller, name, data, filter, metas)
+        end
+
+        def create(data)
+          @collection.create(@caller, data)
+        end
+
+        def list(filter, projection)
+          @collection.list(@caller, filter, projection)
+        end
+
+        def update(filter, data)
+          @collection.update(@caller, filter, data)
+        end
+
+        def delete(filter)
+          @collection.delete(@caller, filter)
+        end
+
+        def aggregate(filter, aggregation, limit = nil)
+          @collection.aggregate(@caller, filter, aggregation, limit)
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/context/relaxed_wrappers/relaxed_data_source.rb

@@ -0,0 +1,18 @@
+module ForestAdminDatasourceCustomizer
+  module Context
+    module RelaxedWrappers
+      class RelaxedDataSource
+        def initialize(datasource, caller)
+          @real_datasource = datasource
+          @caller = caller
+        end
+
+        # Get a collection from a datasource
+        # @param name the name of the collection
+        def get_collection(name)
+          RelaxedCollection.new(@real_datasource.get_collection(name), @caller)
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/datasource_customizer.rb

@@ -8,7 +8,7 @@ module ForestAdminDatasourceCustomizer
     end
 
     def schema
-      @stack.datasource.schema
+      @stack.validation.schema
     end
 
     def get_collection(name)
@@ -19,33 +19,63 @@ module ForestAdminDatasourceCustomizer
       @stack.datasource.collections.transform_values { |collection| get_collection(collection.name) }
     end
 
-    def datasource
-      # TODO: call @stack.apply_queued_customizations(logger);
+    def datasource(logger)
+      @stack.apply_queued_customizations(logger)
 
       @stack.datasource
     end
 
-    def add_datasource(datasource, _options)
-      # TODO: add include/exclude behavior
-      # TODO: add rename behavior
+    def add_datasource(datasource, options)
+      @stack.queue_customization(lambda {
+        if options[:include] || options[:exclude]
+          publication_decorator = Decorators::Publication::PublicationDatasourceDecorator.new(datasource)
+          publication_decorator.keep_collections_matching(options[:include], options[:exclude])
+          datasource = publication_decorator
+        end
 
-      datasource.collections.each_value { |collection| @composite_datasource.add_collection(collection) }
+        if options[:rename]
+          rename_collection_decorator = Decorators::RenameCollection::RenameCollectionDatasourceDecorator.new(
+            datasource
+          )
+          rename_collection_decorator.rename_collections(options[:rename])
+          datasource = rename_collection_decorator
+        end
+
+        datasource.collections.each_value do |collection|
+          @composite_datasource.add_collection(collection)
+        end
+      })
+
+      self
     end
 
-    def add_chart(name, definition)
-      # TODO: to implement
+    # Create a new API chart
+    # @param name name of the chart
+    # @param definition definition of the chart
+    # @example
+    # .addChart('num_customers') { |context, result_builder| result_builder.value(123) }
+    def add_chart(name, &definition)
+      push_customization { @stack.chart.add_chart(name, &definition) }
     end
 
     def use(plugin, options)
-      # TODO: to implement
+      push_customization { plugin.new.run(self, nil, options) }
     end
 
     def customize_collection(name, handle)
-      # TODO: to implement
+      handle.call(get_collection(name))
+    end
+
+    def remove_collection(*names)
+      @stack.queue_customization(-> { @stack.publication.keep_collections_matching(nil, names) })
+
+      self
     end
 
-    def remove_collection(names)
-      # TODO: to implement
+    private
+
+    def push_customization(&customization)
+      @stack.queue_customization(customization)
     end
   end
 end

data/lib/forest_admin_datasource_customizer/decorators/action/action_collection_decorator.rb

@@ -0,0 +1,137 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Action
+      class ActionCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Components
+
+        def initialize(child_collection, datasource)
+          super
+          @actions = {}
+        end
+
+        def add_action(name, action)
+          action.build_fields
+          @actions[name] = action
+
+          mark_schema_as_dirty
+        end
+
+        def execute(caller, name, data, filter = nil)
+          action = @actions[name]
+          return @child_collection.execute(caller, name, data, filter) if action.nil?
+
+          context = get_context(caller, action, data, filter)
+
+          result_builder = ResultBuilder.new
+          result = action.execute.call(context, result_builder)
+
+          return result if result.is_a? Hash
+
+          result_builder.success
+        end
+
+        def get_form(caller, name, data = nil, filter = nil, metas = {})
+          action = @actions[name]
+          return @child_collection.get_form(caller, name, data, filter, metas) if action.nil?
+          return [] if action.form.nil?
+
+          form_values = data || {}
+          used = []
+          context = get_context(caller, action, form_values, filter, used, metas[:change_field])
+
+          dynamic_fields = action.form
+          if metas[:search_field]
+            # in the case of a search hook,
+            # we don't want to rebuild all the fields. only the one searched
+            dynamic_fields = dynamic_fields.select { |field| field.label == metas[:search_field] }
+          end
+          dynamic_fields = drop_defaults(context, dynamic_fields, form_values)
+          dynamic_fields = drop_ifs(context, dynamic_fields) unless metas[:include_hidden_fields]
+
+          fields = drop_deferred(context, metas[:search_values], dynamic_fields)
+
+          fields.each do |field|
+            if field.value.nil?
+              # customer did not define a handler to rewrite the previous value => reuse current one.
+              field.value = form_values[field.label]
+            end
+
+            # fields that were accessed through the context.get_form_value(x) getter should be watched.
+            field.watch_changes = used.include?(field.label)
+          end
+
+          fields
+        end
+
+        def refine_schema(sub_schema)
+          sub_schema[:actions] = @actions
+
+          sub_schema
+        end
+
+        private
+
+        def drop_defaults(context, fields, data)
+          unvalued_fields = fields.reject { |field| data.key?(field.label) }
+          defaults = unvalued_fields.map { |field| evaluate(context, field.default_value) }
+          unvalued_fields.each_with_index { |field, index| data[field.label] = defaults[index] }
+
+          fields.each { |field| field.default_value = nil }
+
+          fields
+        end
+
+        def drop_ifs(context, fields)
+          if_values = fields.map { |field| !field.if_condition || evaluate(context, field.if_condition) }
+          new_fields = fields.select.with_index { |_field, index| if_values[index] }
+          new_fields.each do |field|
+            field = field.dup
+            field.if_condition = nil
+          end
+
+          new_fields
+        end
+
+        def drop_deferred(context, search_values, fields)
+          new_fields = []
+          fields.each do |field|
+            field = field.dup
+            field.instance_variables.each do |key|
+              key = key.to_s.delete('@').to_sym
+
+              next unless field.respond_to?(key)
+
+              # call getter corresponding to the key and then set the evaluated value
+              value = field.send(key)
+              key = key.to_s.concat('=').to_sym
+
+              field.send(key, evaluate(context, value, search_values&.dig(field.label)))
+            end
+
+            new_fields << Actions::ActionFieldFactory.build(field.to_h)
+          end
+
+          new_fields
+        end
+
+        def evaluate(context, value, search_value = nil)
+          if value.respond_to?(:call)
+            return value.call(context, search_value) if search_value
+
+            return value.call(context)
+          end
+
+          value
+        end
+
+        def get_context(caller, action, form_values = [], filter = nil, used = [], change_field = nil)
+          if action.scope == Types::ActionScope::SINGLE
+            return Context::ActionContextSingle.new(self, caller, form_values, filter, used, change_field)
+          end
+
+          Context::ActionContext.new(self, caller, form_values, filter, used, change_field)
+        end
+      end
+    end
+  end
+end