active_shopify_graphql 0.1.0

data/lib/active_shopify_graphql/loader_switchable.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  # Provides capability to switch between different loaders within the same model
+  module LoaderSwitchable
+    extend ActiveSupport::Concern
+
+    # Generic method to execute with a specific loader
+    # @param loader_class [Class] The loader class to use
+    # @yield [Object] Block to execute with the loader
+    # @return [Object] Result of the block
+    def with_loader(loader_class, &_block)
+      old_loader = Thread.current[:active_shopify_graphql_loader]
+      Thread.current[:active_shopify_graphql_loader] = loader_class.new(self.class)
+
+      if block_given?
+        yield(self)
+      else
+        self
+      end
+    ensure
+      Thread.current[:active_shopify_graphql_loader] = old_loader
+    end
+
+    # Executes with the admin API loader
+    # @return [self]
+    def with_admin_api(&block)
+      with_loader(ActiveShopifyGraphQL::Loaders::AdminApiLoader, &block)
+    end
+
+    # Executes with the customer account API loader
+    # @return [self]
+    def with_customer_account_api(&block)
+      with_loader(ActiveShopifyGraphQL::Loaders::CustomerAccountApiLoader, &block)
+    end
+
+    class_methods do
+      # @!method use_loader(loader_class)
+      #   Sets the default loader class for this model.
+      #
+      #   @param loader_class [Class] The loader class to use as default
+      #   @example
+      #     class Customer < ActiveRecord::Base
+      #       use_loader ActiveShopifyGraphQL::Loaders::CustomerAccountApiLoader
+      #     end
+      def use_loader(loader_class)
+        @default_loader_class = loader_class
+      end
+
+      # Define loader-specific attribute and graphql_type overrides
+      # @param loader_class [Class] The loader class to override attributes for
+      def for_loader(loader_class, &block)
+        @current_loader_context = loader_class
+        @loader_contexts ||= {}
+        @loader_contexts[loader_class] ||= {}
+        instance_eval(&block) if block_given?
+        @current_loader_context = nil
+      end
+
+      # Class-level method to execute with admin API loader
+      # @return [LoaderProxy] Proxy object with find method
+      def with_admin_api
+        LoaderProxy.new(self, ActiveShopifyGraphQL::Loaders::AdminApiLoader.new(self))
+      end
+
+      # Class-level method to execute with customer account API loader
+      # @return [LoaderProxy] Proxy object with find method
+      def with_customer_account_api(token = nil)
+        LoaderProxy.new(self, ActiveShopifyGraphQL::Loaders::CustomerAccountApiLoader.new(self, token))
+      end
+
+      private
+
+      # Returns the default loader class (either set via DSL or inferred)
+      # @return [Class] The default loader class
+      def default_loader_class
+        @default_loader_class ||= ActiveShopifyGraphQL::Loaders::AdminApiLoader
+      end
+    end
+
+    # Simple proxy class to handle loader delegation
+    class LoaderProxy
+      def initialize(model_class, loader)
+        @model_class = model_class
+        @loader = loader
+      end
+
+      def find(id = nil)
+        # For Customer Account API, if no ID is provided, load the current customer
+        if id.nil? && @loader.is_a?(ActiveShopifyGraphQL::Loaders::CustomerAccountApiLoader)
+          attributes = @loader.load_attributes
+          return nil if attributes.nil?
+
+          return @model_class.new(attributes)
+        end
+
+        # For other cases, require ID and use standard flow
+        return nil if id.nil?
+
+        gid = GidHelper.normalize_gid(id, @model_class.model_name.name.demodulize)
+
+        attributes = @loader.load_attributes(gid)
+        return nil if attributes.nil?
+
+        @model_class.new(attributes)
+      end
+
+      # Delegate where to the model class with the specific loader
+      def where(*args, **options)
+        @model_class.where(*args, **options.merge(loader: @loader))
+      end
+
+      attr_reader :loader
+
+      def inspect
+        "#{@model_class.name}(with_#{@loader.class.name.demodulize})"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/active_shopify_graphql/loaders/admin_api_loader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  module Loaders
+    class AdminApiLoader < Loader
+      def initialize(model_class = nil, selected_attributes: nil, included_connections: nil)
+        super(model_class, selected_attributes: selected_attributes, included_connections: included_connections)
+      end
+
+      def perform_graphql_query(query, **variables)
+        log_query(query, variables) if should_log?
+
+        client = ActiveShopifyGraphQL.configuration.admin_api_client
+        raise Error, "Admin API client not configured. Please configure it using ActiveShopifyGraphQL.configure" unless client
+
+        client.execute(query, **variables)
+      end
+
+      private
+
+      def should_log?
+        ActiveShopifyGraphQL.configuration.log_queries && ActiveShopifyGraphQL.configuration.logger
+      end
+
+      def log_query(query, variables)
+        logger = ActiveShopifyGraphQL.configuration.logger
+        logger.info("ActiveShopifyGraphQL Query (Admin API):\n#{query}")
+        logger.info("ActiveShopifyGraphQL Variables:\n#{variables}")
+      end
+    end
+  end
+end

