active_shopify_graphql 0.3.0 → 0.5.0

data/lib/active_shopify_graphql/loader_switchable.rb

@@ -1,180 +0,0 @@
-# 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, included_connections: [], selected_attributes: nil)
-        @model_class = model_class
-        @loader = loader
-        @included_connections = included_connections
-        @selected_attributes = selected_attributes
-      end
-
-      def includes(*connection_names)
-        # Validate connections exist
-        @model_class.send(:validate_includes_connections!, connection_names) if @model_class.respond_to?(:validate_includes_connections!, true)
-
-        # Collect connections with eager_load: true
-        auto_included_connections = @model_class.connections.select { |_name, config| config[:eager_load] }.keys
-
-        # Merge manual and automatic connections
-        all_included_connections = (@included_connections + connection_names + auto_included_connections).uniq
-
-        # Create a new loader with the included connections
-        new_loader = @loader.class.new(
-          @model_class,
-          *loader_extra_args,
-          selected_attributes: @selected_attributes,
-          included_connections: all_included_connections
-        )
-
-        LoaderProxy.new(
-          @model_class,
-          new_loader,
-          included_connections: all_included_connections,
-          selected_attributes: @selected_attributes
-        )
-      end
-
-      def select(*attribute_names)
-        new_selected = attribute_names.map(&:to_sym)
-
-        # Create a new loader with the selected attributes
-        new_loader = @loader.class.new(
-          @model_class,
-          *loader_extra_args,
-          selected_attributes: new_selected,
-          included_connections: @included_connections
-        )
-
-        LoaderProxy.new(
-          @model_class,
-          new_loader,
-          included_connections: @included_connections,
-          selected_attributes: new_selected
-        )
-      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
-
-      private
-
-      # Returns extra arguments needed when creating a new loader of the same type
-      # For CustomerAccountApiLoader, this includes the token
-      def loader_extra_args
-        if @loader.is_a?(ActiveShopifyGraphQL::Loaders::CustomerAccountApiLoader)
-          [@loader.instance_variable_get(:@token)]
-        else
-          []
-        end
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/metafield_attributes.rb

@@ -1,61 +0,0 @@
-# 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

@@ -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