active_shopify_graphql 0.4.0 → 0.5.0

data/lib/active_shopify_graphql/query_node.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-# Represents a node in the GraphQL query tree
-# This allows building the complete query structure before converting to a string
-class QueryNode
-  attr_reader :name, :arguments, :children, :node_type, :alias_name
-
-  # @param name [String] The field name (e.g., 'id', 'displayName', 'orders')
-  # @param alias_name [String] Optional field alias (e.g., 'myAlias' for 'myAlias: fieldName')
-  # @param arguments [Hash] Field arguments (e.g., { first: 10, sortKey: 'CREATED_AT' })
-  # @param node_type [Symbol] Type of node: :field, :connection, :singular, :fragment
-  # @param children [Array<QueryNode>] Child nodes for nested structures
-  def initialize(name:, alias_name: nil, arguments: {}, node_type: :field, children: [])
-    @name = name
-    @alias_name = alias_name
-    @arguments = arguments
-    @node_type = node_type
-    @children = children
-  end
-
-  # Add a child node
-  def add_child(node)
-    @children << node
-    node
-  end
-
-  # Check if node has children
-  def has_children?
-    @children.any?
-  end
-
-  # Convert node to GraphQL string
-  def to_s(indent_level: 0)
-    case @node_type
-    when :field
-      render_field(indent_level: indent_level)
-    when :connection
-      render_connection(indent_level: indent_level)
-    when :singular
-      render_singular(indent_level: indent_level)
-    when :fragment
-      render_fragment
-    when :raw
-      render_raw
-    else
-      raise ArgumentError, "Unknown node type: #{@node_type}"
-    end
-  end
-
-  private
-
-  def compact?
-    ActiveShopifyGraphQL.configuration.compact_queries
-  end
-
-  def render_field(indent_level:)
-    # Simple field with no children
-    field_name = @alias_name ? "#{@alias_name}: #{@name}" : @name
-    args_string = format_arguments
-    full_name = "#{field_name}#{args_string}"
-
-    return full_name unless has_children?
-
-    # Field with nested structure (e.g., defaultAddress { city })
-    indent = compact? ? "" : "  " * indent_level
-    nested_indent = compact? ? "" : "  " * (indent_level + 1)
-
-    nested_fields = @children.map { |child| child.to_s(indent_level: indent_level + 1) }
-
-    if compact?
-      "#{full_name} { #{nested_fields.join(' ')} }"
-    else
-      separator = "\n"
-      "#{full_name} {#{separator}#{nested_indent}#{nested_fields.join("\n#{nested_indent}")}#{separator}#{indent}}"
-    end
-  end
-
-  def render_connection(indent_level:)
-    args_string = format_arguments
-
-    indent = compact? ? "" : "  " * indent_level
-    nested_indent = compact? ? "" : "  " * (indent_level + 1)
-
-    # Build nested fields from children
-    nested_fields = @children.map { |child| child.to_s(indent_level: indent_level + 2) }
-    fields_string = nested_fields.join(compact? ? " " : "\n#{nested_indent}  ")
-
-    # Include alias if present
-    field_name = @alias_name ? "#{@alias_name}: #{@name}" : @name
-
-    if compact?
-      "#{field_name}#{args_string} { edges { node { #{fields_string} } } }"
-    else
-      <<~GRAPHQL.strip
-        #{field_name}#{args_string} {
-        #{nested_indent}edges {
-        #{nested_indent}  node {
-        #{nested_indent}    #{fields_string}
-        #{nested_indent}  }
-        #{nested_indent}}
-        #{indent}}
-      GRAPHQL
-    end
-  end
-
-  def render_singular(indent_level:)
-    args_string = format_arguments
-
-    indent = compact? ? "" : "  " * indent_level
-    nested_indent = compact? ? "" : "  " * (indent_level + 1)
-
-    # Build nested fields from children
-    nested_fields = @children.map { |child| child.to_s(indent_level: indent_level + 1) }
-    fields_string = nested_fields.join(compact? ? " " : "\n#{nested_indent}")
-
-    # Include alias if present
-    field_name = @alias_name ? "#{@alias_name}: #{@name}" : @name
-
-    if compact?
-      "#{field_name}#{args_string} { #{fields_string} }"
-    else
-      "#{field_name}#{args_string} {\n#{nested_indent}#{fields_string}\n#{indent}}"
-    end
-  end
-
-  def render_fragment
-    # Fragment fields are the children
-    fields = @children.map { |child| child.to_s(indent_level: 0) }
-    all_fields = fields.join(compact? ? " " : "\n")
-
-    if compact?
-      "fragment #{@name} on #{@arguments[:on]} { #{all_fields} }"
-    else
-      "fragment #{@name} on #{@arguments[:on]} {\n#{all_fields}\n}"
-    end
-  end
-
-  def render_raw
-    # Raw GraphQL string stored in arguments[:raw_graphql]
-    @arguments[:raw_graphql]
-  end
-
-  def format_arguments
-    return "" if @arguments.empty?
-
-    args = @arguments.map do |key, value|
-      # Convert Ruby snake_case to GraphQL camelCase
-      graphql_key = key.to_s.camelize(:lower)
-
-      # Format value based on type
-      formatted_value = case value
-                        when String
-                          # Check if it needs quotes (query parameter vs enum values)
-                          # For metafields and most strings, add quotes
-                          if %i[namespace key].include?(key.to_sym)
-                            "\"#{value}\""
-                          elsif key.to_sym == :query
-                            "\"#{value}\""
-                          else
-                            value
-                          end
-                        when Symbol
-                          value.to_s
-                        else
-                          value
-                        end
-
-      "#{graphql_key}: #{formatted_value}"
-    end
-
-    "(#{args.join(', ')})"
-  end
-end

