eco-helpers 3.2.14 → 3.2.22

data/lib/eco/api/usecases/graphql/helpers/pages/ooze_handlers.rb

@@ -0,0 +1,112 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Native GraphQL re-expression of OozeSamples::Helpers::OozeHandlers.
+    #
+    # `merge_values` combines two values of a data field of the *same* type and
+    # label into one, matching the v2 semantics but dispatching on the GraphQL
+    # DataField TYPE STRING (e.g. 'PlainText', 'Select', 'Date') rather than on
+    # `Ecoportal::API::V2::Page::Component::*` classes. The type strings are the
+    # `__typename`-derived values in
+    # `Ecoportal::API::GraphQL::Base::Page::DataField::TYPE_MAP`.
+    #
+    # `merge_arrays` / `array_indexes` are pure array utilities — ported verbatim.
+    module OozeHandlers
+      # Per-type merge strategy.
+      #   :join   → concatenate origin + append with a delimiter (text, select,
+      #             reference, people, checklist, action list, files, images, geo, law)
+      #   :origin → keep the origin value untouched (date, number, gauge — no sensible
+      #             textual concatenation; the v2 case returned `origin` for these)
+      #
+      # Text-ish types always merge with a NEWLINE delimiter in v2 (RichText /
+      # PlainText) regardless of the caller's `delimiter:`; the rest honour it.
+      MERGE_STRATEGY = {
+        'PlainText'      => %i[join newline],
+        'RichText'       => %i[join newline],
+        'Select'         => %i[join delimiter],
+        'CrossReference' => %i[join delimiter],
+        'People'         => %i[join delimiter],
+        'Checklist'      => %i[join delimiter],
+        'ActionsList'    => %i[join delimiter],
+        'FileField'      => %i[join delimiter],
+        'File'           => %i[join delimiter],
+        'ImageGallery'   => %i[join delimiter],
+        'Geo'            => %i[join delimiter],
+        'Law'            => %i[join delimiter],
+        'DateField'      => %i[origin],
+        'Date'           => %i[origin],
+        'Number'         => %i[origin],
+        'Gauge'          => %i[origin]
+      }.freeze
+
+      # Merge values of fields of the same type and label name.
+      #
+      # @param origin [Object] the value to keep as the base.
+      # @param append [Object] the value to merge onto `origin`.
+      # @param type [String, Symbol, nil] the GraphQL DataField type string
+      #   (e.g. 'PlainText', 'Select'). Nil / unknown → default join. Accepts a
+      #   field object responding to #type too (convenience).
+      # @param delimiter [String] the delimiter for :delimiter-strategy types.
+      # @return [Object] the merged value.
+      def merge_values(origin, append, type: nil, delimiter: "\n")
+        return origin if !append || append.to_s.strip.empty?
+        return append if !origin || origin.to_s.strip.empty?
+
+        type_key = resolve_field_type(type)
+        strategy, delim_kind = MERGE_STRATEGY.fetch(type_key, %i[join delimiter])
+
+        return origin if strategy == :origin
+
+        used_delimiter = delim_kind == :newline ? "\n" : delimiter
+        [origin, append].join(used_delimiter)
+      end
+
+      # Merges arrays `ref` and `plus` by keeping the order of `ref`
+      # but inserting additional elements of `plus` in the correct position
+      # (i.e. when those elements are between two elements that exist in `ref`).
+      # @note this can be used to combine two different header sequences
+      #   by using `ref` as a reference.
+      def merge_arrays(ref, plus) # rubocop:disable Metrics/AbcSize
+        return ref if ref == plus
+
+        href_idx        = array_indexes(ref)
+        hplus_idx       = array_indexes(plus)
+        shared          = ref & plus
+        hshared_ref_idx = href_idx.slice(*shared)
+
+        shared_plus_idxs = hplus_idx.values_at(*shared).sort.reverse
+
+        only_plus      = plus - ref
+        honly_plus_idx = hplus_idx.slice(*only_plus)
+
+        hplus_ref_idx  = honly_plus_idx.each_with_object({}) do |(e, idx), href_idx_plus|
+          ps_idx = shared_plus_idxs.bsearch {|i| idx >= i}
+          rs_idx = ps_idx ? hshared_ref_idx[plus[ps_idx]] : -1
+          href_idx_plus[e] = rs_idx
+        end.group_by do |_e, idx|
+          idx
+        end.to_a.sort_by do |(idx, _pairs)|
+          idx
+        end.reverse.to_h.transform_values do |pairs|
+          pairs.map(&:first)
+        end
+
+        hplus_ref_idx.each_with_object(ref.dup) do |(idx, elements), rf|
+          rf.insert(idx + 1, *elements)
+        end
+      end
+
+      def array_indexes(ary)
+        ary.each_with_index.to_h
+      end
+
+      private
+
+      # Accept either a type string/symbol or a field object that responds to #type.
+      def resolve_field_type(type)
+        return type.type.to_s if type.respond_to?(:type)
+
+        type.to_s
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/pages/rescuable.rb

