active_shopify_graphql 0.4.0 → 0.5.0

data/lib/active_shopify_graphql/fragment_builder.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # Builds GraphQL fragments from model attributes and connections.
-  class FragmentBuilder
-    def initialize(context)
-      @context = context
-    end
-
-    # Build a complete fragment node with all fields and connections
-    def build
-      raise NotImplementedError, "#{@context.loader_class} must define attributes" if @context.defined_attributes.empty?
-
-      fragment_node = QueryNode.new(
-        name: @context.fragment_name,
-        arguments: { on: @context.graphql_type },
-        node_type: :fragment
-      )
-
-      # Add field nodes from attributes
-      build_field_nodes.each { |node| fragment_node.add_child(node) }
-
-      # Add connection nodes
-      build_connection_nodes.each { |node| fragment_node.add_child(node) }
-
-      fragment_node
-    end
-
-    # Build field nodes from attribute definitions (protected for recursive calls)
-    def build_field_nodes
-      path_tree = {}
-      metafield_aliases = {}
-      raw_graphql_nodes = []
-      aliased_field_nodes = []
-
-      # Build a tree structure for nested paths
-      @context.defined_attributes.each do |attr_name, config|
-        if config[:raw_graphql]
-          raw_graphql_nodes << build_raw_graphql_node(attr_name, config[:raw_graphql])
-        elsif config[:is_metafield]
-          store_metafield_config(metafield_aliases, config)
-        else
-          path = config[:path]
-          if path.include?('.')
-            # Nested path - use tree structure (shared prefixes)
-            build_path_tree(path_tree, path)
-          else
-            # Simple path - add aliased field node
-            aliased_field_nodes << build_aliased_field_node(attr_name, path)
-          end
-        end
-      end
-
-      # Convert tree to QueryNode objects
-      nodes_from_tree(path_tree) + aliased_field_nodes + metafield_nodes(metafield_aliases) + raw_graphql_nodes
-    end
-
-    # Build QueryNode objects for all connections (protected for recursive calls)
-    def build_connection_nodes
-      return [] if @context.included_connections.empty?
-
-      connections = @context.connections
-      return [] if connections.empty?
-
-      normalized_includes = normalize_includes(@context.included_connections)
-
-      normalized_includes.filter_map do |connection_name, nested_includes|
-        connection_config = connections[connection_name]
-        next unless connection_config
-
-        build_connection_node(connection_config, nested_includes)
-      end
-    end
-
-    private
-
-    def store_metafield_config(metafield_aliases, config)
-      alias_name = config[:metafield_alias]
-      value_field = config[:type] == :json ? 'jsonValue' : 'value'
-
-      metafield_aliases[alias_name] = {
-        namespace: config[:metafield_namespace],
-        key: config[:metafield_key],
-        value_field: value_field
-      }
-    end
-
-    def build_raw_graphql_node(attr_name, raw_graphql)
-      # Prepend alias to raw GraphQL for predictable response mapping
-      aliased_raw_graphql = "#{attr_name}: #{raw_graphql}"
-      QueryNode.new(
-        name: "raw",
-        arguments: { raw_graphql: aliased_raw_graphql },
-        node_type: :raw
-      )
-    end
-
-    def build_aliased_field_node(attr_name, path)
-      alias_name = attr_name.to_s
-      # Only add alias if the attr_name differs from the GraphQL field name
-      alias_name = nil if alias_name == path
-      QueryNode.new(name: path, alias_name: alias_name, node_type: :field)
-    end
-
-    def build_path_tree(path_tree, path)
-      path_parts = path.split('.')
-      current_level = path_tree
-
-      path_parts.each_with_index do |part, index|
-        if index == path_parts.length - 1
-          current_level[part] = true
-        else
-          current_level[part] ||= {}
-          current_level = current_level[part]
-        end
-      end
-    end
-
-    def nodes_from_tree(tree)
-      tree.map do |key, value|
-        if value == true
-          QueryNode.new(name: key, node_type: :field)
-        else
-          children = nodes_from_tree(value)
-          QueryNode.new(name: key, node_type: :field, children: children)
-        end
-      end
-    end
-
-    def metafield_nodes(metafield_aliases)
-      metafield_aliases.map do |alias_name, config|
-        value_node = QueryNode.new(name: config[:value_field], node_type: :field)
-        QueryNode.new(
-          name: "metafield",
-          alias_name: alias_name,
-          arguments: { namespace: config[:namespace], key: config[:key] },
-          node_type: :field,
-          children: [value_node]
-        )
-      end
-    end
-
-    def build_connection_node(connection_config, nested_includes)
-      target_class = connection_config[:class_name].constantize
-      target_context = @context.for_model(target_class, new_connections: nested_includes)
-
-      # Build child nodes for the target model
-      child_nodes = build_target_field_nodes(target_context, nested_includes)
-
-      query_name = connection_config[:query_name]
-      original_name = connection_config[:original_name]
-      connection_type = connection_config[:type] || :connection
-      formatted_args = (connection_config[:default_arguments] || {}).transform_keys(&:to_sym)
-
-      # Add alias if the connection name differs from the query name
-      alias_name = original_name.to_s == query_name ? nil : original_name.to_s
-
-      node_type = connection_type == :singular ? :singular : :connection
-      QueryNode.new(
-        name: query_name,
-        alias_name: alias_name,
-        arguments: formatted_args,
-        node_type: node_type,
-        children: child_nodes
-      )
-    end
-
-    def build_target_field_nodes(target_context, nested_includes)
-      # Build attribute nodes
-      attribute_nodes = if target_context.defined_attributes.any?
-                          FragmentBuilder.new(target_context.with_connections([])).build_field_nodes
-                        else
-                          [QueryNode.new(name: "id", node_type: :field)]
-                        end
-
-      # Build nested connection nodes
-      return attribute_nodes if nested_includes.empty?
-
-      nested_builder = FragmentBuilder.new(target_context)
-      nested_connection_nodes = nested_builder.build_connection_nodes
-      attribute_nodes + nested_connection_nodes
-    end
-
-    # Normalize includes from various formats to a consistent hash structure
-    def normalize_includes(includes)
-      includes = Array(includes)
-      includes.each_with_object({}) do |inc, normalized|
-        case inc
-        when Hash
-          inc.each do |key, value|
-            key = key.to_sym
-            normalized[key] ||= []
-            case value
-            when Hash then normalized[key] << value
-            when Array then normalized[key].concat(value)
-            else normalized[key] << value
-            end
-          end
-        when Symbol, String
-          normalized[inc.to_sym] ||= []
-        end
-      end
-    end
-
-    class << self
-      # Expose for external use (QueryTree needs this)
-      def normalize_includes(includes)
-        includes = Array(includes)
-        includes.each_with_object({}) do |inc, normalized|
-          case inc
-          when Hash
-            inc.each do |key, value|
-              key = key.to_sym
-              normalized[key] ||= []
-              case value
-              when Hash then normalized[key] << value
-              when Array then normalized[key].concat(value)
-              else normalized[key] << value
-              end
-            end
-          when Symbol, String
-            normalized[inc.to_sym] ||= []
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/graphql_type_resolver.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # Centralizes GraphQL type resolution logic.
-  module GraphqlTypeResolver
-    extend ActiveSupport::Concern
-
-    class_methods do
-      # Set or get the base GraphQL type for this model.
-      #
-      # @param type [String, nil] The GraphQL type name to set, or nil to get
-      # @return [String] The GraphQL type name
-      # @raise [NotImplementedError] If no type is defined
-      def graphql_type(type = nil)
-        if type
-          if @current_loader_context
-            @loader_graphql_types ||= {}
-            @loader_graphql_types[@current_loader_context] = type
-          else
-            @base_graphql_type = type
-          end
-        end
-
-        @base_graphql_type || raise(NotImplementedError, "#{self} must define graphql_type")
-      end
-
-      # Get the GraphQL type for a specific loader class.
-      # Resolution order:
-      #   1. Loader-specific type defined via `for_loader`
-      #   2. Base graphql_type defined on the model
-      #   3. Type defined on the loader class itself
-      #   4. Inferred from model class name
-      #
-      # @param loader_class [Class] The loader class to resolve type for
-      # @return [String] The resolved GraphQL type
-      # @raise [NotImplementedError] If no type can be resolved
-      def graphql_type_for_loader(loader_class)
-        # 1. Check loader-specific override
-        return @loader_graphql_types[loader_class] if @loader_graphql_types&.key?(loader_class)
-
-        # 2. Check base graphql_type
-        return @base_graphql_type if @base_graphql_type
-
-        # 3. Check loader class itself
-        loader_type = loader_class.instance_variable_get(:@graphql_type)
-        return loader_type if loader_type
-
-        # 4. Infer from model name
-        return name.demodulize if respond_to?(:name) && name
-
-        raise NotImplementedError,
-              "#{self} must define graphql_type or #{loader_class} must define graphql_type"
-      end
-
-      # Resolve the GraphQL type from any source (model class, loader, or value).
-      # Useful for external callers that need to resolve type from various inputs.
-      #
-      # @param model_class [Class, nil] The model class
-      # @param loader_class [Class, nil] The loader class
-      # @return [String] The resolved GraphQL type
-      def resolve_graphql_type(model_class: nil, loader_class: nil)
-        if model_class.respond_to?(:graphql_type_for_loader) && loader_class
-          model_class.graphql_type_for_loader(loader_class)
-        elsif model_class.respond_to?(:graphql_type)
-          model_class.graphql_type
-        elsif loader_class.respond_to?(:graphql_type)
-          loader_class.graphql_type
-        elsif model_class.respond_to?(:name) && model_class.name
-          model_class.name.demodulize
-        else
-          raise ArgumentError, "Cannot resolve graphql_type from provided arguments"
-        end
-      end
-    end
-
-    # Module-level resolver for convenience
-    def self.resolve(model_class: nil, loader_class: nil)
-      if model_class.respond_to?(:graphql_type_for_loader) && loader_class
-        model_class.graphql_type_for_loader(loader_class)
-      elsif model_class.respond_to?(:graphql_type)
-        model_class.graphql_type
-      elsif loader_class.respond_to?(:graphql_type)
-        loader_class.graphql_type
-      elsif model_class.respond_to?(:name) && model_class.name
-        model_class.name.demodulize
-      else
-        raise ArgumentError, "Cannot resolve graphql_type"
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/includes_scope.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # A scope object that holds included connections for eager loading.
-  # This allows chaining methods like find() and where() while maintaining
-  # the included connections configuration.
-  class IncludesScope
-    attr_reader :model_class, :included_connections
-
-    def initialize(model_class, included_connections)
-      @model_class = model_class
-      @included_connections = included_connections
-    end
-
-    # Delegate find to the model class with a custom loader
-    def find(id, loader: nil)
-      loader ||= default_loader
-      @model_class.find(id, loader: loader)
-    end
-
-    # Delegate where to the model class with a custom loader
-    def where(*args, **options)
-      loader = options.delete(:loader) || default_loader
-      @model_class.where(*args, **options.merge(loader: loader))
-    end
-
-    # Delegate select to create a new scope with select
-    def select(*attributes)
-      selected_scope = @model_class.select(*attributes)
-      # Chain the includes on top of select
-      IncludesScope.new(selected_scope, @included_connections)
-    end
-
-    # Allow chaining includes calls
-    def includes(*connection_names)
-      @model_class.includes(*(@included_connections + connection_names).uniq)
-    end
-
-    private
-
-    def default_loader
-      @default_loader ||= @model_class.default_loader.class.new(
-        @model_class,
-        included_connections: @included_connections
-      )
-    end
-  end
-end

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