deep_unrest 0.1.36 → 0.1.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49fe70a86a480793222a007af3de245afc7d2bba795d3e42ba0f2e74a5791c3b
-  data.tar.gz: 64ac3b1ffcb724b5bd5b8c15c37143da18241685cc36f76b3a7e63d9c568b461
+  metadata.gz: 81050e835a80fcd169a4bcfe4213d2378575ac6a87942bf07289e1b4b8c6722b
+  data.tar.gz: bdbbc8aa16a157a2103beb572173ea0018a251936dbe132a7e33adcb677afc77
 SHA512:
-  metadata.gz: 5b824d05e3a002abd22057c337c6b5b948c9c54c92c148873bf4239aa47a5319bcf68dd212d9dbb3dc9093addda891a3e2bc17329677e8ae05fee5c9a245b451
-  data.tar.gz: eb20d4d68c51fb7bb383f1e34996841195f1c44a880e2348f839c39968048032a1b2bccabfe3d1738af5e31a92f3e11a5ac84f39371182ac8d1116e1dc02ad62
+  metadata.gz: e02bc06a96e1bc77f6a28be4d334e847c66cce02fbe8cdc7312191f94467d8889abd734716b085c56ab9fc1ab91ecd1a0c58d3794d37fd15948407813521fb14
+  data.tar.gz: c85e21c88985ad241d8c571926357f1ada73a8dee802bdca4c4abebdedf8fe2a3e5469b9681623f171d40489d5b4e8a7aac7fd34141a04626e075143af9ce8db

data/lib/deep_unrest/concerns/map_temp_ids.rb

@@ -36,7 +36,8 @@ module DeepUnrest
         destroyed << {
           type: self.class.to_s.pluralize.camelize(:lower),
           id: pk,
-          destroyed: true
+          destroyed: true,
+          query_uuid: @deep_unrest_query_uuid
         }
       end
 

data/lib/deep_unrest/version.rb

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

data/lib/deep_unrest/write.rb

@@ -6,37 +6,60 @@ module DeepUnrest
       return :destroy if item[:destroy]
       return :show if item[:readOnly] || item[:attributes].blank?
       return :create if item[:id] && DeepUnrest.temp_id?(item[:id].to_s)
+
       :update
     end
 
+    def self.create_write_mapping(k, v, addr, idx = nil)
+      path = k
+      path += '[]' if idx
+      resource_addr = [*addr, path]
+      resource_addr << idx if idx
+      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: get_scope_type(v),
+         addr: resource_addr,
+         key: k.camelize(:lower),
+         uuid: uuid,
+         query: v },
+       *create_write_mappings(v[:include], [*resource_addr, :include])]
+    end
+
+    def self.create_mapping_sequence(k, v, addr)
+      v.each_with_index.map do |item, idx|
+        create_write_mapping(k, item, addr, idx)
+      end
+    end
+
     def self.create_write_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: get_scope_type(v),
-           addr: resource_addr,
-           key: k.camelize(:lower),
-           uuid: uuid,
-           query: DeepUnrest.deep_underscore_keys(v) },
-         *create_write_mappings(v[:included], [*resource_addr, :include])]
+        if v.is_a? Array
+          create_mapping_sequence(k, v, addr)
+        else
+          create_write_mapping(k, v, addr)
+        end
       end.flatten.compact
     end
 
     def self.append_ar_paths(mappings)
       mappings.each do |item|
         item[:ar_addr] = []
-        item[:addr].each_with_index do |segment, i|
-          next if segment == :include
-          item[:ar_addr] << if item[:addr][i - 1] == :include
-                              "#{segment}_attributes".to_sym
-                            else
-                              segment
-                            end
+        addr = [*item[:addr]]
+        until addr.empty?
+          segment = addr.shift
+          item[:ar_addr] << segment if item[:ar_addr].empty?
+          next unless segment == :include
+
+          next_segment = "#{addr.shift.gsub('[]', '')}_attributes"
+          idx = addr.shift if addr[0].is_a? Integer
+          next_segment += '[]' if idx
+          item[:ar_addr] << next_segment
+          item[:ar_addr] << idx if idx
         end
       end
     end
@@ -73,18 +96,19 @@ module DeepUnrest
     end
 
     def self.build_mutation_bodies(mappings)
-      mappings.reject { |m| m[:scope_type] == :show }
-              .each_with_object({}) do |item, memo|
+      mappings.each_with_object({}) do |item, memo|
         # TODO: use pkey instead of "id"
-        next_attrs = item.dig(:query, :attributes || {})
-                         .deep_symbolize_keys
+        next_attrs = (item.dig(:query, :attributes) || {})
+                     .deep_symbolize_keys
         update_body = { id: item.dig(:query, :id),
                         deep_unrest_query_uuid: item.dig(:query, :uuid),
-                        **next_attrs }
+                        **DeepUnrest.deep_underscore_keys(next_attrs) }
         update_body[:_destroy] = true if item[:scope_type] == :destroy
         DeepUnrest.set_attr(memo, item[:ar_addr].clone, update_body)
