rails_ops 1.7.6 → 1.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cbedc7c32b0c2426655e10cc0976a0156d7558fc7ddf60e12a04a554ebd3955
-  data.tar.gz: 06e926c30fb1b8228eb6f818910392ef9d0509fd610e16effca49f0f49d8389a
+  metadata.gz: d40d2ec6a8a45a3725040a4f9fd0837ca7e42d36625827d1253e1722589e2e21
+  data.tar.gz: 53c235fe982863f62f0e6a756f6d7be9f127ad7b7693b1f46f4100b7b914bec8
 SHA512:
-  metadata.gz: cdc2260ce72809585f7bd5b68311d84e9342afdc27dee51f5fb402e9431285a166d9610bc5479f6b5e0837f1c7ec1638da58002e28a912ab4e89447b81da668c
-  data.tar.gz: 580e14d0f3aa76014e806e64efbb575f9f8287dcbf0460fe4d3ae3baed162e7b0d1e444d3d2e21fc4c88dad1cc169cb8cff5bb7c1393428201255a35e49637fd
+  metadata.gz: d226ffc592c1c46ed0c536d6e33e3f54342afc59ef6e162670437b7d2847df8d05d213b62ff128de3cb1084e53470a8bd5c7fa37ac875c9e65610ab54585633d
+  data.tar.gz: 611fbd338f724d311d32d300677bf378d031891543bced3f074134793a45e106c337ea8a07958a36d6696f355965d0f23f004f14e2b881605cb68c1de58ac257

data/.github/workflows/rubocop.yml

@@ -11,7 +11,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.1.0
+          ruby-version: 3.2.0
           bundler-cache: true
       - name: Run rubocop
         run: bundle exec rubocop

data/CHANGELOG.md

@@ -1,14 +1,29 @@
 # Changelog
 
+## 1.7.8 (2026-03-12)
+
+* Add practical examples throughout README covering non-model operations,
+  find-or-create patterns, state validation policies, sub-operation
+  composition, complete CRUD sets, model defaults, custom authorization
+  actions, virtual datetime fields, operation inheritance, and load
+  operations for show pages.
+
+## 1.7.7 (2026-02-24)
+
+* Fix `find_model_relation` to merge the returned relation's conditions
+  into the operation's model class. Previously, overriding the method
+  with a relation on the base class (e.g. `User.where(...)`) would
+  bypass model extensions defined via `model do ... end`. The loaded
+  record is now always an instance of the correct (possibly extended)
+  model type.
+
 ## 1.7.6 (2026-02-24)
 
 * Add `find_model_relation` hook to `RailsOps::Operation::Model::Load`.
   This protected method can be overridden in subclasses to customize the
   relation used for looking up the model, e.g. to apply scopes or use a
   different base query. Since `Update` and `Destroy` inherit from `Load`,
-  the hook is available in all model operations that load a record. The
-  default implementation returns `self.class.model`, preserving existing
-  behavior.
+  the hook is available in all model operations that load a record.
 
 ## 1.7.5 (2026-02-18)
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rails_ops (1.7.6)
+    rails_ops (1.7.8)
       active_type (>= 1.3.0)
       minitest
       rails (> 4)

data/README.md

