e_plat 0.6.0 → 0.7.0

data/lib/e_plat/resource/collection.rb

@@ -2,41 +2,52 @@
 
 module EPlat
 	class Collection < ActiveResource::Collection
+		SHOPIFY_GRAPHQL_PAGINATABLE_CLASSES = %w(
+			EPlat::Product
+			EPlat::Product::Variant
+			EPlat::Shopify::Product
+			EPlat::Shopify::Product::Variant
+		)
 
 		def initialize(parsed = {})
 			super parsed
 		end
 
 		def next_page?
-			return unless pagination_available?
-			@next_url.present?
+			return false unless pagination_available?
+			@next.present?
 		end
 
 		def previous_page?
-			return unless pagination_available?
-			@previous_url.present?
+			return false unless pagination_available?
+			@previous.present?
 		end
 
 		def next_page_info
 			return unless pagination_available?
-			extract_page_info(@next_url)
+			extract_page_info(@next)
 		end
 	
 		def previous_page_info
 			return unless pagination_available?
-			extract_page_info(@previous_url)
+			extract_page_info(@previous)
 		end
 
 		def fetch_next_page
 			return unless pagination_available?
-			fetch_page(@next_url)
+			fetch_page(@next)
 		end
 
 		def fetch_previous_page
 			return unless pagination_available?
-			fetch_page(@previous_url)
+			fetch_page(@previous)
 		end
+		
+		def paginates_via_graphql?
+			return unless SHOPIFY_GRAPHQL_PAGINATABLE_CLASSES.include? resource_class.to_s
 
+			client.shopify? && client.api_version != "2024_01"
+		end
 		
 		private
 
@@ -44,10 +55,17 @@ module EPlat
 			return [] unless url.present?
 			url = "#{ resource_class.collection_path }#{ url }" if client.bigcommerce?
 
-			resource_class.all(from: url)
+			if paginates_via_graphql?
+				arg_name = (url == @next) ? "after" : "before"
+				resource_class.find(:all, params: {arg_name => url})
+			else
+				resource_class.all(from: url)
+			end
 		end
 
 		def pagination_links
