spree_api 5.2.6 → 5.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '078f95314835c35a1dd304acb901e6354f1a97618ff13e3dfdbe6a0788d75756'
-  data.tar.gz: 8c8c35d33b999b0f6e369ed8fbfb1b959e14f3aa4bb53b5d9457efcf03f40f5c
+  metadata.gz: bf006c6d540a502177ba141362ccc562beb80a4ab19e61894c6cd7d270f3071e
+  data.tar.gz: a36baaff83201059e4c4b96b3d97e73c7e6eb8e94644fdc74c67320c4eed9eee
 SHA512:
-  metadata.gz: 5dd9343bb4ab4191438247ba04a57862a4cb745a48500b9a90ded2d7c8f74355ac448d1f189a82eb76316fbc04bff0c8190785d56523fa5749632a2b0f14a6a5
-  data.tar.gz: e67051467b1304370289c55d91bd01eac0924b42a46b7d5b0e6be87544a6e2077abf5b8c9330685f937d9612e5d7ce92355ca03d8c89b5c017aaf50c63d1fa5f
+  metadata.gz: c19e194cf63ffcadaaa3b0e3fb32e6a676fe55a8ff22f5352b32508cd67b87b03f8353d4613f10d9fa31bdb8b96e14a58850d86be323b4d10331ead4c917150e
+  data.tar.gz: 1894f064a469b4afd3952f04728972486bdac54090e2b0100bb31e6e5a9ce0313a31142499cc1c4fd2a17079fe7ad17d93e37d7bff1f7702fd2675d31ab0896e

data/app/controllers/concerns/spree/api/v2/product_list_includes.rb

@@ -1,31 +1,19 @@
 module Spree
   module Api
     module V2
+      # These includes are not picked automatically by ar_lazy_preload gem so we need to specify them manually.
       module ProductListIncludes
         def product_list_includes
