standardapi 7.1.0 → 7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88dd56c94d20d8649c5f755509be1aee880f7dff0133602a4fe46c0408c4e65b
-  data.tar.gz: 3f14301f672ac171f9e2a39620de9f1913300572164978857ea12fcb1bb008de
+  metadata.gz: cf0f6e2d86659b79df8b56eb7b998118541facdc0fd516ad878f4afb0c531299
+  data.tar.gz: dcfebcfd01bd96dbaa8a4a2aef53ea1549c0820b7879845a2e812311efbd3556
 SHA512:
-  metadata.gz: e3c282a6b8898d1c1451e381dea4cf57c3cd58b65bccfba6a0b5f9d302242287bb233dd43b4a078c51f1711a32a449d47c157626a92cc752939d8040ef704534
-  data.tar.gz: 56d90b5dc3d5d04924b7bd5e5fe6a98cfe9cf4f6fa79d30c933abff3e5c6f6b69a6718a699bb5199183f05372f99d8038f99dc7e5ff1b011dca4da978ee4d5ae
+  metadata.gz: e7b0189b209ce50457ba90a8f2c89653557f1f7ff61b0a955f479c40beefc8666f47e9dfe9c2e6b17193fc197510305ff442ea49c0bf31ab482011d729b7b09e
+  data.tar.gz: a31458fac536e7d0e074a3c4c5efee56123f264771316503df1ff69b8a4539e782e29c109d5c9f89a789d5f54b576300fde5de91852dc4a67a526b665bc793ff

data/lib/standard_api/helpers.rb

@@ -1,9 +1,9 @@
 module StandardAPI
   module Helpers
-    
+
     def serialize_attribute(json, record, name, type)
       value = record.send(name)
-      
+
       json.set! name, type == :binary ? value&.unpack1('H*') : value
     end
 
@@ -17,31 +17,25 @@ module StandardAPI
             preloads[key] = value
           when Hash, ActiveSupport::HashWithIndifferentAccess
             if !value.keys.any? { |x| ['when', 'where', 'limit', 'offset', 'order', 'distinct'].include?(x) }
-              if !reflection.polymorphic?
-                preloads[key] = preloadables_hash(reflection.klass, value)
-              end
+               preloads[key.to_sym] = preloadables_hash(value)
             end
           end
         end
       end
 
-      preloads.empty? ? record : record.preload(preloads)
+      preloads.present? ? record.preload(preloads) : record
     end
 
-    def preloadables_hash(klass, iclds)
+    def preloadables_hash(iclds)
       preloads = {}
 
       iclds.each do |key, value|
-        if reflection = klass.reflections[key]
-          case value
-          when true
-            preloads[key] = value
-          when Hash, ActiveSupport::HashWithIndifferentAccess
-            if !value.keys.any? { |x| ['when', 'where', 'limit', 'offset', 'order', 'distinct'].include?(x) }
-              if !reflection.polymorphic?
-                preloads[key] = preloadables_hash(reflection.klass, value)
-              end
-            end
+        case value
+        when true
+          preloads[key] = value
+        when Hash, ActiveSupport::HashWithIndifferentAccess
+          if !value.keys.any? { |x| [ 'when', 'where', 'limit', 'offset', 'order', 'distinct' ].include?(x) }
+            preloads[key] = preloadables_hash(value)
           end
         end
       end

data/lib/standard_api/version.rb

@@ -1,3 +1,3 @@
 module StandardAPI
-  VERSION = '7.1.0'
+  VERSION = '7.1.1'
 end

data/lib/standard_api/views/application/_record.json.jbuilder

@@ -31,11 +31,21 @@ includes.each do |inc, subinc|
       end
     else
       can_cache = can_cache_relation?(record, inc, subinc)
-      if association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-        can_cache = can_cache && !record.send(association.foreign_key).nil?
+      cache_key = nil
+
+      if can_cache
+        if association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+          can_cache = can_cache && !record.send(association.foreign_key).nil?
+        end
+
+        if can_cache
+          cache_key = association_cache_key(record, inc, subinc)
+          can_cache = cache_key.present?
+        end
       end
+
       json.set! inc do
-        json.cache_if!(can_cache, can_cache ? association_cache_key(record, inc, subinc) : nil) do
+        json.cache_if!(can_cache, can_cache ? cache_key : nil) do
           value = record.send(inc)
           if value.nil?
             json.null!

