standardapi 7.1.0 → 7.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88dd56c94d20d8649c5f755509be1aee880f7dff0133602a4fe46c0408c4e65b
-  data.tar.gz: 3f14301f672ac171f9e2a39620de9f1913300572164978857ea12fcb1bb008de
+  metadata.gz: cb9fe722c9847c5c2aa696b36fdbebbc4783f78d92036683b03cde0929f7b78a
+  data.tar.gz: 6723597440138d500614b84f34106279778addc18bd40419d854b0e7bbb628cc
 SHA512:
-  metadata.gz: e3c282a6b8898d1c1451e381dea4cf57c3cd58b65bccfba6a0b5f9d302242287bb233dd43b4a078c51f1711a32a449d47c157626a92cc752939d8040ef704534
-  data.tar.gz: 56d90b5dc3d5d04924b7bd5e5fe6a98cfe9cf4f6fa79d30c933abff3e5c6f6b69a6718a699bb5199183f05372f99d8038f99dc7e5ff1b011dca4da978ee4d5ae
+  metadata.gz: 8aa742b8fda2329a7c17b314ac2b40c8ae46b139fa482516166e7c19a96e851c8438062a89b9de114a5425eaa429c69327faf1fb01b5b4e7e78f1415646a5669
+  data.tar.gz: 8f17ce9c37b5948c726e8cc13166acf8f5be4b7b63103d8c7eb55f308abfe65a6688000ac8b58a062bd30d8d385225a17ae9e8e80d34e8c757634084cab4776a

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.2'
 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/lib/standard_api/views/application/_schema.json.jbuilder

@@ -69,7 +69,17 @@ else
         # TODO: it would be nice if rails responded with a true or false here
         # instead of the function itself
         json.set! 'auto_populated', !!column.auto_populated? if column.respond_to?(:auto_populated?)
-      end
+
+        json.set! 'readonly', (if controller.respond_to?("#{ model.model_name.singular }_attributes")
+          !controller.send("#{ model.model_name.singular }_attributes").include?(column.name)
+        else
+          model.readonly_attribute?(column.name)
+        end)
+        
+        visitor = StandardAPI::Visitors::Validator.new
+        validations = model.validators.select { |v| v.attributes.include?(column.name.to_sym) }.map { |v| visitor.accept(v, {}) }
+        json.set! 'validations', validations
+       end
     end
   end
 

data/lib/standard_api/views/application/_schema.streamer

@@ -79,6 +79,16 @@ else
               # TODO: it would be nice if rails responded with a true or false here
               # instead of the function itself
               json.set! 'auto_populated', !!column.auto_populated? if column.respond_to?(:auto_populated?)
+              
+              json.set! 'readonly', (if controller.respond_to?("#{ model.model_name.singular }_attributes")
+                !controller.send("#{ model.model_name.singular }_attributes").include?(column.name)
+              else
+                true
+              end)
+              
+              visitor = StandardAPI::Visitors::Validator.new
+              validations = model.validators.select { |v| v.attributes.include?(column.name.to_sym) }.map { |v| visitor.accept(v, {}) }
+              json.set! 'validations', validations
             end
           end
         end

data/lib/standard_api/visitors/validations.rb

