stretchy-model 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7dff610329ad21128c58429c6f9d08b62138a7fad9adb0f610984bd744db1cf
-  data.tar.gz: 915256c1b413dd34d4777097b878f0c2c7886342b5d8dcfedc2159a405b3bdf2
+  metadata.gz: f23580fe0c8761ced02da75cbc44f16ab7893a559d30d9a5e0de23aa96ed790a
+  data.tar.gz: 821381d3e9e92822d71aac637d98f8b04a76736a80e421ca7d2c4fd05fd108d8
 SHA512:
-  metadata.gz: 66f98b878a8e78d9d79b53f05edf89a8d4a61d4fd3a5b98d93ef349491c7c87f36d4cadb857b8be5e9e992308609c22d1abc45703eb39b95e78240d87c6ae081
-  data.tar.gz: 0eabc3b84d0aecb0f8051bf53238ec6da5d431c7ff5d0f7c3be20888a20252504e3324c7b558fe455d90c2cf0db827b1d0440e6d03d211569ed8ed7d60dade01
+  metadata.gz: 99dc36ee6cce021e869a8e1f3e2f005f546b1c50bf973434c624574c1dd601757baf4a1d39562f7ddd05bf4a1e640512111b821d8a70b8d5416bf73701b38f03
+  data.tar.gz: 4a58307bd7ae5a5781e7462df9c95438f66eecab5d0ae43238878d228e2ca6939a8a7643b70ac3c2586dcae537935206bfb15339415f6b3c3a70ef2518e401b4

data/.rspec

@@ -1 +1 @@
---require spec_helper
+--require spec_helper

data/README.md

@@ -1,6 +1,5 @@
 stretchy-model
 ===
-
 <p>
     <a href="https://stretchy.io/" target="_blank"><img src="./stretchy.logo.png" alt="Gum Image" width="450" /></a>
     <br><br>
@@ -9,104 +8,42 @@ stretchy-model
 
 </p>
 
-Stretchy provides Elasticsearch models in a Rails environment with an integrated ActiveRecord-like interface and features. 
 
 ## Features
 Stretchy simplifies the process of querying, aggregating, and managing Elasticsearch-backed models, allowing Rails developers to work with search indices as comfortably as they would with traditional Rails models.
 
-## Attributes
-
-```ruby
-class Post < Stretchy::Record
-
-    attribute :title,                   :string
-    attribute :body,                    :string
-    attribute :flagged,                 :boolean,  default: false  
-    attribute :author,                   :hash 
-    attribute :tags,                    :array, default: []
-
-end
-```
->[!NOTE]
->`created_at`, `:updated_at` and `:id` are automatically added to all `Stretchy::Records`
-
-
-## Query
-```ruby
-  Post.where('author.name': "Jadzia", flagged: true).first
-  #=> <Post id: aW02w3092, title: "Fun Cats", body: "...", flagged: true,
-  #         author: {name: "Jadzia", age: 20}, tags: ["cat", "amusing"]>
-```
-
-## Aggregations
-```ruby
-
-  result = Post.filter(:range, 'author.age': {gte: 18})
-    .aggregation(:post_frequency, date_histogram: {
-      field: :created_at,
-      calender_interval: :month
-    })
-
-  result.aggregations.post_frequency
-  #=> {buckets: [{key_as_string: "2024-01-01", doc_count: 20}, ...]}
-```
-
-## Scopes
-
-```ruby
-class Post < Stretchy::Record
-  # ...attributes
-
-  # Scopes
-  scope :flagged, -> { where(flagged: true) }
-  scope :top_links, lambda do |size=10, url=".com"| 
-    aggregation(:links, 
-      terms: {
-        field: :links, 
-        size: size, 
-        include: ".*#{url}.*"
-      })
-  end
-end
+* Model fully back by Elasticsearch/Opensearch
+* Chain queries, scopes and aggregations
+* Reduce Elasticsearch query complexity
+* Support for time-based indices and aliases
+* Associations to both ActiveRecord models and Stretchy::Record
+* Bulk Operations made easy
+* Validations, custom attributes, and more...
 
-# Returns flagged posts and includes the top 10 'youtube.com' 
-# links in results.aggregations.links
-result = Post.flagged.top_links(10, "youtube.com")
+Follow the guides to learn more about:
 
-```
+* [Models](https://theablefew.github.io/stretchy/#/guides/models?id=models)
+* [Querying](https://theablefew.github.io/stretchy/#/guides/querying?id=querying)
+* [Aggregations](https://theablefew.github.io/stretchy/#/guides/aggregations?id=aggregations)
+* [Scopes](https://theablefew.github.io/stretchy/#/guides/scopes?id=scopes)
 
-## Bulk Operations
 
+[Read the Documentation](https://theablefew.github.io/stretchy/#/) or walk through of a simple [Data Analysis](https://theablefew.github.io/stretchy/#/examples/data_analysis?id=data-analysis) example.
 
-```ruby
-Model.bulk(records_as_bulk_operations)
-```
 
-#### Bulk helper
-Generates structure for the bulk operation
-```ruby
-record.to_bulk # default to_bulk(:index)
-record.to_bulk(:delete)
-record.to_bulk(:update)
-```
-
-#### In batches
-Run bulk operations in batches specified by `size`
-```ruby
-Model.bulk_in_batches(records, size: 100) do |batch|
-    batch.map! { |record| Model.new(record).to_bulk }
-end
-```
 
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add stretchy-model
+```sh
+ bundle add stretchy-model
+```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install stretchy-model
+```sh
+  gem install stretchy-model
+```
 
 <details>
 <summary>Rails Configuration</summary>
@@ -145,8 +82,6 @@ end
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 >[!TIP]
->This library is built on top of the excellent [elasticsearch-persistence](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence) gem. 
->
 > Full documentation on [Elasticsearch Query DSL and Aggregation options](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence)
 
 ## Testing

data/lib/rails/instrumentation/railtie.rb

@@ -4,6 +4,8 @@ module Stretchy
     class Railtie < ::Rails::Railtie
 
       require 'rails/instrumentation/publishers'
+      Stretchy.instrument!
+
       ActiveSupport::Notifications.subscribe 'search.stretchy' do |name, start, finish, id, payload|
         message = [
            Rainbow("  #{payload[:klass]}").bright, 

data/lib/stretchy/associations.rb

@@ -3,7 +3,11 @@ module Stretchy
     extend ActiveSupport::Concern
 
     def save!
+      if valid?
         self.save
+      else
+        raise "Record is invalid"
+      end
     end
 
     # Required for Elasticsearch < 7
@@ -34,7 +38,7 @@ module Stretchy
     end
 
     def association_reflection(association)
-      ElasticRelation.new @@_associations[association], (dirty[association.to_sym] || [])
+      Stretchy::Relation.new @@_associations[association], (dirty[association.to_sym] || {})
     end
 
     def _destroy=(bool)
@@ -48,6 +52,7 @@ module Stretchy
     def save_associations
       @_after_save_objects.each_pair do |association, collection|
         collection.each do |instance|
+          # TODO: bulk update 
           instance.send("#{@@_association_options[association.to_sym][:foreign_key]}=", self.id)
           instance.save
         end
@@ -59,59 +64,194 @@ module Stretchy
       @@_associations ||= {}
       @@_association_options ||= {}
 
+      # The belongs_to method is used to set up a one-to-one connection with another model.
+      # This indicates that this model has exactly one instance of another model.
+      # For example, if your application includes authors and books, and each book can be assigned exactly one author,
+      # you'd declare the book model to belong to the author model.
+      #
+      # association:: [Symbol] the name of the association
+      # options:: [Hash] a hash to set up options for the association
+      #           :foreign_key - the foreign key used for the association. Defaults to "#{association}_id"
+      #           :primary_key - the primary key used for the association. Defaults to "id"
+      #           :class_name - the name of the associated object's class. Defaults to the name of the association
+      #
+      # Example:
+      #   belongs_to :author
+      #
+      # This creates a book.author method that returns the author of the book.
+      # It also creates an author= method that allows you to assign the author of the book.
+      #
       def belongs_to(association, options = {})
         @@_association_options[association] = {
           foreign_key: "#{association}_id", 
           primary_key: "id",
           class_name: association
-        }.reverse_merge(options)
+        }.merge(options)
 
         klass = @@_association_options[association][:class_name].to_s.singularize.classify.constantize
         @@_associations[association] = klass
 
         define_method(association.to_sym) do
-          klass.where(_id: self.send(@@_association_options[association][:foreign_key].to_sym)).first
+          instance_variable_get("@#{association}") || 
+            klass.where(_id: self.send(@@_association_options[association][:foreign_key].to_sym)).first
         end
 
         define_method("#{association}=".to_sym) do |val|
           options = @@_association_options[association] 
-          instance_variable_set("@#{options[:foreign_key]}", val.send(options[:primary_key]))
+          self.send("#{options[:foreign_key]}=", val.send(options[:primary_key]))
+          instance_variable_set("@#{association}", val)
+        end
+
+        define_method("build_#{association}") do |*args|
+          associated_object = klass.new(*args)
+          instance_variable_set("@#{association}", associated_object)
+          associated_object
+        end
+
+        before_save do
+          associated_object = instance_variable_get("@#{association}")
+          if associated_object && associated_object.new_record?
+            if associated_object.save!
+              self.send("#{@@_association_options[association][:foreign_key]}=", associated_object.id)
+            end
+          end
         end
       end
 
-      def has_one(association, class_name: nil, foreign_key: nil, dependent: :destroy)
 
-        klass = association.to_s.singularize.classify.constantize unless class_name.present?
-        foreign_key = "#{self.name.downcase}_id" unless foreign_key.present?
+
+
+
+
+
+
+
+
+      # The has_one method is used to set up a one-to-one connection with another model.
+      # This indicates that this model contains the foreign key.
+      #
+      # association:: [Symbol] The name of the association.
+      # options:: [Hash] A hash to set up options for the association.
+      #           :class_name - The name of the associated model. If not provided, it's derived from +association+.
+      #           :foreign_key - The name of the foreign key on the associated model. If not provided, it's derived from the name of this model.
+      #           :dependent - If set to +:destroy+, the associated object will be destroyed when this object is destroyed. This is the default behavior.
+      #           :primary_key - The name of the primary key on the associated model. If not provided, it's assumed to be +id+.
+      #           
+      #
+      # Example:
+      #   has_one :profile
+      #
+      # This creates a user.profile method that returns the profile of the user.
+      # It also creates a profile= method that allows you to assign the profile of the user.
+      #
+      def has_one(association, options = {})
+
+        @@_association_options[association] = {
+          foreign_key: "#{self.name.underscore}_id", 
+          primary_key: "id",
+          class_name: association
+        }.merge(options)
+
+        klass = @@_association_options[association][:class_name].to_s.singularize.classify.constantize
         @@_associations[association] = klass
 
+        foreign_key = @@_association_options[association][:foreign_key]
+
         define_method(association.to_sym) do
-          klass.where("#{foreign_key}": self.id).first
+          instance_variable_get("@#{association}") || 
+            klass.where("#{foreign_key}": self.id).first
+        end
+
+        define_method("#{association}=".to_sym) do |val|
+          instance_variable_set("@#{association}", val)
+          save!
+        end
+
+        before_save do
+          associated_object = instance_variable_get("@#{association}")
+          if associated_object
+            associated_object.send("#{foreign_key}=", self.id)
+            associated_object.save!
+          end
         end
       end
 
-      def has_many(association, klass, options = {})
-        @@_associations[association] = klass
 
-        opt_fk = options.delete(:foreign_key)
-        foreign_key = opt_fk ? opt_fk : "#{self.name.split("::").last.tableize.singularize}_id"
 
-        @@_association_options[association] = { foreign_key: foreign_key }
+
+
+
+
+
+
+      # The has_many method is used to set up a one-to-many connection with another model.
+      # This indicates that this model can be matched with zero or more instances of another model.
+      # For example, if your application includes authors and books, and each author can have many books,
+      # you'd declare the author model to have many books.
+      #
+      # association:: [Symbol] the name of the association
+      # options:: [Hash] a hash to set up options for the association
+      #           :foreign_key - the foreign key used for the association. Defaults to "#{self.name.downcase}_id"
+      #           :primary_key - the primary key used for the association. Defaults to "id"
+      #           :class_name - the name of the associated object's class. Defaults to the name of the association
+      #           :dependent - if set to :destroy, the associated object will be destroyed when this object is destroyed. This is the default behavior.
+      #           
+      #
+      # Example:
+      #   has_many :books
+      #
+      # This creates an author.books method that returns a collection of books for the author.
+      # It also creates a books= method that allows you to assign the books for the author.
+      #
+      def has_many(association, options = {})
+        @@_association_options[association] = {
+          foreign_key: "#{self.name.underscore}_id", 
+          primary_key: "id",
+          class_name: association.to_s.singularize.to_sym
+        }.merge(options)
+
+        klass = @@_association_options[association][:class_name].to_s.classify.constantize
+        foreign_key = @@_association_options[association][:foreign_key]
+        primary_key = @@_association_options[association][:primary_key]
+        @@_associations[association] = klass
 
         define_method(association.to_sym) do
           args = {}
-          args[foreign_key] = self.id
+          args["_#{primary_key}"] = self.send("#{association.to_s.singularize}_ids")
           self.new_record? ? association_reflection(association) : klass.where(args)
         end
 
+        define_method("#{association.to_s.singularize}_ids") do 
+          instance_variable_get("@#{association.to_s.singularize}_ids".to_sym)
+        end
+
+        define_method("#{association.to_s.singularize}_ids=") do |val|
+          instance_variable_set("@#{association.to_s.singularize}_ids".to_sym, val)
+        end
+
+        define_method("#{association}=".to_sym) do |val|
+          val.each { |v| after_save_objects(v.attributes, association)}
+          self.send("#{association.to_s.singularize}_ids=", val.map(&:id))
+          dirty
+        end
+
         define_method("build_#{association}".to_sym) do |*args|
           opts = {}
           opts[foreign_key] = self.id
           args.first.merge! opts
           klass.new *args
         end
+
+        after_save do
+          save_associations
+        end
       end
 
+
+
+
+
+
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)
       end
@@ -131,7 +271,7 @@ module Stretchy
       end
 
       def reflect_on_association(association)
-        ElasticRelation.new @@_associations[association]
+        Stretchy::Relation.new @@_associations[association]
       end
 
       def update_all(records, **attributes)

data/lib/stretchy/attributes/type/array.rb

@@ -0,0 +1,20 @@
+module Stretchy::Attributes::Type
+  class Array < Stretchy::Attributes::Type::Base # :nodoc:
+    OPTIONS = [:data_type, :fields]
+    def type
+      :array
+    end
+
+    def type_for_database
+      data_type || :text
+    end
+
+    def mappings(name)
+      options = {type: type_for_database}
+      self.class::OPTIONS.each { |option| options[option] = send(option) unless send(option).nil? }
+      options.delete(:fields) if fields == false
+      options[:fields] = {keyword: {type: :keyword, ignore_above: 256}} if type_for_database == :text && fields.nil?
+      { name => options }.as_json
+    end
+  end
+end

data/lib/stretchy/attributes/type/base.rb

@@ -0,0 +1,42 @@
+module Stretchy
+    module Attributes
+        module Type
+            class Base < ActiveModel::Type::Value
+
+              OPTIONS = []
+
+      
+              def initialize(**args)
+
+                define_option_methods!
+
+                args.each do |k, v|
+                  if self.class::OPTIONS.include?(k)
+                    instance_variable_set("@#{k}", v) 
+                    args.delete(k)
+                  end
+                end
+                super
+              end
+      
+              def mappings(name)
+                options = {type: type_for_database}
+                self.class::OPTIONS.each { |option| options[option] = send(option) unless send(option).nil? }
+                { name => options }.as_json
+              end
+
+              def type_for_database
+                type
+              end
+
+              private
+
+              def define_option_methods!
+                self.class::OPTIONS.each do |option|
+                  define_singleton_method(option.to_sym) { instance_variable_get("@#{option}") }
+                end
+              end
+            end
+        end
+    end
+end

data/lib/stretchy/attributes/type/binary.rb

@@ -0,0 +1,45 @@
+# Public: Defines a binary attribute for the model.
+#
+# name - The Symbol name of the attribute.
+# opts - The Hash options used to refine the attribute (default: {}):
+#        :doc_values - The Boolean indicating if the field should be stored on disk in a column-stride fashion.
+#                      This allows it to be used later for sorting, aggregations, or scripting. Defaults to false.
+#        :store - The Boolean indicating if the field value should be stored and retrievable separately from the _source field. Defaults to false.
+#
+# Examples
+#
+#   class MyModel
+#     include StretchyModel
+#     attribute :name, :binary, doc_values: true, store: true
+#   end
+#
+# Returns nothing.
+module Stretchy
+    module Attributes
+        module Type
+            class Binary < ActiveModel::Type::Value
+                OPTIONS = [:doc_values, :store]
+                attr_reader *OPTIONS 
+
+                def initialize(**args)  
+                  args.each do |k, v|
+                    instance_variable_set("@#{k}", v) if OPTIONS.include?(k)
+                    args.delete(k)
+                  end
+                  super
+                end
+
+                def type
+                    :binary
+                end
+
+
+                def mappings(name) 
+                  options = {type: type}
+                  OPTIONS.each { |_| options[_] = self.send(_) }
+                  { name => options }.as_json
+                end
+            end
+        end
+    end
+end

data/lib/stretchy/attributes/type/boolean.rb

@@ -0,0 +1,48 @@
+# Public: Defines a boolean attribute for the model.
+#
+# name - The Symbol name of the attribute.
+# opts - The Hash options used to refine the attribute (default: {}):
+#        :doc_values - The Boolean indicating if the field should be stored on disk in a column-stride fashion.
+#                      This allows it to be used later for sorting, aggregations, or scripting. Defaults to true.
+#        :index - The Boolean indicating if the field should be quickly searchable. Defaults to true.
+#        :ignore_malformed - The Boolean indicating if exceptions thrown when trying to index the wrong data type into a field should be ignored. Defaults to false.
+#        :null_value - The Boolean value to be substituted for any explicit null values. Defaults to null.
+#        :on_script_error - The String defining what to do if the script defined by the :script parameter throws an error at indexing time. Can be 'fail' or 'continue'.
+#        :script - The String script that will index values generated by this script, rather than reading the values directly from the source.
+#        :store - The Boolean indicating if the field value should be stored and retrievable separately from the _source field. Defaults to false.
+#        :meta - The Hash metadata about the field.
+#
+# Examples
+#
+#   class MyModel
+#     include StretchyModel
+#     attribute :name, :boolean, doc_values: true, store: true
+#   end
+#
+# Returns nothing.
+module Stretchy
+  module Attributes
+    module Type
+      class Boolean < Stretchy::Attributes::Type::Base
+
+        OPTIONS = [:doc_values, :index, :ignore_malformed, :null_value, :on_script_error, :script, :store, :meta]
+        attr_reader *OPTIONS 
+
+        def initialize(**args)  
+          args.each do |k, v|
+            instance_variable_set("@#{k}", v) if OPTIONS.include?(k)
+            args.delete(k)
+          end
+          super
+        end
+
+        def type
+          :boolean
+        end
+
+
+
+      end
+    end
+  end
+end

data/lib/stretchy/attributes/type/completion.rb

@@ -0,0 +1,25 @@
+module Stretchy::Attributes::Type
+  # Public: Defines a completion attribute for the model.
+  #
+  # opts - The Hash options used to refine the attribute (default: {}):
+  #        :analyzer - The String index analyzer to use. Defaults to 'simple'.
+  #        :search_analyzer - The String search analyzer to use. Defaults to the value of :analyzer.
+  #        :preserve_separators - The Boolean indicating if separators should be preserved. Defaults to true.
+  #        :preserve_position_increments - The Boolean indicating if position increments should be enabled. Defaults to true.
+  #        :max_input_length - The Integer limit for the length of a single input. Defaults to 50.
+  #
+  # Examples
+  #
+  #   class MyModel < Stretchy::Record
+  #     attribute :name, :completion, analyzer: 'simple', max_input_length: 100
+  #   end
+  #
+  # Returns nothing.
+  class Completion < Stretchy::Attributes::Type::Base
+    OPTIONS = [:analyzer, :search_analyzer, :preserve_separators, :preserve_position_increments, :max_input_length]
+    attr_reader *OPTIONS
+    def type
+      :completion
+    end
+  end
+end

data/lib/stretchy/attributes/type/constant_keyword.rb

@@ -0,0 +1,38 @@
+module Stretchy::Attributes::Type
+  # Public: Defines a constant_keyword attribute for the model. This field type is a specialization of the keyword field, but it only accepts a single value.
+  #
+  # opts - The Hash options used to refine the attribute (default: {}):
+  #        :doc_values - The Boolean indicating if the field should be stored on disk in a column-stride fashion. Defaults to true.
+  #        :eager_global_ordinals - The Boolean indicating if global ordinals should be loaded eagerly on refresh. Defaults to false.
+  #        :fields - The Hash of multi-fields for the same string value to be indexed in multiple ways.
+  #        :ignore_above - The Integer limit for the length of the string. Strings longer than this limit will not be indexed. Defaults to 2147483647.
+  #        :index - The Boolean indicating if the field should be quickly searchable. Defaults to true.
+  #        :index_options - The String indicating what information should be stored in the index for scoring purposes. Defaults to 'docs'.
+  #        :meta - The Hash metadata about the field.
+  #        :norms - The Boolean indicating if field-length should be taken into account when scoring queries. Defaults to false.
+  #        :null_value - The String value to be substituted for any explicit null values. Defaults to null.
+  #        :on_script_error - The String defining what to do if the script defined by the :script parameter throws an error at indexing time. Can be 'fail' or 'continue'.
+  #        :script - The String script that will index values generated by this script, rather than reading the values directly from the source.
+  #        :store - The Boolean indicating if the field value should be stored and retrievable separately from the _source field. Defaults to false.
+  #        :similarity - The String scoring algorithm or similarity to be used. Defaults to 'BM25'.
+  #        :normalizer - The String pre-processor for the keyword prior to indexing. Defaults to null.
+  #        :split_queries_on_whitespace - The Boolean indicating if full text queries should split the input on whitespace. Defaults to false.
+  #        :time_series_dimension - The Boolean indicating if the field is a time series dimension. Defaults to false.
+  #        :value - The String value to associate with all documents in the index.
+  #
+  # Examples
+  #
+  #   class MyModel
+  #     include StretchyModel
+  #     attribute :status, :constant_keyword, value: 'active'
+  #   end
+  #
+  # Returns nothing.
+  class ConstantKeyword < Stretchy::Attributes::Type::Keyword
+    OPTIONS = OPTIONS + [:value]
+    attr_reader *OPTIONS
+    def type
+      :constant_keyword
+    end
+  end
+end

data/lib/stretchy/attributes/type/date_time.rb

@@ -0,0 +1,35 @@
+module Stretchy::Attributes::Type
+  # Public: Defines a datetime attribute for the model.
+  #
+  # opts - The Hash options used to refine the attribute (default: {}):
+  #        :doc_values - The Boolean indicating if the field should be stored on disk in a column-stride fashion.
+  #                      This allows it to be used later for sorting, aggregations, or scripting. Defaults to true.
+  #        :format - The String date format(s) that can be parsed. Defaults to 'strict_date_optional_time||epoch_millis'.
+  #        :locale - The String locale to use when parsing dates. Defaults to the ROOT locale.
+  #        :ignore_malformed - The Boolean indicating if malformed numbers should be ignored. Defaults to false.
+  #        :index - The Boolean indicating if the field should be quickly searchable. Defaults to true.
+  #        :null_value - The Date value to be substituted for any explicit null values. Defaults to null.
+  #        :on_script_error - The String defining what to do if the script defined by the :script parameter throws an error at indexing time. Can be 'fail' or 'continue'.
+  #        :script - The String script that will index values generated by this script, rather than reading the values directly from the source.
+  #        :store - The Boolean indicating if the field value should be stored and retrievable separately from the _source field. Defaults to false.
+  #        :meta - The Hash metadata about the field.
+  #
+  # Examples
+  #
+  #   class MyModel < Stretchy::Record
+  #     attribute :created_at, :datetime, format: 'strict_date_optional_time||epoch_millis', locale: 'en'
+  #   end
+  #
+  # Returns nothing.
+  class DateTime < Stretchy::Attributes::Type::Base
+    OPTIONS = [:doc_values, :format, :locale, :ignore_malformed, :index, :null_value, :on_script_error, :script, :store, :meta]
+    attr_reader *OPTIONS
+    def type
+      :datetime
+    end
+
+    def type_for_database
+      :date
+    end
+  end
+end