active_shopify_graphql 0.3.0 → 0.5.0

data/lib/active_shopify_graphql/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveShopifyGraphQL
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/active_shopify_graphql.rb

@@ -1,35 +1,37 @@
 # 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 "active_support"
+require "active_support/concern"
+require "active_model"
+require "active_model/attribute_assignment"
+require "active_model/validations"
+require "active_model/naming"
+require "globalid"
 
-require_relative "active_shopify_graphql/version"
-require_relative "active_shopify_graphql/configuration"
-require_relative "active_shopify_graphql/gid_helper"
-require_relative "active_shopify_graphql/graphql_type_resolver"
-require_relative "active_shopify_graphql/loader_context"
-require_relative "active_shopify_graphql/query_node"
-require_relative "active_shopify_graphql/fragment_builder"
-require_relative "active_shopify_graphql/query_tree"
-require_relative "active_shopify_graphql/response_mapper"
-require_relative "active_shopify_graphql/connection_loader"
-require_relative "active_shopify_graphql/loader"
-require_relative "active_shopify_graphql/loaders/admin_api_loader"
-require_relative "active_shopify_graphql/loaders/customer_account_api_loader"
-require_relative "active_shopify_graphql/loader_switchable"
-require_relative "active_shopify_graphql/finder_methods"
-require_relative "active_shopify_graphql/associations"
-require_relative "active_shopify_graphql/includes_scope"
-require_relative "active_shopify_graphql/connections"
-require_relative "active_shopify_graphql/attributes"
-require_relative "active_shopify_graphql/metafield_attributes"
-require_relative "active_shopify_graphql/search_query"
-require_relative "active_shopify_graphql/base"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "active_shopify_graphql" => "ActiveShopifyGraphQL",
+  "graphql_associations" => "GraphQLAssociations"
+)
+loader.setup
 
 module ActiveShopifyGraphQL
   class Error < StandardError; end
+  class ObjectNotFoundError < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    # Reset configuration (useful for testing)
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_shopify_graphql
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Nicolò Rebughini
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.6'
 description: ActiveShopifyGraphQL provides an ActiveRecord-like interface for interacting
   with Shopify's GraphQL APIs, supporting both Admin API and Customer Account API
   with automatic query building and response mapping.
@@ -69,28 +83,46 @@ files:
 - README.md
 - Rakefile
 - lib/active_shopify_graphql.rb
-- lib/active_shopify_graphql/associations.rb
-- lib/active_shopify_graphql/attributes.rb
-- lib/active_shopify_graphql/base.rb
 - lib/active_shopify_graphql/configuration.rb
-- lib/active_shopify_graphql/connection_loader.rb
-- lib/active_shopify_graphql/connections.rb
+- lib/active_shopify_graphql/connections/connection_loader.rb
 - lib/active_shopify_graphql/connections/connection_proxy.rb
-- lib/active_shopify_graphql/finder_methods.rb
-- lib/active_shopify_graphql/fragment_builder.rb
 - lib/active_shopify_graphql/gid_helper.rb
-- lib/active_shopify_graphql/graphql_type_resolver.rb
-- lib/active_shopify_graphql/includes_scope.rb
+- lib/active_shopify_graphql/graphql_associations.rb
 - lib/active_shopify_graphql/loader.rb
 - lib/active_shopify_graphql/loader_context.rb
-- lib/active_shopify_graphql/loader_switchable.rb
+- lib/active_shopify_graphql/loader_proxy.rb
 - lib/active_shopify_graphql/loaders/admin_api_loader.rb
 - lib/active_shopify_graphql/loaders/customer_account_api_loader.rb