-
-        item[:mutate] = memo.fetch(*item[:ar_addr]) if item[:ar_addr].size == 1
+        if item[:ar_addr].size == 1
+          item[:mutate] = memo.fetch(*item[:ar_addr])
+          item[:scope_type] = :update if item[:scope_type] == :show
+        end
       end
     end
 
@@ -119,6 +143,7 @@ module DeepUnrest
                      end
                    end
 
+          item[:record] = record
           result = { record: record }
           if item[:temp_id]
             result[:temp_ids] = {}
@@ -141,6 +166,28 @@ module DeepUnrest
              end
     end
 
+    def self.addr_to_lodash_path(path_arr)
+      lodash_path = []
+      until path_arr.empty?
+        segment = path_arr.shift
+        if segment.match(/\[\]$/)
+          idx = path_arr.shift
+          segment = "#{segment.gsub('[]', '')}[#{idx}]"
+        end
+        lodash_path << segment
+      end
+      lodash_path.join('.')
+    end
+
+    def self.serialize_destroyed(_ctx, mappings, destroyed)
+      destroyed.select { |d| d[:query_uuid] }
+               .map do |d|
+        mapping = mappings.find { |m| m.dig(:query, :uuid) == d[:query_uuid] }
+        lodash_path = addr_to_lodash_path(mapping[:addr])
+        { id: d[:id], path: lodash_path, type: mapping[:key].pluralize }
+      end
+    end
+
     def self.serialize_errors(mappings)
       { errors: mappings.each_with_object({}) do |item, memo|
         err = {
@@ -152,10 +199,36 @@ module DeepUnrest
       end }.to_json
     end
 
+    def self.format_ar_error_path(base, ar_path)
+      path_arr = ar_path.gsub(/\.(?!\w+$)/, '.included.')
+                        .gsub(/\.(?=\w+$)/, '.attributes.\1')
+                        .gsub(/\[(\d+)\]/, '[].\1')
+                        .split('.')
+
+      if path_arr.size == 1
+        path_arr.unshift('attributes')
+      elsif path_arr.size > 1
+        path_arr.unshift('included')
+      end
+
+      [*base, *path_arr]
+    end
+
+    def self.map_ar_errors_to_param_keys(mappings)
+      mappings
+        .each_with_object({}) do |item, memo|
+          item[:record]&.errors&.messages&.each do |ar_path, msg|
+            err_path = format_ar_error_path(item[:addr], ar_path.to_s)
+            DeepUnrest.set_attr(memo, err_path, msg)
+          end
+        end
+    end
+
     def self.write(ctx, params, user)
       temp_id_map = DeepUnrest::ApplicationController.class_variable_get(
         '@@temp_ids'
       )
+      temp_id_map[ctx[:uuid]] ||= {}
 
       # create mappings for assembly / disassembly
       mappings = create_write_mappings(params.to_unsafe_h)
@@ -173,7 +246,7 @@ module DeepUnrest
       build_mutation_bodies(mappings)
 
       # convert temp_ids from ids to non-activerecord attributes
-      DeepUnrest.convert_temp_ids!(ctx[:uuid], mappings)
+      DeepUnrest.convert_temp_ids!(ctx[:uuid], mappings.select { |m| m[:mutate] })
 
       # save data, run callbaks
       results = execute_queries(mappings, ctx)
@@ -195,13 +268,13 @@ module DeepUnrest
 
         return {
           temp_ids: temp_id_map[ctx[:uuid]],
-          destroyed: destroyed,
+          destroyed: serialize_destroyed(ctx, mappings, destroyed),
           changed: serialize_changes(ctx, mappings, changed)
         }
       end
 
       # map errors to their sources
-      formatted_errors = { errors: map_errors_to_param_keys(scopes, errors) }
+      formatted_errors = { errors: map_ar_errors_to_param_keys(mappings) }
 
       # raise error if there are any errors
       raise DeepUnrest::Conflict, formatted_errors.to_json

data/lib/deep_unrest.rb

@@ -319,6 +319,8 @@ module DeepUnrest
       mutations.map { |val| convert_temp_ids!(ctx, val) }
     end
     mutations
+  rescue Exception => e
+    binding.pry
   end
 
   def self.build_mutation_fragment(op, scopes, user, err_path_memo, rest = nil, memo = nil, cursor = nil, type = nil)
@@ -373,11 +375,12 @@ module DeepUnrest
   def self.set_attr(hash, path, val, cursor = nil)
     cursor ||= hash
     key = path.shift
+    key = key.to_i if cursor.is_a? Array
 
     if path.empty?
       case cursor
       when Array
-        cursor << val
+        cursor[key] = val
       when Hash
         cursor[key] = val
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_unrest
 version: !ruby/object:Gem::Version
-  version: 0.1.36
+  version: 0.1.37
 platform: ruby
 authors:
 - Lynn Hurley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails