typesense_model 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0396e88e835a9892f58864d4598ec27ece27f4fc749b31df76639d4c71fbd34d'
+  data.tar.gz: 81028cc019492513b25c0628cbbd960693698fc6ba46add32e2f35f36c440d2b
+SHA512:
+  metadata.gz: 7a056ab185ce24fa77e3419d9ec3bf3584dedafffd7a268fc0602fb785b8efea3c352e44d5831f013d0533535235246fa2d371c0a5548e8abee5372660931fbd
+  data.tar.gz: 82a7412801f57a83b001e6f4f8ff3a6d1e0ee40ecbd225424baa149d2968f60d80b66cbeb6be0a5715eee4a1ad66440c097617df64966e0c69e6f0ce11ac3506

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ruby Dev SRL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

data/README.md

@@ -0,0 +1,208 @@
+# TypesenseModel
+
+A Ruby gem that provides seamless Typesense integration for ActiveRecord models with automatic syncing and search capabilities.
+
+## Installation
+
+Add to your Gemfile:
+```ruby
+gem 'typesense_model'
+```
+
+Or install directly:
+```bash
+$ gem install typesense_model
+```
+
+## Configuration
+
+Initialize Typesense connection in your Rails application:
+
+```ruby
+# config/initializers/typesense.rb
+TypesenseModel.configure do |config|
+  config.api_key = 'your_api_key'
+  config.host = 'localhost'
+  config.port = 8108
+  config.protocol = 'http'
+end
+```
+
+## ActiveRecord Integration
+
+The gem automatically extends ActiveRecord models with Typesense capabilities. Simply add `uses_typesense` to any model:
+
+```ruby
+class Product < ApplicationRecord
+  uses_typesense collection: 'products' do
+    field :id, :string
+    field :name, :string
+    field :description, :string, optional: true, index: false
+    field :price, :float, sort: true
+    field :categories, "string[]", optional: true, facet: true
+    field :tags, "string[]", optional: true, facet: true
+    field :brand, :string, facet: true
+    field :in_stock, :bool, facet: true
+    field :created_at, :int64, sort: true
+    field :updated_at, :int64, sort: true
+  end
+
+  # Optional: Custom JSON serialization for Typesense
+  def as_json_typesense
+    {
+      id: id,
+      name: name,
+      description: description,
+      price: price,
+      categories: categories,
+      tags: tags,
+      brand: brand,
+      in_stock: in_stock,
+      created_at: created_at.to_i,
+      updated_at: updated_at.to_i
+    }
+  end
+end
+```
+
+## Features
+
+### Automatic Syncing
+When you save or destroy ActiveRecord records, they automatically sync to Typesense:
+
+```ruby
+# Create a product - automatically synced to Typesense
+product = Product.create!(
+  name: "iPhone 15",
+  price: 999.99,
+  categories: ["Electronics", "Phones"],
+  brand: "Apple",
+  in_stock: true
+)
+
+# Update a product - automatically synced to Typesense
+product.update!(price: 899.99)
+
+# Destroy a product - automatically removed from Typesense
+product.destroy!
+```
+
+### Search Capabilities
+Search your ActiveRecord models using Typesense:
+
+```ruby
+# Basic search
+results = Product.search("iPhone")
+
+# Advanced search with filters and sorting
+results = Product.search("smartphone", 
+  filter_by: "brand:Apple && price:< 1000",
+  sort_by: "price:asc",
+  per_page: 20,
+  page: 1
+)
+
+# Search with facets
+results = Product.search("phone")
+results.facet_values("brand")  # Get brand facet counts
+results.facet_values("categories")  # Get category facet counts
+```
+
+### Access Typesense Documents
+Get the Typesense document for any ActiveRecord instance:
+
+```ruby
+product = Product.find(123)
+typesense_doc = product.typesense_model
+# Returns a TypesenseModel::Base instance with the Typesense document data
+```
+
+## Schema Options
+
+Field options available in the schema definition:
+
+- `optional: true` - Field is optional
+- `index: false` - Field is not indexed (not searchable)
+- `facet: true` - Field can be used for faceted search
+- `sort: true` - Field can be used for sorting
+- `default_sort: true` - Field is the default sorting field
+
+## Custom JSON Serialization
+
+You can customize how your model data is serialized for Typesense:
+
+```ruby
+class Product < ApplicationRecord
+  uses_typesense collection: 'products', model_json: :to_typesense_hash do
+    # schema definition
+  end
+
+  def to_typesense_hash
+    {
+      id: id,
+      name: name,
+      price: price,
+      # Add computed fields
+      searchable_text: "#{name} #{description} #{brand}".downcase,
+      price_range: case price
+        when 0..100 then "budget"
+        when 101..500 then "mid-range"
+        else "premium"
+      end
+    }
+  end
+end
+```
+
+Or use a Proc for dynamic serialization:
+
+```ruby
+class Product < ApplicationRecord
+  uses_typesense collection: 'products', 
+    model_json: ->(record) { record.as_json.merge(computed_field: record.compute_something) } do
+    # schema definition
+  end
+end
+```
+
+## Collection Management
+
+Create and manage Typesense collections:
+
+```ruby
+# Create the collection in Typesense
+Product.search("") # This will create the collection if it doesn't exist
+
+# Or explicitly create/update
+proxy = TypesenseModel::ActiveRecordExtension::TypesenseProxy.for(Product)
+proxy.create_collection
+proxy.update_collection
+proxy.delete_collection
+```
+
+## Import Existing Data
+
+Import existing ActiveRecord records to Typesense without N+1 queries:
+
+```ruby
+# Basic import (default batch_size: 1000)
+results = Product.import_all_to_typesense
+
+# With preloads to avoid N+1
+results = Product.import_all_to_typesense(preloads: [:brand, :images])
+
+# With custom transformer and options
+results = Product.import_all_to_typesense(
+  preloads: { variants: [:prices, :stock_items] },
+  transform: :to_typesense_hash,
+  batch_size: 2000,
+  import_options: { action: 'upsert' }
+)
+
+# results => { success: 500, failed: 0, errors: [...] }
+```
+
+## License
+
+Available as open source under the MIT License.
+Copyright (c) 2025 Ruby Dev SRL

