deep_unrest 0.1.30 → 0.1.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3395eda13825d0ecdfe337b515741edc5b5e25a6
-  data.tar.gz: 0fec2b4c1003af2d6ed883fc1d0398bd457eb875
+SHA256:
+  metadata.gz: 0c5e259eeb18f8ac855b773aec2b8eff84771ccf6f71df929d41511c6c4a17a8
+  data.tar.gz: 0d56e539b798f92749bf990ba555bba0d6b2a6c3f886333a772a4c82f7a24f86
 SHA512:
-  metadata.gz: 441ebd1c53d3717286b4b30ef2ac201f5470d3d9f718a5757e3dae79b4152c1232b7c1d919f0ea9b554272137eea75c7d5454a7fc1dd2c01db355415c184f318
-  data.tar.gz: 8b4066e6233a7dd6922e5e9aa55bd2f753d9ceae53714b31b0c3fcf87c1087cc26e95d787d52ced89e3be1c86622fee7ee0304d4c157c8fc4c6c1051b36ba1b4
+  metadata.gz: e7b8688e920dc630b4f6621a79bdbbef6a8fa6b60921a750136e11a22bf4a075567c20d80fec13f232b1515b5e13c08db974ecf6d244900fb45d37277455f21b
+  data.tar.gz: ae706986003c7a10bc541a32bf7f23e763dd63a4fde85bfea89e7eae33824efa0f03478ed7b870c7fa22a7c1056a2f45d8677935606407806a81288fa56fbd88

data/app/controllers/deep_unrest/application_controller.rb

@@ -28,10 +28,29 @@ module DeepUnrest
       end
     end
 
+    def read
+      repaired_params = params[:data]
+      data = repaired_params[:data]
+      context = repaired_params[:context] || {}
+      context[:uuid] = request.uuid
+      context[:current_user] = current_user
+
+      instance_eval &DeepUnrest.before_read if DeepUnrest.before_read
+
+      results = DeepUnrest.perform_read(context, data, current_user)
+      render json: results, status: 200
+    end
+
     def update
-      redirect = allowed_params[:data][:redirect]
-      data = repair_nested_params(allowed_params)[:data][:data]
-      results = DeepUnrest.perform_update(request.uuid, data, current_user)
+      redirect = allowed_write_params[:data][:redirect]
+      context = allowed_write_params[:data][:context] || {}
+      context[:uuid] = request.uuid
+      context[:current_user] = current_user
+      data = repair_nested_params(allowed_write_params)[:data][:data]
+
+      instance_eval &DeepUnrest.before_update if DeepUnrest.before_update
+
+      results = DeepUnrest.perform_update(context, data)
       resp = { destroyed: results[:destroyed],
                tempIds: results[:temp_ids] }
       resp[:redirect] = results[:redirect_regex].call(redirect) if redirect
@@ -50,7 +69,7 @@ module DeepUnrest
       instance_eval &DeepUnrest.get_user
     end
 
