e_plat 0.5.5 → 0.7.0

data/lib/e_plat/mapping/virtual_collection/shopify/product/variant/option_value.rb

@@ -0,0 +1,272 @@
+
+module EPlat
+    class Mapping
+        module VirtualCollection
+            module Shopify
+                module Product
+                    module Variant
+                        class OptionValue < VirtualCollection::Base
+                            attr_accessor :resource
+
+                            def initialize(resource:, map_from:)
+                                @resource = resource
+                                super
+
+                                return unless @resource.try :selected_options
+
+                                @resource.option_values = 
+                                    @resource.selected_options.map.with_index do |data, i|
+                                        item = EPlat::Product::Variant::OptionValue.new(variant_id: @resource.id)
+                                        item.mapping.virtual_collection = self
+                                        item.add_aliases!(native_attribute_aliases(i), EPlat::Product::Variant::OptionValue.schema)
+
+                                        item
+                                    end
+                            end
+
+                            def native_attribute_aliases(i)
+                                [                                
+                                    {
+                                        alias_attribute: {
+                                            native_key: "[selected_options][#{i}][option_value][id]",
+                                            e_plat_key: "id",
+                                            virtual_collection: true,
+                                            custom_e_plat_getter: '-> { _1&.split("/")&.last }',
+                                            custom_native_setter: '-> { "gid://shopify/ProductOptionValue/#{_1}" }'
+                                        }
+                                    },
+                                    {
+                                        alias_attribute: {
+                                            native_key: "[selected_options][#{i}][name]",
+                                            e_plat_key: "name",
+                                            virtual_collection: true
+                                        }
+                                    },
+                                    {
+                                        alias_attribute: {
+                                            native_key: "[selected_options][#{i}][value]",
+                                            e_plat_key: "value",
+                                            virtual_collection: true
+                                        }
+                                    }
+                                ]
+                            end
+
+                        end
+
+                    end
+                end
+            end
+        end
+    end
+end
+
+
+
+# consignments are deliveries, we're just going to operate within the context on one delivery per order
+# this should be reasonable to tie us over for now
+
+# integer 	:id
+# string 	:admin_graphql_api_id
+# integer 	:fulfillable_quantity
+# string 	:fulfillment_service
+# string 	:fulfillment_status
+# boolean 	:gift_card
+# integer 	:grams
+# string 	:name
+# string 	:price
+# hash 		:price_set
+# boolean 	:product_exists
+# integer 	:product_id
+# array 	:properties
+# integer 	:quantity
+# boolean 	:requires_shipping
+# string 	:sku
+# boolean 	:taxable
+# string 	:title
+# string 	:total_discount
+# hash 		:total_discount_set
+# integer 	:variant_id
+# string 	:variant_inventory_management
+# string 	:variant_title
+# string 	:vendor
+# array 	:tax_lines
+# array 	:duties
+# array 	:discount_allocations
+
+
+# BG = {
+# 	"consignments": [
+# 		{
+# 			"pickups": [],
+# 			"shipping": [
+# 				{
+# 					"id": 3,
+# 					"first_name": "Jane",
+# 					"last_name": "Doe",
+# 					"company": "",
+# 					"street_1": "123 Main Street",
+# 					"street_2": "",
+# 					"city": "Austin",
+# 					"zip": "78751",
+# 					"country": "United States",
+# 					"country_iso2": "US",
+# 					"state": "Texas",
+# 					"email": "oli@example.com",
+# 					"phone": "",
+# 					"form_fields": [],
+# 					"line_items": [
+# 						{
+# 							"id": 3,
+# 							"order_id": 102,
+# 							"product_id": 88,
+# 							"variant_id": 81,
+# 							"order_pickup_method_id": 0,
+# 							"order_address_id": 3,
+# 							"name": "Chemex Coffeemaker",
+# 							"name_customer": "Chemex Coffeemaker",
+# 							"name_merchant": "Chemex Coffeemaker",
+# 							"sku": "CC3C-SM",
+# 							"upc": "",
+# 							"type": "physical",
+# 							"base_price": "83.3300",
+# 							"price_ex_tax": "83.3300",
+# 							"price_inc_tax": "83.3300",
+# 							"price_tax": "0.0000",
+# 							"base_total": "83.3300",
+# 							"total_ex_tax": "83.3300",
+# 							"total_inc_tax": "83.3300",
+# 							"total_tax": "0.0000",
+# 							"weight": "1.0000",
+# 							"width": "0.0000",
+# 							"height": "0.0000",
+# 							"depth": "0.0000",
+# 							"quantity": 1,
+# 							"base_cost_price": "0.0000",
+# 							"cost_price_inc_tax": "0.0000",
+# 							"cost_price_ex_tax": "0.0000",
+# 							"cost_price_tax": "0.0000",
+# 							"is_refunded": false,
+# 							"quantity_refunded": 0,
+# 							"refund_amount": "0.0000",
+# 							"return_id": 0,
+# 							"wrapping_id": 0,
+# 							"wrapping_name": "",
+# 							"base_wrapping_cost": "0.0000",
+# 							"wrapping_cost_ex_tax": "0.0000",
+# 							"wrapping_cost_inc_tax": "0.0000",
+# 							"wrapping_cost_tax": "0.0000",
+# 							"wrapping_message": "",
+# 							"quantity_shipped": 0,
+# 							"event_name": null,
+# 							"event_date": null,
+# 							"fixed_shipping_cost": "0.0000",
+# 							"ebay_item_id": "",
+# 							"ebay_transaction_id": "",
+# 							"option_set_id": 18,
+# 							"parent_order_product_id": null,
+# 							"is_bundled_product": false,
+# 							"bin_picking_number": "0",
+# 							"external_id": "",
+# 							"fulfillment_source": "",
+# 							"brand": "",
+# 							"gift_certificate_id": null,
+# 							"applied_discounts": [],
+# 							"product_options": [
+# 								{
+# 									"id": 2,
+# 									"option_id": 34,
+# 									"order_product_id": 3,
+# 									"product_option_id": 114,
+# 									"display_name": "Size",
+# 									"display_name_customer": "Size",
+# 									"display_name_merchant": "Size",
+# 									"display_value": "Small",
+# 									"display_value_customer": "Small",
+# 									"display_value_merchant": "Small",
+# 									"value": "101",
+# 									"type": "Multiple choice",
+# 									"name": "Size1699441692-88",
+# 									"display_style": "Dropdown"
+# 								}
+# 							],
+# 							"configurable_fields": [],
+# 							"discounted_total_inc_tax": "83.3300"
+# 						}
+# 					]
+# 				}
+# 			],
+# 			"items_total": 1,
+# 			"items_shipped": 0,
+# 			"shipping_method": "None",
+# 			"base_cost": 0,
+# 			"cost_ex_tax": 0,
+# 			"cost_inc_tax": 0,
+# 			"cost_tax": 0,
+# 			"cost_tax_class_id": 0,
+# 			"base_handling_cost": 0,
+# 			"handling_cost_ex_tax": 0,
+# 			"handling_cost_inc_tax": 0,
+# 			"handling_cost_tax": 0,
+# 			"handling_cost_tax_class_id": 0,
+# 			"shipping_zone_id": 0,
+# 			"shipping_zone_name": "",
+# 			"shipping_quotes": {
+# 				"url": "https://api.bigcommerce.com/stores/d0kmq3bory/v2/orders/102/consignments/shipping/3/shipping_quotes",
+# 				"resource": "/orders/102/consignments/shipping/3/shipping_quotes"
+# 			}
+# 		}
+# 	]
+# }
+
+# Shopify = {
+# 	"line_items": [
+# 		{
+# 			"id": 13120677806211,
+# 			"admin_graphql_api_id": "gid://shopify/LineItem/13120677806211",
+# 			"fulfillable_quantity": 1,
+# 			"fulfillment_service": "manual",
+# 			"fulfillment_status": null,
+# 			"gift_card": false,
+# 			"grams": 0,
+# 			"name": "Winter Luggage - Sienna the longest name variant in the world",
+# 			"price": "150.00",
+# 			"price_set": {
+# 				"shop_money": {
+# 					"amount": "150.00",
+# 					"currency_code": "GBP"
+# 				},
+# 				"presentment_money": {
+# 					"amount": "150.00",
+# 					"currency_code": "GBP"
+# 				}
+# 			},
+# 			"product_exists": true,
+# 			"product_id": 6610509627523,
+# 			"properties": [],
+# 			"quantity": 1,
+# 			"requires_shipping": true,
+# 			"sku": "skusku123",
+# 			"taxable": true,
+# 			"title": "Winter Luggage",
+# 			"total_discount": "0.00",
+# 			"total_discount_set": {
+# 				"shop_money": {
+# 					"amount": "0.00",
+# 					"currency_code": "GBP"
+# 				},
+# 				"presentment_money": {
+# 					"amount": "0.00",
+# 					"currency_code": "GBP"
+# 				}
+# 			},
+# 			"variant_id": 39428269408387,
+# 			"variant_inventory_management": "shopify",
+# 			"variant_title": "Sienna the longest name variant in the world",
+# 			"vendor": "PreProduct Test",
+# 			"tax_lines": [],
+# 			"duties": [],
+# 			"discount_allocations": []
+# 		}
+# 	]
+# }

