ecoportal-api-graphql 1.3.16 → 2.2.0

data/lib/ecoportal/api/common/graphql/model/diffable/hash_diff_nesting.rb

@@ -1,295 +1,295 @@
-# rubocop:disable Naming/MethodParameterName
-module Ecoportal::API::Common::GraphQL::Model::Diffable
-  # @note this is a literal copy of ecoportal-api-v2 gem `has_diff` function.
-  # @todo the aim is to adapt it by:
-  #   1. Removing the `patch_ver` model ✅
-  #   2. Using symbol keys ✅
-  module HashDiffNesting
-    class << self
-      def included(base)
-        super
-
-        base.send :include, InstanceMethods
-      end
-    end
-
-    META_KEYS  = %i[id].freeze
-    NO_CHANGES = "%not-changed!%".freeze
-
-    module InstanceMethods
-      # The `change data` is built as follows:
-      # 1. detect changes that have occurred translate into one `api_operation` of `OP_TYPE`:
-      #   * `:update`: meaning that the object has changed (existed and has not been removed)
-      #   * `:delete`:  the object has been removed
-      #   * `:create`:     the object is new
-      # 2. at the level of the target object of the model, the object is opened for change
-      # with `id` and `api_operation` as follows:
-      #
-      #    ```json
-      #    {
-      #       "id":            "objectID",
-      #       "api_operation": "OP_TYPE",
-      #       "change_data" {
-      #         "property":      "value",
-      #          "...":          "..."
-      #       }
-      #    }
-      #    ```
-      # 3. the `change_data` property holds the specific changes of the object
-      #   - the properties that have changed
-      # @note
-      #   * there should not be difference between `null` and `""` (empty string)
-      # @param a [Hash] current hash model
-      # @param b [Hash] previous hash model
-      # @return [Hash] a `change data`
-      def change_diff(a, b, ignore: [])
-        ignore = to_a(ignore)
-
-        if b.is_a?(Hash) && !empty?(b) && empty?(a)
-          patch_delete(b)
-        elsif a.is_a?(Hash) && !empty?(a) && empty?(b)
-          patch_new(a, ignore: ignore)
-        elsif a.is_a?(Hash) && b.is_a?(Hash)
-          patch_update(a, b, ignore: ignore)
-        elsif any_array?(a, b)
-          patch_data_array(a, b, ignore: ignore)
-        else
-          a
-        end
-      end
-
-      private
-
-      # Compares `a` as carrying changes of `b`
-      # @return [Hash] change data object with only changes
-      def change_data(a, b = nil, delete: false, ignore: [])
-        {}.tap do |data_hash|
-          next if delete
-
-          a.each do |key, a_value|
-            key = key.to_sym
-
-            next if meta_keys.include?(key)
-            next if ignore.include?(key)
-
-            b_value = nil
-
-            if b&.key?(key)
-              b_value = b[key]
-              next if equal_values?(a_value, b_value)
-            end
-
-            data_hash[key] = change_diff(a_value, b_value)
-
-            data_hash.delete(key) if data_hash[key] == NO_CHANGES
-          end
-
-          return NO_CHANGES if (data_hash.keys - meta_keys).empty?
-        end
-      end
-
-      def patch_delete(b)
-        return NO_CHANGES unless b.is_a?(Hash)
-        return            unless (id = get_id(b, exception: false))
-
-        {
-          id:            id,
-          api_operation: :delete,
-          change_data:   change_data(b, delete: true)
-        }
-      end
-
-      def patch_new(a, ignore: [])
-        return NO_CHANGES unless a.is_a?(Hash)
-        return a          unless (id = get_id(a, exception: false))
-
-        {
-          id:            id,
-          api_operation: :create,
-          change_data:   change_data(a, ignore: ignore)
-        }
-      end
-
-      def patch_update(a, b, ignore: [])
-        return NO_CHANGES unless a.is_a?(Hash)
-        return a          unless (id = get_id(a, exception: false))
-
-        {
-          id:            id,
-          api_operation: :update,
-          change_data:   change_data(a, b, ignore: ignore)
-        }.tap do |update_hash|
-          return nil unless update_hash[:change_data] != NO_CHANGES
-        end
-      end
-
-      def patch_data_array(a, b, ignore: [])
-        return patch_data_nested_array(a, b, ignore: ignore) if nested_array?(a, b)
-
-        patch_data_flat_array(a, b)
-      end
-
-      def patch_data_flat_array(a, b)
-        original_b = b
-        a        ||= []
-        b        ||= []
-
-        same_elements =
-          a.length == b.length &&
-          (a & b).length == b.length
-
-        return a          unless same_elements
-        return NO_CHANGES if original_b
-
-        a
-      end
-
-      def patch_data_nested_array(a, b, ignore: [])
-        a ||= []
-        b ||= []
-
-        # array with nested elements
-        a_ids = array_ids(a)
-        b_ids = array_ids(b)
-
-        del_ids = b_ids - a_ids
-        oth_ids = b_ids & a_ids
-        new_ids = a_ids - b_ids
-
-        arr_delete = del_ids.map do |id|
-          patch_delete(array_id_item(b, id))
-        end.compact
-
-        arr_update = oth_ids.map do |id|
-          patch_update(array_id_item(a, id), array_id_item(b, id), ignore: ignore)
-        end.compact
-
-        arr_new = new_ids.map do |id|
-          patch_new(array_id_item(a, id), ignore: ignore)
-        end.compact
-
-        arr_delete.concat(arr_update).concat(arr_new).tap do |patch_array|
-          # remove data with no `id`
-          patch_array.select! {|item| item.is_a?(Hash)}
-          return NO_CHANGES if patch_array.empty?
-        end
-      end
-
-      def nested_array?(*arr)
-        if arr.length > 1
-          arr.any? {|a| nested_array?(a)}
-        elsif arr.length == 1
-          arr = arr.first || []
-          arr.any? do |item|
-            next false unless item.is_a?(Hash)
-            next true  if item.key?(:id)
-
-            false
-          end
-        else
-          false
-        end
-      end
-
-      def any_array?(a, b)
-        [a, b].any?(Array)
-      end
-
-      def get_id(doc, exception: true)
-        id   = nil
-        id ||= doc.id    if doc.respond_to?(:id)
-        id ||= doc['id'] if doc.is_a?(Hash)
-        id ||= doc[:id]  if doc.is_a?(Hash)
-        id ||= doc       if doc.is_a?(String)
-
-        raise 'No ID has been given!' unless id || !exception
-
-        id
-      end
-
-      # @param arr [Array] the source Array of id-bearing items
-      # @return [Array<String>] the `id`s thereof
-      def array_ids(arr)
-        return [] if !arr.is_a?(Array) || arr.empty?
-
-        arr.map {|item| get_id(item, exception: false)}
-      end
-
-      # @param arr [Array] the source Array
-      # @return [Integer, nil] the position of the item with the given `id`
-      def array_id_index(arr, id)
-        return unless arr.is_a?(Array)
-
-        arr.index {|item| get_id(item, exception: false) == id}
-      end
-
-      # @param arr [Array] the source Array
-      # @return [Object, nil] the item with the given `id`
-      def array_id_item(arr, id)
-        return unless (idx = array_id_index(arr, id))
-
-        arr[idx]
-      end
-
-      def meta_keys
-        return self::META_KEYS if respond_to?(:const_get)
-
-        self.class::META_KEYS
-      end
-
-      def equal_values?(a, b)
-        if a.is_a?(String) || b.is_a?(String)
-          a_empty = a.to_s.strip.empty?
-          b_empty = b.to_s.strip.empty?
-
-          return true if a_empty && b_empty
-        end
-
-        a == b
-      end
-
-      def empty?(a)
-        bool   = !a
-        bool ||= a.respond_to?(:empty?) && a.empty?
-        bool
-      end
-
-      def to_a(*values)
-        [values].flatten.compact.uniq
-      end
-
-      # Hash path helpers — used by DiffService#diff_reduce to navigate
-      # and modify nested result hashes during cascaded diffing.
-
-      def dig_path?(obj, keys)
-        return false unless obj.is_a?(Hash)
-        return obj.key?(keys.first) if keys.length == 1
-        return false unless obj.key?(keys.first)
-
-        dig_path?(obj[keys.first], keys[1..])
-      end
-
-      def dig_set!(obj, keys, value)
-        if keys.length == 1
-          obj[keys.first] = value
-        else
-          dig_set!(obj[keys.first], keys[1..], value)
-        end
-      end
-
-      def dig_delete!(obj, keys)
-        if keys.length == 1
-          return unless obj.respond_to?(:delete)
-
-          obj.delete(keys.first)
-        else
-          dig_delete!(obj[keys.first], keys[1..])
-        end
-      end
-    end
-
-    extend InstanceMethods
-  end
-end
-
-# rubocop:enable Naming/MethodParameterName
+# rubocop:disable Naming/MethodParameterName
+module Ecoportal::API::Common::GraphQL::Model::Diffable
+  # @note this is a literal copy of ecoportal-api-v2 gem `has_diff` function.
+  # @todo the aim is to adapt it by:
+  #   1. Removing the `patch_ver` model ✅
+  #   2. Using symbol keys ✅
+  module HashDiffNesting
+    class << self
+      def included(base)
+        super
+
+        base.send :include, InstanceMethods
+      end
+    end
+
+    META_KEYS  = %i[id].freeze
+    NO_CHANGES = "%not-changed!%".freeze
+
+    module InstanceMethods
+      # The `change data` is built as follows:
+      # 1. detect changes that have occurred translate into one `api_operation` of `OP_TYPE`:
+      #   * `:update`: meaning that the object has changed (existed and has not been removed)
+      #   * `:delete`:  the object has been removed
+      #   * `:create`:     the object is new
+      # 2. at the level of the target object of the model, the object is opened for change
+      # with `id` and `api_operation` as follows:
+      #
+      #    ```json
+      #    {
+      #       "id":            "objectID",
+      #       "api_operation": "OP_TYPE",
+      #       "change_data" {
+      #         "property":      "value",
+      #          "...":          "..."
+      #       }
+      #    }
+      #    ```
+      # 3. the `change_data` property holds the specific changes of the object
+      #   - the properties that have changed
+      # @note
+      #   * there should not be difference between `null` and `""` (empty string)
+      # @param a [Hash] current hash model
+      # @param b [Hash] previous hash model
+      # @return [Hash] a `change data`
+      def change_diff(a, b, ignore: [])
+        ignore = to_a(ignore)
+
+        if b.is_a?(Hash) && !empty?(b) && empty?(a)
+          patch_delete(b)
+        elsif a.is_a?(Hash) && !empty?(a) && empty?(b)
+          patch_new(a, ignore: ignore)
+        elsif a.is_a?(Hash) && b.is_a?(Hash)
+          patch_update(a, b, ignore: ignore)
+        elsif any_array?(a, b)
+          patch_data_array(a, b, ignore: ignore)
+        else
+          a
+        end
+      end
+
+      private
+
+      # Compares `a` as carrying changes of `b`
+      # @return [Hash] change data object with only changes
+      def change_data(a, b = nil, delete: false, ignore: [])
+        {}.tap do |data_hash|
+          next if delete
+
+          a.each do |key, a_value|
+            key = key.to_sym
+
+            next if meta_keys.include?(key)
+            next if ignore.include?(key)
+
+            b_value = nil
+
+            if b&.key?(key)
+              b_value = b[key]
+              next if equal_values?(a_value, b_value)
+            end
+
+            data_hash[key] = change_diff(a_value, b_value)
+
+            data_hash.delete(key) if data_hash[key] == NO_CHANGES
+          end
+
+          return NO_CHANGES if (data_hash.keys - meta_keys).empty?
+        end
+      end
+
+      def patch_delete(b)
+        return NO_CHANGES unless b.is_a?(Hash)
+        return            unless (id = get_id(b, exception: false))
+
+        {
+          id:            id,
+          api_operation: :delete,
+          change_data:   change_data(b, delete: true)
+        }
+      end
+
+      def patch_new(a, ignore: [])
+        return NO_CHANGES unless a.is_a?(Hash)
+        return a          unless (id = get_id(a, exception: false))
+
+        {
+          id:            id,
+          api_operation: :create,
+          change_data:   change_data(a, ignore: ignore)
+        }
+      end
+
+      def patch_update(a, b, ignore: [])
+        return NO_CHANGES unless a.is_a?(Hash)
+        return a          unless (id = get_id(a, exception: false))
+
+        {
+          id:            id,
+          api_operation: :update,
+          change_data:   change_data(a, b, ignore: ignore)
+        }.tap do |update_hash|
+          return nil unless update_hash[:change_data] != NO_CHANGES
+        end
+      end
+
+      def patch_data_array(a, b, ignore: [])
+        return patch_data_nested_array(a, b, ignore: ignore) if nested_array?(a, b)
+
+        patch_data_flat_array(a, b)
+      end
+
+      def patch_data_flat_array(a, b)
+        original_b = b
+        a        ||= []
+        b        ||= []
+
+        same_elements =
+          a.length == b.length &&
+          (a & b).length == b.length
+
+        return a          unless same_elements
+        return NO_CHANGES if original_b
+
+        a
+      end
+
+      def patch_data_nested_array(a, b, ignore: [])
+        a ||= []
+        b ||= []
+
+        # array with nested elements
+        a_ids = array_ids(a)
+        b_ids = array_ids(b)
+
+        del_ids = b_ids - a_ids
+        oth_ids = b_ids & a_ids
+        new_ids = a_ids - b_ids
+
+        arr_delete = del_ids.map do |id|
+          patch_delete(array_id_item(b, id))
+        end.compact
+
+        arr_update = oth_ids.map do |id|
+          patch_update(array_id_item(a, id), array_id_item(b, id), ignore: ignore)
+        end.compact
+
+        arr_new = new_ids.map do |id|
+          patch_new(array_id_item(a, id), ignore: ignore)
+        end.compact
+
+        arr_delete.concat(arr_update).concat(arr_new).tap do |patch_array|
+          # remove data with no `id`
+          patch_array.select! {|item| item.is_a?(Hash)}
+          return NO_CHANGES if patch_array.empty?
+        end
+      end
+
+      def nested_array?(*arr)
+        if arr.length > 1
+          arr.any? {|a| nested_array?(a)}
+        elsif arr.length == 1
+          arr = arr.first || []
+          arr.any? do |item|
+            next false unless item.is_a?(Hash)
+            next true  if item.key?(:id)
+
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def any_array?(a, b)
+        [a, b].any?(Array)
+      end
+
+      def get_id(doc, exception: true)
+        id   = nil
+        id ||= doc.id    if doc.respond_to?(:id)
+        id ||= doc['id'] if doc.is_a?(Hash)
+        id ||= doc[:id]  if doc.is_a?(Hash)
+        id ||= doc       if doc.is_a?(String)
+
+        raise 'No ID has been given!' unless id || !exception
+
+        id
+      end
+
+      # @param arr [Array] the source Array of id-bearing items
+      # @return [Array<String>] the `id`s thereof
+      def array_ids(arr)
+        return [] if !arr.is_a?(Array) || arr.empty?
+
+        arr.map {|item| get_id(item, exception: false)}
+      end
+
+      # @param arr [Array] the source Array
+      # @return [Integer, nil] the position of the item with the given `id`
+      def array_id_index(arr, id)
+        return unless arr.is_a?(Array)
+
+        arr.index {|item| get_id(item, exception: false) == id}
+      end
+
+      # @param arr [Array] the source Array
+      # @return [Object, nil] the item with the given `id`
+      def array_id_item(arr, id)
+        return unless (idx = array_id_index(arr, id))
+
+        arr[idx]
+      end
+
+      def meta_keys
+        return self::META_KEYS if respond_to?(:const_get)
+
+        self.class::META_KEYS
+      end
+
+      def equal_values?(a, b)
+        if a.is_a?(String) || b.is_a?(String)
+          a_empty = a.to_s.strip.empty?
+          b_empty = b.to_s.strip.empty?
+
+          return true if a_empty && b_empty
+        end
+
+        a == b
+      end
+
+      def empty?(a)
+        bool   = !a
+        bool ||= a.respond_to?(:empty?) && a.empty?
+        bool
+      end
+
+      def to_a(*values)
+        [values].flatten.compact.uniq
+      end
+
+      # Hash path helpers — used by DiffService#diff_reduce to navigate
+      # and modify nested result hashes during cascaded diffing.
+
+      def dig_path?(obj, keys)
+        return false unless obj.is_a?(Hash)
+        return obj.key?(keys.first) if keys.length == 1
+        return false unless obj.key?(keys.first)
+
+        dig_path?(obj[keys.first], keys[1..])
+      end
+
+      def dig_set!(obj, keys, value)
+        if keys.length == 1
+          obj[keys.first] = value
+        else
+          dig_set!(obj[keys.first], keys[1..], value)
+        end
+      end
+
+      def dig_delete!(obj, keys)
+        if keys.length == 1
+          return unless obj.respond_to?(:delete)
+
+          obj.delete(keys.first)
+        else
+          dig_delete!(obj[keys.first], keys[1..])
+        end
+      end
+    end
+
+    extend InstanceMethods
+  end
+end
+
+# rubocop:enable Naming/MethodParameterName

