feat(form): add separator layout element

.rubocop.yml

@@ -227,6 +227,7 @@ Metrics/MethodLength:
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/components/actions/action_field_factory.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/action/base_action.rb'
  - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/rename_field/rename_field_collection_decorator.rb'
+ - 'packages/forest_admin_datasource_customizer/lib/forest_admin_datasource_customizer/decorators/action/action_collection_decorator.rb'
 
 Metrics/BlockLength:
  Exclude:
@@ -258,6 +259,7 @@ Metrics/ClassLength:
  - 'packages/forest_admin_datasource_toolkit/lib/forest_admin_datasource_toolkit/validations/rules.rb'
  - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_action_field_widget.rb'
  - 'packages/forest_admin_datasource_active_record/lib/forest_admin_datasource_active_record/collection.rb'
+ - 'packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_action.rb'
 
 Style/OpenStructUse:
  Exclude:

package.json

@@ -1,5 +1,5 @@
 {
- "name": "agent-php",
+ "name": "agent-ruby",
  "version": "1.0.0-beta.66",
  "description": "The official agent Ruby for Forest.",
  "private": false,

packages/forest_admin_agent/lib/forest_admin_agent/routes/action/actions.rb

@@ -69,7 +69,11 @@ def handle_request(args = {})
  )
 
  # Now that we have the field list, we can parse the data again.
- data = Schema::ForestValueConverter.make_form_data(@datasource, raw_data, fields)
+ data = Schema::ForestValueConverter.make_form_data(
+ @datasource,
+ raw_data,
+ fields.reject { |field| field.type == 'Layout' }
+ )
 
  { content: @collection.execute(@caller, @action_name, data, filter_for_caller) }
  end
@@ -82,7 +86,7 @@ def handle_hook_request(args = {})
  search_values = {}
  forest_fields&.each { |field| search_values[field['field']] = field['searchValue'] }
 
-fields = @collection.get_form(
+form = @collection.get_form(
  @caller,
  @action_name,
  data,
@@ -94,10 +98,12 @@ def handle_hook_request(args = {})
  includeHiddenFields: false
  }
  )
+ form_elements = Schema::GeneratorAction.extract_fields_and_layout(form)
 
  {
  content: {
- fields: fields&.map { |field| Schema::GeneratorAction.build_field_schema(@datasource, field) } || {}
+ fields: Schema::GeneratorAction.build_fields(@collection, form_elements[:fields]),
+ layout: Schema::GeneratorAction.build_layout(form_elements[:layout])
  }
  }
  end

packages/forest_admin_agent/lib/forest_admin_agent/utils/schema/generator_action.rb

@@ -2,6 +2,8 @@ module ForestAdminAgent
  module Utils
  module Schema
  class GeneratorAction