-- lib/active_shopify_graphql/metafield_attributes.rb
-- lib/active_shopify_graphql/query_node.rb
-- lib/active_shopify_graphql/query_tree.rb
-- lib/active_shopify_graphql/response_mapper.rb
+- lib/active_shopify_graphql/model.rb
+- lib/active_shopify_graphql/model/associations.rb
+- lib/active_shopify_graphql/model/attributes.rb
+- lib/active_shopify_graphql/model/connections.rb
+- lib/active_shopify_graphql/model/finder_methods.rb
+- lib/active_shopify_graphql/model/graphql_type_resolver.rb
+- lib/active_shopify_graphql/model/loader_switchable.rb
+- lib/active_shopify_graphql/model/metafield_attributes.rb
+- lib/active_shopify_graphql/model_builder.rb
+- lib/active_shopify_graphql/query/node.rb
+- lib/active_shopify_graphql/query/node/collection.rb
+- lib/active_shopify_graphql/query/node/connection.rb
+- lib/active_shopify_graphql/query/node/current_customer.rb
+- lib/active_shopify_graphql/query/node/field.rb
+- lib/active_shopify_graphql/query/node/fragment.rb
+- lib/active_shopify_graphql/query/node/nested_connection.rb
+- lib/active_shopify_graphql/query/node/raw.rb
+- lib/active_shopify_graphql/query/node/root_connection.rb
+- lib/active_shopify_graphql/query/node/single_record.rb
+- lib/active_shopify_graphql/query/node/singular.rb
+- lib/active_shopify_graphql/query/query_builder.rb
+- lib/active_shopify_graphql/query/relation.rb
+- lib/active_shopify_graphql/query/scope.rb
+- lib/active_shopify_graphql/response/page_info.rb
+- lib/active_shopify_graphql/response/paginated_result.rb
+- lib/active_shopify_graphql/response/response_mapper.rb
 - lib/active_shopify_graphql/search_query.rb
+- lib/active_shopify_graphql/search_query/hash_condition_formatter.rb
+- lib/active_shopify_graphql/search_query/parameter_binder.rb
+- lib/active_shopify_graphql/search_query/value_sanitizer.rb
 - lib/active_shopify_graphql/version.rb
 homepage: https://github.com/nebulab/active_shopify_graphql
 licenses:

