active_shopify_graphql 0.3.0 → 0.5.0

data/lib/active_shopify_graphql/finder_methods.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  module FinderMethods
-    extend ActiveSupport::Concern
-
-    class_methods do
-      # Find a single record by ID using the provided loader
-      # @param id [String, Integer] The record ID (will be converted to GID automatically)
-      # @param loader [ActiveShopifyGraphQL::Loader] The loader to use for fetching data
-      # @return [Object, nil] The model instance or nil if not found
-      def find(id, loader: default_loader)
-        gid = GidHelper.normalize_gid(id, model_name.name.demodulize)
-
-        # If we have included connections, we need to handle inverse_of properly
-        if loader.respond_to?(:load_with_instance) && loader.has_included_connections?
-          loader.load_with_instance(gid, self)
-        else
-          attributes = loader.load_attributes(gid)
-          return nil if attributes.nil?
-
-          new(attributes)
-        end
-      end
-
-      # Returns the default loader for this model's queries
-      # @return [ActiveGraphQL::Loader] The default loader instance
-      def default_loader
-        if respond_to?(:default_loader_instance)
-          default_loader_instance
-        else
-          @default_loader ||= begin
-            # Collect connections with eager_load: true
-            eagerly_loaded_connections = connections.select { |_name, config| config[:eager_load] }.keys
-
-            default_loader_class.new(
-              self,
-              included_connections: eagerly_loaded_connections
-            )
-          end
-        end
-      end
-
-      # Allows setting a custom default loader (useful for testing)
-      # @param loader [ActiveGraphQL::Loader] The loader to set as default
-      def default_loader=(loader)
-        @default_loader = loader
-      end
-
-      # Select specific attributes to optimize GraphQL queries
-      # @param *attributes [Symbol] The attributes to select
-      # @return [Class] A class with modified default loader for method chaining
-      #
-      # @example
-      #   Customer.select(:id, :email).find(123)
-      #   Customer.select(:id, :email).where(first_name: "John")
-      def select(*attributes)
-        # Validate attributes exist
-        attrs = Array(attributes).flatten.map(&:to_sym)
-        validate_select_attributes!(attrs)
-
-        # Create a new class that inherits from self with a modified default loader
-        selected_class = Class.new(self)
-
-        # Override the default_loader method to return a loader with selected attributes
-        selected_class.define_singleton_method(:default_loader) do
-          @default_loader ||= superclass.default_loader.class.new(
-            superclass,
-            selected_attributes: attrs
-          )
-        end
-
-        # Preserve the original class name and model name for GraphQL operations
-        selected_class.define_singleton_method(:name) { superclass.name }
-        selected_class.define_singleton_method(:model_name) { superclass.model_name }
-
-        selected_class
-      end
-
-      # Query for multiple records using attribute conditions
-      # @param conditions [Hash] The conditions to query (e.g., { email: "example@test.com", first_name: "John" })
-      # @param options [Hash] Options hash containing loader and limit (when first arg is a Hash)
-      # @option options [ActiveShopifyGraphQL::Loader] :loader The loader to use for fetching data
-      # @option options [Integer] :limit The maximum number of records to return (default: 250, max: 250)
-      # @return [Array<Object>] Array of model instances
-      # @raise [ArgumentError] If any attribute is not valid for querying
-      #
-      # @example
-      #   # Keyword argument style (recommended)
-      #   Customer.where(email: "john@example.com")
-      #   Customer.where(first_name: "John", country: "Canada")
-      #   Customer.where(orders_count: { gte: 5 })
-      #   Customer.where(created_at: { gte: "2024-01-01", lt: "2024-02-01" })
-      #
-      #   # Hash style with options
-      #   Customer.where({ email: "john@example.com" }, loader: custom_loader, limit: 100)
-      def where(conditions_or_first_condition = {}, *args, **options)
-        # Handle both syntaxes:
-        # where(email: "john@example.com") - keyword args become options
-        # where({ email: "john@example.com" }, loader: custom_loader) - explicit hash + options
-        if conditions_or_first_condition.is_a?(Hash) && !conditions_or_first_condition.empty?
-          # Explicit hash provided as first argument
-          conditions = conditions_or_first_condition
-          # Any additional options passed as keyword args or second hash argument
-          final_options = args.first.is_a?(Hash) ? options.merge(args.first) : options
-        else
-          # Keyword arguments style - conditions come from options, excluding known option keys
-          known_option_keys = %i[loader limit]
-          conditions = options.except(*known_option_keys)
-          final_options = options.slice(*known_option_keys)
-        end
-
-        loader = final_options[:loader] || default_loader
-        limit = final_options[:limit] || 250
-
-        # Ensure loader has model class set - needed for graphql_type inference
-        loader.instance_variable_set(:@model_class, self) if loader.instance_variable_get(:@model_class).nil?
-
-        attributes_array = loader.load_collection(conditions, limit: limit)
-
-        attributes_array.map { |attributes| new(attributes) }
-      end
-
-      private
-
-      # Validates that selected attributes exist in the model
-      # @param attributes [Array<Symbol>] The attributes to validate
-      # @raise [ArgumentError] If any attribute is invalid
-      def validate_select_attributes!(attributes)
-        return if attributes.empty?
-
-        available_attrs = available_select_attributes
-        invalid_attrs = attributes - available_attrs
-
-        return unless invalid_attrs.any?
-
-        raise ArgumentError, "Invalid attributes for #{name}: #{invalid_attrs.join(', ')}. " \
-                             "Available attributes are: #{available_attrs.join(', ')}"
-      end
-
-      # Gets all available attributes for selection
-      # @return [Array<Symbol>] Available attribute names
-      def available_select_attributes
-        attrs = []
-
-        # Get attributes from the model class
-        loader_class = default_loader.class
-        model_attrs = attributes_for_loader(loader_class)
-        attrs.concat(model_attrs.keys)
-
-        # Get attributes from the loader class
-        loader_attrs = default_loader.class.defined_attributes
-        attrs.concat(loader_attrs.keys)
-
-        attrs.map(&:to_sym).uniq.sort
-      end
-    end
-  end
-end

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