data/lib/e_plat/mapping.rb

@@ -1,19 +1,43 @@
 # frozen_string_literal: true
 
 module EPlat
-  class Mapping 
-    
-    class << self
-      
-      def new_instance(specifc_mapping:, resource: nil)
-        if Object.const_defined?(specifc_mapping)
-          mapping = specifc_mapping.constantize.new(resource)
-        else
-          mapping = EPlat::Mapping::Base.new(resource)
-        end
-      end
-      
-    end
-    
-  end
+	class Mapping 
+
+		class << self
+			
+			def new_instance(specifc_mapping:, resource: nil)
+				platform = EPlat::Current.e_plat_session.platform.to_s
+				sanitized_mapping = sanitize_mapping(specifc_mapping, platform)
+
+				if Object.const_defined?(sanitized_mapping)
+					sanitized_mapping.constantize.new(resource)
+				elsif Object.const_defined?(specifc_mapping)
+					specifc_mapping.constantize.new(resource)
+				else
+					EPlat::Mapping::Base.new(resource)
+				end
+			end
+
+			private
+
+			def sanitize_mapping(specifc_mapping, platform)
+				# Stripe out all instanced of the platform scope in the mapping
+				# then put platform back in as third scope, as mapping is always platform scoped. 
+				# i.e. EPlat::Mapping::Bigcommerce::V3::Product::Variant
+				parts = specifc_mapping.split("::")
+			
+				parts.reject! do |part| 
+					platform.downcase == part.downcase
+				end
+
+				parts.insert(2, platform.capitalize)
+			
+				parts.join("::")
+			end
+
+			
+		end
+
+	end
 end