data/lib/active_shopify_graphql/query_tree.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # Builds complete GraphQL queries from a LoaderContext.
-  # Refactored for Single Responsibility - only handles query string generation.
-  # Fragment building is delegated to FragmentBuilder.
-  class QueryTree
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-      @fragments = []
-      @query_config = {}
-    end
-
-    # Class-level factory methods for building complete queries
-
-    def self.build_single_record_query(context)
-      new(context).tap do |tree|
-        tree.add_fragment(FragmentBuilder.new(context).build)
-        tree.set_query_config(
-          type: :single_record,
-          model_type: context.graphql_type,
-          query_name: context.query_name,
-          fragment_name: context.fragment_name
-        )
-      end.to_s
-    end
-
-    # Build a query that doesn't require an ID parameter (e.g., Customer Account API's current customer)
-    def self.build_current_customer_query(context, query_name: nil)
-      new(context).tap do |tree|
-        tree.add_fragment(FragmentBuilder.new(context).build)
-        tree.set_query_config(
-          type: :current_customer,
-          model_type: context.graphql_type,
-          query_name: query_name || context.query_name,
-          fragment_name: context.fragment_name
-        )
-      end.to_s
-    end
-
-    def self.build_collection_query(context, query_name:, variables:, connection_type: :nodes_only)
-      new(context).tap do |tree|
-        tree.add_fragment(FragmentBuilder.new(context).build)
-        tree.set_query_config(
-          type: :collection,
-          model_type: context.graphql_type,
-          query_name: query_name,
-          fragment_name: context.fragment_name,
-          variables: variables,
-          connection_type: connection_type
-        )
-      end.to_s
-    end
-
-    def self.build_connection_query(context, query_name:, variables:, parent_query: nil, connection_type: :connection)
-      new(context).tap do |tree|
-        tree.add_fragment(FragmentBuilder.new(context).build)
-        tree.set_query_config(
-          type: :connection,
-          query_name: query_name,
-          fragment_name: context.fragment_name,
-          variables: variables,
-          parent_query: parent_query,
-          connection_type: connection_type
-        )
-      end.to_s
-    end
-
-    # Delegate normalize_includes to FragmentBuilder
-    def self.normalize_includes(includes)
-      FragmentBuilder.normalize_includes(includes)
-    end
-
-    def self.fragment_name(graphql_type)
-      "#{graphql_type}Fragment"
-    end
-
-    def add_fragment(fragment_node)
-      @fragments << fragment_node
-    end
-
-    def set_query_config(config)
-      @query_config = config
-    end
-
-    def to_s
-      case @query_config[:type]
-      when :single_record then render_single_record_query
-      when :current_customer then render_current_customer_query
-      when :collection    then render_collection_query
-      when :connection    then render_connection_query
-      else ""
-      end
-    end
-
-    private
-
-    def compact?
-      ActiveShopifyGraphQL.configuration.compact_queries
-    end
-
-    def fragments_string
-      @fragments.map(&:to_s).join(compact? ? " " : "\n\n")
-    end
-
-    def field_signature(variables)
-      params = build_field_parameters(variables.compact)
-      params.empty? ? "" : "(#{params.join(', ')})"
-    end
-
-    def render_single_record_query
-      type = @query_config[:model_type]
-      query_name = @query_config[:query_name]
-      fragment_name = @query_config[:fragment_name]
-
-      if compact?
-        "#{fragments_string} query get#{type}($id: ID!) { #{query_name}(id: $id) { ...#{fragment_name} } }"
-      else
-        "#{fragments_string}\n\nquery get#{type}($id: ID!) {\n  #{query_name}(id: $id) {\n    ...#{fragment_name}\n  }\n}\n"
-      end
-    end
-
-    def render_current_customer_query
-      type = @query_config[:model_type]
-      query_name = @query_config[:query_name]
-      fragment_name = @query_config[:fragment_name]
-
-      if compact?
-        "#{fragments_string} query getCurrent#{type} { #{query_name} { ...#{fragment_name} } }"
-      else
-        "#{fragments_string}\n\nquery getCurrent#{type} {\n  #{query_name} {\n    ...#{fragment_name}\n  }\n}\n"
-      end
-    end
-
-    def render_collection_query
-      type = @query_config[:model_type]
-      query_name = @query_config[:query_name]
-      fragment_name = @query_config[:fragment_name]
-      variables = @query_config[:variables] || {}
-      connection_type = @query_config[:connection_type] || :nodes_only
-
-      field_sig = field_signature(variables)
-
-      if compact?
-        body = wrap_connection_body_compact(fragment_name, connection_type)
-        "#{fragments_string} query get#{type.pluralize} { #{query_name}#{field_sig} { #{body} } }"
-      else
-        body = wrap_connection_body_formatted(fragment_name, connection_type, 2)
-        "#{fragments_string}\nquery get#{type.pluralize} {\n  #{query_name}#{field_sig} {\n#{body}\n  }\n}\n"
-      end
-    end
-
-    def render_connection_query
-      query_name = @query_config[:query_name]
-      fragment_name = @query_config[:fragment_name]
-      variables = @query_config[:variables] || {}
-      parent_query = @query_config[:parent_query]
-      connection_type = @query_config[:connection_type] || :connection
-
-      field_sig = field_signature(variables)
-
-      if parent_query
-        render_nested_connection_query(query_name, fragment_name, field_sig, parent_query, connection_type)
-      else
-        render_root_connection_query(query_name, fragment_name, field_sig, connection_type)
-      end
-    end
-
-    def render_nested_connection_query(query_name, fragment_name, field_sig, parent_query, connection_type)
-      if compact?
-        body = wrap_connection_body_compact(fragment_name, connection_type)
-        "#{fragments_string} query($id: ID!) { #{parent_query} { #{query_name}#{field_sig} { #{body} } } }"
-      else
-        body = wrap_connection_body_formatted(fragment_name, connection_type, 3)
-        "#{fragments_string}\nquery($id: ID!) {\n  #{parent_query} {\n    #{query_name}#{field_sig} {\n#{body}\n    }\n  }\n}\n"
-      end
-    end
-
-    def render_root_connection_query(query_name, fragment_name, field_sig, connection_type)
-      if compact?
-        body = wrap_connection_body_compact(fragment_name, connection_type)
-        "#{fragments_string} query { #{query_name}#{field_sig} { #{body} } }"
-      else
-        body = wrap_connection_body_formatted(fragment_name, connection_type, 2)
-        "#{fragments_string}\nquery {\n  #{query_name}#{field_sig} {\n#{body}\n  }\n}\n"
-      end
-    end
-
-    def wrap_connection_body_compact(fragment_name, connection_type)
-      case connection_type
-      when :singular    then "...#{fragment_name}"
-      when :nodes_only  then "nodes { ...#{fragment_name} }"
-      else                   "edges { node { ...#{fragment_name} } }"
-      end
-    end
-
-    def wrap_connection_body_formatted(fragment_name, connection_type, indent_level)
-      indent = "  " * indent_level
-      case connection_type
-      when :singular
-        "#{indent}...#{fragment_name}"
-      when :nodes_only
-        "#{indent}nodes {\n#{indent}  ...#{fragment_name}\n#{indent}}"
-      else
-        "#{indent}edges {\n#{indent}  node {\n#{indent}    ...#{fragment_name}\n#{indent}  }\n#{indent}}"
-      end
-    end
-
-    def build_field_parameters(variables)
-      variables.map do |key, value|
-        "#{key.to_s.camelize(:lower)}: #{format_inline_value(key, value)}"
-      end
-    end
-
-    def format_inline_value(key, value)
-      case value
-      when Integer, TrueClass, FalseClass then value.to_s
-      when String then key.to_sym == :query ? "\"#{value}\"" : value
-      else value.to_s
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/response_mapper.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # Handles mapping GraphQL responses to model attributes.
-  # Refactored to use LoaderContext and unified mapping methods.
-  class ResponseMapper
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-    end
-
-    # Map GraphQL response to attributes using declared attribute metadata
-    # @param response_data [Hash] The full GraphQL response
-    # @param root_path [Array<String>] Path to the data root (e.g., ["data", "customer"])
-    # @return [Hash] Mapped attributes
-    def map_response(response_data, root_path: nil)
-      root_path ||= ["data", @context.query_name]
-      root_data = response_data.dig(*root_path)
-      return {} unless root_data
-
-      map_node_to_attributes(root_data)
-    end
-
-    # Map a single node's data to attributes (used for both root and nested)
-    def map_node_to_attributes(node_data)
-      return {} unless node_data
-
-      result = {}
-      @context.defined_attributes.each do |attr_name, config|
-        value = extract_and_transform_value(node_data, config, attr_name)
-        result[attr_name] = value
-      end
-      result
-    end
-
-    # Extract connection data from GraphQL response for eager loading
-    def extract_connection_data(response_data, root_path: nil, parent_instance: nil)
-      return {} if @context.included_connections.empty?
-
-      root_path ||= ["data", @context.query_name]
-      root_data = response_data.dig(*root_path)
-      return {} unless root_data
-
-      extract_connections_from_node(root_data, parent_instance)
-    end
-
-    # Extract connections from a node (reusable for nested connections)
-    def extract_connections_from_node(node_data, parent_instance = nil)
-      return {} if @context.included_connections.empty?
-
-      connections = @context.connections
-      return {} if connections.empty?
-
-      normalized_includes = FragmentBuilder.normalize_includes(@context.included_connections)
-      connection_cache = {}
-
-      normalized_includes.each do |connection_name, nested_includes|
-        connection_config = connections[connection_name]
-        next unless connection_config
-
-        records = extract_connection_records(node_data, connection_config, nested_includes, parent_instance: parent_instance)
-        connection_cache[connection_name] = records if records
-      end
-
-      connection_cache
-    end
-
-    # Map nested connection response (when loading via parent query)
-    def map_nested_connection_response(response_data, connection_field_name, parent, connection_config = nil)
-      parent_type = parent.class.graphql_type_for_loader(@context.loader_class)
-      parent_query_name = parent_type.camelize(:lower)
-      connection_type = connection_config&.dig(:type) || :connection
-
-      if connection_type == :singular
-        node_data = response_data.dig("data", parent_query_name, connection_field_name)
-        return nil unless node_data
-
-        build_model_instance(node_data)
-      else
-        edges = response_data.dig("data", parent_query_name, connection_field_name, "edges")
-        return [] unless edges
-
-        edges.filter_map do |edge|
-          node_data = edge["node"]
-          build_model_instance(node_data) if node_data
-        end
-      end
-    end
-
-    # Map root connection response
-    def map_connection_response(response_data, query_name, connection_config = nil)
-      connection_type = connection_config&.dig(:type) || :connection
-
-      if connection_type == :singular
-        node_data = response_data.dig("data", query_name)
-        return nil unless node_data
-
-        build_model_instance(node_data)
-      else
-        edges = response_data.dig("data", query_name, "edges")
-        return [] unless edges
-
-        edges.filter_map do |edge|
-          node_data = edge["node"]
-          build_model_instance(node_data) if node_data
-        end
-      end
-    end
-
-    private
-
-    def extract_and_transform_value(node_data, config, attr_name)
-      path = config[:path]
-
-      value = if config[:raw_graphql]
-                # For raw_graphql, the alias is the attr_name, then dig using path if nested
-                raw_data = node_data[attr_name.to_s]
-                if path.include?('.')
-                  # Path is relative to the aliased root
-                  path_parts = path.split('.')[1..] # Skip the first part (attr_name itself)
-                  path_parts.any? ? raw_data&.dig(*path_parts) : raw_data
-                else
-                  raw_data
-                end
-              elsif path.include?('.')
-                # Nested path - dig using the full path
-                path_parts = path.split('.')
-                node_data.dig(*path_parts)
-              else
-                # Simple path - use attr_name as key (matches the alias in the query)
-                node_data[attr_name.to_s]
-              end
-
-      value = apply_defaults_and_transforms(value, config)
-      validate_null_constraint!(value, config, attr_name)
-      coerce_value(value, config[:type])
-    end
-
-    def apply_defaults_and_transforms(value, config)
-      if value.nil?
-        return config[:default] unless config[:default].nil?
-
-        return config[:transform]&.call(value)
-      end
-
-      config[:transform] ? config[:transform].call(value) : value
-    end
-
-    def validate_null_constraint!(value, config, attr_name)
-      return unless !config[:null] && value.nil?
-
-      raise ArgumentError, "Attribute '#{attr_name}' (GraphQL path: '#{config[:path]}') cannot be null but received nil"
-    end
-
-    def coerce_value(value, type)
-      return nil if value.nil?
-      return value if value.is_a?(Array) # Preserve arrays
-
-      type_caster(type).cast(value)
-    end
-
-    def type_caster(type)
-      case type
-      when :string   then ActiveModel::Type::String.new
-      when :integer  then ActiveModel::Type::Integer.new
-      when :float    then ActiveModel::Type::Float.new
-      when :boolean  then ActiveModel::Type::Boolean.new
-      when :datetime then ActiveModel::Type::DateTime.new
-      else ActiveModel::Type::Value.new
-      end
-    end
-
-    def extract_connection_records(node_data, connection_config, nested_includes, parent_instance: nil)
-      # Use original_name (Ruby attr name) as the response key since we alias connections
-      response_key = connection_config[:original_name].to_s
-      connection_type = connection_config[:type] || :connection
-      target_class = connection_config[:class_name].constantize
-      connection_name = connection_config[:original_name]
-
-      if connection_type == :singular
-        item_data = node_data[response_key]
-        return nil unless item_data
-
-        build_nested_model_instance(item_data, target_class, nested_includes,
-                                    parent_instance: parent_instance,
-                                    parent_connection_name: connection_name,
-                                    connection_config: connection_config)
-      else
-        edges = node_data.dig(response_key, "edges")
-        return nil unless edges
-
-        edges.filter_map do |edge|
-          item_data = edge["node"]
-          if item_data
-            build_nested_model_instance(item_data, target_class, nested_includes,
-                                        parent_instance: parent_instance,
-                                        parent_connection_name: connection_name,
-                                        connection_config: connection_config)
-          end
-        end
-      end
-    end
-
-    def build_model_instance(node_data)
-      return nil unless node_data
-
-      attributes = map_node_to_attributes(node_data)
-      @context.model_class.new(attributes)
-    end
-
-    def build_nested_model_instance(node_data, target_class, nested_includes, parent_instance: nil, parent_connection_name: nil, connection_config: nil) # rubocop:disable Lint/UnusedMethodArgument
-      nested_context = @context.for_model(target_class, new_connections: nested_includes)
-      nested_mapper = ResponseMapper.new(nested_context)
-
-      attributes = nested_mapper.map_node_to_attributes(node_data)
-      instance = target_class.new(attributes)
-
-      # Populate inverse cache if inverse_of is specified
-      if parent_instance && connection_config && connection_config[:inverse_of]
-        inverse_name = connection_config[:inverse_of]
-        instance.instance_variable_set(:@_connection_cache, {}) unless instance.instance_variable_get(:@_connection_cache)
-        cache = instance.instance_variable_get(:@_connection_cache)
-
-        # Check the type of the inverse connection to determine how to cache
-        if target_class.respond_to?(:connections) && target_class.connections[inverse_name]
-          inverse_type = target_class.connections[inverse_name][:type]
-          cache[inverse_name] =
-            if inverse_type == :singular
-              parent_instance
-            else
-              # For collection inverses, wrap parent in an array
-              [parent_instance]
-            end
-        end
-      end
-
-      # Handle nested connections recursively (instance becomes parent for its children)
-      if nested_includes.any?
-        nested_data = nested_mapper.extract_connections_from_node(node_data, instance)
-        nested_data.each do |nested_name, nested_records|
-          instance.send("#{nested_name}=", nested_records)
-        end
-      end
-
-      instance
-    end
-  end
-end