-    def allowed_params
+    def allowed_write_params
       params.permit(data: [:redirect,
                            data: [:destroy,
                                   :path,

data/config/routes.rb

@@ -1,3 +1,4 @@
 DeepUnrest::Engine.routes.draw do
   patch 'update', to: 'application#update'
+  get 'read', to: 'application#read'
 end

data/lib/deep_unrest/engine.rb

@@ -1,6 +1,7 @@
 require 'deep_unrest/authorization/base_strategy'
 require 'deep_unrest/authorization/none_strategy'
 require 'deep_unrest/authorization/pundit_strategy'
+require 'deep_unrest/paginators/basic'
 require 'deep_unrest/concerns/null_concern'
 require 'deep_unrest/concerns/map_temp_ids'
 
@@ -10,12 +11,20 @@ module DeepUnrest
   end
 
   mattr_accessor :authorization_strategy
+  mattr_accessor :pagination_strategy
+  mattr_accessor :page_size
   mattr_accessor :authentication_concern
   mattr_accessor :get_user
+  mattr_accessor :before_read
+  mattr_accessor :before_update
 
   self.authorization_strategy = DeepUnrest::Authorization::PunditStrategy
+  self.pagination_strategy = DeepUnrest::Paginators::Basic
+  self.page_size = 25
   self.authentication_concern = DeepUnrest::Concerns::NullConcern
   self.get_user = proc { current_user }
+  self.before_read = nil
+  self.before_update = nil
 
   def self.configure(&_block)
     yield self

data/lib/deep_unrest/paginators/basic.rb

@@ -0,0 +1,11 @@
+module DeepUnrest
+  module Paginators
+    module Basic
+      def self.get_page(item, results)
+        page = [item[:query][:page] || 1].max
+        page_size = item[:query][:pageSize] || DeepUnrest.page_size
+        results.limit(page_size).offset(page - 1)
+      end
+    end
+  end
+end

data/lib/deep_unrest/read.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module DeepUnrest
+  module Read
+    # def self.map_included(params, addr)
+    # params[:include].map { |k, v| create_read_mappings({ "#{k}": v }, [*addr, :include]) }
+    # end
+
+    def self.create_read_mappings(params, addr = [])
+      return unless params
+      params.map do |k, v|
+        resource_addr = [*addr, k]
+        uuid = SecureRandom.uuid
+        v[:uuid] = uuid
+        [{ klass: k.singularize.classify.constantize,
+           policy: "#{k.singularize.classify}Policy".constantize,
+           resource: "#{k.singularize.classify}Resource".constantize,
+           scope_type: :index,
+           addr: resource_addr,
+           key: k.camelize(:lower),
+           uuid: uuid,
+           query: deep_underscore_keys(v) },
+         *create_read_mappings(v[:include], [*resource_addr, :include])]
+      end.flatten.compact
+    end
+
+    def self.plural?(str)
+      str.pluralize == str && str.singularize != str
+    end
+
+    def self.serialize_result(ctx, item)
+      JSONAPI::ResourceSerializer.new(item[:resource],
+                                      fields: {
+                                        "#{item[:key].pluralize}": item[:query][:fields].map(&:underscore).map(&:to_sym)
+                                      }).serialize_to_hash(item[:resource].new(item[:record], ctx))[:data]
+    end
+
+    def self.serialize_results(ctx, data)
+      data.each do |item|
+        item[:serialized_result] = serialize_result(ctx, item)
+      end
+    end
+
+    def self.deep_underscore_keys(query)
+      query.deep_transform_keys! do |key|
+        k = begin
+              key.to_s.underscore
+            rescue StandardError
+              key
+            end
+        begin
+          k.to_sym
+        rescue StandardError
+          key
+        end
+      end
+    end
+
+    def self.resolve_conditions(query, parent_context)
+      if query.is_a? Array
+        query.each { |item| resolve_conditions(item, parent_context) }
+      elsif query.is_a? Hash
+        query.each do |k, v|
+          next unless v.is_a? Hash
+          if v[:from_context]
+            name, attr = v[:from_context].split('.')
+            next unless parent_context[name]
+            query[k] = parent_context[name].send(attr.underscore)
+          else
+            resolve_conditions(v, parent_context)
+          end
+        end
+      end
+      query
+    end
+
+    def self.recurse_included_queries(item, mappings, parent_context, included, meta, addr)
+      return unless item[:query].key?(:include)
+      item[:query][:include].each do |_k, v|
+        next_context = parent_context.clone
+        next_context[item[:key].singularize] = item[:record]
+        next_mapping = mappings.find { |m| m[:uuid] == v[:uuid] }.clone
+        execute_query(next_mapping, mappings, next_context, included, meta, addr, item)
+      end
+    end
+
+    def self.query_item(mapping, mappings, parent_context, included, meta, addr, _parent)
+      query = resolve_conditions(mapping[:query].deep_dup, parent_context)
+      raise DeepUnrest::InvalidQuery unless query[:id] || query[:find]
+      record = if query.key?(:id)
+                 mapping[:scope].find(query[:id]) if query.key?(:id)
+               else
+                 mapping[:scope].find_by!(query[:find])
+               end
+
+      next_addr = [*addr, mapping[:key]]
+
+      result = {
+        **mapping,
+        addr: next_addr,
+        record: record
+      }
+
+      included << result
+
+      recurse_included_queries(result, mappings, parent_context, included, meta, [*next_addr, :included])
+    end
+
+    def self.get_paginator(query, _parent)
+      opts = query.dig(:paginate) || {}
+      params = ActionController::Parameters.new(opts)
+
+      case params[:type]
+      when :offset
+        OffsetPaginator.new(params)
+      else
+        PagedPaginator.new(params)
+      end
+    end
+
+    def self.query_list(item, mappings, parent_context, included, meta, addr, parent)
+      base_query = item[:query].deep_dup
+      extension = base_query.dig(:extend, parent&.fetch(:record)&.id&.to_s) || {}
+      query = resolve_conditions(base_query.deep_merge(extension),
+                                 parent_context)
+
+      paginator = get_paginator(query, parent)
+      resource = item[:resource]
+
+      # monkey patch the resource to only show authorized records
+      def resource.records_base(_opts)
+        item[:scope]
+      end
+
+      # results = resource.find(query[:filter], paginator: paginator,
+                                              # sort_criteria: query[:sort])
+
+      processor = JSONAPI::Processor.new(item[:resource],
+                                         :find,
+                                         filters: query[:filter] || {},
+                                         sort_criteria: query[:sort],
+                                         paginator: paginator)
+
+      jsonapi_result = processor.process
+
+      meta << {
+        addr: [*addr, item[:key], 'meta'],
+        serialized_result: {
+          paginationParams: jsonapi_result.pagination_params,
+          recordCount: jsonapi_result.record_count,
+        }
+      }
+
+      jsonapi_result.resources.each_with_index do |record, i|
+        next_addr = [*addr, item[:key], 'data[]', i]
+        result = {
+          **item,
+          addr: next_addr,
+          record: record._model
+        }
+
+        included << result
+        recurse_included_queries(result, mappings, parent_context, included, meta, [*next_addr, :included])
+      end
+    end
+
+    def self.get_query_type(item)
+      return :detail unless plural?(item[:key])
+      :list
+    end
+
+    def self.execute_query(item, mappings, parent_context, included, meta, addr, parent = nil)
+      if get_query_type(item) == :list
+        query_list(item, mappings, parent_context, included, meta, addr, parent)
+      else
+        query_item(item, mappings, parent_context, included, meta, addr, parent)
+      end
+    end
+
+    def self.execute_queries(mappings, parent_context = {}, included = [], meta = [], addr = [])
+      mappings.select { |m| m[:addr].size == 1 }.each do |item|
+        item[:results] = execute_query(item, mappings, parent_context, included, meta, addr)
+      end
+      [included, meta]
+    end
+
+    def self.set_attr(hash, path, val, cursor = nil)
+      cursor ||= hash
+      key = path.shift
+
+      if path.empty?
+        case cursor
+        when Array
+          cursor << val
+        when Hash
+          cursor[key] = val
+        end
+        return hash
+      end
+
+      next_cursor = case key
+                    when /\[\]$/
+                      cursor[key.gsub('[]', '')] ||= []
+                    else
+                      cursor[key] ||= {}
+                    end
+
+      set_attr(hash, path, val, next_cursor)
+    end
+
+    def self.format_response(mappings)
+      response = {}
+      mappings.each do |mapping|
+        set_attr(response, mapping[:addr], mapping[:serialized_result])
+      end
+      response
+    end
+
+    def self.collect_authorized_scopes(mappings, user)
+      mappings.each do |mapping|
+        mapping[:scope] = DeepUnrest.authorization_strategy.get_authorized_scope(user, mapping[:klass])
+      end
+    end
+
+    def self.read(ctx, params, user)
+      # create mappings for assembly / disassembly
+      mappings = create_read_mappings(params.to_unsafe_h)
+
+      # authorize user for requested scope(s)
+      DeepUnrest.authorization_strategy.authorize(mappings, user).flatten
+
+      # collect authorized scopes
+      collect_authorized_scopes(mappings, user)
+
+      # read data
+      data, meta = execute_queries(mappings)
+
+      # serialize using JSONAPI resource serializers
+      serialize_results(ctx, data)
+
+      # assemble results into something resembling shape of request
+      format_response([*data, *meta])
+    end
+  end
+end

data/lib/deep_unrest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepUnrest
-  VERSION = '0.1.30'
+  VERSION = '0.1.31'
 end

data/lib/deep_unrest.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'deep_unrest/engine'
+require 'deep_unrest/read'
 
 # workaronud for rails bug with association indices.
 # see https://github.com/rails/rails/pull/24728
@@ -48,6 +49,9 @@ module DeepUnrest
   class Unauthorized < ::StandardError
   end
 
+  class InvalidQuery < ::StandardError
+  end
+
   def self.to_class(str)
     str.classify.constantize
   end
@@ -377,7 +381,8 @@ module DeepUnrest
     end
   end
 
-  def self.mutate(mutation, user)
+  def self.mutate(mutation, context)
+    user = context[:current_user]
     ActiveRecord::Base.transaction do
       mutation.map do |_, item|
         item[:operations].map do |id, ops|
@@ -396,7 +401,7 @@ module DeepUnrest
                      when :update
                        model = item[:klass].find(id)
                        model.assign_attributes(action[:body])
-                       resource = item[:resource].new(model, current_user: user)
+                       resource = item[:resource].new(model, context)
                        resource.run_callbacks :save do
                          resource.run_callbacks :update do
                            model.save
@@ -405,17 +410,16 @@ module DeepUnrest
                        end
                      when :create
                        model = item[:klass].new(action[:body])
-                       resource = item[:resource].new(model, current_user: user)
+                       resource = item[:resource].new(model, context)
                        resource.run_callbacks :save do
                          resource.run_callbacks :create do
-                           # item[:klass].create(action[:body])
                            resource._model.save
                            resource._model
                          end
                        end
                      when :destroy
                        model = item[:klass].find(id)
-                       resource = item[:resource].new(model, current_user: user)
+                       resource = item[:resource].new(model, context)
                        resource.run_callbacks :remove do
                          item[:klass].destroy(id)
                        end
@@ -508,12 +512,19 @@ module DeepUnrest
     record&.errors&.messages
   end
 
-  def self.perform_update(ctx, params, user)
+  def self.perform_read(ctx, params, user)
+    DeepUnrest::Read.read(ctx, params, user)
+  end
+
+  def self.perform_update(ctx, params)
     temp_id_map = DeepUnrest::ApplicationController.class_variable_get(
       '@@temp_ids'
     )
 
-    temp_id_map[ctx] ||= {}
+    user = ctx[:current_user]
+    uuid = ctx[:uuid]
+
+    temp_id_map[uuid] ||= {}
 
     # reject new resources marked for destruction
     viable_params = params.reject do |param|
@@ -530,10 +541,10 @@ module DeepUnrest
     mutations = build_mutation_body(viable_params, scopes, user)
 
     # convert temp_ids from ids to non-activerecord attributes
-    convert_temp_ids!(ctx, mutations)
+    convert_temp_ids!(uuid, mutations)
 
     # perform update
-    results = mutate(mutations, user).flatten
+    results = mutate(mutations, ctx).flatten
 
     # check results for errors
     errors = results.map { |res| format_error_keys(res) }
@@ -546,8 +557,8 @@ module DeepUnrest
         '@@destroyed_entities'
       )
       return {
-        redirect_regex: build_redirect_regex(temp_id_map[ctx]),
-        temp_ids: temp_id_map[ctx],
+        redirect_regex: build_redirect_regex(temp_id_map[uuid]),
+        temp_ids: temp_id_map[uuid],
         destroyed: destroyed
       }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_unrest
 version: !ruby/object:Gem::Version
-  version: 0.1.30
+  version: 0.1.31
 platform: ruby
 authors:
 - Lynn Hurley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-11 00:00:00.000000000 Z
+date: 2019-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 5.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 5.2.3
 - !ruby/object:Gem::Dependency
   name: jsonapi-utils
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +162,8 @@ files:
 - lib/deep_unrest/concerns/map_temp_ids.rb
 - lib/deep_unrest/concerns/null_concern.rb
 - lib/deep_unrest/engine.rb
+- lib/deep_unrest/paginators/basic.rb
+- lib/deep_unrest/read.rb
 - lib/deep_unrest/version.rb
 - lib/tasks/deep_unrest_tasks.rake
 homepage: https://github.com/graveflex/deep_unrest
@@ -184,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Update multiple or deeply nested JSONAPI resources