data/lib/active_shopify_graphql/associations.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  # Handles associations between ActiveShopifyGraphQL objects and ActiveRecord objects
-  module Associations
-    extend ActiveSupport::Concern
-
-    included do
-      class << self
-        attr_accessor :associations
-      end
-
-      self.associations = {}
-    end
-
-    class_methods do
-      def has_many(name, class_name: nil, foreign_key: nil, primary_key: nil)
-        association_class_name = class_name || name.to_s.classify
-        association_foreign_key = foreign_key || "shopify_#{model_name.element.downcase}_id"
-        association_primary_key = primary_key || :id
-
-        # Store association metadata
-        associations[name] = {
-          type: :has_many,
-          class_name: association_class_name,
-          foreign_key: association_foreign_key,
-          primary_key: association_primary_key
-        }
-
-        # Define the association method
-        define_method name do
-          return @_association_cache[name] if @_association_cache&.key?(name)
-
-          @_association_cache ||= {}
-
-          primary_key_value = send(association_primary_key)
-          return @_association_cache[name] = [] if primary_key_value.blank?
-
-          # Extract numeric ID from Shopify GID if needed
-          primary_key_value = primary_key_value.to_plain_id if primary_key_value.gid?
-
-          association_class = association_class_name.constantize
-          @_association_cache[name] = association_class.where(association_foreign_key => primary_key_value)
-        end
-
-        # Define the association setter method for testing/mocking
-        define_method "#{name}=" do |value|
-          @_association_cache ||= {}
-          @_association_cache[name] = value
-        end
-      end
-
-      def has_one(name, class_name: nil, foreign_key: nil, primary_key: nil)
-        association_class_name = class_name || name.to_s.classify
-        association_foreign_key = foreign_key || "shopify_#{model_name.element.downcase}_id"
-        association_primary_key = primary_key || :id
-
-        # Store association metadata
-        associations[name] = {
-          type: :has_one,
-          class_name: association_class_name,
-          foreign_key: association_foreign_key,
-          primary_key: association_primary_key
-        }
-
-        # Define the association method
-        define_method name do
-          return @_association_cache[name] if @_association_cache&.key?(name)
-
-          @_association_cache ||= {}
-
-          primary_key_value = send(association_primary_key)
-          return @_association_cache[name] = nil if primary_key_value.blank?
-
-          # Extract numeric ID from Shopify GID if needed
-          primary_key_value = primary_key_value.to_plain_id if primary_key_value.gid?
-
-          association_class = association_class_name.constantize
-          @_association_cache[name] = association_class.find_by(association_foreign_key => primary_key_value)
-        end
-
-        # Define the association setter method for testing/mocking
-        define_method "#{name}=" do |value|
-          @_association_cache ||= {}
-          @_association_cache[name] = value
-        end
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/attributes.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveShopifyGraphQL
-  module Attributes
-    extend ActiveSupport::Concern
-
-    class_methods do
-      # Define an attribute with automatic GraphQL path inference and type coercion.
-      #
-      # @param name [Symbol] The Ruby attribute name
-      # @param path [String] The GraphQL field path (auto-inferred if not provided)
-      # @param type [Symbol] The type for coercion (:string, :integer, :float, :boolean, :datetime)
-      # @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
-      # @param raw_graphql [String] Raw GraphQL string to inject directly (escape hatch for unsupported features)
-      def attribute(name, path: nil, type: :string, null: true, default: nil, transform: nil, raw_graphql: nil)
-        path ||= infer_path(name)
-        config = { path: path, type: type, null: null, default: default, transform: transform, raw_graphql: raw_graphql }
-
-        if @current_loader_context
-          # Store in loader-specific context
-          @loader_contexts[@current_loader_context][name] = config
-        else
-          # Store in base attributes
-          @base_attributes ||= {}
-          @base_attributes[name] = config
-        end
-
-        # Always create attr_accessor
-        attr_accessor name unless method_defined?(name) || method_defined?("#{name}=")
-      end
-
-      # Get attributes for a specific loader class, merging base with loader-specific overrides.
-      def attributes_for_loader(loader_class)
-        base = @base_attributes || {}
-        overrides = @loader_contexts&.dig(loader_class) || {}
-
-        base.merge(overrides) { |_key, base_val, override_val| base_val.merge(override_val) }
-      end
-
-      private
-
-      # Infer GraphQL path from Ruby attribute name (snake_case -> camelCase)
-      def infer_path(name)
-        name.to_s.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase }
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/connection_loader.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'global_id'
-
-module ActiveShopifyGraphQL
-  # Handles loading records for GraphQL connections.
-  # Refactored to use LoaderContext for cleaner parameter passing.
-  class ConnectionLoader
-    attr_reader :context
-
-    def initialize(context, loader_instance:)
-      @context = context
-      @loader_instance = loader_instance
-    end
-
-    # Load records for a connection query
-    # @param query_name [String] The connection field name (e.g., 'orders', 'addresses')
-    # @param variables [Hash] The GraphQL variables (first, sort_key, reverse, query)
-    # @param parent [Object] The parent object that owns this connection
-    # @param connection_config [Hash] The connection configuration
-    # @return [Array<Object>] Array of model instances
-    def load_records(query_name, variables, parent = nil, connection_config = nil)
-      is_nested = connection_config&.dig(:nested) || parent.respond_to?(:id)
-
-      if is_nested && parent
-        load_nested_connection(query_name, variables, parent, connection_config)
-      else
-        load_root_connection(query_name, variables, connection_config)
-      end
-    end
-
-    private
-
-    def load_nested_connection(query_name, variables, parent, connection_config)
-      parent_type = parent.class.graphql_type_for_loader(@context.loader_class)
-      parent_query_name = parent_type.camelize(:lower)
-      connection_type = connection_config&.dig(:type) || :connection
-
-      query = QueryTree.build_connection_query(
-        @context,
-        query_name: query_name,
-        variables: variables,
-        parent_query: "#{parent_query_name}(id: $id)",
-        connection_type: connection_type
-      )
-
-      parent_id = extract_gid(parent)
-      response_data = @loader_instance.perform_graphql_query(query, id: parent_id)
-
-      return [] if response_data.nil?
-
-      mapper = ResponseMapper.new(@context)
-      mapper.map_nested_connection_response(response_data, query_name, parent, connection_config)
-    end
-
-    def load_root_connection(query_name, variables, connection_config)
-      connection_type = connection_config&.dig(:type) || :connection
-
-      query = QueryTree.build_connection_query(
-        @context,
-        query_name: query_name,
-        variables: variables,
-        parent_query: nil,
-        connection_type: connection_type
-      )
-
-      response_data = @loader_instance.perform_graphql_query(query)
-
-      return [] if response_data.nil?
-
-      mapper = ResponseMapper.new(@context)
-      mapper.map_connection_response(response_data, query_name, connection_config)
-    end
-
-    def extract_gid(parent)
-      return parent.gid if parent.respond_to?(:gid) && !parent.gid.nil?
-
-      id_value = parent.id
-      parent_type = resolve_parent_type(parent)
-
-      GidHelper.normalize_gid(id_value, parent_type)
-    end
-
-    def resolve_parent_type(parent)
-      klass = parent.class
-
-      if klass.respond_to?(:graphql_type_for_loader)
-        klass.graphql_type_for_loader(@context.loader_class)
-      elsif klass.respond_to?(:graphql_type)
-        klass.graphql_type
-      else
-        klass.name
-      end
-    end
-  end
-end