+ include ForestAdminDatasourceToolkit::Components
+
  DEFAULT_FIELDS = [
  {
  field: 'Loading...',
@@ -23,27 +25,46 @@ def self.get_action_slug(name)
  end
 
  def self.build_schema(collection, name)
-schema = collection.schema[:actions][name]
+action = collection.schema[:actions][name]
  action_index = collection.schema[:actions].keys.index(name)
  slug = get_action_slug(name)
- fields = build_fields(collection, name, schema)
 
- {
+ form_elements = extract_fields_and_layout(collection.get_form(nil, name))
+ if action.static_form? && form_elements[:layout].empty?
+ # if action.static_form?
+ fields = build_fields(collection, form_elements[:fields])
+ layout = form_elements[:layout]
+ else
+ fields = DEFAULT_FIELDS
+ layout = nil
+ end
+
+ schema = {
  id: "#{collection.name}-#{action_index}-#{slug}",
  name: name,
- type: schema.scope.downcase,
+ type: action.scope.downcase,
  baseUrl: nil,
  endpoint: "/forest/_actions/#{collection.name}/#{action_index}/#{slug}",
  httpMethod: 'POST',
  redirect: nil, # frontend ignores this attribute
- download: schema.is_generate_file,
+ download: action.is_generate_file,
  fields: fields,
  hooks: {
- load: !schema.static_form?,
+ load: !action.static_form?,
  # Always registering the change hook has no consequences, even if we don't use it.
  change: ['changeHook']
  }
  }
+
+ return schema unless layout && !layout.empty?
+
+ schema[:layout] = build_layout(layout)
+
+ schema
+ end
+
+ def self.build_layout_schema(field)
+ { **field.to_h, component: field.component.downcase }
  end
 
  def self.build_field_schema(datasource, field)
@@ -76,26 +97,49 @@ def self.build_field_schema(datasource, field)
  output
  end
 
- class << self
- private
-
- def build_fields(collection, name, action)
- return DEFAULT_FIELDS unless action.static_form?
+ def self.build_fields(collection, fields)
+ if fields
+ return fields.map do |field|
+ new_field = build_field_schema(collection.datasource, field)
+ new_field[:default_value] = new_field[:value]
+ new_field.delete(:value)
 
- fields = collection.get_form(nil, name)
+ new_field
+ end
+ end
 
- if fields
- return fields.map do |field|
- new_field = build_field_schema(collection.datasource, field)
- new_field[:default_value] = new_field[:value]
- new_field.delete(:value)
+ []
+ end
 
- new_field
- end
+ def self.build_layout(elements)
+ if elements
+ return elements.map do |element|
+ build_layout_schema(element)
  end
+ end
+
+ []
+ end
+
+ def self.extract_fields_and_layout(form)
+ fields = []
+ layout = []
+ has_real_layout = false
 
- []
+ form&.each do |element|
+ if element.type == Actions::FieldType::LAYOUT
+ layout << element
+ has_real_layout = true
+ else
+ fields << element
+ # frontend rule
+ layout << Actions::ActionLayoutElement::InputElement.new(component: 'Input', field_id: element.label)
+ end
  end
+
+ layout = [] unless has_real_layout
+
+ { fields: fields, layout: layout }
  end
  end
  end

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

@@ -66,6 +66,7 @@ def serialize(schema)
  schema[:collections].each do |collection|
  collection_actions = collection[:actions]
  collection_segments = collection[:segments]
+
  collection.delete(:actions)
  collection.delete(:segments)
 
@@ -94,6 +95,7 @@ def serialize(schema)
 
  def get_smart_features_by_collection(type, data, with_attributes: false)
  smart_features = []
+
  data.each do |value|
  smart_feature = { id: value[:id], type: type }
  smart_feature[:attributes] = value if with_attributes

packages/forest_admin_agent/spec/lib/forest_admin_agent/routes/resources/action/actions_spec.rb

@@ -162,7 +162,7 @@ module Action
 
  describe 'handle_hook' do
  it 'generate a clean form if called without params' do
- allow(@action_collection).to receive(:get_form)
+ allow(@action_collection).to receive(:get_form).and_return([])
  action.handle_hook_request(args)
  expect(@action_collection).to have_received(:get_form) do |caller, action, data, filter, meta|
  expect(caller).to be_instance_of(Components::Caller)

packages/forest_admin_agent/spec/lib/forest_admin_agent/utils/schema/generator_action_spec.rb

@@ -200,6 +200,86 @@ module Schema
  )
  end
  end
+
+ describe 'with layout element' do
+ before do
+ @collection = collection_build(
+ schema: {
+ actions: {
+ 'Send email' => BaseAction.new(
+ scope: Types::ActionScope::SINGLE
+ )
+ }
+ },
+ get_form: [
+ ActionField.new(label: 'label', type: 'String'),
+ ActionLayoutElement::SeparatorElement.new
+ ]
+ )
+ end
+
+ describe 'build_schema' do
+ it 'generate schema correctly' do
+ schema = described_class.build_schema(@collection, 'Send email')
+
+ expect(schema).to eq(
+ {
+ id: 'collection-0-send-email',
+ name: 'Send email',
+ type: 'single',
+ baseUrl: nil,
+ endpoint: '/forest/_actions/collection/0/send-email',
+ httpMethod: 'POST',
+ redirect: nil,
+ download: false,
+ fields: [
+ {
+ defaultValue: 'Form is loading',
+ description: '',
+ enums: nil,
+ field: 'Loading...',
+ hook: nil,
+ isReadOnly: true,
+ isRequired: false,
+ reference: nil,
+ type: 'String',
+ value: nil,
+ widgetEdit: nil
+ }
+ ],
+ # uncomment when back validations will be done ...
+ # fields: [
+ # {
+ # default_value: nil,
+ # description: nil,
+ # field: 'label',
+ # isReadOnly: false,
+ # isRequired: false,
+ # type: 'String',
+ # widgetEdit: nil
+ # }
+ # ],
+ # layout: [
+ # { component: 'input', fieldId: 'label', type: 'Layout' },
+ # { component: 'separator', type: 'Layout' }
+ # ],
+ hooks: { load: false, change: ['changeHook'] }
+ }
+ )
+ end
+ end
+
+ describe 'extract_fields_and_layout' do
+ it 'return fields and layout separately from form' do
+ result = described_class.extract_fields_and_layout(@collection.get_form(nil, 'Send email'))
+
+ expect(result).to have_key(:fields)
+ expect(result).to have_key(:layout)
+ expect(result[:fields]).to all(be_a(ActionField))
+ expect(result[:layout]).to all(be_a(ActionLayoutElement::BaseLayoutElement))
+ end
+ end
+ end
  end
  end
  end

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

@@ -10,7 +10,7 @@ def initialize(child_collection, datasource)
  end
 
  def add_action(name, action)
- action.build_fields
+ action.build_elements
  @actions[name] = action
 
  mark_schema_as_dirty
@@ -51,6 +51,8 @@ def get_form(caller, name, data = nil, filter = nil, metas = {})
  fields = drop_deferred(context, metas[:search_values], dynamic_fields)
 
  fields.each do |field|
+ next if field.type == 'Layout'
+
  if field.value.nil?
  # customer did not define a handler to rewrite the previous value => reuse current one.
  field.value = form_values[field.label]
@@ -72,13 +74,20 @@ def refine_schema(sub_schema)
  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.map do |field|
+ if field.type == 'Layout'
+ field
+ else
+ drop_default(context, field, data)
+ end
+ end
+ end
 
- fields.each { |field| field.default_value = nil }
+ def drop_default(context, field, data)
+ data[field.label] = evaluate(context, field.default_value) unless data.key?(field.label)
+ field.default_value = nil
 
-fields
+field
  end
 
  def drop_ifs(context, fields)
@@ -105,7 +114,8 @@ def drop_deferred(context, search_values, fields)
  value = field.send(key)
  key = key.to_s.concat('=').to_sym
 
- field.send(key, evaluate(context, value, search_values&.dig(field.label)))
+ search_value = field.type == 'Layout' ? nil : search_values&.dig(field.label)
+ field.send(key, evaluate(context, value, search_value))
  end
 
  new_fields << Actions::ActionFieldFactory.build(field.to_h)