search-engine-for-typesense 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 40c59f9aee799bdf68e236563e8c6f77c6fb20a698416685685f27adbce81657
+  data.tar.gz: 8c6e21a6c33287344fe0d9a336c2a9830ab8cd3c298b95a2a4d957b28b3b269a
+SHA512:
+  metadata.gz: 5f1c329eb77d31ccac5fc595909b8b853fb021b48179d33504e37b1ed65408ddff1051cb4aa16f14e7160c0c752828bfc10249b9b88f2ea9ec6bef644ad4120b
+  data.tar.gz: 54c259f69e49fdf98345fc87af72f3f84a718f08e5e76e5ffe2d78f841a541bc830c1b21f71398a003adaa2fbf72ff52ef7d82a465c57bb34f8ab563342f9527

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nikita Shkoda
+
+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,148 @@
+# Search Engine for Typesense [![CI][ci-badge]][ci-url] [![Gem][gem-badge]][gem-url] [![Docs][docs-badge]][docs-url]
+[![Typesense](https://img.shields.io/badge/Typesense-Typesense-blue)](https://typesense.org) [![Typesense Ruby gem](https://img.shields.io/badge/Typesense%20Ruby%20gem-TypesenseRubyGem-blue)](https://github.com/typesense/typesense-ruby)
+
+> [!WARNING]
+> **⚠️ This project is under maintenance – work in progress. APIs and docs may change. ⚠️**
+
+Mountless Rails::Engine for [Typesense](https://typesense.org). Expressive Relation/DSL with JOINs, grouping, presets/curation — with strong DX and observability.
+
+> [!NOTE]
+> This project is not affiliated with [Typesense](https://typesense.org) and is a wrapper for the [`typesense` gem](https://github.com/typesense/typesense-ruby).
+
+## Quickstart
+
+```ruby
+# Gemfile
+gem "search-engine-for-typesense"
+```
+
+```ruby
+# config/initializers/search_engine_for_typesense.rb
+SearchEngine.configure do |c|
+  c.host = ENV.fetch("TYPESENSE_HOST", "localhost")
+  c.port = 8108
+  c.protocol = "http"
+  c.api_key = ENV.fetch("TYPESENSE_API_KEY")
+end
+```
+
+```ruby
+class SearchEngine::Product < SearchEngine::Base
+  collection :products
+
+  attribute :id, :integer
+  attribute :name, :string
+
+  query_by %i[name brand description]
+end
+
+SearchEngine::Product.where(name: "milk").select(:id, :name).limit(5).to_a
+```
+
+See [Quickstart](https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/quickstart).
+
+### Host app SearchEngine models
+
+By default, the gem manages a dedicated Zeitwerk loader for your SearchEngine models under `app/search_engine/`. The loader is initialized after Rails so that application models/constants are available, auto-reloads in development, and is eager-loaded in production/test.
+
+Customize or disable via configuration:
+
+```ruby
+# config/initializers/search_engine.rb
+SearchEngine.configure do |c|
+  # Relative to Rails.root or absolute; set to nil/false to disable
+  c.search_engine_models = 'app/search_engine'
+end
+```
+
+## Usage examples
+
+```ruby
+# Model
+class SearchEngine::Product < SearchEngine::Base
+  collection "products"
+
+  attribute :id, :integer
+  attribute :name, :string
+end
+
+# Basic query
+SearchEngine::Product
+  .where(name: "milk")
+  # Explicit query_by always wins over model/global defaults
+  .options(query_by: 'name,brand')
+  .select(:id, :name)
+  .order(price_cents: :asc)
+  .limit(5)
+  .to_a
+
+# JOIN + nested selection
+SearchEngine::Product
+  .joins(:brands)
+  .select(:id, :name, brands: %i[id name])
+  .where(brands: { name: "Acme" })
+  .per(10)
+  .to_a
+
+# Faceting + grouping
+rel = SearchEngine::Product
+        .facet_by(:brand_id, max_values: 5)
+        .facet_by(:category)
+        .group_by(:brand_id, limit: 3)
+params = rel.to_h # compiled Typesense params
+
+# Multi-search
+result_set = SearchEngine.multi_search(common: { query_by: SearchEngine.config.default_query_by }) do |m|
+  m.add :products, SearchEngine::Product.where("name:~rud").per(10)
+  m.add :brands,   SearchEngine::Brand.all.per(5)
+end
+result_set[:products].found
+
+# Upserting documents
+product_record = Product.first
+mapped = SearchEngine::Product.mapped_data_for(product_record)
+
+# Map + upsert a single record
+SearchEngine::Product.upsert(record: product_record)
+
+# Upsert already-mapped data
+SearchEngine::Product.upsert(data: mapped)
+
+# Bulk upsert records (mapper runs internally)
+SearchEngine::Product.upsert_bulk(records: Product.limit(2))
+
+# Bulk upsert mapped payloads
+SearchEngine::Product.upsert_bulk(data: [mapped])
+```
+
+## Documentation
+
+See the [Docs](https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/index)
+
+## Test/offline mode
+
+In test environments (`Rails.env.test?` or `RACK_ENV=test`), SearchEngine defaults to an offline client
+(`SearchEngine::Test::OfflineClient`) so no Typesense HTTP calls are made.
+
+You can control this explicitly with:
+- `SEARCH_ENGINE_TEST_MODE=1` to force offline mode
+- `SEARCH_ENGINE_TEST_MODE=0` to disable offline mode
+- `SEARCH_ENGINE_OFFLINE=1` (legacy alias)
+
+If you set `SearchEngine.configure { |c| c.client = ... }`, the custom client is always used.
+
+## Example app
+
+See `examples/demo_shop` — demonstrates single/multi search, JOINs, grouping, presets/curation, and DX/observability. Supports offline mode via the stub client (see [Testing](https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/testing)).
+
+## Contributing
+
+See [Docs Style Guide](https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/docs-style-guide). Follow YARDoc for public APIs, add backlinks on docs landing pages, and redact secrets in examples.
+
+<!-- Badge references (placeholders) -->
+[ci-badge]: https://img.shields.io/github/actions/workflow/status/lstpsche/search-engine-for-typesense/ci.yml?branch=main
+[ci-url]: #
+[gem-badge]: https://img.shields.io/gem/v/search-engine-for-typesense.svg?label=gem
+[gem-url]: https://rubygems.org/gems/search-engine-for-typesense
+[docs-badge]: https://img.shields.io/badge/docs-index-blue
+[docs-url]: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/index

data/app/search_engine/search_engine/app_info.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SearchEngine
+  # Provides basic information about the engine for smoke testing.
+  class AppInfo
+    # @return [String] a short identifier proving autoload worked
+    def self.identifier
+      'search_engine/app_info'
+    end
+  end
+end

data/app/search_engine/search_engine/index_partition_job.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module SearchEngine
+  # ActiveJob to rebuild a single partition using the same orchestration as inline.
+  #
+  # Arguments:
+  # - collection_class_name [String]
+  # - partition [Object] (JSON-serializable)
+  # - into [String, nil]
+  # - metadata [Hash]
+  class IndexPartitionJob < ::ActiveJob::Base
+    queue_as do
+      cfg = SearchEngine.config.indexer
+      (cfg&.queue_name || 'search_index').to_s
+    end
+
+    # Handle transient errors with exponential backoff based on Indexer config.
+    rescue_from(SearchEngine::Errors::Timeout) { |error| retry_if_possible(error) }
+    rescue_from(SearchEngine::Errors::Connection) { |error| retry_if_possible(error) }
+    rescue_from(SearchEngine::Errors::Api) do |error|
+      if transient_status?(error.status.to_i)
+        retry_if_possible(error)
+      else
+        instrument_error(error)
+        raise
+      end
+    end
+
+    # Perform a single-partition rebuild.
+    # @param collection_class_name [String]
+    # @param partition [Object]
+    # @param into [String, nil]
+    # @param metadata [Hash]
+    # @return [void]
+    def perform(collection_class_name, partition, into: nil, metadata: {})
+      klass = constantize_collection!(collection_class_name)
+      payload = base_payload(klass, partition: partition, into: into)
+      instrument('search_engine.dispatcher.job_started',
+                 payload.merge(queue: queue_name, job_id: job_id, metadata: metadata)
+                )
+
+      started = monotonic_ms
+      summary = nil
+      SearchEngine::Instrumentation.with_context(dispatch_mode: :active_job, job_id: job_id) do
+        summary = SearchEngine::Indexer.rebuild_partition!(klass, partition: partition, into: into)
+      end
+      duration = (monotonic_ms - started).round(1)
+
+      instrument(
+        'search_engine.dispatcher.job_finished',
+        payload.merge(queue: queue_name, job_id: job_id, duration_ms: duration, status: summary.status,
+                      metadata: metadata
+        )
+      )
+      nil
+    rescue StandardError => error
+      instrument_error(error, payload: payload.merge(metadata: metadata))
+      raise
+    end
+
+    private
+
+    def base_payload(klass, partition:, into:)
+      {
+        collection: (klass.respond_to?(:collection) ? klass.collection.to_s : klass.name.to_s),
+        partition: partition,
+        into: into
+      }
+    end
+
+    def constantize_collection!(name)
+      raise ArgumentError, 'collection_class_name must be a String' unless name.is_a?(String)
+
+      klass = name.constantize
+      unless klass.is_a?(Class) && klass.ancestors.include?(SearchEngine::Base)
+        raise ArgumentError, 'collection_class_name must be a SearchEngine::Base subclass'
+      end
+
+      klass
+    rescue NameError => error
+      raise ArgumentError, "unknown collection class: #{name}", error.backtrace
+    end
+
+    def retry_if_possible(error)
+      attempts, base, max, jitter = retry_settings
+      attempt_no = executions.to_i # number of times we've run so far (1-based)
+      if attempt_no >= attempts
+        instrument_error(error)
+        raise
+      end
+
+      wait_seconds = backoff_seconds(attempt_no + 1, base: base, max: max, jitter_fraction: jitter)
+      instrument(
+        'search_engine.dispatcher.job_error',
+        error_payload(error).merge(queue: queue_name, job_id: job_id, retry_after_s: wait_seconds)
+      )
+      retry_job wait: wait_seconds
+    end
+
+    def error_payload(error)
+      {
+        collection: arguments_dig_collection,
+        partition: arguments[1],
+        into: begin
+          arguments_hash[:into]
+        rescue StandardError
+          nil
+        end,
+        error_class: error.class.name,
+        message_truncated: error.message.to_s[0, 200]
+      }
+    end
+
+    def instrument_error(error, payload: nil)
+      instrument(
+        'search_engine.dispatcher.job_error',
+        (payload || {}).merge(queue: queue_name, job_id: job_id, error_class: error.class.name,
+                              message_truncated: error.message.to_s[0, 200]
+        )
+      )
+    end
+
+    def instrument(event, payload)
+      SearchEngine::Instrumentation.instrument(event, payload) {}
+    end
+
+    def retry_settings
+      cfg = SearchEngine.config.indexer
+      attempts = cfg&.retries && cfg.retries[:attempts].to_i.positive? ? cfg.retries[:attempts].to_i : 3
+      base = cfg&.retries && cfg.retries[:base].to_f.positive? ? cfg.retries[:base].to_f : 0.5
+      max = cfg&.retries && cfg.retries[:max].to_f.positive? ? cfg.retries[:max].to_f : 5.0
+      jitter = cfg&.retries && cfg.retries[:jitter_fraction].to_f >= 0 ? cfg.retries[:jitter_fraction].to_f : 0.2
+      [attempts, base, max, jitter]
+    end
+
+    def backoff_seconds(attempt, base:, max:, jitter_fraction:)
+      exp = [base * (2 ** (attempt - 1)), max].min
+      jitter = exp * jitter_fraction
+      delta = rand(-jitter..jitter)
+      sleep_time = exp + delta
+      sleep_time.positive? ? sleep_time : 0.0
+    end
+
+    def transient_status?(code)
+      return true if code == 429
+      return true if code >= 500 && code <= 599
+
+      false
+    end
+
+    def monotonic_ms
+      SearchEngine::Instrumentation.monotonic_ms
+    end
+
+    def arguments_hash
+      # ActiveJob stores keyword args in the last Hash argument when using perform(class, partition, into:, metadata:)
+      args = arguments
+      args.last.is_a?(Hash) ? args.last.symbolize_keys : {}
+    end
+
+    def arguments_dig_collection
+      begin
+        name = arguments[0].to_s
+      rescue StandardError
+        name = nil
+      end
+      name || 'unknown'
+    end
+  end
+end

data/lib/generators/search_engine/install/install_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module SearchEngine
+  module Generators
+    # Install generator that creates the initializer with ENV-based defaults.
+    #
+    # @example
+    #   rails g search_engine:install
+    # @see https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/dx
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def create_initializer
+        template 'initializer.rb.tt', 'config/initializers/search_engine.rb'
+      end
+    end
+  end
+end

data/lib/generators/search_engine/install/templates/initializer.rb.tt

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+# SearchEngine configuration — ENV-based defaults
+#
+# This initializer is idempotent and safe for local development. Keep secrets
+# out of code: prefer ENV variables for API keys and sensitive config.
+#
+# Next steps:
+# - Define a model under `app/search_engine/` (or your configured `c.search_engine_models`; see Quickstart)
+# - Run the CLI doctor to verify connectivity and config
+# - Explore queries in `rails console` using SE helpers: `SE.q("milk")`
+#
+# Docs:
+# - Quickstart: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/quickstart
+# - CLI (Doctor): https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/cli
+# - DX helpers: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/dx
+# - Configuration: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/configuration
+SearchEngine.configure do |c|
+  c.host = ENV.fetch('TYPESENSE_HOST', 'localhost')
+  c.port = Integer(ENV.fetch('TYPESENSE_PORT', 8108))
+  c.protocol = ENV.fetch('TYPESENSE_PROTOCOL', 'http')
+  # Read API key from ENV; do not hardcode secrets here.
+  c.api_key = ENV['TYPESENSE_API_KEY']
+
+  # Default fields used when query_by is not provided explicitly.
+  # Uncomment and customize to your schema.
+  # c.default_query_by = 'name, description'
+
+  # Tip: You can also set per-collection defaults in your model:
+  # class SearchEngine::Product < SearchEngine::Base
+  #   collection 'products'
+  #   # Accepts String, Symbol, or Array; stored as a canonical String
+  #   query_by %i[name brand description]
+  # end
+
+  # Optional: set a default console model for SE.q/SE.rel helpers.
+  # Accepts a constant or String name (e.g., 'SearchEngine::Product').
+  # c.default_console_model = nil
+
+  # Host app SearchEngine models directory. Relative paths are resolved against
+  # Rails.root. Set to nil/false to disable gem-managed loading.
+  # Defaults to 'app/search_engine'.
+  # c.search_engine_models = 'app/search_engine'
+
+  # --- Typesense transport -------------------------------------------------
+
+  # Request total timeout in milliseconds. Default: 3_600_000 (60 minutes)
+  # c.timeout_ms = 3_600_000
+
+  # Connect/open timeout in milliseconds. Default: 1000
+  # c.open_timeout_ms = 1_000
+
+  # Retry policy for client requests. Default: { attempts: 2, backoff: 10.0..60.0 }
+  # Use a Range for backoff to introduce jitter between retries (seconds).
+  # c.retries = { attempts: 2, backoff: 10.0..60.0 }
+  # Recommendation: keep a 60-minute timeout and add jitter for long-running writes.
+  # See wiki: Configuration → Timeouts & retries
+
+  # Default Typesense infix behavior for queries. Default: 'fallback'
+  # c.default_infix = 'fallback'
+
+  # --- URL-level caching ---------------------------------------------------
+
+  # Allow URL-level caching (passed as common params). Default: true
+  # c.use_cache = true
+
+  # Cache TTL in seconds (URL/common params). Default: 60
+  # c.cache_ttl_s = 60
+
+  # --- Field strictness & limits ------------------------------------------
+
+  # Enforce strict field validation at compile/hydration time.
+  # Default: true in development/test; false in production
+  # c.strict_fields = !Rails.env.production?
+
+  # Max number of searches in a single multi-search call. Default: 50
+  # c.multi_search_limit = 50
+
+  # Whether Relation#inspect pretty-prints by materializing a preview. Default: true
+  # c.relation_print_materializes = true
+
+  # Override the logger used by the engine (defaults to Rails.logger). Example:
+  # c.logger = Rails.logger
+
+  # --- Presets -------------------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/presets
+
+  # Enable preset namespacing and resolution. Default: true
+  # c.presets.enabled = true
+
+  # Optional namespace to prepend to preset names. Default: nil
+  # c.presets.namespace = nil
+
+  # Limit which domains presets may modify. Default: %i[filter_by sort_by include_fields exclude_fields]
+  # c.presets.locked_domains = %i[filter_by sort_by include_fields exclude_fields]
+
+  # --- Selection & Grouping ------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/field-selection
+
+  # Raise when requested fields are missing during hydration. Default: false
+  # c.selection.strict_missing = false
+
+  # Emit warnings for ambiguous grouping combinations. Default: true
+  # c.grouping.warn_on_ambiguous = true
+
+  # --- Observability & Logging --------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/observability
+
+  # Quiet by default: structured instrumentation logs ([se.*]) are OFF unless
+  # explicitly enabled below.
+
+  # Preferred (new) structured logs via LoggingSubscriber (opt-in):
+  # - :compact (single-line) or :json
+  # - optional sampling to reduce noise
+  # c.logging.mode   = :compact   # Default: nil (OFF)
+  # c.logging.level  = :info      # :debug | :info | :warn | :error
+  # c.logging.sample = 1.0        # e.g., 0.1 to sample 10%
+  # c.logging.logger = c.logger
+
+  # Legacy compact logger (fallback, also opt-in):
+  # Enable only if you prefer the legacy subscriber instead of LoggingSubscriber.
+  # c.observability.enabled = false   # Default: false (OFF)
+  # c.observability.log_format = :kv  # :kv or :json
+  # c.observability.max_message_length = 200
+  # c.observability.include_error_messages = false
+  # c.observability.emit_legacy_event_aliases = true
+
+  # OpenTelemetry integration (only when the SDK is present). Defaults shown.
+  # c.opentelemetry = { enabled: false, service_name: 'search_engine' }
+
+  # --- Schema lifecycle ----------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/schema
+
+  # Retention: how many previous physical collections to keep after swap. Default: 0
+  # c.schema.retention.keep_last = 0
+
+  # --- Indexer -------------------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/indexer
+
+  # Default batch size for imports when not provided. Default: 2000
+  # c.indexer.batch_size = 2000
+
+  # Optional read timeout override (ms) for imports. Default: nil
+  # c.indexer.timeout_ms = nil
+
+  # Retry policy for imports. Default: { attempts: 3, base: 0.5, max: 5.0, jitter_fraction: 0.2 }
+  # c.indexer.retries = { attempts: 3, base: 0.5, max: 5.0, jitter_fraction: 0.2 }
+
+  # Gzip JSONL payloads during import. Default: false
+  # c.indexer.gzip = false
+
+  # Dispatch mode for import jobs (:active_job or :inline). Default depends on ActiveJob presence
+  # c.indexer.dispatch = :active_job
+
+  # Queue name for ActiveJob dispatch. Default: 'search_index'
+  # c.indexer.queue_name = 'search_index'
+
+  # --- Sources -------------------------------------------------------------
+
+  # ActiveRecord source: default ORM batch size. Default: 2000
+  # c.sources.active_record.batch_size = 2000
+
+  # ActiveRecord source: mark relations as readonly. Default: true
+  # c.sources.active_record.readonly = true
+
+  # ActiveRecord source: wrap fetching in a read-only transaction. Default: false
+  # c.sources.active_record.use_transaction = false
+
+  # SQL source: server-side cursor fetch size. Default: 2000
+  # c.sources.sql.fetch_size = 2000
+
+  # SQL source: per-statement timeout (ms). Default: nil
+  # c.sources.sql.statement_timeout_ms = nil
+
+  # SQL source: preferred row shape (:auto, :hash). Default: :auto
+  # c.sources.sql.row_shape = :auto
+
+  # Lambda source: optional max batch size hint for validation/metrics. Default: nil
+  # c.sources.lambda.max_batch_size_hint = nil
+
+  # --- Mapper --------------------------------------------------------------
+
+  # Treat unknown keys as errors instead of warnings. Default: false
+  # c.mapper.strict_unknown_keys = false
+
+  # Nested coercions configuration. Default: { enabled: false, rules: {} }
+  # c.mapper.coercions = { enabled: false, rules: {} }
+
+  # Maximum number of error samples included in reports. Default: 5
+  # c.mapper.max_error_samples = 5
+
+  # --- Partitioning --------------------------------------------------------
+
+  # Optional resolver Proc for default physical collection. Default: nil
+  # c.partitioning.default_into_resolver = nil
+
+  # Before/after hook timeouts (ms) for partitioning callbacks. Default: nil
+  # c.partitioning.before_hook_timeout_ms = nil
+  # c.partitioning.after_hook_timeout_ms = nil
+
+  # Maximum error samples included in partition payloads. Default: 5
+  # c.partitioning.max_error_samples = 5
+
+  # --- Stale deletes -------------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/deletion
+
+  # Global kill switch for stale delete workflows. Default: true
+  # c.stale_deletes.enabled = true
+
+  # Strict mode blocks suspicious filters. Default: false
+  # c.stale_deletes.strict_mode = false
+
+  # Timeout (ms) for delete requests. Default: nil
+  # c.stale_deletes.timeout_ms = nil
+
+  # Enable found estimation via search for stale deletes. Default: false
+  # c.stale_deletes.estimation_enabled = false
+
+  # --- Curation ------------------------------------------------------------
+  # See: https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/curation
+
+  # Maximum number of pinned IDs allowed. Default: 50
+  # c.curation.max_pins = 50
+
+  # Maximum number of hidden IDs allowed. Default: 200
+  # c.curation.max_hidden = 200
+
+  # Allowed curated ID pattern. Default: /\A[\w\-:.]+\z/
+  # c.curation.id_regex = /\A[\w\-:.]+\z/
+end