data/lib/active_shopify_graphql/loaders/customer_account_api_loader.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  module Loaders
+    class CustomerAccountApiLoader < Loader
+      def initialize(model_class = nil, token = nil, selected_attributes: nil, included_connections: nil)
+        super(model_class, selected_attributes: selected_attributes, included_connections: included_connections)
+        @token = token
+      end
+
+      # Override to handle Customer queries that don't need an ID
+      def graphql_query(model_type = nil)
+        type = model_type || graphql_type
+        if type == 'Customer'
+          customer_only_query(type)
+        else
+          super(type)
+        end
+      end
+
+      # Override load_attributes to handle the Customer case
+      def load_attributes(id = nil)
+        type = graphql_type
+        query = graphql_query(type)
+
+        variables = type == 'Customer' ? {} : { id: id }
+        response_data = perform_graphql_query(query, **variables)
+
+        return nil if response_data.nil?
+
+        map_response_to_attributes(response_data)
+      end
+
+      def client
+        client_class = ActiveShopifyGraphQL.configuration.customer_account_client_class
+        raise Error, "Customer Account API client class not configured" unless client_class
+
+        @client ||= client_class.from_config(@token)
+      end
+
+      def perform_graphql_query(query, **variables)
+        log_query(query, variables) if should_log?
+        client.query(query, variables)
+      end
+
+      private
+
+      def should_log?
+        ActiveShopifyGraphQL.configuration.log_queries && ActiveShopifyGraphQL.configuration.logger
+      end
+
+      def log_query(query, variables)
+        logger = ActiveShopifyGraphQL.configuration.logger
+        logger.info("ActiveShopifyGraphQL Query (Customer Account API):\n#{query}")
+        logger.info("ActiveShopifyGraphQL Variables:\n#{variables}")
+      end
+
+      def customer_only_query(model_type = nil)
+        type = model_type || graphql_type
+        compact = ActiveShopifyGraphQL.configuration.compact_queries
+        frag = fragment
+
+        if compact
+          "#{frag} query getCurrentCustomer { #{query_name(type)} { ...#{fragment_name(type)} } }"
+        else
+          "#{frag}\n\nquery getCurrentCustomer {\n  #{query_name(type)} {\n    ...#{fragment_name(type)}\n  }\n}\n"
+        end
+      end
+    end
+  end
+end

data/lib/active_shopify_graphql/metafield_attributes.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  module MetafieldAttributes
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Define a metafield attribute for this model.
+      #
+      # @param name [Symbol] The Ruby attribute name
+      # @param namespace [String] The metafield namespace
+      # @param key [String] The metafield key
+      # @param type [Symbol] The type for coercion (:string, :integer, :float, :boolean, :datetime, :json)
+      # @param null [Boolean] Whether the attribute can be null (default: true)
+      # @param default [Object] Default value when GraphQL response is nil
+      # @param transform [Proc] Custom transform block for the value
+      def metafield_attribute(name, namespace:, key:, type: :string, null: true, default: nil, transform: nil)
+        @metafields ||= {}
+        @metafields[name] = { namespace: namespace, key: key, type: type }
+
+        # Build metafield config
+        alias_name = "#{infer_path(name)}Metafield"
+        value_field = type == :json ? 'jsonValue' : 'value'
+        path = "#{alias_name}.#{value_field}"
+
+        config = {
+          path: path,
+          type: type,
+          null: null,
+          default: default,
+          transform: transform,
+          is_metafield: true,
+          metafield_alias: alias_name,
+          metafield_namespace: namespace,
+          metafield_key: key
+        }
+
+        if @current_loader_context
+          @loader_contexts[@current_loader_context][name] = config
+        else
+          @base_attributes ||= {}
+          @base_attributes[name] = config
+        end
+
+        attr_accessor name unless method_defined?(name) || method_defined?("#{name}=")
+      end
+
+      # Get metafields defined for this model
+      def metafields
+        @metafields || {}
+      end
+
+      private
+
+      # Infer GraphQL path from Ruby attribute name (delegates to Attributes if available)
+      def infer_path(name)
+        name.to_s.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase }
+      end
+    end
+  end
+end

data/lib/active_shopify_graphql/query_node.rb

@@ -0,0 +1,160 @@
+# 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
+    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}  ")
+
+    if compact?
+      "#{@name}#{args_string} { edges { node { #{fields_string} } } }"
+    else
+      <<~GRAPHQL.strip
+        #{@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}")
+
+    if compact?
+      "#{@name}#{args_string} { #{fields_string} }"
+    else
+      "#{@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 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

@@ -0,0 +1,204 @@
+# 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
+
+    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
+
+    # Helper methods (kept for backward compatibility)
+    def self.query_name(graphql_type)
+      graphql_type.downcase
+    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 :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_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