active_shopify_graphql 0.1.0

data/lib/active_shopify_graphql/response_mapper.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  # Handles mapping GraphQL responses to model attributes.
+  # Refactored to use LoaderContext and unified mapping methods.
+  class ResponseMapper
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    # Map GraphQL response to attributes using declared attribute metadata
+    # @param response_data [Hash] The full GraphQL response
+    # @param root_path [Array<String>] Path to the data root (e.g., ["data", "customer"])
+    # @return [Hash] Mapped attributes
+    def map_response(response_data, root_path: nil)
+      root_path ||= ["data", @context.query_name]
+      root_data = response_data.dig(*root_path)
+      return {} unless root_data
+
+      map_node_to_attributes(root_data)
+    end
+
+    # Map a single node's data to attributes (used for both root and nested)
+    def map_node_to_attributes(node_data)
+      return {} unless node_data
+
+      result = {}
+      @context.defined_attributes.each do |attr_name, config|
+        value = extract_and_transform_value(node_data, config, attr_name)
+        result[attr_name] = value
+      end
+      result
+    end
+
+    # Extract connection data from GraphQL response for eager loading
+    def extract_connection_data(response_data, root_path: nil)
+      return {} if @context.included_connections.empty?
+
+      root_path ||= ["data", @context.query_name]
+      root_data = response_data.dig(*root_path)
+      return {} unless root_data
+
+      extract_connections_from_node(root_data)
+    end
+
+    # Extract connections from a node (reusable for nested connections)
+    def extract_connections_from_node(node_data)
+      return {} if @context.included_connections.empty?
+
+      connections = @context.connections
+      return {} if connections.empty?
+
+      normalized_includes = FragmentBuilder.normalize_includes(@context.included_connections)
+      connection_cache = {}
+
+      normalized_includes.each do |connection_name, nested_includes|
+        connection_config = connections[connection_name]
+        next unless connection_config
+
+        records = extract_connection_records(node_data, connection_config, nested_includes)
+        connection_cache[connection_name] = records if records
+      end
+
+      connection_cache
+    end
+
+    # Map nested connection response (when loading via parent query)
+    def map_nested_connection_response(response_data, connection_field_name, parent, connection_config = nil)
+      parent_type = parent.class.graphql_type_for_loader(@context.loader_class)
+      parent_query_name = parent_type.downcase
+      connection_type = connection_config&.dig(:type) || :connection
+
+      if connection_type == :singular
+        node_data = response_data.dig("data", parent_query_name, connection_field_name)
+        return nil unless node_data
+
+        build_model_instance(node_data)
+      else
+        edges = response_data.dig("data", parent_query_name, connection_field_name, "edges")
+        return [] unless edges
+
+        edges.filter_map do |edge|
+          node_data = edge["node"]
+          build_model_instance(node_data) if node_data
+        end
+      end
+    end
+
+    # Map root connection response
+    def map_connection_response(response_data, query_name, connection_config = nil)
+      connection_type = connection_config&.dig(:type) || :connection
+
+      if connection_type == :singular
+        node_data = response_data.dig("data", query_name)
+        return nil unless node_data
+
+        build_model_instance(node_data)
+      else
+        edges = response_data.dig("data", query_name, "edges")
+        return [] unless edges
+
+        edges.filter_map do |edge|
+          node_data = edge["node"]
+          build_model_instance(node_data) if node_data
+        end
+      end
+    end
+
+    private
+
+    def extract_and_transform_value(node_data, config, attr_name)
+      path_parts = config[:path].split('.')
+      value = node_data.dig(*path_parts)
+
+      value = apply_defaults_and_transforms(value, config)
+      validate_null_constraint!(value, config, attr_name)
+      coerce_value(value, config[:type])
+    end
+
+    def apply_defaults_and_transforms(value, config)
+      if value.nil?
+        return config[:default] unless config[:default].nil?
+
+        return config[:transform]&.call(value)
+      end
+
+      config[:transform] ? config[:transform].call(value) : value
+    end
+
+    def validate_null_constraint!(value, config, attr_name)
+      return unless !config[:null] && value.nil?
+
+      raise ArgumentError, "Attribute '#{attr_name}' (GraphQL path: '#{config[:path]}') cannot be null but received nil"
+    end
+
+    def coerce_value(value, type)
+      return nil if value.nil?
+      return value if value.is_a?(Array) # Preserve arrays
+
+      type_caster(type).cast(value)
+    end
+
+    def type_caster(type)
+      case type
+      when :string   then ActiveModel::Type::String.new
+      when :integer  then ActiveModel::Type::Integer.new
+      when :float    then ActiveModel::Type::Float.new
+      when :boolean  then ActiveModel::Type::Boolean.new
+      when :datetime then ActiveModel::Type::DateTime.new
+      else ActiveModel::Type::Value.new
+      end
+    end
+
+    def extract_connection_records(node_data, connection_config, nested_includes)
+      query_name = connection_config[:query_name]
+      connection_type = connection_config[:type] || :connection
+      target_class = connection_config[:class_name].constantize
+
+      if connection_type == :singular
+        item_data = node_data[query_name]
+        return nil unless item_data
+
+        build_nested_model_instance(item_data, target_class, nested_includes)
+      else
+        edges = node_data.dig(query_name, "edges")
+        return nil unless edges
+
+        edges.filter_map do |edge|
+          item_data = edge["node"]
+          build_nested_model_instance(item_data, target_class, nested_includes) if item_data
+        end
+      end
+    end
+
+    def build_model_instance(node_data)
+      return nil unless node_data
+
+      attributes = map_node_to_attributes(node_data)
+      @context.model_class.new(attributes)
+    end
+
+    def build_nested_model_instance(node_data, target_class, nested_includes)
+      nested_context = @context.for_model(target_class, new_connections: nested_includes)
+      nested_mapper = ResponseMapper.new(nested_context)
+
+      attributes = nested_mapper.map_node_to_attributes(node_data)
+      instance = target_class.new(attributes)
+
+      # Handle nested connections recursively
+      if nested_includes.any?
+        nested_data = nested_mapper.extract_connections_from_node(node_data)
+        nested_data.each do |nested_name, nested_records|
+          instance.send("#{nested_name}=", nested_records)
+        end
+      end
+
+      instance
+    end
+  end
+end

