sunstone 8.0.0 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd0eae0dbdee21a95ca29317302b67b50647f7d6654af15553425f55d1d11aed
-  data.tar.gz: b0cdc960489411360b1ee4f2cb4cdcce93b7df2464dabdafa2bc26955be002b3
+  metadata.gz: e9d85052377699e6030067ce89f33b964b2193a1cd345a2ed013682fd457ecb3
+  data.tar.gz: 6f1f0054a2d338d2aaa6dd7ab9528a4e8be697a72ff670772afd89fe5d1928f7
 SHA512:
-  metadata.gz: ce768f425153db1d5a2242f845bc3de221a4d0d0d8a30a1428c128d2bb1e4353ef986020283fdd1d17e7652937c38d03eb1f42478acbc694da32135f335cab22
-  data.tar.gz: ece020a27e0554bad07f0e831919e8969cebdd6970adc344fb4f018b3a45032588dcd7c4eb512d9fcb8ff4acfc09ef27d9fe6124fa2b9db0d5eeff659885d800
+  metadata.gz: fcb5ec1577d0671923144212ab4048276db625873b9e1cdf4a6f5e8f655de64ee0c60593167efb5e04c04fa37214763184ac5f6f8e881ec1b2b952244d1b0b58
+  data.tar.gz: 1441be879d54bbaa74f3f980813809f08b4c5c4497e35da5e40fe4f64d2a4157482b5c06413840f75ee4e8af087e4b0525b2fa8fd1adf2d1ca6608441adb38ae

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+## [8.1.0] - 2026-08-27
+
+### Changed
+- Support both Rails 8.0 and 8.1. The ActiveRecord overrides in `ext/` had been
+  synced to Rails 8.1 and used 8.1-only APIs; they now work against 8.0 as well.
+- Require Ruby >= 3.3. The gemspec previously declared `>= 2.6`, which the
+  `activerecord >= 8.0.1` dependency never actually permitted.
+- Require `arel-extensions >= 9.0.0` and `activerecord-filter >= 9.0.0`; the
+  previous `>= 7.x` floors predated Rails 8 support.
+
+### Added
+- Declare the MIT license in the gemspec.
+- Add gemspec `metadata` (source code and changelog URIs, `rubygems_mfa_required`).
+
+### Fixed
+- Package `README.md` in the published gem. The gemspec referenced a
+  non-existent `README.rdoc`, so the README was omitted from the built gem.
+
+### Internal
+- Modernized CI: test Rails 8.0 and 8.1 across Ruby 3.3–4.0, run the upstream
+  ActiveRecord suites on Postgres 18, SQLite, and a MySQL service container,
+  auto-resolve the latest Rails patch per series, and guard every upstream
+  source patch so the build fails loudly if an anchor moves.
+
+## Earlier releases
+
+Prior versions tracked the matching Rails release. See the Git tags for the
+full history; notable releases:
+
+- [8.0.0] - 2025-01-24
+- [7.1.0.1] - 2023-12-20
+- [7.1.0] - 2023-12-15
+- [6.1.0.2] - 2021-03-23
+- [6.1.0] - 2021-01-14
+- [6.0.0] - 2019-06-10
+
+[8.1.0]: https://github.com/malomalo/sunstone/compare/v8.0.0...v8.1.0
+[8.0.0]: https://github.com/malomalo/sunstone/releases/tag/v8.0.0
+[7.1.0.1]: https://github.com/malomalo/sunstone/releases/tag/v7.1.0.1
+[7.1.0]: https://github.com/malomalo/sunstone/releases/tag/v7.1.0
+[6.1.0.2]: https://github.com/malomalo/sunstone/releases/tag/v6.1.0.2
+[6.1.0]: https://github.com/malomalo/sunstone/releases/tag/v6.1.0
+[6.0.0]: https://github.com/malomalo/sunstone/releases/tag/v6.0.0

data/README.md