-          @product_list_includes ||= {
-            taggings: [:tag],
-            variants: [],
-            master: [:prices]
+          {
+            option_types: [],
+            product_properties: [],
+            metafields: [],
+            variant_images: [],
+            tags: [],
+            taxons: [:taxonomy],
+            master: [:prices, :images, { stock_items: :stock_location }, metafields: [], option_values: []],
+            variants: [:prices, :images, { stock_items: :stock_location }, metafields: [], option_values: []]
           }
-
-          @product_list_includes[:variant_images] = [] if params[:include]&.match('images')
-          @product_list_includes[:option_types] = [] if params[:include]&.match('option_types')
-          @product_list_includes[:product_properties] = [:property] if params[:include]&.match('product_properties')
-          @product_list_includes[:master] = variant_includes if params[:include]&.match(/master|default_variant/)
-          @product_list_includes[:variants] = variant_includes if params[:include]&.match(/variants|default_variant/)
-          @product_list_includes[:taxons] = [:taxonomy, :icon, :store, :rich_text_translations, image_attachment: :blob] if params[:include]&.match('taxons')
-          @product_list_includes
-        end
-
-        def variant_includes
-          variant_includes = {
-            prices: [],
-            option_values: :option_type,
-            stock_items: :stock_location
-          }
-          variant_includes[:images] = [] if params[:include]&.match(/images/)
-          variant_includes
         end
       end
     end

data/app/controllers/concerns/spree/api/v2/storefront/order_concern.rb

@@ -39,7 +39,7 @@ module Spree
           end
 
           def serialize_order(order)
-            Spree::Deprecation.warn('OrderConcern#serialize_order is deprecated and will be removed in Spree 6.0. Please use `serialize_resource` method')
+            Spree::Deprecation.warn('OrderConcern#serialize_order is deprecated and will be removed in Spree 5.5. Please use `serialize_resource` method')
             serialize_resource(order)
           end
         end

data/app/controllers/spree/api/v2/platform/classifications_controller.rb

@@ -12,7 +12,7 @@ module Spree
           def scope_includes
             [
               taxon: [],
-              product: [:variants_including_master, :variant_images, :master, { variants: [:prices] }]
+              product: [:variants_including_master, :master, { variants: [:prices] }]
             ]
           end
 

data/app/controllers/spree/api/v2/resource_controller.rb

@@ -51,11 +51,14 @@ module Spree
         end
 
         def collection
-          @collection ||= if defined?(collection_finder)
-                            collection_finder.new(scope: scope, params: finder_params).execute
-                          else
-                            scope
-                          end
+          @collection ||= begin
+            result = if defined?(collection_finder)
+                       collection_finder.new(scope: scope, params: finder_params).execute
+                     else
+                       scope
+                     end
+            result.preload_associations_lazily
+          end
         end
 
         def finder_params

data/app/controllers/spree/api/v2/storefront/products_controller.rb

@@ -21,10 +21,7 @@ module Spree
           end
 
           def variant_includes
-            [
-              :prices,
-              { option_values: [:option_type] }
-            ]
+            [:images, :prices, { stock_items: :stock_location }]
           end
 
           def collection_sorter

data/app/helpers/spree/api/v2/display_money_helper.rb

@@ -5,37 +5,57 @@ module Spree
         extend ActiveSupport::Concern
 
         class_methods do
-          def find_price(product_or_variant, currency)
-            product_or_variant.price_in(currency)
+          def find_price(product_or_variant, currency, context_options = {})
+            variant = product_or_variant.is_a?(Spree::Product) ? product_or_variant.default_variant : product_or_variant
+
+            if context_options.present?
+              context = build_pricing_context(variant, currency, context_options)
+              variant.price_for(context)
+            else
+              variant.price_in(currency)
+            end
           end
 
-          def price(product_or_variant, currency)
-            price = find_price(product_or_variant, currency)
+          def price(product_or_variant, currency, context_options = {})
+            price = find_price(product_or_variant, currency, context_options)
             return nil if price.new_record?
 
             price.amount
           end
 
-          def display_price(product_or_variant, currency)
-            price = find_price(product_or_variant, currency)
+          def display_price(product_or_variant, currency, context_options = {})
+            price = find_price(product_or_variant, currency, context_options)
             return nil if price.new_record?
 
             Spree::Money.new(price.amount, currency: currency).to_s
           end
 
-          def compare_at_price(product_or_variant, currency)
-            price = find_price(product_or_variant, currency)
+          def compare_at_price(product_or_variant, currency, context_options = {})
+            price = find_price(product_or_variant, currency, context_options)
             return nil if price.new_record? || price.compare_at_amount.blank?
 
             price.compare_at_amount
           end
 
-          def display_compare_at_price(product_or_variant, currency)
-            price = find_price(product_or_variant, currency)
+          def display_compare_at_price(product_or_variant, currency, context_options = {})
+            price = find_price(product_or_variant, currency, context_options)
             return nil if price.new_record? || price.compare_at_amount.blank?
 
             Spree::Money.new(price.compare_at_amount, currency: currency).to_s
           end
+
+          private
+
+          def build_pricing_context(variant, currency, options)
+            Spree::Pricing::Context.new(
+              variant: variant,
+              currency: currency,
+              store: options[:store],
+              zone: options[:tax_zone] || options[:zone],
+              user: options[:user],
+              quantity: options[:quantity]
+            )
+          end
         end
       end
     end

data/app/jobs/spree/webhook_delivery_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Spree
+  class WebhookDeliveryJob < Spree::BaseJob
+    queue_as Spree.queues.webhooks
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 5
+
+    def perform(delivery_id, secret_key)
+      delivery = Spree::WebhookDelivery.find_by(id: delivery_id)
+      return if delivery.nil?
+
+      Spree::Webhooks::DeliverWebhook.call(delivery: delivery, secret_key: secret_key)
+    end
+  end
+end

data/app/paginators/spree/api/paginate.rb

@@ -0,0 +1,68 @@
+require 'pagy'
+
+module Spree
+  module Api
+    class Paginate
+      include Pagy::Method
+
+      def initialize(collection, params)
+        @collection = collection
+        @params = params
+
+        per_page_limit = Spree::Api::Config[:api_v2_per_page_limit]
+        @per_page = if params[:per_page].to_i.between?(1, per_page_limit)
+                      params[:per_page].to_i
+                    else
+                      25
+                    end
+      end
+
+      def call
+        # Pass params as a hash-based request object for Pagy
+        # Pagy::Request accepts a hash with :params key
+        # Use to_unsafe_h for ActionController::Parameters, fallback to to_h for regular hashes
+        params_hash = @params.respond_to?(:to_unsafe_h) ? @params.to_unsafe_h : @params.to_h
+        request_hash = { params: params_hash }
+
+        # Uses countish paginator which is faster as it avoids COUNT queries
+        pagy, records = pagy(:countish, @collection, limit: @per_page, request: request_hash)
+
+        PagyCollection.new(records, pagy)
+      end
+    end
+
+    # Wrapper providing Kaminari-compatible interface for CollectionOptionsHelpers
+    # Includes Enumerable so jsonapi-serializer detects it as a collection
+    class PagyCollection < SimpleDelegator
+      include Enumerable
+
+      attr_reader :pagy
+
+      def initialize(records, pagy)
+        super(records)
+        @pagy = pagy
+      end
+
+      # Enumerable requires #each to be defined
+      def each(&block)
+        __getobj__.each(&block)
+      end
+
+      def next_page
+        @pagy.next
+      end
+
+      def prev_page
+        @pagy.previous
+      end
+
+      def total_pages
+        @pagy.pages
+      end
+
+      def total_count
+        @pagy.count
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v2/platform/product_serializer.rb

@@ -27,19 +27,27 @@ module Spree
           end
 
           attribute :price do |product, params|
-            price(product, params[:currency])
+            price(product, params[:currency], pricing_context_options(params))
           end
 
           attribute :display_price do |product, params|
-            display_price(product, params[:currency])
+            display_price(product, params[:currency], pricing_context_options(params))
           end
 
           attribute :compare_at_price do |product, params|
-            compare_at_price(product, params[:currency])
+            compare_at_price(product, params[:currency], pricing_context_options(params))
           end
 
           attribute :display_compare_at_price do |product, params|
-            display_compare_at_price(product, params[:currency])
+            display_compare_at_price(product, params[:currency], pricing_context_options(params))
+          end
+
+          def self.pricing_context_options(params)
+            {
+              store: params[:store],
+              user: params[:user],
+              tax_zone: params.dig(:price_options, :tax_zone)
+            }
           end
 
           belongs_to :tax_category, serializer: Spree.api.platform_tax_category_serializer

data/app/serializers/spree/api/v2/platform/variant_serializer.rb

@@ -29,19 +29,27 @@ module Spree
           end
 
           attribute :price do |object, params|
-            price(object, params[:currency])
+            price(object, params[:currency], pricing_context_options(params))
           end
 
           attribute :display_price do |object, params|
-            display_price(object, params[:currency])
+            display_price(object, params[:currency], pricing_context_options(params))
           end
 
           attribute :compare_at_price do |object, params|
-            compare_at_price(object, params[:currency])
+            compare_at_price(object, params[:currency], pricing_context_options(params))
           end
 
           attribute :display_compare_at_price do |object, params|
-            display_compare_at_price(object, params[:currency])
+            display_compare_at_price(object, params[:currency], pricing_context_options(params))
+          end
+
+          def self.pricing_context_options(params)
+            {
+              store: params[:store],
+              user: params[:user],
+              tax_zone: params.dig(:price_options, :tax_zone)
+            }
           end
 
           belongs_to :product, serializer: Spree.api.platform_product_serializer

data/app/serializers/spree/v2/storefront/product_serializer.rb

@@ -30,19 +30,27 @@ module Spree
         end
 
         attribute :price do |product, params|
-          price(product, params[:currency])
+          price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :display_price do |product, params|
-          display_price(product, params[:currency])
+          display_price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :compare_at_price do |product, params|
-          compare_at_price(product, params[:currency])
+          compare_at_price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :display_compare_at_price do |product, params|
-          display_compare_at_price(product, params[:currency])
+          display_compare_at_price(product, params[:currency], pricing_context_options(params))
+        end
+
+        def self.pricing_context_options(params)
+          {
+            store: params[:store],
+            user: params[:user],
+            tax_zone: params.dig(:price_options, :tax_zone)
+          }
         end
 
         attribute :localized_slugs do |product, params|
@@ -57,7 +65,7 @@ module Spree
         has_many :product_properties, serializer: Spree.api.storefront_product_property_serializer
 
         has_many :taxons, serializer: Spree.api.storefront_taxon_serializer, record_type: :taxon do |object, params|
-          object.taxons_for_store(params[:store]).order(:id)
+          object.taxons_for_store(params[:store])
         end
 
         # all images from all variants

data/app/serializers/spree/v2/storefront/taxon_serializer.rb

@@ -14,7 +14,7 @@ module Spree
         end
 
         attribute :has_products do |taxon|
-          taxon.active_products_with_descendants.exists?
+          taxon.classification_count.positive? || taxon.active_products_with_descendants.exists?
         end
 
         attribute :header_url do |taxon|

data/app/serializers/spree/v2/storefront/variant_serializer.rb

@@ -26,19 +26,27 @@ module Spree
         end
 
         attribute :price do |product, params|
-          price(product, params[:currency])
+          price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :display_price do |product, params|
-          display_price(product, params[:currency])
+          display_price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :compare_at_price do |product, params|
-          compare_at_price(product, params[:currency])
+          compare_at_price(product, params[:currency], pricing_context_options(params))
         end
 
         attribute :display_compare_at_price do |product, params|
-          display_compare_at_price(product, params[:currency])
+          display_compare_at_price(product, params[:currency], pricing_context_options(params))
+        end
+
+        def self.pricing_context_options(params)
+          {
+            store: params[:store],
+            user: params[:user],
+            tax_zone: params.dig(:price_options, :tax_zone)
+          }
         end
 
         belongs_to :product, serializer: Spree.api.storefront_product_serializer

data/app/services/spree/webhooks/deliver_webhook.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+
+module Spree
+  module Webhooks
+    class DeliverWebhook
+      TIMEOUT = 30
+
+      def self.call(delivery:, secret_key:)
+        new(delivery: delivery, secret_key: secret_key).call
+      end
+
+      def initialize(delivery:, secret_key:)
+        @delivery = delivery
+        @secret_key = secret_key
+      end
+
+      def call
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        response = make_request
+        execution_time = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+
+        @delivery.complete!(
+          response_code: response.code.to_i,
+          execution_time: execution_time,
+          response_body: response.body.to_s.truncate(10_000)
+        )
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        execution_time = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+        Rails.error.report(e, context: { webhook_delivery_id: @delivery.id, url: @delivery.url })
+        @delivery.complete!(
+          execution_time: execution_time,
+          error_type: 'timeout',
+          request_errors: e.message
+        )
+      rescue StandardError => e
+        execution_time = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+        Rails.error.report(e, context: { webhook_delivery_id: @delivery.id, url: @delivery.url })
+        @delivery.complete!(
+          execution_time: execution_time,
+          error_type: 'connection_error',
+          request_errors: e.message
+        )
+      end
+
+      private
+
+      def make_request
+        uri = URI.parse(@delivery.url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.verify_mode = ssl_verify_mode
+        http.open_timeout = TIMEOUT
+        http.read_timeout = TIMEOUT
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request['Content-Type'] = 'application/json'
+        request['User-Agent'] = 'Spree-Webhooks/1.0'
+        request['X-Spree-Webhook-Signature'] = generate_signature
+        request['X-Spree-Webhook-Event'] = @delivery.event_name
+        request.body = @delivery.payload.to_json
+
+        http.request(request)
+      end
+
+      def generate_signature
+        payload_json = @delivery.payload.to_json
+        OpenSSL::HMAC.hexdigest('SHA256', @secret_key, payload_json)
+      end
+
+      def ssl_verify_mode
+        if Spree::Api::Config.webhooks_verify_ssl
+          OpenSSL::SSL::VERIFY_PEER
+        else
+          OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+    end
+  end
+end

data/app/subscribers/spree/webhook_event_subscriber.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Spree
+  # Listens to Spree events and queues webhook deliveries for enabled endpoints.
+  #
+  # This subscriber listens to all Spree events and for each event, finds
+  # all enabled webhook endpoints that are subscribed to that event and queues
+  # a delivery job for each one.
+  #
+  # The event payload is passed through directly without transformation.
+  # Events should already be serialized by the EventSerializer.
+  #
+  # @example
+  #   # Webhooks are automatically delivered when events are published
+  #   Spree::Events.publish('order.completed', order: order)
+  #
+  class WebhookEventSubscriber < Spree::Subscriber
+    subscribes_to '*'
+
+    def handle(event)
+      return unless Spree::Api::Config.webhooks_enabled
+      return if event.store_id.blank?
+
+      # Find all active endpoints for this store subscribed to this event
+      endpoints = Spree::WebhookEndpoint.active.where(store_id: event.store_id).select { |endpoint| endpoint.subscribed_to?(event.name) }
+
+      return if endpoints.empty?
+
+      # Queue delivery for each endpoint
+      endpoints.each do |endpoint|
+        queue_delivery(endpoint, event)
+      end
+    rescue StandardError => e
+      Rails.logger.error "[Spree Webhooks] Error processing event: #{e.message}"
+      Rails.error.report(e)
+    end
+
+    private
+
+    def queue_delivery(endpoint, event)
+      # Build base payload (without delivery ID)
+      payload = build_payload(event)
+
+      # Create delivery record
+      delivery = endpoint.webhook_deliveries.create!(
+        event_name: event.name,
+        payload: payload
+      )
+
+      # Queue the delivery job
+      Spree::WebhookDeliveryJob.perform_later(delivery.id, endpoint.secret_key)
+    rescue StandardError => e
+      Rails.logger.error "[Spree Webhooks] Error queuing delivery for endpoint #{endpoint.id}: #{e.message}"
+      Rails.error.report(e)
+    end
+
+    def build_payload(event)
+      {
+        id: event.id,
+        name: event.name,
+        created_at: event.created_at.iso8601,
+        data: event.payload,
+        metadata: event.metadata
+      }
+    end
+  end
+end

data/config/routes.rb

@@ -206,8 +206,6 @@ Spree::Core::Engine.add_routes do
 
         # Webhooks API
         namespace :webhooks do
-          resources :events, only: :index
-          resources :subscribers
         end
 
         # Gift Cards API

data/lib/generators/spree/api/install/install_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        class_option :migrate, type: :boolean, default: true
+
+        def add_migrations
+          run 'bundle exec rake railties:install:migrations FROM=spree_api'
+        end
+
+        def run_migrations
+          run_migrations = options[:migrate] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]'))
+          if run_migrations
+            run 'bin/rails db:migrate'
+          else
+            puts 'Skipping rails db:migrate, don\'t forget to run it!'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/api/configuration.rb

@@ -8,6 +8,9 @@ module Spree
       preference :api_v2_collection_cache_namespace, :string, default: 'api_v2_collection_cache'
       preference :api_v2_content_type, :string, default: 'application/vnd.api+json'
       preference :api_v2_per_page_limit, :integer, default: 500
+
+      preference :webhooks_enabled, :boolean, default: true
+      preference :webhooks_verify_ssl, :boolean, default: !Rails.env.development?
     end
   end
 end

data/lib/spree/api/dependencies.rb

@@ -101,7 +101,7 @@ module Spree
         storefront_posts_sorter: -> { Spree::Dependencies.posts_sorter },
 
         # paginators
-        storefront_collection_paginator: -> { Spree::Dependencies.collection_paginator },
+        storefront_collection_paginator: 'Spree::Api::Paginate',
 
         # finders
         storefront_address_finder: -> { Spree::Dependencies.address_finder },

data/lib/spree/api/engine.rb

@@ -1,4 +1,5 @@
 require 'rails/engine'
+require 'pagy'
 
 require_relative 'dependencies'
 require_relative 'configuration'
@@ -18,6 +19,11 @@ module Spree
         Migrations.new(config, engine_name).check unless Rails.env.test?
       end
 
+      # Add API event subscribers
+      config.after_initialize do
+        Spree.subscribers << Spree::WebhookEventSubscriber
+      end
+
       def self.root
         @root ||= Pathname.new(File.expand_path('../../..', __dir__))
       end