@@ -0,0 +1,52 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Prevents a script from stopping on a per-item error, prompting the operator to
+    # continue or abort. Ported from OozeSamples::Helpers::Rescuable; the only change is
+    # the base-type guard, which now requires a native GraphQL::Base case.
+    module Rescuable
+      module InstanceMethods
+        private
+
+        # Helper to prevent script from stopping
+        def with_rescue(reference, trace_count: 1)
+          raise ArgumentError, 'Expecting block, but not given' unless block_given?
+          yield
+        rescue StandardError => e
+          str_err = e.patch_full_message(trace_count: trace_count)
+          log(:error) { [reference, str_err].join(" => \n") }
+          lines = []
+          lines << "\nThere was an error. Choose one option:\n"
+          lines << '  (C)      - Continue/resume. Just ignore this one.'
+          lines << '  (A)      - Abort. Just break this run.'
+
+          session.prompt_user('Type one option (C/a):', explanation: lines.join("\n"), default: 'C') do |res|
+            res = res.upcase
+            raise if res.start_with?('A')
+
+            # 'C'
+            log(:warn) { "Script resumed after error...\n  * #{reference}" }
+            nil
+          end
+        end
+      end
+
+      class << self
+        def included(base)
+          super
+          validate_base_type!(base)
+          base.include(InstanceMethods)
+        end
+
+        def validate_base_type!(base)
+          return super if defined?(super)
+
+          msg  = "#{self} can only be included in Eco::API::UseCases::GraphQL::Base"
+          msg << "\nCan't be included in #{base}"
+          raise LoadError, msg unless base <= Eco::API::UseCases::GraphQL::Base
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/pages/shortcuts.rb