@@ -0,0 +1,221 @@
+# Sunstone
+
+Sunstone is an [ActiveRecord](https://rubygems.org/gems/activerecord) adapter for
+querying APIs that conform to [StandardAPI](https://github.com/waratuman/standardapi).
+
+It lets you talk to a remote HTTP API using the ActiveRecord query interface you
+already know — `where`, `order`, `limit`, `find`, associations, and persistence
+(`create`/`update`/`destroy`) — while Sunstone translates those calls into
+StandardAPI HTTP requests instead of SQL.
+
+## Requirements
+
+- Ruby >= 3.3
+- ActiveRecord >= 8.0.1 (Rails 8.0 and 8.1)
+
+## Installation
+
+Add `sunstone` to your Gemfile:
+
+```ruby
+gem 'sunstone'
+```
+
+## Configuration
+
+### Rails
+
+Configure the connection in `config/database.yml`:
+
+```yaml
+development:
+  adapter: sunstone
+  url: https://my-api-key@mystanda.rd/api
+```
+
+The connection accepts the following options:
+
+| Option        | Description                                                        |
+| ------------- | ------------------------------------------------------------------ |
+| `url`         | Sets `host`, `port`, `use_ssl`, and (from userinfo) `api_key`      |
+| `host`        | API host (defaults to `127.0.0.1`)                                 |
+| `port`        | API port (defaults to `80`, or `443` when `use_ssl`)              |
+| `use_ssl`     | Connect over HTTPS (inferred from an `https://` url)               |
+| `api_key`     | Token sent in the `Api-Key` request header                         |
+| `user_agent`  | String prepended to Sunstone's own `User-Agent`                    |
+| `ca_cert`     | Path to a CA certificate file (used when `use_ssl` is set)         |
+
+`url` is a convenience that fills in the others, so this:
+
+```yaml
+  url: https://my-api-key@mystanda.rd:443/api
+```
+
+is equivalent to:
+
+```yaml
+  host: mystanda.rd
+  port: 443
+  use_ssl: true
+  api_key: my-api-key
+```
+
+### Standalone ActiveRecord
+
+Establish the connection on `ActiveRecord::Base` (or your abstract model, e.g.
+`ApplicationRecord`):
+
+```ruby
+ActiveRecord::Base.establish_connection(
+  adapter: 'sunstone',
+  url: 'https://my-api-key@mystanda.rd/api'
+)
+```
+
+## Usage
+
+The models below are used throughout the examples:
+
+```ruby
+class Fleet < ApplicationRecord
+  has_many :ships
+end
+
+class Ship < ApplicationRecord
+  belongs_to :fleet
+  has_and_belongs_to_many :sailors
+end
+```
+
+### Querying
+
+```ruby
+Ship.find(42)                 # where: {id: 42}, limit: 1
+Ship.all                      # GET /ships
+Ship.where(id: 10)            # where: {id: 10}
+Ship.where(fleet_id: nil)     # where: {fleet_id: nil}
+Ship.where(id: [10, 12])      # id IN (10, 12)
+Ship.order(:id)               # order: [{id: :asc}]
+Ship.limit(5000)              # limit: 5000
+```
+
+`find_each` pages through the collection automatically:
+
+```ruby
+Ship.find_each { |ship| ... } # GET /ships in batches with limit/offset
+```
+
+Arel predicates are supported for comparisons and boolean logic:
+
+```ruby
+Ship.where(Ship.arel_table[:id].gt(10))
+Ship.where(Ship.arel_table[:id].eq(10).or(Ship.arel_table[:name].eq('name')))
+```
+
+You can inspect the query a relation will send:
+
+```ruby
+Ship.where(id: 10).to_sql
+# => "SELECT ships.* FROM ships WHERE ships.id = 10"
+```
+
+### Querying across associations
+
+Pass a nested hash to filter on an associated resource:
+
+```ruby
+Ship.where(fleet: { id: 1 })              # belongs_to
+Fleet.where(ships: { id: 1 })             # has_many
+Ship.where(sailors: { id: 1 })            # has_and_belongs_to_many
+Fleet.where(ships: { sailors: { id: 1 } }) # nested
+```
+
+### Aggregations
+
+```ruby
+Ship.count          # select: [{count: "*"}]  (GET /ships/calculate)
+Ship.count(:id)     # select: [{count: "id"}]
+Ship.sum(:weight)   # select: [{sum: "weight"}]
+Ship.distinct       # distinct: true
+```
+
+### Eager loading
+
+`eager_load` loads associations in a single request; `preload` issues a
+separate request per association:
+
+```ruby
+Fleet.eager_load(ships: :sailors)  # one request, nested payload
+Fleet.preload(ships: :sailors)     # a request per association
+```
+
+### Persistence
+
+```ruby
+fleet = Fleet.create(name: 'Armada Uno')   # POST   /fleets
+ship  = Ship.find(1)
+ship.update(name: 'Definant')              # PATCH  /ships/1
+ship.destroy                               # DELETE /ships/1
+```
+
+Validation errors returned by the API (e.g. a `400` response) are written back
+onto the record:
+
+```ruby
+fleet = Fleet.create(name: nil)
+fleet.errors[:name] # => [...]  populated from the API response
+```
+
+Associations can be written through the parent, matching ActiveRecord's nested
+attributes and `*_ids` conventions:
+
+```ruby
+# belongs_to — creates the fleet alongside the ship
+Ship.create(name: 'Definant', fleet: Fleet.new(name: 'Armada Duo'))
+
+# has_many — assign by id, by records, or clear
+Fleet.create(name: 'Spanish Armada', ship_ids: [2])
+fleet.update(ships: fleet.ships + [Ship.find(3)])
+fleet.update(ships: [])   # clears the relation
+
+# has_and_belongs_to_many
+ship.update(sailors: [Sailor.find(1)])
+```
+
+### RPC
+
+`rpc` declares a custom, non-CRUD action that maps to a `POST` on a member
+endpoint. Any attributes the API returns are written back onto the record:
+
+```ruby
+class Ship < ApplicationRecord
+  rpc :self_destruct
+end
+
+ship.self_destruct!   # POST /ships/:id/self_destruct
+```
+
+## Column types
+
+Beyond the standard ActiveRecord types, the adapter registers:
+
+- `array` — JSON-serialized arrays of any subtype
+- `json`
+- `uuid` — validated and cast as a UUID
+- `binary` — Base64-encoded over the wire
+- `datetime` — serialized as ISO 8601
+
+Geospatial (GIS) support is opt-in. Require it to register the `geometry` /
+`geography` (EWKB) types, which use [RGeo](https://rubygems.org/gems/rgeo):
+
+```ruby
+require 'sunstone/gis'
+```
+
+## License
+
+Sunstone is released under the [MIT License](LICENSE).
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).

data/ext/active_record/associations/collection_association.rb

@@ -1,73 +1,55 @@
-# The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
-module ActiveRecord
-  module Associations
-    class CollectionAssociation
-
-      def replace(other_array)
-        other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = skip_strict_loading { load_target }.dup
-
-        if owner.new_record?
-          replace_records(other_array, original_target)
-        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
-          replace_common_records_in_memory(other_array, original_target)
-
-          # Remove from target
-          records_for_removal = (original_target - other_array)
-          if !records_for_removal.empty?
-            self.instance_variable_set(:@sunstone_changed, true)
-            records_for_removal.each { |record| callback(:before_remove, record) }
-            records_for_removal.each { |record| target.delete(record) }
-            records_for_removal.each { |record| callback(:after_remove, record) }
-          end
+# frozen_string_literal: true
 
-          # Add to target
-          records_for_addition = (other_array - original_target)
-          if !records_for_addition.empty?
-            self.instance_variable_set(:@sunstone_changed, true)
-            (other_array - original_target).each do |record|
-              add_to_target(record)
-            end
-          end
-
-          other_array
-        else
-          replace_common_records_in_memory(other_array, original_target)
-          if other_array != original_target
-            transaction { replace_records(other_array, original_target) }
-          else
-            other_array
-          end
-        end
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+class ActiveRecord::Associations::CollectionAssociation
+
+  def replace(other_array)
+    other_array.each { |val| raise_on_type_mismatch!(val) }
+    original_target = skip_strict_loading { load_target }.dup
+
+    if owner.new_record?
+      replace_records(other_array, original_target)
+    elsif owner.sunstone? && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
+      replace_common_records_in_memory(other_array, original_target)
+
+      # Remove from target
+      records_for_removal = (original_target - other_array)
+      if !records_for_removal.empty?
+        self.instance_variable_set(:@sunstone_changed, true)
+        records_for_removal.each { |record| callback(:before_remove, record) }
+        records_for_removal.each { |record| target.delete(record) }
+        records_for_removal.each { |record| callback(:after_remove, record) }
       end
 
-      def insert_record(record, validate = true, raise = false, &block)
-        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
-          true
-        elsif raise
-          record.save!(validate: validate, &block)
-        else
-          record.save(validate: validate, &block)
+      # Add to target
+      records_for_addition = (other_array - original_target)
+      if !records_for_addition.empty?
+        self.instance_variable_set(:@sunstone_changed, true)
+        (other_array - original_target).each do |record|
+          add_to_target(record)
         end
       end
 
-    end
-
-    class HasManyThroughAssociation
-
-      private
-      def save_through_record(record)
-        return if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        association = build_through_record(record)
-        if association.changed?
-          association.save!
-        end
-      ensure
-        @through_records.delete(record.object_id)
+      other_array
+    else
+      replace_common_records_in_memory(other_array, original_target)
+      if other_array != original_target
+        transaction { replace_records(other_array, original_target) }
+      else
+        other_array
       end
-
     end
+  end
 
+  def insert_record(record, validate = true, raise = false, &block)
+    if record.sunstone? && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
+      true
+    elsif raise
+      record.save!(validate: validate, &block)
+    else
+      record.save(validate: validate, &block)
+    end
   end
-end
+
+end

data/ext/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
+class ActiveRecord::Associations::CollectionAssociation::HasManyThroughAssociation
+
+  private
+
+  def save_through_record(record)
+    return if record.sunstone?
+    
+    association = build_through_record(record)
+    if association.changed?
+      association.save!
+    end
+  ensure
+    @through_records.delete(record)
+  end
+
+end

data/ext/active_record/associations.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+# ref: 90a1eaa1b3
 
 require 'active_record'
 require 'active_record/associations'
@@ -10,23 +12,23 @@ module ActiveRecord
       def has_and_belongs_to_many(name, scope = nil, **options, &extension)
         habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)
 
-        builder = Builder::HasAndBelongsToMany.new name, self, options
+        builder = Builder::HasAndBelongsToMany.new(name, self, options)
 
         join_model = builder.through_model
 
-        const_set join_model.name, join_model
-        private_constant join_model.name
+        const_set(join_model.name, join_model)
+        private_constant(join_model.name)
 
-        middle_reflection = builder.middle_reflection join_model
+        middle_reflection = builder.middle_reflection(join_model)
 
-        Builder::HasMany.define_callbacks self, middle_reflection
-        Reflection.add_reflection self, middle_reflection.name, middle_reflection
+        Builder::HasMany.define_callbacks(self, middle_reflection)
+        Reflection.add_reflection(self, middle_reflection.name, middle_reflection)
         middle_reflection.parent_reflection = habtm_reflection
 
         include Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def destroy_associations
-              if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+              if !self.sunstone?
                 association(:#{middle_reflection.name}).delete_all(:delete_all)
                 association(:#{name}).reset
               end
@@ -39,8 +41,8 @@ module ActiveRecord
         hm_options[:through] = middle_reflection.name
         hm_options[:source] = join_model.right_reflection.name
 
-        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading].each do |k|
-          hm_options[k] = options[k] if options.key? k
+        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading, :deprecated].each do |k|
+          hm_options[k] = options[k] if options.key?(k)
         end
 
         has_many name, scope, **hm_options, &extension

data/ext/active_record/attribute_methods.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+# ref: 90a1eaa1b3
 
 module ActiveRecord
   module AttributeMethods
@@ -11,7 +13,7 @@ module ActiveRecord
     def attributes_with_values(attribute_names)
       attrs = attribute_names.index_with { |name| @attributes[name] }
 
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      if self.sunstone?
         self.class.reflect_on_all_associations.each do |reflection|
           if reflection.belongs_to?
             if association(reflection.name).loaded? && association(reflection.name).target == Thread.current[:sunstone_updating_model]

data/ext/active_record/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
+class ActiveRecord::Base
+  
+  def self.sunstone?
+    connection_pool.db_config.adapter_class == ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter
+  end
+  
+  def sunstone?
+    self.class.sunstone?
+  end
+  
+end

data/ext/active_record/callbacks.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 # The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+# ref: 90a1eaa1b3
 
 module ActiveRecord
   module Callbacks
     private
 
       def create_or_update(**) #:nodoc:
-        if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        if self.sunstone?
           @_already_called ||= {}
           self.class.reflect_on_all_associations.each do |r|
             @_already_called[:"autosave_associated_records_for_#{r.name}"] = true

data/ext/active_record/locking/optimistic.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
+module ActiveRecord
+  module Locking
+    module Optimistic
+      
+      private
+
+        def _update_row(attribute_values, attempted_action = "update")
+          return super unless locking_enabled?
+
+          begin
+            locking_column = self.class.locking_column
+            lock_attribute_was = @attributes[locking_column]
+
+            update_constraints = _query_constraints_hash
+
+            if self[locking_column].nil?
+              raise(<<-MSG.squish)
+                For optimistic locking, locking_column ('#{locking_column}') can't be nil.
+                Are you missing a default value or validation on '#{locking_column}'?
+              MSG
+            end
+            
+            self[locking_column] += 1
+
+            attribute_values = if attribute_values.is_a?(Hash)
+              attribute_values.merge(attributes_with_values([locking_column]))
+            else
+              attribute_values = attribute_values.dup if attribute_values.frozen?
+              attribute_values << locking_column
+              attributes_with_values(attribute_values)
+            end
+
+            # Suntone returns the row(s) not a int of afftecd_rows
+            result = self.class._update_record(
+              attribute_values,
+              update_constraints
+            )
+            affected_rows = sunstone? ? result.rows.size : result
+
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
+            end
+
+            affected_rows
+
+          # If something went wrong, revert the locking_column value.
+          rescue Exception
+            @attributes[locking_column] = lock_attribute_was
+            raise
+          end
+        end
+
+    end
+  end
+end