Add ".where" functionality to graphql models

Author: nirebu

examples/customer_loader_example.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Example usage of the new graphql_type class method and simplified fragment API
+# This demonstrates the desired API with improved fragment definition
+
+module ActiveShopifyGraphQL
+  module Loaders
+    module AdminApi
+      class CustomerLoader < AdminApiLoader
+        graphql_type "Customer" # <- this informs the rest of the class
+
+        # New class-level fragment definition - just define the fields!
+        # No need to specify fragment name or "on Customer" - it's derived automatically
+        fragment <<~GRAPHQL
+          id
+          displayName
+          email
+          phone
+          createdAt
+          updatedAt
+          defaultEmailAddress {
+            emailAddress
+          }
+          tags
+        GRAPHQL
+
+        def map_response_to_attributes(response_data)
+          customer_data = response_data.dig("data", "customer")
+          return {} unless customer_data
+
+          {
+            id: customer_data["id"],
+            display_name: customer_data["displayName"],
+            email: customer_data["email"],
+            phone: customer_data["phone"],
+            created_at: customer_data["createdAt"],
+            updated_at: customer_data["updatedAt"]
+          }
+        end
+      end
+    end
+  end
+end
+
+# Usage examples:
+# loader = ActiveShopifyGraphQL::Loaders::AdminApi::CustomerLoader.new
+# customer_attrs = loader.load_attributes("gid://shopify/Customer/123")
+# customers = loader.load_collection({ email: "test@example.com" })

lib/active_shopify_graphql.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_model'
+require 'globalid'
+
 require_relative "active_shopify_graphql/version"
 require_relative "active_shopify_graphql/configuration"
 require_relative "active_shopify_graphql/base"

lib/active_shopify_graphql/connections.rb

@@ -49,7 +49,7 @@ def metafield(attribute_name, graphql_field: "metafield", target_class: "Shopify
         end
       end
 
-      def connection(name, target_class: nil, arguments: {}, &block)
+      def connection(name, target_class: nil, arguments: {})
         target_class_name = target_class&.to_s || name.to_s.singularize.classify
 
         # Store connection metadata

lib/active_shopify_graphql/customer_account_api_loader.rb

@@ -7,22 +7,38 @@ def initialize(token)
     end
 
     # Override to handle Customer queries that don't need an ID
-    def graphql_query(model_type = 'Customer')
-      if model_type == 'Customer'
+    def graphql_query(model_type = nil)
+      type = model_type || self.class.graphql_type
+      if type == 'Customer'
         # Customer Account API doesn't need ID for customer queries - token identifies the customer
-        customer_only_query(model_type)
+        customer_only_query(type)
       else
         # For other types, use the standard query with ID
-        super(model_type)
+        super(type)
       end
     end
 
     # Override load_attributes to handle the Customer case
-    def load_attributes(id = nil, model_type = 'Customer')
-      query = graphql_query(model_type)
+    def load_attributes(model_type_or_id = nil, id = nil)
+      # Handle both old and new signatures like the parent class
+      if id.nil? && model_type_or_id.is_a?(String) && model_type_or_id != self.class.graphql_type
+        # Old signature: load_attributes(model_type)
+        type = model_type_or_id
+        actual_id = nil
+      elsif id.nil?
+        # New signature: load_attributes() or load_attributes(id) - but for Customer, we don't need ID
+        type = self.class.graphql_type
+        actual_id = model_type_or_id
+      else
+        # Old signature: load_attributes(model_type, id)
+        type = model_type_or_id
+        actual_id = id
+      end
+
+      query = graphql_query(type)
 
       # For Customer queries, we don't need variables; for others, we need the ID
-      variables = model_type == 'Customer' ? {} : { id: id }
+      variables = type == 'Customer' ? {} : { id: actual_id }
 
       response_data = execute_graphql_query(query, **variables)
 
@@ -46,9 +62,10 @@ def execute_graphql_query(query, **variables)
     end
 
     # Builds a customer-only query (no ID parameter needed)
-    def customer_only_query(model_type)
-      query_name_value = query_name(model_type)
-      fragment_name_value = fragment_name(model_type)
+    def customer_only_query(model_type = nil)
+      type = model_type || self.class.graphql_type
+      query_name_value = query_name(type)
+      fragment_name_value = fragment_name(type)
 
       <<~GRAPHQL
         #{fragment}

lib/active_shopify_graphql/finder_methods.rb

@@ -12,7 +12,7 @@ module FinderMethods
       def find(id, loader: default_loader)
         gid = URI::GID.build(app: "shopify", model_name: model_name.name.demodulize, model_id: id)
         model_type = name.demodulize
-        attributes = loader.load_attributes(gid, model_type)
+        attributes = loader.load_attributes(model_type, gid)
 
         return nil if attributes.nil?
 
@@ -35,6 +35,48 @@ def default_loader=(loader)
         @default_loader = loader
       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
+
+        model_type = name.demodulize
+        attributes_array = loader.load_collection(model_type, conditions, limit: limit)
+
+        attributes_array.map { |attributes| new(attributes) }
+      end
+
       private
 
       # Infers the loader class name from the model name