data/lib/typesense_model/active_record_extension.rb

@@ -0,0 +1,126 @@
+module TypesenseModel
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Usage: uses_typesense collection: 'plugs', model_json: :as_json, schema: ->(s) { s.field :id, :string }
+      def uses_typesense(collection: nil, model_json: :as_json_typesense, schema: nil, &block)
+        @_typesense_collection_name = collection || name.underscore.pluralize
+        @_typesense_model_json_method = model_json
+
+        if schema
+          @_typesense_schema = Schema.new
+          schema.call(@_typesense_schema)
+        elsif block_given?
+          @_typesense_schema = Schema.new
+          @_typesense_schema.instance_eval(&block)
+        end
+
+        define_singleton_method(:typesense_collection_name) do
+          @_typesense_collection_name
+        end
+
+        define_singleton_method(:typesense_schema) do
+          @_typesense_schema
+        end
+
+        define_singleton_method(:typesense_model_json_method) do
+          @_typesense_model_json_method
+        end
+
+        define_singleton_method(:search) do |query, options = {}|
+          proxy = TypesenseProxy.for(self)
+          proxy.search(query, options)
+        end
+
+        define_method(:typesense_model) do
+          TypesenseProxy.for(self.class).find(id)
+        end
+
+        # Add callbacks for automatic syncing
+        after_save :sync_to_typesense
+        after_destroy :remove_from_typesense
+      end
+
+      # Import all records of this AR model into Typesense
+      # @param batch_size [Integer] number of records per batch
+      # @param transform [Symbol, Proc, nil] method or proc to generate document JSON
+      # @param preloads [Array, Symbol, Hash, nil] associations to preload to avoid N+1
+      # @param import_options [Hash] options passed to Typesense import
+      # @return [Hash] { success: Integer, failed: Integer }
+      def import_all_to_typesense(batch_size: 1000, transform: nil, preloads: nil, import_options: {})
+        proxy = TypesenseProxy.for(self)
+        # Ensure collection exists and schema is up-to-date before import
+        proxy.create_collection unless proxy.collection_exists?
+        transformer = transform || (respond_to?(:typesense_model_json_method) ? typesense_model_json_method : :as_json_typesense)
+        proxy.import_from_model(self, batch_size, transformer, preloads, import_options)
+      end
+    end
+
+    # Instance methods for callbacks
+    def sync_to_typesense
+      return unless self.class.respond_to?(:typesense_model_json_method)
+      
+      json_method = self.class.typesense_model_json_method
+      document_data = if json_method.is_a?(Proc)
+        json_method.call(self)
+      else
+        respond_to?(json_method) ? send(json_method) : as_json_typesense
+      end
+      
+      proxy = TypesenseProxy.for(self.class)
+      sanitized = proxy.send(:sanitize_document, stringify_keys(document_data))
+      proxy.client.collections[proxy.collection_name].documents.upsert(sanitized)
+    rescue => e
+      Rails.logger.error "Failed to sync #{self.class.name}##{id} to Typesense: #{e.message}" if defined?(Rails)
+    end
+
+    def remove_from_typesense
+      return unless self.class.respond_to?(:typesense_model_json_method)
+      
+      proxy = TypesenseProxy.for(self.class)
+      proxy.client.collections[proxy.collection_name].documents[id].delete
+    rescue => e
+      Rails.logger.error "Failed to remove #{self.class.name}##{id} from Typesense: #{e.message}" if defined?(Rails)
+    end
+
+    # Default JSON method for Typesense
+    def as_json_typesense
+      as_json
+    end
+
+    private
+
+    def stringify_keys(hash)
+      return hash unless hash.is_a?(Hash)
+      hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    end
+
+    # Simple adapter that maps an AR model class into a TypesenseModel::Base-like class
+    class TypesenseProxy < TypesenseModel::Base
+      class << self
+        def for(ar_class)
+          @ar_class = ar_class
+          collection_name(ar_class.respond_to?(:typesense_collection_name) ? ar_class.typesense_collection_name : ar_class.name.underscore.pluralize)
+
+          if ar_class.respond_to?(:typesense_schema) && ar_class.typesense_schema
+            @_schema_definition = ar_class.typesense_schema
+          end
+
+          self
+        end
+
+        def ar_class
+          @ar_class
+        end
+
+        def client
+          TypesenseModel.configuration.client
+        end
+      end
+    end
+  end
+end
+