@@ -245,6 +245,78 @@ end
 puts Operations::GenerateHelloWorld.run!(name: 'John Doe').result
 ```
 
+#### Practical Example: Non-Model Business Logic Operation
+
+Operations don't have to involve models. Use the base `RailsOps::Operation`
+class for business logic, background tasks, or service calls:
+
+```ruby
+module Operations::Cache
+  class Rebuild < RailsOps::Operation
+    schema3 do
+      boo? :include_archived, default: false
+      boo? :rebuild_counters, default: true
+    end
+
+    # Internal use only (called from background jobs)
+    without_authorization
+
+    protected
+
+    def perform
+      rebuild_counters if osparams.rebuild_counters
+      rebuild_search_index
+    end
+
+    private
+
+    def rebuild_counters
+      Category.find_each do |category|
+        Category.reset_counters(category.id, :articles)
+      end
+    end
+
+    def rebuild_search_index
+      Article.where(indexed: false).find_each(&:update_search_index!)
+    end
+  end
+end
+```
+
+#### Practical Example: Find-or-Create Pattern
+
+A common pattern for idempotent operations that either find an existing record
+or create a new one. Since this doesn't fit neatly into `Model::Create` or
+`Model::Load`, use the base `RailsOps::Operation` and expose the result via
+`attr_reader`:
+
+```ruby
+module Operations::Tag
+  class FindOrCreate < RailsOps::Operation
+    schema3 do
+      str! :name
+      str? :color
+    end
+
+    without_authorization
+
+    attr_reader :model
+
+    protected
+
+    def perform
+      @model = ::Tag.find_or_create_by!(name: osparams.name) do |tag|
+        tag.color = osparams.color || '#000000'
+      end
+    rescue ActiveRecord::RecordNotUnique
+      # Race condition: another process created the record between
+      # our SELECT and INSERT. Just find the existing one.
+      @model = ::Tag.find_by!(name: osparams.name)
+    end
+  end
+end
+```
+
 ## Params Handling
 
 ### Passing Params to Operations
@@ -526,6 +598,51 @@ In this case the model is not yet set. That will happen later in the `:on_init`
 It is also important to note, that this block is
 not guaranteed to be run first in the chain, if multiple blocks have set `:prepend_action` to true.
 
+#### Practical Example: State Validation Policies
+
+Use policies to validate preconditions based on the model's state. This is
+particularly useful in model operations where you want to reject the operation
+before `perform` runs:
+
+```ruby
+module Operations::Article
+  class Publish < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+    end
+
+    model ::Article
+
+    # Ensure the article is still a draft before publishing.
+    # Runs at instantiation time (i.e. when the model is loaded).
+    policy :on_init do
+      unless model.draft?
+        fail 'Only draft articles can be published.'
+      end
+    end
+
+    # Ensure the article has required content.
+    # Runs just before perform is called.
+    policy do
+      if model.body.blank?
+        fail RailsOps::Exceptions::ValidationFailed,
+             'Article body cannot be empty.'
+      end
+    end
+
+    protected
+
+    def perform
+      model.status = 'published'
+      model.published_at = Time.current
+      super
+    end
+  end
+end
+```
+
+Use `:on_init` for checks that should prevent even *displaying* a form, and
+`:before_perform` (the default) for checks that should prevent *submitting* it.
 
 ## Calling Sub-Operations
 
@@ -579,6 +696,49 @@ catches any validation errors and re-throws them as
 {RailsOps::Exceptions::SubOpValidationFailed} which is not caught by the
 surrounding op.
 
+#### Practical Example: Composing Operations
+
+Here is a realistic example of an operation that uses sub-operations to compose
+a complex workflow:
+
+Building on the `Article::Publish` example from the *Policies* section, here
+is a version that also triggers sub-operations after publishing:
+
+```ruby
+module Operations::Article
+  class PublishWithNotification < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+    end
+
+    model ::Article
+
+    protected
+
+    def perform
+      model.status = 'published'
+      model.published_at = Time.current
+      super # Save the article
+
+      with_rollback_on_exception do
+        run_sub! Operations::Cache::Rebuild, rebuild_counters: true
+        run_sub! Operations::Notification::Send,
+                 template: 'article_published',
+                 record_id: model.id,
+                 record_type: 'Article'
+      end
+    end
+  end
+end
+```
+
+Note the use of `with_rollback_on_exception`: if any sub-operation fails after
+`super` has already saved the article, the exception is re-raised as
+`RailsOps::Exceptions::RollbackRequired`, which is not caught by `run` and
+therefore causes a surrounding transaction to roll back. Without it, the article
+could remain saved even if the notification fails (since `run` catches standard
+validation errors). See section *Transactions* for more details.
+
 ## Contexts
 
 Most operations make use of generic parameters like the current user or an
@@ -1046,7 +1206,6 @@ Rails Ops offers multiple ways of disabling authorization:
   end
   ```
 
-
 ## Model Operations
 
 One of the key features of RailsOps is model operations. RailsOps provides
@@ -1169,15 +1328,21 @@ end
 
 #### Customizing the Lookup Relation
 