+			return pagination_cursors if paginates_via_graphql?
+
 			case client.platform
 			when :shopify
 				@pagination_links ||= EPlat::Paginated::LinkHeaders.new(
@@ -67,17 +85,28 @@ module EPlat
 			end
 		end
 
-		def pagination_available?
-			@next_url 	  = pagination_links&.next_link&.url&.to_s
-			@previous_url = pagination_links&.previous_link&.url&.to_s
+		def pagination_cursors
+			response_body = JSON.parse(full_response.body)
+			page_info     = response_body.dig("data", resource_class.graphql_collection_name, "pageInfo") || {}
+
+			earliest_cursor = page_info["hasPreviousPage"] ? page_info["startCursor"] : nil
+			latest_cursor 	= page_info["hasNextPage"]     ? page_info["endCursor"]   : nil
 
-			@next_url.present? or @previous_url.present?
+			[earliest_cursor, latest_cursor]
+		end
+
+		def pagination_available?
+			@previous = (paginates_via_graphql?) ? pagination_cursors[0] : pagination_links&.previous_link&.url&.to_s
+			@next 	  = (paginates_via_graphql?) ? pagination_cursors[1] : pagination_links&.next_link&.url&.to_s
+			
+			@next.present? or @previous.present?
 		end
 
-		def extract_page_info(url)
-			return unless url.present?
+		def extract_page_info(request_data)
+			return unless request_data.present?
+			return request_data if paginates_via_graphql?
 
-			query_params = URI.decode_www_form(URI(url).query).to_h 
+			query_params = URI.decode_www_form(URI(request_data).query).to_h 
 			query_params[client.pagination_param]
 		end
 

data/lib/e_plat/resource/concerns/aliases.rb

@@ -8,33 +8,35 @@ module EPlat
 		 				
 			def add_aliases!(aliases, type_schema)
 				@type_coercer = EPlat::TypeCoercer.new(type_schema)
-				processed = []
+				processed = { getter: [], setter: [] }
 
 				aliases.each do |action|
-					action_name = action.keys.first
-					args 		= action.values.first
-					e_plat_key	= args[:e_plat_key]
-					native_key	= args[:native_key]
-					@is_virtual = args[:virtual_collection]
+					action_name, args 	   = action.keys.first, action.values.first
+					e_plat_key, native_key = args[:e_plat_key], args[:native_key]
+					@is_virtual = !!args[:virtual_collection]
 
 					case action_name
 					when :alias_attribute
 						add_to_instance! alias_mapped_getter(e_plat_key, native_key, proc: args[:custom_e_plat_getter])
 						add_to_instance! alias_mapped_setter(e_plat_key, native_key, proc: args[:custom_native_setter])
-						# puts alias_mapped_setter(e_plat_key, native_key, proc: args[:custom_native_setter]) if e_plat_key == 'variant_id'
-						processed << e_plat_key
+						processed[:getter] << e_plat_key
+						processed[:setter] << e_plat_key
+					when :existing_entry
+						add_to_instance! mapped_getter(e_plat_key, proc: args[:custom_e_plat_getter])
+						add_to_instance! native_setter(native_key, proc: args[:custom_native_setter])
+						processed[:getter] << e_plat_key
+						processed[:setter] << native_key
 					end
 				end
 				
 				type_schema.each do |e_plat_key, type|
-					next if processed.include?(e_plat_key)
+					next if processed[:getter].include?(e_plat_key)
 					add_to_instance! mapped_getter(e_plat_key), @is_virtual
 				end
 
 				native_keys.each do |native_key|
-					next if processed.include?(native_key)
-
-					add_to_instance! native_setter(native_key), @is_virtual
+					add_to_instance!(mapped_getter(native_key), @is_virtual) unless processed[:getter].include?(native_key)
+					add_to_instance!(native_setter(native_key), @is_virtual) unless processed[:setter].include?(native_key)
 				end
 			end
 			
@@ -42,7 +44,7 @@ module EPlat
 			private 
 
 			
-				def alias_mapped_getter(e_plat_key, native_key, proc: nil)
+				def alias_mapped_getter(e_plat_key, native_key, proc: '->{_1}')
 					proc_line = (proc) ? "current_value = #{ proc.strip }.call(current_value)" : nil
 					
 					<<-STRING
@@ -54,7 +56,7 @@ module EPlat
 					STRING
 				end
 				
-				def alias_mapped_setter(e_plat_key, native_key, proc: nil)
+				def alias_mapped_setter(e_plat_key, native_key, proc: '->{_1}')
 					proc_line = (proc) ? "new_value = #{ proc.strip }.call(new_value)" : nil
 					
 					<<-STRING
@@ -71,19 +73,28 @@ module EPlat
 					STRING
 				end
 				
-				def mapped_getter(e_plat_key)
+				def mapped_getter(e_plat_key, proc: '->{_1}')
+					proc_line = (proc) ? "value = #{ proc.strip }.call(value)" : nil
+
 					<<-STRING
 						def #{ e_plat_key }
-							type_coercer.type_value!('#{ e_plat_key }', self.attributes['#{ e_plat_key }'])
+							value = self.attributes['#{ e_plat_key }']
+							#{ proc_line }
+							type_coercer.type_value!('#{ e_plat_key }', value)
 						end
 					STRING
 				end
 
-				def native_setter(native_key)
+				# we force the native_setter result into changed_attributes, incase the key is the same as the e_plat key
+				# we dont want the eplat version of the value in change_attributes, we want the native version.
+				def native_setter(native_key, proc: '->{_1}')
+					proc_line = (proc) ? "value = #{ proc.strip }.call(value)" : nil
+
 					<<-STRING
 						def #{native_key}=(value)
+							#{proc_line}
 							super
-							attribute_will_change!('#{native_key}')
+							attribute_will_change!('#{native_key}', force_value: value) 
 						end
 					STRING
 				end
@@ -136,8 +147,17 @@ module EPlat
 						change_statements << change_statement 
 					end 
 
+					method_chain_array = method_chain.split(".").compact_blank
+					will_change_statement = 
+						if method_chain_array.one? or @is_virtual
+							"attribute_will_change!('#{method_chain_array.last}')"
+						elsif method_chain_array.many?
+							method_chain_array[-1] = "attribute_will_change!('#{method_chain_array.last}')"
+							"#{method_chain_array.join('.')}"
+						end
+
 					<<-STRING
-						attribute_will_change!('#{parts.last}')
+						#{ will_change_statement }
 						#{change_statements.join("\n")}
 					STRING
 				end

data/lib/e_plat/resource/concerns/dirty.rb

@@ -11,16 +11,20 @@ module EPlat
 					@changed_attributes ||= {}
 				end
 
-				def attribute_will_change!(attr)
+				# attribute will change adds to changed_attributes. 
+				# We support a force_value option, so we can bipass the getter if the e_plat key is the same as the native key
+				# this lets us pass in the native_setter result directly from native_attribute_will_change!
+				def attribute_will_change!(attr, force_value: nil)
 					changed_attributes[attr] = read_attribute(attr)
-
-					native_keys.include?(attr) ? e_plat_attribute_will_change!(attr) : native_attribute_will_change!(attr)
+					
+					native_keys.include?(attr) ? e_plat_attribute_will_change!(attr, force_value:) : native_attribute_will_change!(attr, force_value:)
 				end
 
 				def attribute_changed?(attr)
 					changed_attributes.include?(attr)
 				end
 
+
 				def read_attribute(attr)
 					self.send(attr)
 				end
@@ -33,18 +37,18 @@ module EPlat
 
 				private
 
-				def native_attribute_will_change!(eplat_attr)
+				def native_attribute_will_change!(eplat_attr, force_value: nil)
 					key = self.mapping.native_key_to(eplat_attr)
 					return unless key && self.respond_to?(key)
 
-					changed_attributes[key] = send(key)
+					changed_attributes[key] = force_value || send(key)
 				end
 
-				def e_plat_attribute_will_change!(native_attr)
+				def e_plat_attribute_will_change!(native_attr, force_value: nil)
 					key = self.mapping.e_plat_key_to(native_attr)
 					return unless key && self.respond_to?(key)
-					
-					changed_attributes[key] = send(key)
+		
+					changed_attributes[key] = force_value || send(key)
 				end
 			end
 

data/lib/e_plat/resource/concerns/graph_q_lable.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module EPlat
+    module Concerns::GraphQLable
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :before_graphql_callbacks, default: {}
+        end
+
+        FILTER_ARGS    = [:id, :after, :before, :last, :first].freeze
+        QUERY_ARG_ARGS = [:available_for_sale, :created_at, :product_type, :product_id, :tag, :tag_not, :title, :updated_at, :vendor].freeze
+
+        class_methods do
+
+            def requests_via_graphql(with: {}, **options)
+                return if (options[:unless] && options[:unless].call)
+
+                with.each do |action, graphql_proc|
+                    graphql_proc = graphql_proc.gsub("{API_VERSION}", EPlat.shopify_graphql_version)
+                    
+                    if graphql_proc.to_s.include?("::Query")
+                        define_singleton_graphql_method(action, graphql_proc)
+                    elsif graphql_proc.to_s.include?("::Mutation")
+                        define_instance_graphql_method(action, graphql_proc)
+                    else
+                        raise EPlat::Error.new("Invalid graphql request type")
+                    end
+                end
+            end
+
+            def add_to_graphql_requests(action, graphql_proc)
+                before_graphql_callbacks[action] = graphql_proc
+            end
+
+            def define_singleton_graphql_method(action, graphql_proc)
+                define_singleton_method(action) do |*args|
+                    initialize_singleton!
+                    query_graphql(action, graphql_proc, *args)
+                end
+            end
+
+            def define_instance_graphql_method(action, graphql_proc)
+                define_method(action) do |*args|
+                    self.class.initialize_singleton!
+                    mutate_graphql(action, graphql_proc, *args)
+                end
+            end
+            
+            def query_graphql(action, graphql_proc, *args)
+                graphql = eval graphql_proc
+                args    = scope_with_options_hash(args, action)
+
+                response = execute_graphql_request graphql_query_with_args(graphql, args)
+
+                if !response.is_a?(Hash)
+                    raise EPlat::GraphqlError.new(response.first["message"])
+                elsif response["errors"]
+                    raise EPlat::GraphqlError.new(response["errors"].first["message"])
+                else
+                    case action
+                    when :find_one, :find_single
+                        instantiate_record     resources_parsed_from(response)
+                    else
+                        instantiate_collection resources_parsed_from(response)
+                    end
+                end
+            rescue StandardError => e
+                raise EPlat::GraphqlError.new(e.message)
+            end
+
+            def execute_graphql_request(graphql_string)
+                puts graphql_string if EPlat.config.print_graphql_requests
+
+                format.decode connection.post(
+                    client.graphql_request_url,
+                    { query: graphql_string }.to_json,
+                    headers
+                ).body
+            end
+
+            #utils
+
+            def scope_with_options_hash(args, action)
+                if args.length > 1
+                    scope, options = args.slice!(0), args.slice!(0)
+                elsif args.first.is_a?(Hash)
+                    scope, options = nil, args.slice!(0) || {}
+                else
+                    scope, options = args.slice!(0), {}
+                end
+
+                scope_arg = 
+                    case action
+                    when :find_single
+                        {id: formatted_id(scope)}
+                    when :find_one
+                        {first: 1}
+                    when :find_every
+                        {first: scope || 200}
+                    end
+                
+                (options[:params] || {}).with_defaults(scope_arg)
+            end
+
+            def graphql_query_with_args(graphql, args)
+                params = filter_graphql_args(**args).merge(
+                    query: graphql_query_arg(**args)
+                ).compact_blank
+
+                graphql.call(params.to_graphql_args)
+            end
+
+            def filter_graphql_args(**args)
+                arguments = sanitize_filter_args args.with_indifferent_access
+
+                arguments.slice(*FILTER_ARGS).deep_stringify_keys
+            end
+
+            def sanitize_filter_args(args)
+                args.transform_keys!{|key| (key == "limit") ? "first" : key}
+                args.transform_keys!{|key| (key == "first") ? "last" : key} if args.include?("before")
+                args.delete("last") if args.include?("first") && args.include?("last")
+                
+                args
+            end
+
+            def graphql_query_arg(**args)
+                args.with_indifferent_access.slice(*QUERY_ARG_ARGS).to_shopify_graphql_query_string
+            end
+
+            def resources_parsed_from(response)
+                remove_nodes_from(response).then{remove_root_from _1}.then{ snake_case_keys _1}
+            end
+
+            def remove_nodes_from(data)
+                return data unless data.is_a?(Hash) or data.is_a?(Array)
+                
+                if data.is_a?(Array)
+                    return data.map { |item| remove_nodes_from(item) }
+                end
+
+                data.transform_values do |value|
+                    if value.is_a?(Hash) && value.key?('nodes')
+                        remove_nodes_from(value['nodes'])
+                    elsif value.is_a?(Array)
+                        value.map { |item| remove_nodes_from(item) } 
+                    else
+                        remove_nodes_from(value) 
+                    end
+                end
+            end
+
+            def remove_root_from(data)
+                return data unless data.is_a?(Hash)
+              
+                if data.has_key?(graphql_element_name)
+                    data[graphql_element_name]
+                elsif data.has_key?(graphql_collection_name)
+                    data[graphql_collection_name]
+                else
+                    data
+                end
+            end
+
+            def snake_case_keys(data)
+                return data unless data.is_a?(Hash) or data.is_a?(Array)
+                
+                if data.is_a?(Array)
+                    return data.map { |item| snake_case_keys(item) }
+                end
+
+                data.deep_transform_keys(&:underscore)
+            end
+
+            def graphql_element_name
+                case element_name
+                when "variant"
+                    "productVariant"
+                else
+                    element_name
+                end
+            end
+
+            def graphql_collection_name
+                case collection_name
+                when "variants"
+                    "productVariants"
+                else
+                    collection_name
+                end
+            end
+
+            def formatted_id(id)
+                return id unless client.shopify? && client.api_version != "2024_01"
+                return if id.to_s.include?("gid://")
+    
+                case element_name
+                when "product"
+                    "gid://shopify/Product/#{id}"
+                when "variant"
+                    "gid://shopify/ProductVariant/#{id}"
+                when "image"
+                    "gid://shopify/ProductImage/#{id}"
+                else
+                    raise EPlat::Errors.new("Unsupported element name")
+                end
+            end
+            
+        end
+
+        def mutate_graphql(action, graphql_proc_constant, *args)
+            callback_name = (action == :delete) ? :destroy : action
+
+            run_callbacks callback_name.to_sym do
+                response = self.class.execute_graphql_request graphql_mutation_string(graphql_proc_constant, action)
+
+                if !response.is_a?(Hash)
+                    raise EPlat::GraphqlError.new(response.first["message"])
+                elsif response["errors"]
+                    raise EPlat::GraphqlError.new(response["errors"].first["message"])
+                else
+                    response = remove_mutation_root_from(response, graphql_proc_constant)
+                    load self.class.resources_parsed_from(response), true, true
+                    
+                    @persisted = true
+                    changed_attributes.clear
+                end
+            end
+        rescue StandardError => e
+            raise EPlat::GraphqlError.new(e.message)
+        end
+
+        def graphql_mutation_string(graphql_proc_constant, action)
+            mutation_proc      = eval graphql_proc_constant
+            additional_graphql = self.class.before_graphql_callbacks[action.to_sym]&.call(self)
+            input  = 
+                if action == :delete 
+                    self.is_a?(EPlat::Product::Variant) ? graphql_input.new(id: formatted_id(id)) : graphql_input.new({id: formatted_id(id)})
+                else
+                    graphql_input.new mapping.via_native_attributes_where_possible(self.class.remove_root_from as_json)
+                end
+                
+            mutation_proc.call(input.to_graphql_args, additional_graphql:) 
+        end
+
+        def remove_mutation_root_from(data, graphql_proc_constant)
+            mutation_root = graphql_proc_constant.split(".").last.camelcase(:lower)
+            (mutation_root && data[mutation_root]) ? data[mutation_root] : data
+        end
+
+    end
+end

data/lib/e_plat/resource/concerns/overwrite_instance_methods.rb

@@ -84,14 +84,14 @@ module EPlat
 			end
 
 			def arrayOfPresentHashes?(value)
-				value.is_a?(Array) && value.first.is_a?(Hash) && value.first.present?
+				value.is_a?(Array) && value.first.is_a?(Hash) && value.any?(&:present?)
 			end
 
-			def unrepresented_collection_ids(key, arrayOfHashes)
+			def unrepresented_collection_ids(key, array_of_hashes)
 				return [] unless client.can_update_nested_resources?
 				
-				all_instance_ids 		 = try(key)&.map(&:id) || [] 
-				represented_instance_ids = arrayOfHashes.map{|item| item["id"] }
+				all_instance_ids 		 = send(key).map{|resource| resource.formatted_id resource.id} || [] 
+				represented_instance_ids = array_of_hashes.map{|item| item["id"] }
 				
 				all_instance_ids.compact - represented_instance_ids.compact
 			end

data/lib/e_plat/resource/concerns/overwrite_request_methods.rb

@@ -15,7 +15,7 @@ module EPlat
 					else
 						initialize_singleton!
 
-						if arguments.second && arguments.second[:params]
+						if arguments.second && arguments.second.is_a?(Hash) && arguments.second[:params]
 							arguments.second[:params].merge!(client.try("#{element_name}_default_request_args") || {})
 							arguments.second[:params] = mapping.via_native_attributes_where_possible(arguments.second[:params])
 						else

data/lib/e_plat/resource/countable.rb

@@ -6,16 +6,19 @@ module EPlat
 		def count(options = {})
 			initialize_singleton!
 
-			if counts_via_meta_data?
-				raw_data  = connection.get(collection_path, headers)
-				data_hash = ActiveSupport::JSON.decode(raw_data.body)
-				data = data_hash.dig("meta", "pagination", "total")
-			elsif count_key_next_to_root?
-				raw = get(:count, options)
-				data = JSON.parse raw.full_response.body
-			else
-				data = get(:count, options)
-			end
+			data = 
+				if counts_via_graphql?
+					graphql_count
+				elsif counts_via_meta_data?
+					raw_data  = connection.get(collection_path, headers)
+					data_hash = ActiveSupport::JSON.decode(raw_data.body)
+					data_hash.dig("meta", "pagination", "total")
+				elsif count_key_next_to_root?
+					raw = get(:count, options)
+					JSON.parse(raw.full_response.body)
+				else
+					get(:count, options)
+				end
 
 			count = 
 				case data
@@ -29,6 +32,13 @@ module EPlat
 
 		private
 
+			def counts_via_graphql?
+				return unless client.shopify?
+				return if client.api_version == "2024_01"
+
+				self == EPlat::Product or self == EPlat::Shopify::Product
+			end
+
 			def counts_via_meta_data?
 				return false unless client.bigcommerce?
 
@@ -39,5 +49,22 @@ module EPlat
 				client.bigcommerce? && self == EPlat::Order
 			end
 
+			def graphql_count_query
+				"EPlat::Shopify::GraphQL::#{EPlat.shopify_graphql_version}::Query.products_count"
+			end
+
+			def graphql_count
+				graphql_query = eval graphql_count_query
+				response = execute_graphql_request(graphql_query.call(""))
+
+				if !response.is_a?(Hash)
+					raise EPlat::GraphqlError.new(response.first["message"])
+				elsif response["errors"]
+					raise EPlat::GraphqlError.new(response["errors"].first["message"])
+				else
+					response["productsCount"]
+				end
+			end
+
 	end
 end

data/lib/e_plat/resource/platform_specific/bigcommerce/product/variant/option_value.rb

@@ -0,0 +1,2 @@
+
+class EPlat::Bigcommerce::Product::Variant::OptionValue < EPlat::Product::Variant::OptionValue; end

data/lib/e_plat/resource/platform_specific/shopify/graph_q_l/v_2024_07/input/product/variant.rb

@@ -0,0 +1,47 @@
+class EPlat::Shopify::GraphQL::V202407::Input::Product::Variant < EPlat::Shopify::GraphQL::V202407::Input
+	SUPPORTED_FIELDS = %w[
+		barcode
+		compareAtPrice
+		id
+		inventoryItem
+		inventoryPolicy
+		inventoryQuantities
+		mediaId
+		mediaSrc
+		metafields
+		optionValues
+		price
+		taxCode
+		taxable
+	].freeze
+
+	SUPPORTED_NAMED_ARGUMENT_FIELDS = {
+		variant: %w[
+			barcode
+			compareAtPrice
+			id
+			inventoryItem
+			inventoryPolicy
+			inventoryQuantities
+			mediaId
+			mediaSrc
+			metafields
+			optionValues
+			price
+			taxCode
+			taxable
+		],
+		inventory_item: %w[
+			cost
+			countryCodeOfOrigin
+			countryHarmonizedSystemCodes
+			harmonizedSystemCode
+			measurement
+			provinceCodeOfOrigin
+			requiresShipping
+			sku
+			tracked
+		]
+	}.with_indifferent_access.freeze
+
+end