Was there a recommend approach in Alchmey 6 for "fallback elements"

[phantomwhale]

We've used the fallback option for render_elements in quite a few places to allow a "global page" to provide the element unless over-written, which in most cases is what we want.

However, I see this has been deprecated and subsequently removed in Alchemy 6 (#1982)

Was there a recommended alternative to this now? Was this just a feature the team didn't want to support any more? Or was there a reason it needed to be removed?

Just trying to understand what direction I should ideally take to migrate these pages onto Alchemy 6 (patching this method back in 😬 or changing the code to use a preferred approach in the library etc...)

[tvdeyen]

Was this just a feature the team didn't want to support any more?

Yes, and since this only works for HTML rendered elements and we're also want to support API driven sites. Also it was a feature hard to migrate into the versioned pages.

I would recommend to build your own elements finder class. You can pass an instance of any class that inherits from Alchemy::ElementsFinder into the render_elements helper

alchemy_cms/app/helpers/alchemy/elements_helper.rb

Lines 31 to 51 in 99b547f

	# === Custom elements finder:
	#
	# Having a custom element finder class:
	#
	# class MyCustomNewsArchive
	# def elements(page:)
	# news_page.elements.named('news').order(created_at: :desc)
	# end
	#
	# private
	#
	# def news_page
	# Alchemy::Page.where(page_layout: 'news-archive')
	# end
	# end
	#
	# In your view:
	#
	# <div class="news-archive">
	# <%= render_elements finder: MyCustomNewsArchive.new %>
	# </div>

This gives you much more control over what to load and when. Probably want to add some proper caching and eager loading, etc.

[phantomwhale]

Ah cool - have pulled code out of the Alchemy 5.x version of the code, and written a naive one as follows:

As you say, might need some eager loading (although suspect this should be no worse than the current library code, given it's a straight copy/paste of what's needed)

module Alchemy
  class FallbackElementsFinder < ElementsFinder
    def initialize(options = {})
      @fallback_options = options.delete(:fallback)
      super(options)
    end

    def elements(page:)
      elements = super(page: page)
      elements = elements.merge(fallback_elements) if with_fallback?(elements)
      elements
    end

    private

    attr_reader :fallback_options

    def with_fallback?(elements)
      fallback_options && elements.where(Alchemy::Element.table_name => { name: fallback_options[:for] }).none?
    end

    def fallback_elements
      find_elements(fallback_options[:from])
        .named(fallback_options[:with] || fallback_options[:for])
    end
  end
end