@@ -0,0 +1,60 @@
+module StandardAPI
+  module Visitors
+
+    class Validator < Arel::Visitors::Visitor
+
+      def visit_ActiveRecord_Validations_AbsenceValidator(o, col)
+        visit_validator(:absence, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_AcceptanceValidator(o, col)
+        visit_validator(:acceptance, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_ComparisonValidator(o, col)
+        visit_validator(:comparison, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_ConfirmationValidator(o, col)
+        visit_validator(:confirmation, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_ExclusionValidator(o, col)
+        visit_validator(:exclusion, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_FormatValidator(o, col)
+        visit_validator(:format, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_InclusionValidator(o, col)
+        visit_validator(:inclusion, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_LengthValidator(o, col)
+        visit_validator(:length, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_NumericalityValidator(o, col)
+        visit_validator(:numericality, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_PresenceValidator(o, col)
+        visit_validator(:presence, o.options)
+      end
+
+      def visit_ActiveRecord_Validations_WithValidator(o, col)
+        visit_validator(:with, o.options)
+      end
+
+      private
+
+      def visit_validator(name, options)
+        { name => options.empty? ? true : options.as_json }
+      end
+
+
+    end
+
+  end
+end

data/lib/standard_api.rb

@@ -16,6 +16,7 @@ require 'standard_api/helpers'
 require 'standard_api/route_helpers'
 require 'standard_api/active_record/connection_adapters/postgresql/schema_statements'
 require 'standard_api/railtie'
+require 'standard_api/visitors/validations'
 
 module StandardAPI
   autoload :AccessControlList, 'standard_api/access_control_list'

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,13 +154,34 @@ 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
       end
     end
 
+    assert_equal true, schema['models']['Account']['attributes']['id']['readonly']
+    assert_equal false, schema['models']['Account']['attributes']['name']['readonly']
+
+    assert_equal [
+      { "presence" => true }
+    ], schema['models']['Property']['attributes']['name']['validations']
+    
+    assert_equal [
+      { "numericality" => {
+          "greater_than" => 1,
+          "greater_than_or_equal_to" => 2,
+          "equal_to" => 2,
+          "less_than_or_equal_to" => 2,
+          "less_than" => 3,
+          "other_than" => 0,
+          "even" => true,
+          "in" => "1..3"
+        }
+      }
+    ], schema['models']['Property']['attributes']['numericality']['validations']
+
     assert_equal 'test comment', schema['comment']
   end
 
@@ -263,7 +284,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 +295,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 +747,36 @@ 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/app/controllers/acl/property_acl.rb

@@ -7,7 +7,8 @@ module PropertyACL
       :description,
       :constructed,
       :size,
-      :active
+      :active,
+      :numericality
       # :photos_attributes,
       # { photos_attributes: [ :id, :account_id, :property_id, :format] }
     ]
@@ -15,7 +16,17 @@ module PropertyACL
 
   # Orderings allowed
   def orders
-    ["id", "name", "aliases", "description", "constructed", "size", "created_at", "active"]
+    [
+      "id",
+      "name",
+      "aliases",
+      "description",
+      "constructed",
+      "size",
+      "created_at",
+      "active",
+      "numericality"
+    ]
   end
 
   # Sub resources allowed to be included in the response

data/test/standard_api/test_app/models.rb

@@ -14,7 +14,7 @@ end
 
 class Document < ActiveRecord::Base
   attr_accessor :file
-  
+
   enum level:   { public: 0, secret: 1 }, _suffix: true
   enum rating:  { poor: 0, ok: 1, good: 2 }
 end
@@ -29,13 +29,25 @@ class Property < ActiveRecord::Base
   has_one :document_attachments, class_name: "Attachment", as: :record, inverse_of: :record
   has_one :document, through: "document_attachments"
 
-
   validates :name, presence: true
   accepts_nested_attributes_for :photos
 
   def english_name
     'A Name'
   end
+
+  # Numericality Validation
+  validates :numericality, numericality: {
+    greater_than: 1,
+    greater_than_or_equal_to: 2,
+    equal_to: 2,
+    less_than_or_equal_to: 2,
+    less_than: 3,
+    other_than: 0,
+    even: true,
+    in: 1..3
+  }
+  
 end
 
 class LSNType < ActiveRecord::Type::Value
@@ -129,6 +141,7 @@ class CreateModelTables < ActiveRecord::Migration[6.0]
       t.decimal  "size"
       t.datetime "created_at",                         null: false
       t.boolean  "active",             default: false
+      t.integer  "numericality",       default: 2
     end
 
     create_table "references", force: :cascade do |t|
@@ -167,12 +180,12 @@ class CreateModelTables < ActiveRecord::Migration[6.0]
       t.integer  'record_id'
       t.integer  'document_id'
     end
-    
+
     create_table "uuid_models", id: :uuid, force: :cascade do |t|
       t.string 'title', default: 'recruit'
       t.string 'name', default: -> { 'round(random() * 1000)' }
     end
-    
+
   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.2
 platform: ruby
 authors:
 - James Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-30 00:00:00.000000000 Z
+date: 2024-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -306,6 +306,7 @@ files:
 - lib/standard_api/views/application/schema.streamer
 - lib/standard_api/views/application/show.json.jbuilder
 - lib/standard_api/views/application/show.streamer
+- lib/standard_api/visitors/validations.rb
 - test/standard_api/caching_test.rb
 - test/standard_api/controller/include_test.rb
 - test/standard_api/controller/subresource_test.rb
@@ -361,7 +362,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
 summary: StandardAPI makes it easy to expose a query interface for your Rails models