data/lib/active_shopify_graphql/connections.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "connections/connection_proxy"
-
-module ActiveShopifyGraphQL
-  module Connections
-    extend ActiveSupport::Concern
-
-    included do
-      class << self
-        attr_accessor :connections
-      end
-
-      self.connections = {}
-    end
-
-    class_methods do
-      # Define a singular connection (returns a single object)
-      # @see #connection
-      def has_one_connected(name, inverse_of: nil, **options)
-        connection(name, type: :singular, inverse_of: inverse_of, **options)
-      end
-
-      # Define a plural connection (returns a collection via edges)
-      # @see #connection
-      def has_many_connected(name, inverse_of: nil, **options)
-        connection(name, type: :connection, inverse_of: inverse_of, **options)
-      end
-
-      # Define a GraphQL connection to another ActiveShopifyGraphQL model
-      # @param name [Symbol] The connection name (e.g., :orders)
-      # @param class_name [String] The target model class name (defaults to name.to_s.classify)
-      # @param query_name [String] The GraphQL query field name (auto-determined based on nested/root-level)
-      # @param foreign_key [String] The field to filter by (auto-determined for root-level queries)
-      # @param loader_class [Class] Custom loader class to use (defaults to model's default loader)
-      # @param eager_load [Boolean] Whether to automatically eager load this connection (default: false)
-      # @param type [Symbol] The type of connection (:connection, :singular). Default is :connection.
-      # @param default_arguments [Hash] Default arguments to pass to the GraphQL query (e.g. first: 10)
-      # @param inverse_of [Symbol] The name of the inverse connection on the target model (optional)
-      def connection(name, class_name: nil, query_name: nil, foreign_key: nil, loader_class: nil, eager_load: false, type: :connection, default_arguments: {}, inverse_of: nil)
-        # Infer defaults
-        connection_class_name = class_name || name.to_s.classify
-
-        # Set query_name - default to camelCase for nested fields
-        connection_query_name = query_name || name.to_s.camelize(:lower)
-
-        connection_loader_class = loader_class
-
-        # Store connection metadata
-        connections[name] = {
-          class_name: connection_class_name,
-          query_name: connection_query_name,
-          foreign_key: foreign_key,
-          loader_class: connection_loader_class,
-          eager_load: eager_load,
-          type: type,
-          nested: true, # Always treated as nested (accessed via parent field)
-          target_class_name: connection_class_name,
-          original_name: name,
-          default_arguments: default_arguments,
-          inverse_of: inverse_of
-        }
-
-        # Validate inverse relationship if specified (validation is deferred to runtime)
-        validate_inverse_of!(name, connection_class_name, inverse_of) if inverse_of
-
-        # Define the connection method that returns a proxy
-        define_method name do |**options|
-          # Check if this connection was eager loaded
-          return @_connection_cache[name] if @_connection_cache&.key?(name)
-
-          config = self.class.connections[name]
-          if config[:type] == :singular
-            # Lazy load singular association
-            loader_class = config[:loader_class] || self.class.default_loader.class
-            target_class = config[:class_name].constantize
-            loader = loader_class.new(target_class)
-
-            # Load the record
-            records = loader.load_connection_records(config[:query_name], options, self, config)
-
-            # Populate inverse cache if inverse_of is specified
-            populate_inverse_cache_for_connection(records, config, self)
-
-            # Cache it
-            @_connection_cache ||= {}
-            @_connection_cache[name] = records
-            records
-          elsif options.empty?
-            # If no runtime options are provided, reuse existing proxy if it exists
-            @_connection_proxies ||= {}
-            @_connection_proxies[name] ||= ConnectionProxy.new(
-              parent: self,
-              connection_name: name,
-              connection_config: self.class.connections[name],
-              options: options
-            )
-          else
-            # Create a new proxy for custom options (don't cache these)
-            ConnectionProxy.new(
-              parent: self,
-              connection_name: name,
-              connection_config: self.class.connections[name],
-              options: options
-            )
-          end
-        end
-
-        # Define setter method for testing/caching
-        define_method "#{name}=" do |value|
-          @_connection_cache ||= {}
-          @_connection_cache[name] = value
-        end
-      end
-
-      # Load records with eager-loaded connections
-      # @param *connection_names [Symbol, Hash] The connection names to eager load
-      # @return [Class] A modified class for method chaining
-      #
-      # @example
-      #   Customer.includes(:orders).find(123)
-      #   Customer.includes(:orders, :addresses).where(email: "john@example.com")
-      #   Order.includes(line_items: :variant)
-      def includes(*connection_names)
-        # Validate connections exist
-        validate_includes_connections!(connection_names)
-
-        # Collect connections with eager_load: true
-        auto_included_connections = connections.select { |_name, config| config[:eager_load] }.keys
-
-        # Merge manual and automatic connections
-        all_included_connections = (connection_names + auto_included_connections).uniq
-
-        # Create a scope object that holds the included connections
-        IncludesScope.new(self, all_included_connections)
-      end
-
-      private
-
-      def validate_inverse_of!(_name, _target_class_name, _inverse_name)
-        # Validation is deferred until runtime when connections are actually used
-        # This allows class definitions to be in any order
-        # The validation logic will be checked when inverse cache is populated
-        nil
-      end
-
-      def validate_includes_connections!(connection_names)
-        connection_names.each do |name|
-          if name.is_a?(Hash)
-            name.each do |key, value|
-              raise ArgumentError, "Invalid connection for #{self.name}: #{key}. Available connections: #{connections.keys.join(', ')}" unless connections.key?(key.to_sym)
-
-              # Recursively validate nested connections
-              target_class = connections[key.to_sym][:class_name].constantize
-              if target_class.respond_to?(:validate_includes_connections!, true)
-                nested_names = value.is_a?(Array) ? value : [value]
-                target_class.send(:validate_includes_connections!, nested_names)
-              end
-            end
-          else
-            raise ArgumentError, "Invalid connection for #{self.name}: #{name}. Available connections: #{connections.keys.join(', ')}" unless connections.key?(name.to_sym)
-          end
-        end
-      end
-    end
-
-    # Instance method to populate inverse cache for lazy-loaded connections
-
-    def populate_inverse_cache_for_connection(records, connection_config, parent)
-      return unless connection_config[:inverse_of]
-      return if records.nil? || (records.is_a?(Array) && records.empty?)
-
-      inverse_name = connection_config[:inverse_of]
-      target_class = connection_config[:class_name].constantize
-
-      # Ensure target class has the inverse connection defined
-      return unless target_class.respond_to?(:connections) && target_class.connections[inverse_name]
-
-      inverse_type = target_class.connections[inverse_name][:type]
-      records_array = records.is_a?(Array) ? records : [records]
-
-      records_array.each do |record|
-        next unless record
-
-        record.instance_variable_set(:@_connection_cache, {}) unless record.instance_variable_get(:@_connection_cache)
-        cache = record.instance_variable_get(:@_connection_cache)
-
-        cache[inverse_name] =
-          if inverse_type == :singular
-            parent
-          else
-            # For collection inverses, wrap parent in an array
-            [parent]
-          end
-      end
-    end
-  end
-end