data/lib/typesense_model/base.rb

@@ -0,0 +1,245 @@
+module TypesenseModel
+  class Base
+    class << self
+      attr_accessor :_collection_name, :_schema_definition
+
+      def collection_name(name = nil)
+        if name
+          @_collection_name = name
+        else
+          @_collection_name ||= self.name.underscore.pluralize
+        end
+      end
+
+      def define_schema(&block)
+        @_schema_definition = Schema.new
+        @_schema_definition.instance_eval(&block)
+      end
+
+      def schema_definition
+        @_schema_definition
+      end
+
+      def create(attributes = {})
+        new(attributes).save
+      end
+
+      def find(id)
+        response = client.collections[collection_name].documents[id].retrieve
+        new(response)
+      rescue Typesense::Error::ObjectNotFound
+        nil
+      end
+
+      def search(query, options = {})
+        Search.new(self, query, options).execute
+      end
+
+      # Create the collection in Typesense
+      def create_collection(force = false)
+        delete_collection if force
+        return if collection_exists? 
+        
+        schema = schema_definition.to_hash.merge(
+          name: collection_name
+        )
+
+        client.collections.create(schema)
+      end
+
+      # Delete the collection from Typesense
+      def delete_collection
+        client.collections[collection_name].delete if collection_exists?
+      end
+
+      # Check if collection exists
+      def collection_exists?
+        client.collections[collection_name].retrieve
+        true
+      rescue Typesense::Error::ObjectNotFound
+        false
+      end
+
+      # Update the collection schema in Typesense
+      def update_collection
+        return create_collection unless collection_exists?
+
+        # Typesense only allows updating `fields` (and `metadata`).
+        # Do not send `name` or `default_sorting_field` on update.
+        # Exclude the implicit `id` field from updates (Typesense does not allow altering it)
+        updated_fields = (schema_definition.to_hash[:fields] || []).reject { |f| f[:name] == 'id' || f['name'] == 'id' }
+
+        update_payload = { fields: updated_fields }.compact
+
+        client.collections[collection_name].update(update_payload)
+      end
+
+      # Create or update collection
+      def create_or_update_collection
+        collection_exists? ? update_collection : create_collection
+      end
+
+      # Retrieve collection details
+      def retrieve_collection
+        return nil unless collection_exists?
+        client.collections[collection_name].retrieve
+      end
+
+      # Get collection stats
+      def collection_stats
+        return nil unless collection_exists?
+        client.collections[collection_name].stats
+      end
+
+      # Get number of documents in collection
+      def count
+        collection_stats&.dig('num_documents') || 0
+      end
+
+      # Import multiple records
+      # @return [Hash] { success: Integer, failed: Integer }
+      def import(documents, options = {})
+        sanitized_documents = Array(documents).map { |doc| sanitize_document(doc) }
+
+        response = client.collections[collection_name]
+          .documents
+          .import(sanitized_documents, options)
+
+        results = response.each_with_object({ success: 0, failed: 0, errors: [] }) do |result, counts|
+          if result['success']
+            counts[:success] += 1
+          else
+            counts[:failed] += 1
+            counts[:errors] << {
+              code: result['code'],
+              error: result['error'],
+              document: result['document']
+            }
+          end
+        end
+
+        results
+      end
+
+      # Import records from an ActiveRecord model
+      # @param model_class [Class] The ActiveRecord model class to import from
+      # @param batch_size [Integer] Number of records to fetch per batch
+      # @param transform_method [Symbol, Proc] Method or Proc to transform records
+      # @param preloads [Array, Symbol, Hash, nil] Associations to preload to avoid N+1
+      # @param import_options [Hash] Options to pass to the import method
+      # @return [Hash] { success: Integer, failed: Integer }
+      def import_from_model(model_class, batch_size, transform_method = :as_json, preloads = nil, import_options = {})
+        total_results = { success: 0, failed: 0 }
+
+        transformer = transform_method.is_a?(Proc) ? transform_method : ->(record) { record.send(transform_method) }
+
+        relation = model_class.all
+        relation = relation.preload(preloads) if preloads
+
+        relation.find_in_batches(batch_size: batch_size) do |batch|
+          documents = batch.map(&transformer)
+          results = import(documents, import_options)
+          
+          total_results[:success] += results[:success]
+          total_results[:failed] += results[:failed]
+          if results[:errors].is_a?(Array) && results[:errors].any?
+            (total_results[:errors] ||= []).concat(results[:errors])
+          end
+        end
+
+        total_results
+      end
+
+      # Delete a record by ID
+      def delete(id)
+        client.collections[collection_name]
+          .documents[id]
+          .delete
+      rescue Typesense::Error::ObjectNotFound
+        false
+      end
+
+      # Delete multiple records by query
+      def delete_by(filter_by)
+        client.collections[collection_name]
+          .documents
+          .delete({ filter_by: filter_by })
+      end
+
+      private
+
+      def client
+        TypesenseModel.configuration.client
+      end
+
+      # Keep only fields defined in schema (plus 'id'), and coerce id to string
+      def sanitize_document(document)
+        return document unless schema_definition
+
+        allowed = schema_definition.fields.map { |f| f[:name] } + ['id']
+        sanitized = document.select { |k, _| allowed.include?(k.to_s) }
+        sanitized['id'] = sanitized['id'].to_s if sanitized.key?('id')
+        sanitized
+      end
+    end
+
+    attr_accessor :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes.transform_keys(&:to_s)
+    end
+
+    def save
+      response = self.class.send(:client).collections[self.class.collection_name].documents.upsert(attributes)
+      
+      @attributes = response.transform_keys(&:to_s)
+      self
+    end
+
+    def id
+      attributes['id']
+    end
+
+    def method_missing(method_name, *args)
+      attribute_name = method_name.to_s
+      
+      # Handle setters (e.g., name=)
+      if attribute_name.end_with?('=')
+        attribute_name = attribute_name.chop # Remove the '=' from the end
+        return set_attribute(attribute_name, args.first)
+      end
+      
+      # Handle getters (e.g., name)
+      if attributes.key?(attribute_name)
+        return attributes[attribute_name]
+      end
+      
+      nil
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      attribute_name = method_name.to_s
+      return true if attribute_name.end_with?('=') && attributes.key?(attribute_name.chop)
+      return true if attributes.key?(attribute_name)
+      super
+    end
+
+    private
+
+    def set_attribute(name, value)
+      attributes[name.to_s] = value
+    end
+
+    def client
+      self.class.send(:client)
+    end
+
+    # Instance method to delete the current record
+    def delete
+      return false unless id
+      
+      response = self.class.delete(id)
+      !response.nil?
+    end
+  end
+end 

data/lib/typesense_model/configuration.rb

@@ -0,0 +1,24 @@
+module TypesenseModel
+  class Configuration
+    attr_accessor :api_key, :host, :port, :protocol
+
+    def initialize
+      @api_key = nil
+      @host = 'localhost'
+      @port = 8108
+      @protocol = 'http'
+    end
+
+    def client
+      @client ||= Typesense::Client.new(
+        api_key: api_key,
+        nodes: [{
+          host: host,
+          port: port,
+          protocol: protocol
+        }],
+        connection_timeout_seconds: 5
+      )
+    end
+  end
+end 

data/lib/typesense_model/schema.rb

@@ -0,0 +1,39 @@
+module TypesenseModel
+  class Schema
+    attr_reader :fields, :collection_name, :default_sorting_field
+
+    def initialize(collection_name = nil)
+      @fields = []
+      @collection_name = collection_name
+      @default_sorting_field = nil
+    end
+
+    def field(name, type, options = {})
+      @fields << {
+        name: name.to_s,
+        type: type.to_s,
+        facet: options[:facet] || false,
+        optional: options[:optional] || false,
+        index: options[:index].nil? ? true : options[:index],
+        sort: options[:sort] || false
+      }
+
+      # Set as default sorting field if specified
+      @default_sorting_field = name.to_s if options[:default_sort]
+    end
+
+    def to_hash
+      {
+        name: @collection_name,
+        fields: @fields,
+        default_sorting_field: @default_sorting_field
+      }.compact
+    end
+
+    private
+
+    def default_sorting_field
+      @fields.find { |f| f[:name] == 'id' }&.dig(:name)
+    end
+  end
+end 