data/lib/active_shopify_graphql/search_query.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveShopifyGraphQL
+  # Represents a Shopify search query, converting Ruby conditions into Shopify's search syntax
+  class SearchQuery
+    def initialize(conditions = {})
+      @conditions = conditions
+    end
+
+    # Converts conditions to Shopify search query string
+    # @return [String] The Shopify query string
+    def to_s
+      return "" if @conditions.empty?
+
+      query_parts = @conditions.map do |key, value|
+        format_condition(key.to_s, value)
+      end
+
+      query_parts.join(" AND ")
+    end
+
+    private
+
+    # Formats a single query condition into Shopify's query syntax
+    # @param key [String] The attribute name
+    # @param value [Object] The attribute value
+    # @return [String] The formatted query condition
+    def format_condition(key, value)
+      case value
+      when String
+        format_string_condition(key, value)
+      when Numeric, true, false
+        "#{key}:#{value}"
+      when Hash
+        format_range_condition(key, value)
+      else
+        "#{key}:#{value}"
+      end
+    end
+
+    # Formats a string condition with proper quoting
+    def format_string_condition(key, value)
+      # Handle special string values and escape quotes
+      if value.include?(" ") && !value.start_with?('"')
+        # Multi-word values should be quoted
+        "#{key}:\"#{value.gsub('"', '\\"')}\""
+      else
+        "#{key}:#{value}"
+      end
+    end
+
+    # Formats a range condition (e.g., { created_at: { gte: '2024-01-01' } })
+    def format_range_condition(key, value)
+      range_parts = value.map do |operator, range_value|
+        case operator.to_sym
+        when :gt, :>
+          "#{key}:>#{range_value}"
+        when :gte, :>=
+          "#{key}:>=#{range_value}"
+        when :lt, :<
+          "#{key}:<#{range_value}"
+        when :lte, :<=
+          "#{key}:<=#{range_value}"
+        else
+          raise ArgumentError, "Unsupported range operator: #{operator}"
+        end
+      end
+      range_parts.join(" ")
+    end
+  end
+end

data/lib/active_shopify_graphql/version.rb

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

data/lib/active_shopify_graphql.rb

@@ -0,0 +1,34 @@
+# 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/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/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"
+
+module ActiveShopifyGraphQL
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: active_shopify_graphql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicolò Rebughini
+autorequire:
+bindir: exe
+cert_chain: []
+date:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+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.
+email:
+- nicolorebughini@nebulab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/lint.yml"
+- ".github/workflows/test.yml"
+- ".rubocop.yml"
+- AGENTS.md
+- LICENSE.txt
+- 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_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/loader.rb
+- lib/active_shopify_graphql/loader_context.rb
+- lib/active_shopify_graphql/loader_switchable.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/search_query.rb
+- lib/active_shopify_graphql/version.rb
+homepage: https://github.com/nebulab/active_shopify_graphql
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nebulab/active_shopify_graphql
+  source_code_uri: https://github.com/nebulab/active_shopify_graphql
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: An ActiveRecord-like interface for Shopify GraphQL APIs
+test_files: []