@@ -0,0 +1,186 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # String simplification / comparison helpers, ported from
+    # OozeSamples::Helpers::Shortcuts. Everything here is pure except #object_reference,
+    # which is re-expressed with duck-typing (no Ecoportal::API::V2 constants) so it
+    # describes GraphQL page/stage/section/field/force models.
+    module Shortcuts
+      # Basic simplification pattern (matches all but a-z and blank space)
+      def non_letters_regex
+        @non_letters_regex ||= /[^a-z ]+/
+      end
+
+      # Matches anything between two consecutive (), inclusive
+      def bracked_regex
+        @bracked_regex ||= /(?<bracked>\([^\)]+?\))/ # rubocop:disable Style/RedundantRegexpEscape
+      end
+
+      # It always downcase, trim and remove double spaces.
+      # @param ignore [Boolean, Regexp, String, Array] ignored when `exact` is `true`
+      #   * when `false`: it does not do anything additional
+      #   * when `Regexp`: it removes all characters that match the expression.
+      #   * when `String`: each character listed is removed.
+      #   * when `Array`: reduces `str` processing `ignore` in order.
+      #   * when `true` (or otherwise): it removes all non a-zA-Z characters but blank spaces.
+      def simplify_string(str, ignore: false)
+        str = str.to_s.strip.downcase.gsub(/\s+/, ' ')
+        return str unless ignore
+
+        sub = non_letters_regex
+        case ignore
+        when Regexp then sub = ignore
+        when String then sub = /[#{ignore}]+/
+        when Array
+          return ignore.reduce(str) do |out, sub_ignore|
+            simplify_string(out, ignore: sub_ignore)
+          end
+        end
+        str.gsub(sub, '').gsub(/\s+/, ' ').strip
+      end
+
+      # Offers multiple simplification methods to compare two strings
+      # @note only one of the values can be a Regexp
+      def same_string?(value_1, value_2, exact: false, mild: false, ignore: false) # rubocop:disable Metrics/AbcSize
+        return true  if value_1.to_s.strip.empty? && value_2.to_s.strip.empty?
+        return false if value_1.to_s.strip.empty? || value_2.to_s.strip.empty?
+
+        val_1 = value_1
+        val_2 = value_2
+
+        unless exact
+          if val_1.is_a?(String)
+            val_1 = simplify_string(val_1, ignore: ignore) if ignore
+            val_1 = simplify_string(val_1, ignore: non_letters_regex) if mild
+          end
+          if val_2.is_a?(String)
+            val_2 = simplify_string(val_2, ignore: ignore) if ignore
+            val_2 = simplify_string(val_2, ignore: non_letters_regex) if mild
+          end
+        end
+
+        if val_1.is_a?(String) && val_2.is_a?(String)
+          val_1 == val_2
+        elsif val_1.is_a?(Regexp) && val_2.is_a?(String)
+          val_2 =~ val_1
+        elsif val_1.is_a?(String) && val_2.is_a?(Regexp)
+          val_1 =~ val_2
+        else
+          msg  = 'Expected at least one String, and either a String or Regex. '
+          msg << "Given: (1: #{val_1.class}) and (2: #{val_2.class})"
+          raise ArgumentError, msg
+        end
+      end
+
+      def titleize(str)
+        return nil unless str
+        return str if str.strip.empty?
+
+        str.split(/\s+/).map do |part|
+          part[0] = part[0].upcase
+          part[1..] = part[1..].downcase
+          part
+        end.join(' ')
+      end
+
+      def normalize_string(str)
+        return nil unless str
+
+        str.gsub(/[^[:print:]]/, '').
+          gsub(/[[:space:]]+/, ' ').
+          gsub(/[[:space:]]$/, '').
+          gsub(/[-‑‒–]/, '-').then do |aux|
+            aux = yield(aux) if block_given?
+            aux
+          end
+      end
+
+      def clean_question(str)
+        return nil unless str
+
+        normalize_string(str) do |x|
+          x.gsub("\r\n", ' ').then do |aux|
+            aux = yield(aux) if block_given?
+            aux
+          end
+        end
+      end
+
+      # Human-readable reference for a GraphQL page-model object, for logs/errors.
+      #
+      # Re-expressed with duck-typing (was a V2 `case/when` on Page/Stage/Section/Component/
+      # Force/Binding). We inspect the object's shape rather than its class so this works
+      # across Base::/Model:: GraphQL types without coupling to constants that may move.
+      def object_reference(obj)
+        return 'No reference' unless obj
+
+        if binding_like?(obj)
+          "Binding '#{safe_name(obj)}' in #{object_reference(obj.force)}"
+        elsif force_like?(obj)
+          "Force '#{safe_name(obj)}'"
+        elsif component_like?(obj)
+          label = obj.respond_to?(:label) ? obj.label : nil
+          type  = obj.respond_to?(:type) ? obj.type : nil
+          ref = "Component '#{label || "(unnamed of type '#{type}')"}'"
+          ref += " in #{object_reference(obj.section)}" if obj.respond_to?(:section) && obj.section
+          ref
+        elsif section_like?(obj)
+          heading = obj.respond_to?(:heading) ? obj.heading : nil
+          "Section '#{heading || '(unnamed)'}'"
+        elsif stage_like?(obj)
+          named_ref('Stage', obj)
+        elsif page_like?(obj)
+          named_ref("Page (#{obj.id})", obj)
+        else
+          named_ref('', obj).strip
+        end
+      end
+
+      def to_i(value)
+        Float(value).to_i
+      end
+
+      # https://stackoverflow.com/a/5661695/4352306
+      # Kept as `is_number?` for naming parity with OozeSamples::Helpers::Shortcuts.
+      def is_number?(value) # rubocop:disable Naming/PredicatePrefix
+        true if Float(value)
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      private
+
+      def binding_like?(obj)
+        obj.respond_to?(:force) && obj.respond_to?(:name) && !obj.respond_to?(:bindings)
+      end
+
+      def force_like?(obj)
+        obj.respond_to?(:bindings) && obj.respond_to?(:name)
+      end
+
+      def component_like?(obj)
+        obj.respond_to?(:label) && (obj.respond_to?(:type) || obj.respond_to?(:section))
+      end
+
+      def section_like?(obj)
+        obj.respond_to?(:heading) && obj.respond_to?(:components)
+      end
+
+      def stage_like?(obj)
+        obj.respond_to?(:ordering) && obj.respond_to?(:state)
+      end
+
+      def page_like?(obj)
+        obj.respond_to?(:id) && obj.respond_to?(:stages)
+      end
+
+      def safe_name(obj)
+        obj.respond_to?(:name) ? obj.name : nil
+      end
+
+      def named_ref(prefix, obj)
+        name = safe_name(obj)
+        name ? "#{prefix} '#{name}'" : prefix
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/pages/typed_fields_pairing.rb

@@ -0,0 +1,303 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  module Pages
+    # Native GraphQL re-expression of
+    # OozeSamples::HelpersMigration::TypedFieldsPairing.
+    #
+    # It pairs fields of the SAME type with the SAME label name across two page
+    # models (a source `src` and a destination `dst`). This is the cross-template
+    # field-pairing used by migration cases — DISTINCT from the value-merge
+    # `OozeHandlers#merge_values` (which combines two values of one already-paired
+    # field).
+    #
+    # It runs two screenings:
+    #   (1) exact label match,
+    #   (2) then the rest, case-insensitive a-z only, content between brackets removed.
+    #
+    # Other features (ported verbatim from the v2 "World Wonder of 2022"):
+    #   * tracks src / dst fields that were NOT paired
+    #   * lets you `resolve` fields paired by other means out of the unpaired sets
+    #   * tracks src fields with MULTIPLE candidate dst fields (`src_dst_multi`)
+    #
+    # == What differs from the v2 class
+    #
+    # Fields are grouped and compared by the GraphQL DataField TYPE STRING (the
+    # `__typename`-derived value in `Ecoportal::API::GraphQL::Base::Page::DataField::TYPE_MAP`,
+    # e.g. 'PlainText', 'Select', 'Date') rather than the v2 snake_case component type
+    # (`'plain_text'`, `'select'`, `'date'`). Same-type grouping still guarantees a
+    # pair only forms between fields of identical type. `EXCLUDED_TYPES` therefore
+    # lists the GraphQL type strings for the never-pair types (charts / tag fields).
+    #
+    # `ximport?` detects an import-marker field via its `#tooltip` (unchanged), and
+    # `object_reference` / `same_string?` come from the native `Shortcuts`.
+    class TypedFieldsPairing
+      include Eco::API::UseCases::GraphQL::Helpers::Pages::Shortcuts
+
+      # GraphQL DataField type strings that must never be paired (no meaningful,
+      # copyable content). Mirrors the v2 EXCLUDED_TYPES
+      # (%w[tag_field chart frequency_rate_chart]) in GraphQL terms — GraphQL has no
+      # distinct chart data-field types, so TagField is the practical excluded type;
+      # any additional non-content types can be added here.
+      EXCLUDED_TYPES = %w[TagField Chart FrequencyRateChart].freeze
+
+      attr_reader :src, :dst
+      attr_reader :src_unpaired, :dst_unpaired
+      attr_reader :src_dst_pairs, :src_dst_multi
+
+      def initialize(source, destination, src_excluded: nil, dst_excluded: nil,
+          exclude_ximport: false)
+        @src             = source
+        @dst             = destination
+        @src_excluded    = src_excluded || []
+        @dst_excluded    = dst_excluded || []
+        @exclude_ximport = exclude_ximport
+
+        reset!
+        process(exact: true)
+        process
+      end
+
+      def each_pair
+        src_dst_pairs.each do |(src_field, dst_field)|
+          yield(src_field, dst_field) if block_given?
+        end
+      end
+
+      def report_src_unpaired(only_present: true, only_indexed: false)
+        return if src_unpaired.empty?
+
+        msg = "Source entry with unpaired fields (#{object_reference(src)}):\n"
+
+        src_filtered = src_unpaired.values.flatten.reject do |src_fld|
+          only_present && field_empty?(src_fld)
+        end.reject do |src_fld|
+          only_indexed && src_fld.deindex
+        end
+
+        return if src_filtered.empty?
+
+        msg << src_filtered.map do |src_fld|
+          "  * #{object_reference(src_fld)}"
+        end.join("\n")
+      end
+
+      def report_dst_unpaired(only_required: false, exclude_ximport: true)
+        return if dst_unpaired.empty?
+
+        msg = "Destination entry with unpaired fields (#{object_reference(src)}):\n"
+
+        dst_filtered = dst_unpaired.values.flatten.reject do |dst_fld|
+          only_required && !dst_fld.required
+        end.reject do |dst_fld|
+          exclude_ximport && ximport?(dst_fld)
+        end
+
+        return if dst_filtered.empty?
+
+        msg << dst_filtered.map do |dst_fld|
+          "  * #{object_reference(dst_fld)}"
+        end.join("\n")
+      end
+
+      def report_multi_pairs(only_present: true, only_indexed: false, dst_exclude_ximport: true)
+        return nil if src_dst_multi.empty?
+
+        ''.tap do |msg|
+          msg     << "Source fields in (#{object_reference(src)}) paired with multiple destination fields:\n"
+          msg_flds = ''
+          src_dst_multi.each_value do |pairs|
+            pairs.each do |(src_fld, dst_flds)|
+              next if (only_present && field_empty?(src_fld)) || (only_indexed && src_fld.deindex)
+
+              dst_filtered = dst_flds.reject do |dst_fld|
+                dst_exclude_ximport && ximport?(dst_fld)
+              end
+              next if dst_filtered.empty?
+
+              msg_flds << "  * #{object_reference(src_fld)}\n"
+              msg_flds << dst_filtered.map do |dst_fld|
+                "    * #{object_reference(dst_fld)}"
+              end.compact.join("\n")
+            end
+          end
+
+          return nil if msg_flds.empty?
+
+          msg << msg_flds
+        end
+      end
+
+      # Remove from unpaired tracking those `flds`.
+      def resolve(*flds)
+        flds.each do |fld|
+          next if unpaired_delete?(fld, src_unpaired)
+
+          unpaired_delete?(fld, dst_unpaired)
+        end
+
+        multi_delete(*flds)
+      end
+
+      def some_multi?
+        !src_dst_multi.empty?
+      end
+
+      private
+
+      # When comparing, use only a-z letters.
+      def only_letters?
+        true
+      end
+
+      # When comparing, remove anything between brackets from the field label name.
+      def non_bracked?
+        true
+      end
+
+      # If `false`, it compares with all lower case.
+      def exact?
+        !(only_letters? || non_bracked?)
+      end
+
+      def process(exact: false)
+        src_unpaired.each do |type, src_pend|
+          next unless (dst_pend = dst_unpaired[type]) && !dst_pend.empty?
+
+          src_pend.dup.each do |src_fld|
+            dst_candidates = dst_pend.select do |dst_fld|
+              str_eq?(src_fld.label, dst_fld.label, exact: exact)
+            end
+            next if dst_candidates.empty?
+
+            if dst_candidates.one?
+              pair_add(src_fld, dst_candidates.first)
+            else
+              multi_add(type, src_fld, *dst_candidates)
+            end
+          end
+        end
+      end
+
+      def str_eq?(str_1, str_2, exact: false)
+        same_string?(str_1, str_2, **str_eq_params, exact: exact)
+      end
+
+      def str_eq_params
+        {
+          exact:  exact?,
+          mild:   only_letters?,
+          ignore: false
+        }.tap do |params|
+          params.merge!(ignore: bracked_regex) if non_bracked?
+        end
+      end
+
+      def pair_add(src_fld, dst_fld)
+        resolve(src_fld, dst_fld)
+        src_dst_pairs << [src_fld, dst_fld]
+      end
+
+      # Removes a field from a (src or dst) unpaired set.
+      # @return [Boolean] true when the field was present and removed.
+      def unpaired_delete?(fld, unpaired)
+        type = fld.type
+        return false unless unpaired.key?(type)
+        return false unless (flds = unpaired[type]).delete(fld)
+
+        unpaired.delete(type) if flds.empty?
+        true
+      end
+
+      def multi_add(type, src_fld, *dst_flds)
+        (src_dst_multi[type] ||= []) << (pair = [src_fld, dst_flds])
+        @src_multi[src_fld]          = pair
+
+        dst_flds.each do |dst_fld|
+          (@dst_multi[dst_fld] ||= []) << pair
+        end
+      end
+
+      def multi_delete(*flds)
+        flds.each do |fld|
+          next unless (type_pairs = src_dst_multi[fld.type])
+
+          if (pairs = @dst_multi.delete(fld))
+            pairs.each do |pair|
+              src_fld  = pair.first
+              dst_flds = pair.last
+              dst_flds.delete(fld)
+              if dst_flds.empty?
+                @src_multi.delete(src_fld)
+                type_pairs.delete(pair)
+              end
+            end
+          elsif @src_multi.key?(fld)
+            pair = @src_multi.delete(fld)
+            type_pairs.delete(pair)
+
+            pair.last.each do |dst_fld|
+              pairs = @dst_multi[dst_fld]
+              pairs.delete(pair)
+              @dst_multi.delete(dst_fld) if pairs.empty?
+            end
+          end
+
+          src_dst_multi.delete(fld.type) if type_pairs.empty?
+        end
+      end
+
+      def by_type(components)
+        components.to_a.group_by(&:type).tap do |out|
+          EXCLUDED_TYPES.each {|type| out.delete(type)}
+        end
+      end
+
+      def src_components
+        flds = components_of(src)
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @src_excluded
+      end
+
+      def dst_components
+        flds = components_of(dst)
+        flds = flds.reject {|fld| ximport?(fld)} if @exclude_ximport
+        flds - @dst_excluded
+      end
+
+      # Duck-typed access to a page model's data fields. Native GraphQL page
+      # models expose `#components` (a SectionCollection-backed collection); the
+      # v2 class relied on the same method name.
+      def components_of(entry)
+        entry.components.to_a
+      end
+
+      def ximport?(fld)
+        return false unless fld.respond_to?(:tooltip)
+
+        fld.tooltip.to_s.include?('ximport')
+      end
+
+      # A field is "empty" when it carries no content. Native DataField types do
+      # not universally expose `#empty?`; fall back to `#value` emptiness so the
+      # report filters behave like the v2 ones.
+      def field_empty?(fld)
+        return fld.empty? if fld.respond_to?(:empty?)
+        return fld.value.to_s.strip.empty? if fld.respond_to?(:value)
+
+        false
+      end
+
+      def reset!
+        @src_unpaired  = by_type(src_components)
+        @dst_unpaired  = by_type(dst_components)
+        @src_dst_pairs = []
+        reset_multi!
+      end
+
+      def reset_multi!
+        @src_dst_multi = {}
+        @src_multi     = {}
+        @dst_multi     = {}
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/pages.rb

@@ -0,0 +1,21 @@
+module Eco::API::UseCases::GraphQL::Helpers
+  # Native GraphQL page-processing helper substrate.
+  #
+  # These mirror the *pure* parts of Eco::API::UseCases::OozeSamples::Helpers::* but drop the
+  # Ecoportal::API::V2 coupling: string/date utilities are ported verbatim, while the few
+  # methods that inspected V2 model types (object_reference, field_key_name) are re-expressed
+  # with duck-typing so they work against the GraphQL page/section/field models.
+  #
+  # This is Phase 1 of the ooze -> native GraphQL migration (build the shared substrate before
+  # any case). See ecoportal-api-graphql/.ai-assistance/projects/ooze-graphql-native-migration/.
+  module Pages
+  end
+end
+
+require_relative 'pages/shortcuts'
+require_relative 'pages/filters'
+require_relative 'pages/ooze_handlers'
+require_relative 'pages/rescuable'
+require_relative 'pages/creatable'
+require_relative 'pages/typed_fields_pairing'
+require_relative 'pages/copying'

data/lib/eco/api/usecases/graphql/helpers.rb

@@ -6,3 +6,4 @@ end
 require_relative 'helpers/base'
 require_relative 'helpers/location'
 require_relative 'helpers/contractors'
+require_relative 'helpers/pages'