data/lib/ecoportal/api/common/graphql/model/diffable/leaf_diff_service.rb

@@ -0,0 +1,97 @@
+module Ecoportal::API::Common::GraphQL::Model::Diffable
+  # Diff strategy for models whose *array* attributes are leaf DATA, not nested
+  # `GraphQL::Model` children.
+  #
+  # Array attributes declared with `passarray` (tag lists, id lists, config lists)
+  # — and `embeds_many` id-collections written as a whole set (e.g. page `locations`)
+  # — are registered as *cascaded* attributes. The default `DiffService`:
+  #   1. strips cascaded keys from the flat classic diff
+  #      (`doc_with_non_cascaded_attributes`), on the assumption that a later
+  #      `diff_reduce` pass re-adds them by cascading into nested `GraphQL::Model`
+  #      children; and
+  #   2. in `diff_reduce`, deletes the flat placeholder for every cascaded key and
+  #      only re-adds it when the child object `is_a?(GraphQL::Model)`.
+  # A `passarray` is wrapped as a v2 `ArrayModel` and a whole-set `embeds_many` as a
+  # `CollectionModel` — neither is a `GraphQL::Model`, so the re-add never happens and
+  # the array change becomes **invisible to `as_update`** (scalar `passthrough` fields
+  # are unaffected). This is the systemic "array/leaf fields don't diff" root cause
+  # (see `.ai-assistance/code/model_input_mapping/SYNTHESIS.md` §3.1).
+  #
+  # This service fixes it for leaf models by:
+  #   1. keeping cascaded keys in the flat classic diff (`doc_with_non_cascaded_attributes`
+  #      is a no-op), and
+  #   2. overriding `diff_reduce` so the flat-diff placeholder for a NON-model leaf
+  #      child is preserved (only real `GraphQL::Model` children are cascade-diffed;
+  #      `root!` children are still dropped as independent entities), and
+  #   3. treating a leaf array as an OPAQUE value: a change replaces the whole array
+  #      (a full-set replace), rather than the id-keyed nested update/delete/create
+  #      patch-ops the default array diff would emit. This matches how the write inputs
+  #      consume these arrays (`PageInput.otherTags`, `PageInput.locations = [{ id: }]`,
+  #      register `filterTags`, PresetView `fieldConfigurations`).
+  #
+  # A model can either behave as a full leaf (call `dirty?`/`as_update` with
+  # `flat: true`, as `Base::Page::DataField` does — it has no nested `GraphQL::Model`
+  # children at all) or as a mixed model with both leaf arrays and real nested model
+  # children (page / register / preset view — the default cascaded `as_update` still
+  # recurses into the model children while the leaf arrays now diff inline).
+  class LeafDiffService < DiffService
+    private
+
+    # Keep all doc keys: leaf-field arrays are data, not nested models, so the flat
+    # classic diff must see them (the default strips every cascaded key).
+    def doc_with_non_cascaded_attributes(json)
+      json
+    end
+
+    # Treat array values as opaque leaves: emit the whole (current) array on any
+    # change, instead of the default id-keyed nested-array patch-ops. Non-array
+    # values fall through to the standard diff.
+    def change_diff(curr, prev, ignore: [])
+      return super unless curr.is_a?(Array) || prev.is_a?(Array)
+      return NO_CHANGES if same_array?(curr, prev)
+
+      keys_to_sym_deep(curr)
+    end
+
+    # Full-set equality (order-insensitive), mirroring `patch_data_flat_array`.
+    def same_array?(curr, prev)
+      curr ||= []
+      prev ||= []
+      curr.length == prev.length && (curr & prev).length == prev.length
+    end
+
+    # Preserve the flat-diff placeholder for non-model leaf children; only
+    # cascade-diff real `GraphQL::Model` children, and still drop `root!` children.
+    def diff_reduce(init, ignore: [])
+      subject.cascaded_reduce(init, recurs: false) do |result, obj, _key, key_path, _trace|
+        next result if key_path.empty?
+        next result if obj == subject
+
+        sym_path = key_path.map(&:to_sym)
+
+        unless cascadeable_model?(obj)
+          # Leaf array (ArrayModel / CollectionModel) → keep the flat-diff value.
+          # A root! child is not mutation payload → drop its placeholder.
+          dig_delete!(result, sym_path) if root?(obj) && result && dig_path?(result, sym_path)
+          next result
+        end
+
+        # Remove the flat-diff placeholder before the child computes its own diff.
+        dig_delete!(result, sym_path) if result && dig_path?(result, sym_path)
+
+        value = obj.as_update(ignore: ignore)
+        next result if value.nil?
+
+        result      ||= {}
+        result[:id] ||= get_id(keys_to_sym_deep(curr_doc(flat: true) || {}), exception: false)
+        dig_set!(result, sym_path, value)
+        result
+      end
+    end
+
+    # A child worth cascading into: a non-root GraphQL::Model.
+    def cascadeable_model?(obj)
+      obj.is_a?(Ecoportal::API::Common::GraphQL::Model) && !root?(obj)
+    end
+  end
+end