data/lib/typesense_model/search.rb

@@ -0,0 +1,95 @@
+module TypesenseModel
+  class Search
+    def initialize(model_class, query, options = {})
+      @model_class = model_class
+      @query = query
+      @options = options
+    end
+
+    def execute
+      search_parameters = {
+        q: @query,
+        query_by: @options[:query_by] || default_queryable_fields,
+        per_page: @options[:per_page] || 10,
+        page: @options[:page] || 1
+      }.merge(@options.except(:query_by, :per_page, :page))
+
+      response = @model_class.send(:client)
+        .collections[@model_class.collection_name]
+        .documents
+        .search(search_parameters)
+
+      SearchResults.new(response, @model_class)
+    end
+
+    private
+
+    def default_queryable_fields
+      @model_class.schema_definition.fields
+        .select { |f| f[:index] }
+        .select { |f| f[:type] == 'string' }
+        .reject { |f| f[:name] == 'id' }
+        .map { |f| f[:name] }
+        .join(',')
+    end
+  end
+
+  class SearchResults
+    include Enumerable
+
+    attr_reader :raw_response
+
+    def initialize(response, model_class)
+      @raw_response = response
+      @model_class = model_class
+    end
+
+    def each(&block)
+      hits.each do |hit|
+        yield @model_class.new(hit['document'])
+      end
+    end
+
+    def map(&block)
+      hits.map do |hit|
+        block.call(@model_class.new(hit['document']))
+      end
+    end
+
+    def hits
+      @raw_response['hits'] || []
+    end
+
+    def size
+      total_hits
+    end
+
+    def total_hits
+      @raw_response['found'] || 0
+    end
+    # PAGY COMPATIBILITY
+    def count(_)
+      total_hits
+    end
+    def offset(_)
+      self
+    end
+    def limit(_)
+      self
+    end
+
+    def facets
+      @raw_response['facet_counts'] || []
+    end
+
+    # Get a specific facet by field name
+    def facet(field_name)
+      facets.find { |f| f['field_name'] == field_name.to_s }
+    end
+
+    # Get facet values for a specific field
+    def facet_values(field_name)
+      facet(field_name)&.fetch('counts', []) || []
+    end
+  end
+end 

data/lib/typesense_model/version.rb

@@ -0,0 +1,3 @@
+module TypesenseModel
+  VERSION = "0.2.0"
+end 

data/lib/typesense_model.rb

@@ -0,0 +1,25 @@
+require "typesense"
+require "typesense_model/version"
+require "typesense_model/base"
+require "typesense_model/search"
+require "typesense_model/schema"
+require "typesense_model/configuration"
+require "typesense_model/active_record_extension"
+
+module TypesenseModel
+  class Error < StandardError; end
+  
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+end 
+
+# Auto-include into ActiveRecord if available
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.include(TypesenseModel::ActiveRecordExtension)
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: typesense_model
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Emanuel Comsa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typesense
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Ruby gem that provides an ActiveModel-like interface for working with
+  Typesense search engine
+email:
+- office@rubydev.ro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/typesense_model.rb
+- lib/typesense_model/active_record_extension.rb
+- lib/typesense_model/base.rb
+- lib/typesense_model/configuration.rb
+- lib/typesense_model/schema.rb
+- lib/typesense_model/search.rb
+- lib/typesense_model/version.rb
+homepage: https://github.com/rubydevro/typesense_model
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://www.rubydev.ro
+  source_code_uri: https://github.com/rubydevro/typesense_model
+  changelog_uri: https://github.com/rubydevro/typesense_model/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: ActiveModel-like interface for Typesense
+test_files: []