+

data/lib/e_plat/resource/base.rb

@@ -4,11 +4,12 @@ module EPlat
 	class Base < ActiveResource::Base
 		include Concerns::OverwriteRequestMethods, Concerns::OverwriteInstanceMethods
 		include Concerns::Aliases, Concerns::Dirty, Concerns::FullJson
+		include Concerns::GraphQLable
 		
 		self.connection_class  = EPlat::Connection
 		self.collection_parser = EPlat::Collection
 		self.site = "/" # this is overwritten below in initialize_singleton! when EPlat::Session is initialized
-		add_response_method :full_response
+		add_response_method :full_response #full response of the request
 
 		class << self
 			include Countable
@@ -18,6 +19,12 @@ module EPlat
 			threadsafe_attribute :_headers, :_connection, :_user, :_password, :_bearer_token, :_site, :_proxy, # active resource
 								 :mapping, :include_root_in_json, :include_format_in_path # e_plat specific
 			
+			def inherited(subclass)
+				super
+				subclass.exclude_from_json(read_only) if read_only
+				subclass.schema ||= schema.dup
+			end
+
 			def initialize_singleton!
 				self.site  = client.base_url # .site is an ActiveResource method that uses the threadsafe _site attribute underneath
 				self.prefix  = client.url_prefix(klass: self) # this is overwritten below in prefix= for threadsafety
@@ -60,6 +67,9 @@ module EPlat
 				self.read_only = read_only
 			end
 
+			def platform_specific_class?
+				self.class.to_s.include? client.platform.to_s.capitalize
+			end
 			
 			private
 				
@@ -83,6 +93,7 @@ module EPlat
 
 			@mapped_attributes = ensure_e_plat_attributes!
 			ensure_native_attributes!
+			
 			add_aliases!(mapping.native_attribute_aliases, type_schema || {})
 		end
 
@@ -96,7 +107,7 @@ module EPlat
 		
 		def native_keys
 			if client.shopify? 
-				schema.keys # EPlat uses Shopify's schema, so keys are always native
+				@mapping.native_attributes.presence || schema.keys # EPlat uses Shopify's schema, apar from a couple of Graphql only fields
 			elsif mapping.class.to_s != EPlat::Mapping::Base && @mapping.native_attributes.present?
 				@mapping.native_attributes.presence
 			else
@@ -117,7 +128,26 @@ module EPlat
 			
 			top_level_resource?
 		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
+
+		def graphql_input
+			raise EPlat::Error.new("GraphQL input not supported for this resource and platform")
+		end
 		
 		private 
 
@@ -126,7 +156,7 @@ module EPlat
 			end
 
 			def ensure_native_attributes!
-				return if client.shopify? # EPlat uses Shopify's schema
+				return if client.shopify? && EPlat.config.shopify_api_version == "2024_01"
 
 				AttributeInterface.new(self, keys: native_keys)
 			end
@@ -170,7 +200,11 @@ module EPlat
 			end
 			
 			def top_level_resource?
-				self.class.name.split("::").count <= 2
+				parts = self.class.name.split("::")
+				# platform scope not included, as top level resources can optionally be platform specific
+				parts.reject!{|part| EPlat::SUPPORTED_PLATFORMS.include? part.downcase } 
+
+				parts.count <= 2
 			end
 
 			def element_name

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