-By default, `Load` operations look up the model using the relation returned
-by `self.class.model` (i.e. the model class itself). If you need to use a
-custom relation — for example to apply a scope, join additional tables, or
-restrict visibility — you can override the `protected` method
-`find_model_relation`.
+By default, `Load` operations look up the model using the class specified
+via the `model` DSL method. If you need to customize the lookup — for
+example to apply a scope, join additional tables, or restrict visibility
+— you can override the `protected` method `find_model_relation`.
+
+The conditions from the returned relation are **merged** into the
+operation's model class, so the loaded record is always an instance of
+the correct (possibly extended) model type. This means model extensions
+defined via `model do ... end` (e.g. validations, callbacks) are always
+preserved.
 
-Since `Update` and `Destroy` operations inherit from `Load`, this hook is
-available in all of them. For example, you can scope an `Update` operation
-so that it only finds records belonging to the current user's organization:
+Since `Update` and `Destroy` operations inherit from `Load`, this hook
+is available in all of them. For example, you can scope an `Update`
+operation so that it only finds records belonging to the current user's
+organization:
 
 ```ruby
 class Operations::User::Update < RailsOps::Operation::Model::Update
@@ -1191,9 +1356,8 @@ class Operations::User::Update < RailsOps::Operation::Model::Update
 end
 ```
 
-The returned object must be an ActiveRecord relation (or the model class
-itself, which acts as one). Locking and eager loading via `model_includes`
-are applied on top of whatever relation this method returns.
+Locking and eager loading via `model_includes` are applied on top of
+the merged relation.
 
 #### Locking
 
@@ -1355,6 +1519,124 @@ end
 As this base class is very minimalistic, it is recommended to fully read and
 comprehend its source code.
 
+### Practical Example: Complete CRUD Operation Set
+
+Here is a complete, minimal CRUD set for a single model using `schema3`:
+
+```ruby
+# app/operations/category/load.rb
+module Operations::Category
+  class Load < RailsOps::Operation::Model::Load
+    schema3 do
+      int! :id
+    end
+
+    model ::Category
+  end
+end
+
+# app/operations/category/create.rb
+module Operations::Category
+  class Create < RailsOps::Operation::Model::Create
+    schema3 do
+      hsh? :category do
+        str? :name
+        str? :description
+      end
+    end
+
+    model ::Category
+  end
+end
+
+# app/operations/category/update.rb
+module Operations::Category
+  class Update < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+      hsh? :category do
+        str? :name
+        str? :description
+      end
+    end
+
+    model ::Category
+  end
+end
+
+# app/operations/category/destroy.rb
+module Operations::Category
+  class Destroy < RailsOps::Operation::Model::Destroy
+    schema3 do
+      int! :id
+    end
+
+    model ::Category
+  end
+end
+```
+
+For `Create` and `Update`, parameter extraction happens automatically: the
+params nested under the model's `param_key` (`:category`) are assigned to the
+model. No `perform` method is needed — the base class handles `save!`.
+
+### Practical Example: Setting Defaults on Create
+
+Override `build_model` to set default values or assign associations that aren't
+part of the user's input:
+
+```ruby
+module Operations::Article
+  class Create < RailsOps::Operation::Model::Create
+    schema3 do
+      hsh? :article do
+        str? :title
+        str? :body
+        int? :category_id
+      end
+    end
+
+    model ::Article
+
+    protected
+
+    def build_model
+      super # Builds the model and assigns params from :article key
+      model.author = context.user
+      model.status = 'draft'
+    end
+  end
+end
+```
+
+`super` in `build_model` creates a new model instance and assigns the
+attributes from params. After `super`, you can set additional attributes.
+
+### Practical Example: Overriding `build_model` in Update
+
+In `Update` operations, `build_model` first loads the record (via `Load`), then
+assigns the params. Override it to modify the model after loading:
+
+```ruby
+module Operations::Token
+  class MarkUsed < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+    end
+
+    model ::Token
+    without_authorization
+
+    protected
+
+    def build_model
+      super # Loads the record and assigns params
+      model.used_at = Time.current
+    end
+  end
+end
+```
+
 ### Including Associated Records
 
 Normally, when inheriting from `RailsOps::Operation::Model::Load` (as well as from the
@@ -1383,6 +1665,46 @@ class Operations::User::Load < RailsOps::Operation::Model::Load
 end
 ```
 
+#### Practical Example: Load Operation for Show Pages
+
+A common pattern for "show" pages: a `Load` operation that provides helper
+methods for loading related data in the view:
+
+```ruby
+module Operations::Frontend::Articles
+  class Show < RailsOps::Operation::Model::Load
+    model ::Article
+    model_includes [:tags, :category, { comments: :author }]
+
+    def recent_comments(limit: 10)
+      model.comments.order(created_at: :desc).limit(limit)
+    end
+
+    def related_articles
+      @related_articles ||= ::Article
+        .where(category_id: model.category_id)
+        .where.not(id: model.id)
+        .limit(5)
+    end
+
+    protected
+
+    # Load operations don't need perform logic, but the base class
+    # raises NotImplementedError, so we override with a no-op.
+    def perform; end
+  end
+end
+```
+
+In the controller:
+
+```ruby
+def show
+  op Operations::Frontend::Articles::Show
+  # In the view: op.model, op.recent_comments, op.related_articles
+end
+```
+
 ### Parameter Extraction for Create and Update
 
 As mentioned before, the `Create` and `Update` base classes provide an
@@ -1478,6 +1800,43 @@ class Operations::User::Update < RailsOps::Operation::Model::Update
 end
 ```
 
+#### Practical Example: Custom Authorization Actions
+
+For operations beyond standard CRUD (e.g., archiving, classifying, publishing),
+specify custom authorization actions:
+
+```ruby
+module Operations::Article
+  class Archive < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+    end
+
+    load_model_authorization_action :read
+    model_authorization_action :archive
+
+    model ::Article
+
+    protected
+
+    def perform
+      model.archived = true
+      model.archived_at = Time.current
+      model.archived_by = context.user
+      super
+    end
+  end
+end
+```
+
+In your ability file, define the custom action:
+
+```ruby
+can :archive, Article do |article|
+  article.author_id == user.id || user.admin?
+end
+```
+
 ### Model Nesting
 
 Using active record, multiple nested models can be saved at once by using
@@ -1733,6 +2092,51 @@ class Operations::Order::Checkout < RailsOps::Operation::Model::Update
 end
 ```
 
+#### Practical Example: Virtual Datetime Fields for Forms
+
+A very common use case is adding virtual datetime attributes for form inputs
+that need to be transformed before saving:
+
+```ruby
+module Operations::Event
+  class Create < RailsOps::Operation::Model::Create
+    schema3 do
+      hsh? :event do
+        str? :title
+        str? :virtual_start_datetime
+        str? :virtual_end_datetime
+        boo? :all_day
+      end
+    end
+
+    model ::Event do
+      attribute :virtual_start_datetime, :datetime
+      attribute :virtual_end_datetime, :datetime
+
+      validates :virtual_start_datetime, presence: true, unless: :all_day?
+      validates :virtual_end_datetime, presence: true, unless: :all_day?
+      validates :virtual_end_datetime,
+                comparison: { greater_than_or_equal_to: :virtual_start_datetime },
+                if: -> { !all_day? && virtual_start_datetime.present? }
+    end
+
+    protected
+
+    def build_model
+      super
+
+      if model.all_day?
+        model.start_date = model.virtual_start_datetime&.beginning_of_day
+        model.end_date = model.virtual_end_datetime&.end_of_day
+      else
+        model.start_date = model.virtual_start_datetime
+        model.end_date = model.virtual_end_datetime
+      end
+    end
+  end
+end
+```
+
 ### Combining Real and Virtual Models
 
 You can create operations that work with both persisted and virtual data:
@@ -2122,6 +2526,103 @@ sub-operations, see section *Calling sub-operations* for more information.
 
 ## Operation Inheritance
 
+Operations support standard Ruby class inheritance. This is useful when multiple
+models share the same operation pattern. Create an abstract base operation and
+then inherit from it for each model:
+
+```ruby
+# app/operations/base/toggle_active.rb
+module Operations::Base
+  class ToggleActive < RailsOps::Operation::Model::Update
+    schema3 do
+      int! :id
+    end
+
+    protected
+
+    def perform
+      model.active = !model.active
+      super
+    end
+  end
+end
+
+# app/operations/category/toggle_active.rb
+module Operations::Category
+  class ToggleActive < Operations::Base::ToggleActive
+    model ::Category
+  end
+end
+
+# app/operations/tag/toggle_active.rb
+module Operations::Tag
+  class ToggleActive < Operations::Base::ToggleActive
+    model ::Tag
+  end
+end
+```
+
+The base class defines the common schema and behavior. Subclasses only need to
+specify the `model`. This avoids duplicating logic across many operations.
+
+Schemas, policies, and authorization settings are all inherited. Subclasses can
+add additional policies or override methods as needed.
+
+### Practical Example: Bulk Insert Operation Base
+
+Another common base class is for bulk insert operations:
+
+```ruby
+module Operations::Base
+  class BulkCreate < RailsOps::Operation
+    BATCH_SIZE = 500
+
+    without_authorization
+
+    protected
+
+    def perform
+      unique_ids = ids_to_insert.uniq
+      return if unique_ids.empty?
+
+      now = Time.current
+
+      unique_ids.each_slice(self.class::BATCH_SIZE) do |batch|
+        records = build_records(batch, now)
+        target_class.insert_all!(records)
+      rescue ActiveRecord::RecordNotUnique
+        # Race condition: filter out already-existing records and retry
+        existing = existing_ids_for(batch)
+        new_records = records.reject { |r| existing.include?(r[id_column]) }
+        target_class.insert_all!(new_records) if new_records.any?
+      end
+    end
+
+    private
+
+    def ids_to_insert
+      fail NotImplementedError
+    end
+
+    def build_records(_batch, _now)
+      fail NotImplementedError
+    end
+
+    def target_class
+      fail NotImplementedError
+    end
+
+    def id_column
+      :id
+    end
+
+    def existing_ids_for(_batch)
+      fail NotImplementedError
+    end
+  end
+end
+```
+
 ## Generators
 
 RailsOps features a generator to easily create a structure for common CRUD-style

data/VERSION

@@ -1 +1 @@
-1.7.6
+1.7.8

data/lib/rails_ops/operation/model/load.rb

@@ -79,8 +79,10 @@ class RailsOps::Operation::Model::Load < RailsOps::Operation::Model
       fail "Param #{model_id_field.inspect} must be given."
     end
 
-    # Obtain relation
-    relation = find_model_relation
+    # Obtain relation, always starting from the operation's model class
+    # to ensure the loaded record is of the correct (possibly extended)
+    # type, then merge in any custom conditions from find_model_relation.
+    relation = self.class.model.all.merge(find_model_relation)
 
     # Express intention to lock if required
     relation = lock_relation(relation)
@@ -112,23 +114,25 @@ class RailsOps::Operation::Model::Load < RailsOps::Operation::Model
 
   protected
 
-  # Returns the base relation used by {#find_model} to look up the model
-  # record. Override this method in subclasses to customize the lookup
-  # relation, e.g. to apply scopes or restrict visibility.
+  # Returns a relation whose conditions are merged into the operation's
+  # model class when looking up the record. Override this method in
+  # subclasses to customize the lookup, e.g. to apply scopes or
+  # restrict visibility.
   #
-  # The returned object must respond to `find_by!` (i.e. be an
-  # `ActiveRecord::Relation` or the model class itself). Locking and
-  # eager loading via {.model_includes} are applied on top of this
-  # relation.
+  # The conditions from this relation are merged onto
+  # `self.class.model`, so the loaded record is always an instance of
+  # the operation's (possibly extended) model class. This means model
+  # extensions defined via `model do ... end` are preserved.
   #
-  # @return [ActiveRecord::Relation] the relation to query against
+  # @return [ActiveRecord::Relation] the relation whose conditions are
+  #   merged into the model class
   #
   # @example Scoping to the current user's organization
   #   def find_model_relation
   #     User.where(organization: context.user.organization)
   #   end
   def find_model_relation
-    self.class.model
+    self.class.model.all
   end
 
   private

data/rails_ops.gemspec

@@ -1,14 +1,14 @@
 # -*- encoding: utf-8 -*-
-# stub: rails_ops 1.7.6 ruby lib
+# stub: rails_ops 1.7.8 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails_ops".freeze
-  s.version = "1.7.6"
+  s.version = "1.7.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Sitrox".freeze]
-  s.date = "2026-02-24"
+  s.date = "2026-03-12"
   s.files = [".github/workflows/rubocop.yml".freeze, ".github/workflows/ruby.yml".freeze, ".gitignore".freeze, ".releaser_config".freeze, ".rubocop.yml".freeze, "Appraisals".freeze, "CHANGELOG.md".freeze, "CLAUDE.md".freeze, "Gemfile".freeze, "Gemfile.lock".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "VERSION".freeze, "gemfiles/rails_6.0.gemfile".freeze, "gemfiles/rails_6.1.gemfile".freeze, "gemfiles/rails_7.0.gemfile".freeze, "gemfiles/rails_7.1.gemfile".freeze, "gemfiles/rails_7.2.gemfile".freeze, "gemfiles/rails_8.0.gemfile".freeze, "lib/generators/operation/USAGE".freeze, "lib/generators/operation/operation_generator.rb".freeze, "lib/generators/operation/templates/controller.erb".freeze, "lib/generators/operation/templates/controller_wrapper.erb".freeze, "lib/generators/operation/templates/create.erb".freeze, "lib/generators/operation/templates/destroy.erb".freeze, "lib/generators/operation/templates/load.erb".freeze, "lib/generators/operation/templates/update.erb".freeze, "lib/generators/operation/templates/view.erb".freeze, "lib/rails_ops.rb".freeze, "lib/rails_ops/authorization_backend/abstract.rb".freeze, "lib/rails_ops/authorization_backend/can_can_can.rb".freeze, "lib/rails_ops/configuration.rb".freeze, "lib/rails_ops/context.rb".freeze, "lib/rails_ops/controller_mixin.rb".freeze, "lib/rails_ops/exceptions.rb".freeze, "lib/rails_ops/hooked_job.rb".freeze, "lib/rails_ops/hookup.rb".freeze, "lib/rails_ops/hookup/dsl.rb".freeze, "lib/rails_ops/hookup/dsl_validator.rb".freeze, "lib/rails_ops/hookup/hook.rb".freeze, "lib/rails_ops/log_subscriber.rb".freeze, "lib/rails_ops/mixins.rb".freeze, "lib/rails_ops/mixins/authorization.rb".freeze, "lib/rails_ops/mixins/log_settings.rb".freeze, "lib/rails_ops/mixins/model.rb".freeze, "lib/rails_ops/mixins/model/authorization.rb".freeze, "lib/rails_ops/mixins/model/nesting.rb".freeze, "lib/rails_ops/mixins/param_authorization.rb".freeze, "lib/rails_ops/mixins/policies.rb".freeze, "lib/rails_ops/mixins/require_context.rb".freeze, "lib/rails_ops/mixins/routes.rb".freeze, "lib/rails_ops/mixins/schema_validation.rb".freeze, "lib/rails_ops/mixins/sub_ops.rb".freeze, "lib/rails_ops/model_mixins.rb".freeze, "lib/rails_ops/model_mixins/ar_extension.rb".freeze, "lib/rails_ops/model_mixins/marshalling.rb".freeze, "lib/rails_ops/model_mixins/parent_op.rb".freeze, "lib/rails_ops/model_mixins/sti_fixes.rb".freeze, "lib/rails_ops/model_mixins/virtual_attributes.rb".freeze, "lib/rails_ops/model_mixins/virtual_attributes/virtual_column_wrapper.rb".freeze, "lib/rails_ops/model_mixins/virtual_has_one.rb".freeze, "lib/rails_ops/model_mixins/virtual_model_name.rb".freeze, "lib/rails_ops/operation.rb".freeze, "lib/rails_ops/operation/model.rb".freeze, "lib/rails_ops/operation/model/create.rb".freeze, "lib/rails_ops/operation/model/destroy.rb".freeze, "lib/rails_ops/operation/model/load.rb".freeze, "lib/rails_ops/operation/model/update.rb".freeze, "lib/rails_ops/profiler.rb".freeze, "lib/rails_ops/profiler/node.rb".freeze, "lib/rails_ops/railtie.rb".freeze, "lib/rails_ops/scoped_env.rb".freeze, "lib/rails_ops/virtual_model.rb".freeze, "rails_ops.gemspec".freeze, "test/db/models.rb".freeze, "test/db/schema.rb".freeze, "test/dummy/Rakefile".freeze, "test/dummy/app/assets/config/manifest.js".freeze, "test/dummy/app/assets/images/.keep".freeze, "test/dummy/app/assets/javascripts/application.js".freeze, "test/dummy/app/assets/javascripts/cable.js".freeze, "test/dummy/app/assets/javascripts/channels/.keep".freeze, "test/dummy/app/assets/stylesheets/application.css".freeze, "test/dummy/app/channels/application_cable/channel.rb".freeze, "test/dummy/app/channels/application_cable/connection.rb".freeze, "test/dummy/app/controllers/application_controller.rb".freeze, "test/dummy/app/controllers/concerns/.keep".freeze, "test/dummy/app/controllers/group_controller.rb".freeze, "test/dummy/app/helpers/application_helper.rb".freeze, "test/dummy/app/jobs/application_job.rb".freeze, "test/dummy/app/mailers/application_mailer.rb".freeze, "test/dummy/app/models/ability.rb".freeze, "test/dummy/app/models/animal.rb".freeze, "test/dummy/app/models/application_record.rb".freeze, "test/dummy/app/models/bird.rb".freeze, "test/dummy/app/models/cat.rb".freeze, "test/dummy/app/models/computer.rb".freeze, "test/dummy/app/models/concerns/.keep".freeze, "test/dummy/app/models/cpu.rb".freeze, "test/dummy/app/models/dog.rb".freeze, "test/dummy/app/models/flower.rb".freeze, "test/dummy/app/models/group.rb".freeze, "test/dummy/app/models/mainboard.rb".freeze, "test/dummy/app/models/nightingale.rb".freeze, "test/dummy/app/models/phoenix.rb".freeze, "test/dummy/app/models/user.rb".freeze, "test/dummy/app/views/layouts/application.html.erb".freeze, "test/dummy/app/views/layouts/mailer.html.erb".freeze, "test/dummy/app/views/layouts/mailer.text.erb".freeze, "test/dummy/bin/bundle".freeze, "test/dummy/bin/rails".freeze, "test/dummy/bin/rake".freeze, "test/dummy/bin/setup".freeze, "test/dummy/bin/update".freeze, "test/dummy/bin/yarn".freeze, "test/dummy/config.ru".freeze, "test/dummy/config/application.rb".freeze, "test/dummy/config/boot.rb".freeze, "test/dummy/config/cable.yml".freeze, "test/dummy/config/database.yml".freeze, "test/dummy/config/environment.rb".freeze, "test/dummy/config/environments/development.rb".freeze, "test/dummy/config/environments/production.rb".freeze, "test/dummy/config/environments/test.rb".freeze, "test/dummy/config/hookup.rb".freeze, "test/dummy/config/initializers/application_controller_renderer.rb".freeze, "test/dummy/config/initializers/assets.rb".freeze, "test/dummy/config/initializers/backtrace_silencers.rb".freeze, "test/dummy/config/initializers/cookies_serializer.rb".freeze, "test/dummy/config/initializers/filter_parameter_logging.rb".freeze, "test/dummy/config/initializers/inflections.rb".freeze, "test/dummy/config/initializers/mime_types.rb".freeze, "test/dummy/config/initializers/rails_ops.rb".freeze, "test/dummy/config/initializers/wrap_parameters.rb".freeze, "test/dummy/config/locales/en.yml".freeze, "test/dummy/config/puma.rb".freeze, "test/dummy/config/routes.rb".freeze, "test/dummy/config/secrets.yml".freeze, "test/dummy/config/spring.rb".freeze, "test/dummy/db/schema.rb".freeze, "test/dummy/lib/assets/.keep".freeze, "test/dummy/log/.keep".freeze, "test/dummy/package.json".freeze, "test/dummy/public/404.html".freeze, "test/dummy/public/422.html".freeze, "test/dummy/public/500.html".freeze, "test/dummy/public/apple-touch-icon-precomposed.png".freeze, "test/dummy/public/apple-touch-icon.png".freeze, "test/dummy/public/favicon.ico".freeze, "test/dummy/tmp/.keep".freeze, "test/test_helper.rb".freeze, "test/unit/rails_ops/generators/operation_generator_test.rb".freeze, "test/unit/rails_ops/hookup_test.rb".freeze, "test/unit/rails_ops/mixins/controller_test.rb".freeze, "test/unit/rails_ops/mixins/model/deep_nesting_test.rb".freeze, "test/unit/rails_ops/mixins/model/marshalling_test.rb".freeze, "test/unit/rails_ops/mixins/param_authorization_test.rb".freeze, "test/unit/rails_ops/mixins/policies_test.rb".freeze, "test/unit/rails_ops/operation/auth_test.rb".freeze, "test/unit/rails_ops/operation/model/create_test.rb".freeze, "test/unit/rails_ops/operation/model/destroy_test.rb".freeze, "test/unit/rails_ops/operation/model/load_test.rb".freeze, "test/unit/rails_ops/operation/model/sti_test.rb".freeze, "test/unit/rails_ops/operation/model/update_test.rb".freeze, "test/unit/rails_ops/operation/model_test.rb".freeze, "test/unit/rails_ops/operation/update_lazy_auth_test.rb".freeze, "test/unit/rails_ops/operation_test.rb".freeze, "test/unit/rails_ops/profiler_test.rb".freeze]
   s.homepage = "https://github.com/sitrox/rails_ops".freeze
   s.licenses = ["MIT".freeze]

data/test/dummy/app/models/group.rb

@@ -1,2 +1,3 @@
 class Group < ApplicationRecord
+  has_many :users
 end

data/test/dummy/db/schema.rb

@@ -15,6 +15,11 @@ ActiveRecord::Schema.define do
     t.boolean :planted, null: false, default: true
   end
 
+  create_table :users, force: true do |t|
+    t.string :name
+    t.references :group
+  end
+
   create_table :computers, force: true do |t|
     t.string :name
     t.references :mainboard

data/test/unit/rails_ops/operation/model/load_test.rb

@@ -74,7 +74,7 @@ class RailsOps::Operation::Model::LoadTest < ActiveSupport::TestCase
     assert_equal g, op.model
   end
 
-  def test_find_model_relation_override
+  def test_find_model_relation_with_where
     g1 = Group.create(name: 'visible')
     g2 = Group.create(name: 'hidden')
 
@@ -94,4 +94,49 @@ class RailsOps::Operation::Model::LoadTest < ActiveSupport::TestCase
       cls.new(id: g2.id)
     end
   end
+
+  def test_find_model_relation_with_joins
+    g1 = Group.create(name: 'with_users')
+    g2 = Group.create(name: 'empty')
+    User.create(name: 'Alice', group: g1)
+
+    cls = Class.new(RailsOps::Operation::Model::Load) do
+      model Group
+
+      protected
+
+      def find_model_relation
+        Group.joins(:users).where(users: { name: 'Alice' })
+      end
+    end
+
+    assert_equal g1, cls.new(id: g1.id).model
+
+    assert_raise ActiveRecord::RecordNotFound do
+      cls.new(id: g2.id)
+    end
+  end
+
+  def test_find_model_relation_preserves_model_extensions
+    g = Group.create(name: 'test')
+
+    cls = Class.new(RailsOps::Operation::Model::Load) do
+      model Group do
+        def custom_method
+          'extended'
+        end
+      end
+
+      protected
+
+      def find_model_relation
+        Group.where(name: 'test')
+      end
+    end
+
+    op = cls.new(id: g.id)
+    assert_equal 'extended', op.model.custom_method
+    assert op.model.class < Group
+    assert_not_equal Group, op.model.class
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails_ops
 version: !ruby/object:Gem::Version
-  version: 1.7.6
+  version: 1.7.8
 platform: ruby
 authors:
 - Sitrox
 bindir: bin
 cert_chain: []
-date: 2026-02-24 00:00:00.000000000 Z
+date: 2026-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_type