standardapi 6.0.0.15 → 6.0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbc6b3f7345e1df82060abcc37ee0bcf5f11b88863e1cdab4299f514129b44f6
-  data.tar.gz: cae2c3d6859933c99ac13f0704e35997e3c10603f53d325b3a8ace63607fce94
+  metadata.gz: 3670132e90418137f095c8e7741310e2911bfde21e78579e27ea6c54ae88d0f1
+  data.tar.gz: 205778759e7188eda509e289495a383d6a5ff037116fd5043a519f95c5b7222d
 SHA512:
-  metadata.gz: 75a1555b14bbbcfd99f2dcd31cbba472a157c0066a22d597cd1fff9daa7c4f53e1c6461c21c8adde888715a90df07ae7e4e8eb48467b702a7ba45e6dba21de10
-  data.tar.gz: a9deedd375a788e22502b4caea542fdbe935ac6f4d594d8e46ceb79bcf9202e5813b795df9c60c7360ef84a9068b5388d862e95734e9bd05f427f4286ff3d114
+  metadata.gz: 2d4a009d0ea47b18ebc5088d81bdf4518e9a22749b1ea0a17e8f7b5504be42dbeea60945ad75eeb5a4cdfda866f39edc12391262ff64b2a5cc3748011cb0c4bc
+  data.tar.gz: 49a638815647e3fbe6d63dc4eda87eda4703425b2c36e4565763cc0aad1abf0934d54d8f18858d00ac733f1e4662873f5ff586e1cdf27aafdaebfbc825703b71

data/README.md

@@ -105,11 +105,12 @@ including the author, the photos that the author took can also be included.
 # API Usage
 Resources can be queried via REST style end points
 ```
-GET     /records/:id    fetch record
-PATCH   /records/:id    update record
-GET     /records        fetch records
-POST    /records        create record
-DELETE  /records        destroy record
+GET     /records/:id        fetch record
+PATCH   /records/:id        update record
+GET     /records/           fetch records
+GET     /records/calculate  apply count and other functions on record(s)
+POST    /records            create record
+DELETE  /records            destroy record
 ```
 
 All resource end points can be filtered, ordered, limited, offset, and have includes. All options are passed via query string in a nested URI encoded format.