data/test/standard_api/standard_api_test.rb

@@ -112,7 +112,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     @controller.params = {}
     assert_equal 'SELECT "references".* FROM "references" WHERE "references"."subject_id" = 1', @controller.send(:resources).to_sql
   end
-  
+
   test "Auto includes on a controller without a model" do
     @controller = SessionsController.new
     assert_nil @controller.send(:model)
@@ -154,7 +154,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
         else
           assert_nil schema.dig('models', model.name, 'attributes', column.name, 'comment')
         end
-        
+
         if column.respond_to?(:auto_populated?)
           assert_equal !!column.auto_populated?, schema.dig('models', model.name, 'attributes', column.name, 'auto_populated')
         end
@@ -263,7 +263,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     assert JSON(response.body).has_key?('document')
     assert_nil JSON(response.body)['document']
   end
-  
+
   test 'rendering serialize_attribute' do
     property = create(:property, description: 'This text will magically change')
     get property_path(property, format: 'json'), params: { id: property.id, magic: true }
@@ -274,15 +274,15 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
 
   test 'rendering an enum' do
     public_document = create(:document, level: 'public')
-    
+
     get documents_path(format: 'json'), params: { limit: 1 }
     assert_equal JSON(response.body)[0]['level'], 'public'
-    
+
     secret_document = create(:document, level: 'secret')
     get document_path(secret_document, format: 'json')
     assert_equal JSON(response.body)['level'], 'secret'
   end
-  
+
   test '#index.json uses overridden partial' do
     create(:property, photos: [create(:photo)])
     get properties_path(format: 'json'), params: { limit: 100, include: [{:photos => { order: :id }}] }
@@ -726,4 +726,34 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
     assert_equal [1], JSON(response.body)
   end
 
+  test 'preloading polymorphic associations' do
+    p1 = create(:property)
+    p2 = create(:property)
+    c1 = create(:camera)
+    c2 = create(:camera)
+    a1 = create(:account, subject: p1, subject_cached_at: Time.now)
+    a2 = create(:account, subject: p2, subject_cached_at: Time.now)
+    a3 = create(:account, subject: c1, subject_cached_at: Time.now)
+    a4 = create(:account, subject: c2, subject_cached_at: Time.now)
+    a5 = create(:account, subject: c2, subject_cached_at: Time.now)
+
+    assert_sql(
+      'SELECT "properties".* FROM "properties" WHERE "properties"."id" IN ($1, $2)',
+      'SELECT "cameras".* FROM "cameras" WHERE "cameras"."id" IN ($1, $2)'
+    ) do
+      assert_no_sql("SELECT \"properties\".* FROM \"properties\" WHERE \"properties\".\"id\" = $1 LIMIT $2") do
+        get accounts_path(limit: 10, include: { subject: { landlord: { when: { subject_type: 'Property' } } } }, format: 'json')
+
+        assert_equal p1.id, a1.subject_id
+        assert_equal p2.id, a2.subject_id
+        assert_equal c1.id, a3.subject_id
+        assert_equal p1.id, JSON(response.body).dig(0, 'subject', 'id')
+        assert_equal p2.id, JSON(response.body).dig(1, 'subject', 'id')
+        assert_equal c1.id, JSON(response.body).dig(2, 'subject', 'id')
+        assert_equal c2.id, JSON(response.body).dig(3, 'subject', 'id')
+        assert_equal c2.id, JSON(response.body).dig(4, 'subject', 'id')
+      end
+    end
+  end
+
 end

data/test/standard_api/test_app/app/controllers/acl/account_acl.rb

@@ -9,7 +9,11 @@ module AccountACL
   end
 
   def includes
-    [ "photos", "subject", "property" ]
+    {
+      photos: true,
+      subject: [ 'landlord' ],
+      property: true
+    }
   end
 
 end

data/test/standard_api/test_app.rb

@@ -53,6 +53,7 @@ Rails.application.routes.draw do
   end
 
   standard_resource :account
+  standard_resources :accounts, only: :index
   # standard_resources :photos, only: [ :index, :show ]
 
 end

data/test/standard_api/test_helper.rb

@@ -85,16 +85,58 @@ class ActiveSupport::TestCase
     { :controller => controller_path, :action => action }.merge(options)
   end
 
