index.rb.erb in esse-0.1.1

- old
+ new
@@ -1,59 +1,124 @@
 # frozen_string_literal: true
 
+<%- @types.each do |type| -%>
+require_relative '<%= @index_name.demodulize.underscore.to_s %>/collections/<%= type.underscore %>_collection'
+<%- end -%>
+<%- @types.each do |type| -%>
+require_relative '<%= @index_name.demodulize.underscore.to_s %>/serializers/<%= type.underscore %>_serializer'
+<%- end -%>
+
 class <%= @index_name %> < <%= @base_class %>
   # plugin :active_record
   # plugin :sequel
 
+  <%- if @types.empty? -%>
+  # Collection
+  # ==========
+  #
+  # Collection is the source of data for the index. We hightly recommend using a
+  # another class that implements the Enumerable interface to better split the
+  # responsabilities and easy to test.
+  #
+  #   collection Collections::DocumentCollection
+  #
+  # but you can also use block definition style:
+  #   collection do |_context, &block|
+  #     block.call [{ title: 'foo' }, { title: 'bar' }], context
+  #   end
+  #
+  # Serializer block or class yielder should be called with an array of objects.
+  # Each these objects should be serialized using the serializer in described in the next section.
+  # The number of objects will be indexed to elasticsearch using the bulk api. So adjust the
+  # number of objects to be indexed accordingly.
+  #
+  # Here is a good place to eager loading data from database or any other repository.
+  # The bellow example is a rails like application that could preload using activerecord
+  #
+  #   collection do |**context, &block|
+  #     query = <%= @index_name.camelize %>.all
+  #     query = query.where(**context[:conditions]) if context[:conditions]
+  #     query = query.includes(:user) if context[:include_user]
+  #     query.find_in_batches(batch_size: 5000) do |batch|
+  #       block.call batch, context
+  #     end
+  #   end
+
+
+  # Serializer
+  # ==========
+  #
+  # Serializer is the class responsible for serializing indexing documents.
+  # Each object yielded by the collection will be serialized on this step.
+  # We recommend using a another class to handle the serialization. The only requirement is
+  # that the class implements the `#to_h` method.
+  # The serializer class may also be initialized with context if collection block is called with that extra parameter.
+  # Ability to call serializer with context is useful for preloading data from database or any other repository.
+  #
+  #    serializer Serializers::DocumentSerializer
+  #
+  # You can also serialize the collection entry using a block:
+  #
+  #   serializer do |model, context|
+  #     hash = {
+  #       name: <%= @index_name.underscore %>.name,
+  #     }
+  #     # Context is just an example here. But it's useful for eager loading data.
+  #     # I'll think a better example when implement this idea.
+  #     hash[:some_attribute] = <%= @index_name.underscore %>.some_attribute if context[:include_some_attribute]
+  #     hash
+  #   end
+  <%- end -%>
   <%- @types.each do |type| -%>
-  define_type :<%= type %> do
+  define_type :<%= type.underscore %> do
     # Collection
     # ==========
     #
     # Collection wraps the data into an array of items that should be serialized. The first argument that is
     # yielded must extends Enumerable.
     # Useful for eager loading data from database or any other repository. Below is an example of a rails like
     # application could load using activerecord.
     #
-    #   collection do |conditions, &block|
-    #     context = {}
-    #     <%= type.camelize %>.where(conditions).find_in_batches(batch_size: 5000) do |batch|
-    #       block.call batch, context, ...
+    #   collection do |context, &block|
+    #     <%= type.camelize %>.where(context[:conditions]).find_in_batches(batch_size: 5000) do |batch|
+    #       block.call batch, context
     #     end
     #   end
+    collection Collections::<%= type.camelize %>Collection
     #
     #
     # Serializer
     # ==========
     #
-    # The serializer can be any class that respond with the `as_json` class method.
-    # And the result of its as_json is a Hash.
+    # The serializer can be any class that respond with the `to_h` class method.
+    # And the result of its to_h is a Hash.
     #
     # Here is an example of a simple serializer:
     # app/serializers/<%= type %>_serializer.rb
     #   class <%= type.camelize %>Serializer
     #     def initialize(<%= type %>, _context)
     #       @<%= type %> = <%= type %>
     #     end
     #
-    #     def as_json
+    #     def to_h
     #       { '_id' => @<%= type %>.id, 'name' => @<%= type %>.name }
     #     end
     #   end
     #
     # And here you specify your serializer classe.
     #    serializer Serializers::<%= type.camelize %>Serializer
     #
     # You can also serialize the collection entry using a block:
     #
-    #   serializer do |model, context = {}|
+    #   serializer do |model, **context|
     #     hash = {
     #       name: <%= type %>.name,
     #     }
     #     # Context is just an example here. But it's useful for eager loading data.
     #     # I'll think a better example when implement this idea.
     #     hash[:some_attribute] = <%= type %>.some_attribute if context[:include_some_attribute]
     #     hash
     #   end
+    serializer Serializers::<%= type.camelize %>Serializer
   end
   <%- end -%>
 end