@@ -163,8 +164,16 @@ location: {within: 0106000020e6...}         WHERE ST_Within("listings"."location
 
 // On Relationships
 property: {size: 10000}         JOIN properties WHERE properties.size = 10000"
+```
+## Calculations
+
+The only change on calculate routes is the `selects` paramater contains the functions to apply. Currently just `minimum`, `maximum`, `average`, `sum`, and `count`.
 
-// 
+```
+{ count: '*' }                                          SELECT COUNT(*)
+[{ count: '*' }]                                        SELECT COUNT(*)
+[{ count: '*', maximum: :id, minimum: :id }]            SELECT COUNT(*), MAXIMUM(id), MINIMUM(id)
+[{ maximum: :id }, { maximum: :count }]                 SELECT MAXIMUM(id), MAXIMUM(count)
 ```
 
 # Testing

data/lib/standard_api.rb

@@ -8,9 +8,11 @@ require 'active_record/sort'
 require 'active_support/core_ext/hash/indifferent_access'
 
 require 'standard_api/version'
+require 'standard_api/errors'
 require 'standard_api/orders'
 require 'standard_api/includes'
 require 'standard_api/controller'
 require 'standard_api/helpers'
 require 'standard_api/route_helpers'
+require 'standard_api/active_record/connection_adapters/postgresql/schema_statements'
 require 'standard_api/railtie'

data/lib/standard_api/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+
+      # Returns a comment stored in database for given table
+      def database_comment(database_name=nil) # :nodoc:
+        database_name ||= current_database
+
+        scope = quoted_scope(database_name, type: "BASE TABLE")
+        if scope[:name]
+          query_value(<<~SQL, "SCHEMA")
+            SELECT pg_catalog.shobj_description(d.oid, 'pg_database')
+            FROM   pg_catalog.pg_database d
+            WHERE  datname = #{scope[:name]};
+          SQL
+        end
+      end
+
+    end
+  end
+end

data/lib/standard_api/controller.rb

@@ -1,26 +1,36 @@
 module StandardAPI
   module Controller
 
+    delegate :preloadables, to: :helpers
+
     def self.included(klass)
-      klass.helper_method :includes, :orders, :model, :resource_limit,
-        :default_limit, :preloadables
+      klass.helper_method :includes, :orders, :model, :models, :resource_limit,
+        :default_limit
       klass.before_action :set_standardapi_headers
+      klass.rescue_from StandardAPI::UnpermittedParameters, with: :bad_request
       klass.append_view_path(File.join(File.dirname(__FILE__), 'views'))
       klass.extend(ClassMethods)
     end
 
     def tables
-      Rails.application.eager_load! if Rails.env == 'development'.freeze
-      
-      controllers = ApplicationController.descendants
-      controllers.select! { |c| c.ancestors.include?(self.class) && c != self.class }
-      controllers.map!(&:model).compact!
-      controllers.map!(&:table_name)
-      render json: controllers
+      Rails.application.eager_load! if !Rails.application.config.eager_load
+
+      tables = ApplicationController.descendants
+      tables.select! { |c| c.ancestors.include?(self.class) && c != self.class }
+      tables.map!(&:model).compact!
+      tables.map!(&:table_name)
+      render json: tables
+    end
+
+    if Rails.env == 'development'
+      def schema
+        Rails.application.eager_load! if !Rails.application.config.eager_load
+      end
     end
 
     def index
-      instance_variable_set("@#{model.model_name.plural}", resources.limit(limit).offset(params[:offset]).sort(orders))
+      records = preloadables(resources.limit(limit).offset(params[:offset]).sort(orders), includes)
+      instance_variable_set("@#{model.model_name.plural}", records)
     end
 
     def calculate
@@ -32,12 +42,13 @@ module StandardAPI
         end
       end
       @calculations = Hash[@calculations] if @calculations[0].is_a?(Array) && params[:group_by]
-      
+
       render json: @calculations
     end
 
     def show
-      instance_variable_set("@#{model.model_name.singular}", resources.find(params[:id]))
+      record = preloadables(resources, includes).find(params[:id])
+      instance_variable_set("@#{model.model_name.singular}", record)
     end
 
     def new
@@ -93,13 +104,40 @@ module StandardAPI
       head :no_content
     end
 
+    def remove_resource
+      resource = resources.find(params[:id])
+      subresource_class = resource.association(params[:relationship]).klass
+      subresource = subresource_class.find_by_id(params[:resource_id])
+
+      if(subresource)
+        result = resource.send(params[:relationship]).delete(subresource)
+        head result ? :no_content : :bad_request
+      else
+        head :not_found
+      end
+    end
+
+    def add_resource
+      resource = resources.find(params[:id])
+
+      subresource_class = resource.association(params[:relationship]).klass
+      subresource = subresource_class.find_by_id(params[:resource_id])
+      if(subresource)
+        result = resource.send(params[:relationship]) << subresource
+        head result ? :created : :bad_request
+      else
+        head :not_found
+      end
+
+    end
+
     # Override if you want to support masking
     def current_mask
       @current_mask ||= {}
     end
 
     module ClassMethods
-    
+
       def model
         return @model if defined?(@model)
         @model = name.sub(/Controller\z/, '').singularize.camelize.safe_constantize
@@ -109,6 +147,10 @@ module StandardAPI
 
     private
 
+    def bad_request(exception)
+      render body: exception.to_s, status: :bad_request
+    end
+
     def set_standardapi_headers
       headers['StandardAPI-Version'] = StandardAPI::VERSION
     end
@@ -117,6 +159,15 @@ module StandardAPI
       self.class.model
     end
 
+    def models
+      return @models if defined?(@models)
+      Rails.application.eager_load! if !Rails.application.config.eager_load
+
+      @models = ApplicationController.descendants
+      @models.select! { |c| c.ancestors.include?(self.class) && c != self.class }
+      @models.map!(&:model).compact!
+    end
+
     def model_includes
       if self.respond_to?("#{model.model_name.singular}_includes", true)
         self.send("#{model.model_name.singular}_includes")
@@ -156,81 +207,39 @@ module StandardAPI
 
     def resources
       query = model.filter(params['where']).filter(current_mask[model.table_name])
-      
+
       if params[:distinct_on]
         query = query.distinct_on(params[:distinct_on])
       elsif params[:distinct]
         query = query.distinct
       end
-      
+
       if params[:join]
         query = query.joins(params[:join].to_sym)
       end
-      
+
       if params[:group_by]
         query = query.group(params[:group_by])
       end
-      
+
       query
     end
 
     def includes
-      @includes ||= StandardAPI::Includes.normalize(params[:include])
-    end
-    
-    def preloadables(record, iclds)
-      preloads = {}
-      
-      iclds.each do |key, value|
-        if reflection = record.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
-          end
-        end
-      end
-      
-      preloads.empty? ? record : record.preload(preloads)
-    end
-
-    def preloadables_hash(klass, 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
-          end
-        end
-      end
-  
-      preloads
+      @includes ||= StandardAPI::Includes.sanitize(params[:include], model_includes)
     end
-    
+
     def required_orders
       []
     end
-    
+
     def default_orders
       nil
     end
 
     def orders
       exluded_required_orders = required_orders.map(&:to_s)
-      
+
       case params[:order]
       when Hash, ActionController::Parameters
         exluded_required_orders -= params[:order].keys.map(&:to_s)
@@ -246,7 +255,7 @@ module StandardAPI
       when String
         exluded_required_orders.delete(params[:order])
       end
-      
+
       if !exluded_required_orders.empty?
         params[:order] = exluded_required_orders.unshift(params[:order])
       end
@@ -304,10 +313,12 @@ module StandardAPI
             @model = parts[0].singularize.camelize.constantize
             column = parts[1]
           end
-          
+
           column = column == '*' ? Arel.star : column.to_sym
           if functions.include?(func.to_s.downcase)
-            @selects << ((defined?(@model) ? @model : model).arel_table[column].send(func))
+            node = (defined?(@model) ? @model : model).arel_table[column].send(func)
+            node.distinct = true if params[:distinct]
+            @selects << node
           end
         end
       end

data/lib/standard_api/errors.rb

@@ -0,0 +1,13 @@
+module StandardAPI
+  class StandardAPIError < StandardError
+  end
+
+  class UnpermittedParameters < StandardAPIError
+    attr_reader :params
+
+    def initialize(params)
+      @params = params
+      super("found unpermitted parameter#{'s' if params.size > 1 }: #{params.map { |e| e.inspect }.join(", ")}")
+    end
+  end
+end

data/lib/standard_api/helpers.rb

@@ -1,6 +1,58 @@
 module StandardAPI
   module Helpers
-    
+
+    def preloadables(record, includes)
+      preloads = {}
+
+      includes.each do |key, value|
+        if reflection = record.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
+          end
+        end
+      end
+
+      preloads.empty? ? record : record.preload(preloads)
+    end
+
+    def preloadables_hash(klass, 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
+          end
+        end
+      end
+
+      preloads
+    end
+
+    def schema_partial(model)
+      path = model.model_name.plural
+
+      if lookup_context.exists?("schema", path, true)
+        [path, "schema"].join('/')
+      else
+        'application/schema'
+      end
+    end
+
     def model_partial(record)
       if lookup_context.exists?(record.model_name.element, record.model_name.plural, true)
         [record.model_name.plural, record.model_name.element].join('/')
@@ -17,7 +69,7 @@ module StandardAPI
         false
       end
     end
-    
+
     def cache_key(record, includes)
       timestamp_keys = ['cached_at'] + record.class.column_names.select{|x| x.ends_with? "_cached_at"}
       if includes.empty?
@@ -27,7 +79,7 @@ module StandardAPI
         "#{record.model_name.cache_key}/#{record.id}-#{digest_hash(sort_hash(includes))}-#{timestamp.utc.to_s(record.cache_timestamp_format)}"
       end
     end
-    
+
     def can_cache_relation?(klass, relation, subincludes)
       cache_columns = ["#{relation}_cached_at"] + cached_at_columns_for_includes(subincludes).map {|c| "#{relation}_#{c}"}
       if (cache_columns - klass.column_names).empty?
@@ -36,12 +88,12 @@ module StandardAPI
         false
       end
     end
-    
+
     def association_cache_key(record, relation, subincludes)
       timestamp = ["#{relation}_cached_at"] + cached_at_columns_for_includes(subincludes).map {|c| "#{relation}_#{c}"}
       timestamp.map! { |col| record.send(col) }
       timestamp = timestamp.max
-      
+
       case association = record.class.reflect_on_association(relation)
       when ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasAndBelongsToManyReflection, ActiveRecord::Reflection::HasOneReflection, ActiveRecord::Reflection::ThroughReflection
         "#{record.model_name.cache_key}/#{record.id}/#{includes_to_cache_key(relation, subincludes)}-#{timestamp.utc.to_s(record.cache_timestamp_format)}"
@@ -56,13 +108,13 @@ module StandardAPI
         raise ArgumentError, 'Unkown association type'
       end
     end
-    
+
     def cached_at_columns_for_includes(includes)
-      includes.select { |k,v| !['when', 'where', 'limit', 'order', 'distinct'].include?(k) }.map do |k, v|
+      includes.select { |k,v| !['when', 'where', 'limit', 'order', 'distinct', 'distinct_on'].include?(k) }.map do |k, v|
         ["#{k}_cached_at"] + cached_at_columns_for_includes(v).map { |v2| "#{k}_#{v2}" }
       end.flatten
     end
-    
+
     def includes_to_cache_key(relation, subincludes)
       if subincludes.empty?
         relation.to_s
@@ -70,7 +122,7 @@ module StandardAPI
         "#{relation}-#{digest_hash(sort_hash(subincludes))}"
       end
     end
-    
+
     def sort_hash(hash)
       hash.keys.sort.reduce({}) do |seed, key|
         if seed[key].is_a?(Hash)
@@ -81,7 +133,7 @@ module StandardAPI
         seed
       end
     end
-    
+
     def digest_hash(*hashes)
       hashes.compact!
       hashes.map! { |h| sort_hash(h) }
@@ -103,8 +155,6 @@ module StandardAPI
 
     def json_column_type(sql_type)
       case sql_type
-      when /character varying(\(\d+\))?/
-        'string'
       when 'timestamp without time zone'
         'datetime'
       when 'time without time zone'
@@ -133,12 +183,14 @@ module StandardAPI
        'string'
       when 'boolean'
         'boolean'
-      when 'geometry'
-        'ewkb'
       when 'uuid' # TODO: should be uuid
         'string'
+      when /character varying(\(\d+\))?/
+        'string'
+      when /^geometry/
+        'ewkb'
       end
     end
 
   end
-end
+end