-  def assert_sql(sql, &block)
-    queries = []
-    callback = -> (*, payload) do
-      queries << payload[:sql]
+  def assert_sql(*expected)
+    return_value = nil
+
+    queries_ran = if block_given?
+      queries_ran = SQLLogger.log.size
+      return_value = yield if block_given?
+      SQLLogger.log[queries_ran...]
+    else
+      [expected.pop]
+    end
+
+    failed_patterns = []
+    expected.each do |pattern|
+      failed_patterns << pattern unless queries_ran.any?{ |sql| sql_equal(pattern, sql) }
     end
 
-    ActiveSupport::Notifications.subscribed(callback, "sql.active_record", &block)
+    assert failed_patterns.empty?, <<~MSG
+      Query pattern(s) not found:
+        - #{failed_patterns.map{|l| l.gsub(/\n\s*/, " ")}.join('\n  - ')}
+      Queries Ran (queries_ran.size):
+        - #{queries_ran.map{|l| l.gsub(/\n\s*/, "\n    ")}.join("\n  - ")}
+    MSG
 
-    assert_not_nil queries.map { |x| x.strip.gsub(/\s+/, ' ') }.
-      find { |x| x == sql.strip.gsub(/\s+/, ' ') }
+    return_value
+  end
+
+  def assert_no_sql(*not_expected)
+    return_value = nil
+    queries_ran = block_given? ? SQLLogger.log.size : 0
+    return_value = yield if block_given?
+  ensure
+    failed_patterns = []
+    queries_ran = SQLLogger.log[queries_ran...]
+    not_expected.each do |pattern|
+      failed_patterns << pattern if queries_ran.any?{ |sql| sql_equal(pattern, sql) }
+    end
+    assert failed_patterns.empty?, <<~MSG
+      Unexpected Query pattern(s) found:
+        - #{failed_patterns.map(&:inspect).join('\n  - ')}
+      Queries Ran (queries_ran.size):
+        - #{queries_ran.map{|l| l.gsub(/\n\s*/, "\n    ")}.join("\n  - ")}
+    MSG
+
+    return_value
+  end
+  def sql_equal(expected, sql)
+    sql = sql.strip.gsub(/"(\w+)"/, '\1').gsub(/\(\s+/, '(').gsub(/\s+\)/, ')').gsub(/\s+/, ' ')
+    if expected.is_a?(String)
+      expected = Regexp.new(Regexp.escape(expected.strip.gsub(/"(\w+)"/, '\1').gsub(/\(\s+/, '(').gsub(/\s+\)/, ')').gsub(/\s+/, ' ')), Regexp::IGNORECASE)
+    end
+
+    expected.match(sql)
   end
 
   def assert_rendered(options = {}, message = nil)
@@ -234,6 +276,48 @@ class ActiveSupport::TestCase
     end
   end
 
+  class SQLLogger
+    class << self
+      attr_accessor :ignored_sql, :log, :log_all
+      def clear_log; self.log = []; self.log_all = []; end
+    end
+
+    self.clear_log
+
+    self.ignored_sql = [/^PRAGMA/i, /^SELECT currval/i, /^SELECT CAST/i, /^SELECT @@IDENTITY/i, /^SELECT @@ROWCOUNT/i, /^SAVEPOINT/i, /^ROLLBACK TO SAVEPOINT/i, /^RELEASE SAVEPOINT/i, /^SHOW max_identifier_length/i, /^BEGIN/i, /^COMMIT/i]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL, or better yet, use a different notification for the queries
+    # instead examining the SQL content.
+    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
+    mysql_ignored      = [/^SHOW FULL TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i, /^SHOW VARIABLES /, /^\s*SELECT (?:column_name|table_name)\b.*\bFROM information_schema\.(?:key_column_usage|tables)\b/im]
+    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select tablename\b.*from pg_tables\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
+    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im, /^\s*SELECT sql\b.*\bFROM sqlite_master/im]
+
+    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
+      ignored_sql.concat db_ignored_sql
+    end
+
+    attr_reader :ignore
+
+    def initialize(ignore = Regexp.union(self.class.ignored_sql))
+      @ignore = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name]
+
+      self.class.log_all << sql
+      # puts sql
+      self.class.log << sql unless ignore =~ sql
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLLogger.new)
+
 end
 
 class ActionController::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standardapi
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.1.1
 platform: ruby
 authors:
 - James Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-30 00:00:00.000000000 Z
+date: 2024-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails