Need a non-cached index_scope

[codezomb]

I may be misunderstanding this, but I wanted to double check.

We have a multi tenant situation. We have index names dynamically set, but we need to have dynamic scopes. From what I'm seeing, index_scope is run once, but then "cached" for subsequent runs.

Example:

DocumentIndex < Chewy::Index
  index_scope Document.where(license_ids: Tenant.current.license_ids)
end

Apartment.tenant_names.each do |tenant|
  DocumentIndex.sync
end

What we end up seeing, is the first sync in the loop has the correct license_ids, but every subsequent query is a cached version of the first query.

Is there a way to ensure in this case that the query is called with the appropriate scope?

Thanks!

[codezomb]

Just updating here in case anyone else runs into this issue. We created a custom adapter to solve the issue for us.

class Chewy::Index::Adapter::ActiveRecordProc < Chewy::Index::Adapter::ActiveRecord
  def self.accepts?(target)
    target.is_a?(Proc) && target.call.is_a?(::ActiveRecord::Relation)
  end

  def initialize(target, **options)
    @default_scope = target
    @target        = model_of_relation(target.call)
    @options       = options
  end

  def default_scope
    super.call.reorder(nil).offset(nil).limit(nil)
  end
end

Chewy.adapters.prepend(Chewy::Index::Adapter::ActiveRecordProc)

[bbatsov]

The workaround in the comments (custom adapter with a Proc-based scope) looks reasonable. Is this still something you need built into Chewy core, or does the adapter approach solve your use case? If you'd like first-class support, could you describe the specific multi-tenant pattern you're using (e.g., schema-based, row-based, separate databases)?

[codezomb]

The multi-tenancy approach were using is schema based. I tend to build a lot of applications this way, so for me it would be nice to have support, but the workaround is working well for us currently.