shopify_api 9.5.1 → 13.1.0

data/lib/shopify_api/webhooks/registrations/event_bridge.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Webhooks
+    module Registrations
+      class EventBridge < Registration
+        extend T::Sig
+
+        sig { override.returns(String) }
+        def callback_address
+          @path
+        end
+
+        sig { override.returns(T::Hash[Symbol, String]) }
+        def subscription_args
+          { arn: callback_address, includeFields: fields }.compact
+        end
+
+        sig { override.params(webhook_id: T.nilable(String)).returns(String) }
+        def mutation_name(webhook_id)
+          webhook_id ? "eventBridgeWebhookSubscriptionUpdate" : "eventBridgeWebhookSubscriptionCreate"
+        end
+
+        sig { override.returns(String) }
+        def build_check_query
+          <<~QUERY
+            {
+              webhookSubscriptions(first: 1, topics: #{@topic}) {
+                edges {
+                  node {
+                    id
+                    endpoint {
+                      __typename
+                      ... on WebhookEventBridgeEndpoint {
+                        arn
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+        end
+
+        sig { override.params(body: T::Hash[String, T.untyped]).returns(T::Hash[Symbol, String]) }
+        def parse_check_result(body)
+          edges = body.dig("data", "webhookSubscriptions", "edges") || {}
+          webhook_id = nil
+          current_address = nil
+          unless edges.empty?
+            node = edges[0]["node"]
+            webhook_id = node["id"].to_s
+            current_address = node["endpoint"]["arn"].to_s
+          end
+          { webhook_id: webhook_id, current_address: current_address }
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/webhooks/registrations/http.rb

@@ -0,0 +1,72 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Webhooks
+    module Registrations
+      class Http < Registration
+        extend T::Sig
+
+        sig { override.returns(String) }
+        def callback_address
+          if @path.match?(%r{^https?://})
+            @path
+          elsif @path.match?(/^#{Context.host_name}/)
+            "#{Context.host_scheme}://#{@path}"
+          else
+            "#{Context.host}/#{@path}"
+          end
+        end
+
+        sig { override.returns(T::Hash[Symbol, String]) }
+        def subscription_args
+          { callbackUrl: callback_address, includeFields: fields }.compact
+        end
+
+        sig { override.params(webhook_id: T.nilable(String)).returns(String) }
+        def mutation_name(webhook_id)
+          webhook_id ? "webhookSubscriptionUpdate" : "webhookSubscriptionCreate"
+        end
+
+        sig { override.returns(String) }
+        def build_check_query
+          <<~QUERY
+            {
+              webhookSubscriptions(first: 1, topics: #{@topic}) {
+                edges {
+                  node {
+                    id
+                    endpoint {
+                      __typename
+                      ... on WebhookHttpEndpoint {
+                        callbackUrl
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+        end
+
+        sig { override.params(body: T::Hash[String, T.untyped]).returns(T::Hash[Symbol, String]) }
+        def parse_check_result(body)
+          edges = body.dig("data", "webhookSubscriptions", "edges") || {}
+          webhook_id = nil
+          current_address = nil
+          unless edges.empty?
+            node = edges[0]["node"]
+            webhook_id = node["id"].to_s
+            current_address =
+              if node.key?("endpoint")
+                node["endpoint"]["callbackUrl"].to_s
+              else
+                node["callbackUrl"].to_s
+              end
+          end
+          { webhook_id: webhook_id, current_address: current_address }
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/webhooks/registrations/pub_sub.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Webhooks
+    module Registrations
+      class PubSub < Registration
+        extend T::Sig
+
+        sig { override.returns(String) }
+        def callback_address
+          @path
+        end
+
+        sig { override.returns(T::Hash[Symbol, String]) }
+        def subscription_args
+          project_topic_pair = callback_address.gsub(%r{^pubsub://}, "").split(":")
+          project = project_topic_pair[0]
+          topic = project_topic_pair[1]
+          { pubSubProject: project, pubSubTopic: topic, includeFields: fields }.compact
+        end
+
+        sig { override.params(webhook_id: T.nilable(String)).returns(String) }
+        def mutation_name(webhook_id)
+          webhook_id ? "pubSubWebhookSubscriptionUpdate" : "pubSubWebhookSubscriptionCreate"
+        end
+
+        sig { override.returns(String) }
+        def build_check_query
+          <<~QUERY
+            {
+              webhookSubscriptions(first: 1, topics: #{@topic}) {
+                edges {
+                  node {
+                    id
+                    endpoint {
+                      __typename
+                      ... on WebhookPubSubEndpoint {
+                        pubSubProject
+                        pubSubTopic
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+        end
+
+        sig { override.params(body: T::Hash[String, T.untyped]).returns(T::Hash[Symbol, String]) }
+        def parse_check_result(body)
+          edges = body.dig("data", "webhookSubscriptions", "edges") || {}
+          webhook_id = nil
+          current_address = nil
+          unless edges.empty?
+            node = edges[0]["node"]
+            webhook_id = node["id"].to_s
+            current_address = "pubsub://#{node["endpoint"]["pubSubProject"]}:#{node["endpoint"]["pubSubTopic"]}"
+          end
+          { webhook_id: webhook_id, current_address: current_address }
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/webhooks/registry.rb

@@ -0,0 +1,215 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Webhooks
+    class Registry
+      @registry = T.let({}, T::Hash[String, Registration])
+
+      class << self
+        extend T::Sig
+        sig do
+          params(topic: String,
+            delivery_method: Symbol,
+            path: String,
+            handler: T.nilable(Handler),
+            fields: T.nilable(String)).void
+        end
+        def add_registration(topic:, delivery_method:, path:, handler: nil, fields: nil)
+          @registry[topic] = case delivery_method
+          when :pub_sub
+            Registrations::PubSub.new(topic: topic, path: path, fields: fields)
+          when :event_bridge
+            Registrations::EventBridge.new(topic: topic, path: path, fields: fields)
+          when :http
+            unless handler
+              raise Errors::InvalidWebhookRegistrationError, "Cannot create an Http registration without a handler."
+            end
+
+            Registrations::Http.new(topic: topic, path: path, handler: handler, fields: fields)
+          else
+            raise Errors::InvalidWebhookRegistrationError,
+              "Unsupported delivery method #{delivery_method}. Allowed values: {:http, :pub_sub, :event_bridge}."
+          end
+        end
+
+        sig { void }
+        def clear
+          @registry.clear
+        end
+
+        sig do
+          params(
+            topic: String,
+            session: Auth::Session,
+          ).returns(RegisterResult)
+        end
+        def register(topic:, session:)
+          registration = @registry[topic]
+
+          unless registration
+            raise Errors::InvalidWebhookRegistrationError, "Webhook topic #{topic} has not been added to the registry."
+          end
+
+          client = Clients::Graphql::Admin.new(session: session)
+          register_check_result = webhook_registration_needed?(client, registration)
+
+          registered = true
+          register_body = nil
+
+          if register_check_result[:must_register]
+            register_body = send_register_request(
+              client,
+              registration,
+              register_check_result[:webhook_id],
+            )
+            registered = registration_sucessful?(
+              register_body,
+              registration.mutation_name(register_check_result[:webhook_id]),
+            )
+          end
+
+          RegisterResult.new(topic: topic, success: registered, body: register_body)
+        end
+
+        sig do
+          params(
+            session: Auth::Session,
+          ).returns(T::Array[RegisterResult])
+        end
+        def register_all(session:)
+          topics = @registry.keys
+          result = T.let([], T::Array[RegisterResult])
+          topics.each do |topic|
+            register_response = register(
+              topic: topic,
+              session: session,
+            )
+            result.push(register_response)
+          end
+          result
+        end
+
+        sig do
+          params(
+            topic: String,
+            session: T.nilable(Auth::Session),
+          ).returns(T::Hash[String, T.untyped])
+        end
+        def unregister(topic:, session:)
+          client = Clients::Graphql::Admin.new(session: session)
+
+          webhook_id = get_webhook_id(topic: topic, client: client)
+          return {} if webhook_id.nil?
+
+          delete_mutation = <<~MUTATION
+            mutation webhookSubscription {
+              webhookSubscriptionDelete(id: "#{webhook_id}") {
+                userErrors {
+                  field
+                  message
+                }
+                deletedWebhookSubscriptionId
+              }
+            }
+          MUTATION
+
+          delete_response = client.query(query: delete_mutation)
+          raise Errors::WebhookRegistrationError,
+            "Failed to delete webhook from Shopify" unless delete_response.ok?
+          result = T.cast(delete_response.body, T::Hash[String, T.untyped])
+          errors = result["errors"] || {}
+          raise Errors::WebhookRegistrationError,
+            "Failed to delete webhook from Shopify: #{errors[0]["message"]}" unless errors.empty?
+          user_errors = result.dig("data", "webhookSubscriptionDelete", "userErrors") || {}
+          raise Errors::WebhookRegistrationError,
+            "Failed to delete webhook from Shopify: #{user_errors[0]["message"]}" unless user_errors.empty?
+          result
+        end
+
+        sig do
+          params(
+            topic: String,
+            client: Clients::Graphql::Admin,
+          ).returns(T.nilable(String))
+        end
+        def get_webhook_id(topic:, client:)
+          fetch_id_query = <<~QUERY
+            {
+              webhookSubscriptions(first: 1, topics: #{topic.gsub(%r{/|\.}, "_").upcase}) {
+                edges {
+                  node {
+                    id
+                  }
+                }
+              }
+            }
+          QUERY
+
+          fetch_id_response = client.query(query: fetch_id_query)
+          raise Errors::WebhookRegistrationError,
+            "Failed to fetch webhook from Shopify" unless fetch_id_response.ok?
+          body = T.cast(fetch_id_response.body, T::Hash[String, T.untyped])
+          errors = body["errors"] || {}
+          raise Errors::WebhookRegistrationError,
+            "Failed to fetch webhook from Shopify: #{errors[0]["message"]}" unless errors.empty?
+
+          edges = body.dig("data", "webhookSubscriptions", "edges") || {}
+          return nil if edges.empty?
+
+          edges[0]["node"]["id"].to_s
+        end
+        sig { params(request: Request).void }
+        def process(request)
+          raise Errors::InvalidWebhookError, "Invalid webhook HMAC." unless Utils::HmacValidator.validate(request)
+
+          handler = @registry[request.topic]&.handler
+
+          unless handler
+            raise Errors::NoWebhookHandler, "No webhook handler found for topic: #{request.topic}."
+          end
+
+          handler.handle(topic: request.topic, shop: request.shop, body: request.parsed_body)
+        end
+
+        private
+
+        sig do
+          params(
+            client: Clients::Graphql::Admin,
+            registration: Registration,
+          ).returns(T::Hash[Symbol, T.untyped])
+        end
+        def webhook_registration_needed?(client, registration)
+          check_response = client.query(query: registration.build_check_query)
+          raise Errors::WebhookRegistrationError,
+            "Failed to check if webhook was already registered" unless check_response.ok?
+          parsed_check_result = registration.parse_check_result(T.cast(check_response.body, T::Hash[String, T.untyped]))
+          must_register = parsed_check_result[:current_address] != registration.callback_address
+
+          { webhook_id: parsed_check_result[:webhook_id], must_register: must_register }
+        end
+
+        sig do
+          params(
+            client: Clients::Graphql::Admin,
+            registration: Registration,
+            webhook_id: T.nilable(String),
+          ).returns(T::Hash[String, T.untyped])
+        end
+        def send_register_request(client, registration, webhook_id)
+          register_response = client.query(query: registration.build_register_query(webhook_id: webhook_id))
+
+          raise Errors::WebhookRegistrationError, "Failed to register webhook with Shopify" unless register_response.ok?
+
+          T.cast(register_response.body, T::Hash[String, T.untyped])
+        end
+
+        sig { params(body: T::Hash[String, T.untyped], mutation_name: String).returns(T::Boolean) }
+        def registration_sucessful?(body, mutation_name)
+          !body.dig("data", mutation_name, "webhookSubscription").nil?
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/webhooks/request.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Webhooks
+    class Request
+      extend T::Sig
+      include Utils::VerifiableQuery
+
+      sig { override.returns(String) }
+      def hmac
+        Digest.hexencode(Base64.decode64(T.cast(@headers["x-shopify-hmac-sha256"], String)))
+      end
+
+      sig { returns(String) }
+      def topic
+        T.cast(@headers["x-shopify-topic"], String)
+      end
+
+      sig { returns(String) }
+      def shop
+        T.cast(@headers["x-shopify-shop-domain"], String)
+      end
+
+      sig { override.returns(String) }
+      def to_signable_string
+        @raw_body
+      end
+
+      sig { returns(T::Hash[String, T.untyped]) }
+      def parsed_body
+        JSON.parse(@raw_body)
+      end
+
+      sig { params(raw_body: String, headers: T::Hash[String, T.untyped]).void }
+      def initialize(raw_body:, headers:)
+        # normalize the headers by forcing lowercase, removing any prepended "http"s, and changing underscores to dashes
+        headers = headers.to_h { |k, v| [k.to_s.downcase.sub("http_", "").gsub("_", "-"), v] }
+
+        missing_headers = []
+        [
+          "x-shopify-topic",
+          "x-shopify-hmac-sha256",
+          "x-shopify-shop-domain",
+        ].each { |header| missing_headers << header unless headers.include?(header) }
+        unless missing_headers.empty?
+          raise Errors::InvalidWebhookError,
+            "Missing one or more of the required HTTP headers to process webhooks: #{missing_headers}"
+        end
+
+        @headers = headers
+        @raw_body = raw_body
+      end
+    end
+  end
+end

data/lib/shopify_api.rb

@@ -1,45 +1,23 @@
+# typed: strict
 # frozen_string_literal: true
-$:.unshift(File.dirname(__FILE__))
-require 'active_resource'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'digest/md5'
-require 'base64'
-require 'active_resource/detailed_log_subscriber'
-require 'shopify_api/limits'
-require 'shopify_api/api_version'
-require 'shopify_api/meta'
-require 'active_resource/json_errors'
-require 'shopify_api/paginated_collection'
-require 'shopify_api/disable_prefix_check'
 
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
-  puts("\nshopify_api: NOTE: Support for Ruby #{RUBY_VERSION} will be dropped in the next major release. Please update to Ruby 2.6 or newer before updating this gem.\n\n")
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
-module ShopifyAPI
-  include Limits
-end
+require "oj"
+require "sorbet-runtime"
+require "securerandom"
+require "cgi"
+require "uri"
+require "openssl"
+require "httparty"
+require "zeitwerk"
+require "jwt"
+require "concurrent"
 
-require 'shopify_api/events'
-require 'shopify_api/metafields'
-require 'shopify_api/countable'
-require 'shopify_api/resources'
-require 'shopify_api/session'
-require 'shopify_api/hmac_params'
-require 'shopify_api/api_access'
-require 'shopify_api/message_enricher'
-require 'shopify_api/connection'
-require 'shopify_api/pagination_link_headers'
-require 'shopify_api/graphql'
-require 'shopify_api/graphql/railtie' if defined?(Rails)
+require_relative "shopify_api/inflector"
+require_relative "shopify_api/admin_versions"
 
-if ShopifyAPI::Base.respond_to?(:connection_class)
-  ShopifyAPI::Base.connection_class = ShopifyAPI::Connection
-else
-  require 'active_resource/connection_ext'
-end
-
-if ENV["SHOPIFY_LOG_PATH"]
-  ActiveResource::Base.logger = Logger.new(ENV["SHOPIFY_LOG_PATH"])
-  ActiveResource::DetailedLogSubscriber.attach_to(:active_resource_detailed)
-end
+loader = Zeitwerk::Loader.for_gem
+loader.inflector = ShopifyAPI::Inflector.new(__FILE__)
+loader.ignore("#{__dir__}/shopify_api/rest/resources")
+loader.setup

data/service.yml

@@ -1,5 +1 @@
 audience: partner
-classification: library
-slack_channels:
-- core-build-learn
-- help-api-patterns

data/shipit.rubygems.yml

@@ -1 +1 @@
-# using the default shipit config
+# using the default shipit config

data/shopify_api.gemspec

@@ -1,47 +1,54 @@
 # frozen_string_literal: true
-$:.push(File.expand_path("../lib", __FILE__))
+
+$LOAD_PATH.push(File.expand_path("../lib", __FILE__))
 require "shopify_api/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{shopify_api}
+  s.name = "shopify_api"
   s.version = ShopifyAPI::VERSION
   s.author = "Shopify"
 
-  s.summary = %q{The Shopify API gem is a lightweight gem for accessing the Shopify admin REST web services}
+  s.summary = "The gem for accessing the Shopify API"
   s.description = <<~HERE
-    The Shopify API gem allows Ruby developers to programmatically access the admin
-    section of Shopify stores. The API is implemented as JSON or XML over HTTP using
-    all four verbs (GET/POST/PUT/DELETE). Each resource, like Order, Product, or
-    Collection, has its own URL and is manipulated in isolation.
+    This gem allows Ruby developers to programmatically access the admin
+    section of Shopify stores.
   HERE
-  s.email = %q{developers@jadedpixel.com}
-  s.homepage = %q{http://www.shopify.com/partners/apps}
+  s.email = "developers@shopify.com"
+  s.homepage = "https://shopify.dev/docs/apps"
 
-  s.metadata['allowed_push_host'] = 'https://rubygems.org'
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
 
   s.extra_rdoc_files = [
     "LICENSE",
     "README.md",
   ]
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test)/}) }
+  end
 
   s.rdoc_options = ["--charset=UTF-8"]
-  s.summary = %q{ShopifyAPI is a lightweight gem for accessing the Shopify admin REST web services}
+
   s.license = "MIT"
 
-  s.required_ruby_version = ">= 2.4"
+  s.required_ruby_version = ">= 2.6"
 
-  s.add_runtime_dependency("activeresource", ">= 4.1.0")
-  s.add_runtime_dependency("rack")
-  s.add_runtime_dependency("graphql-client")
+  s.add_runtime_dependency("activesupport")
+  s.add_runtime_dependency("concurrent-ruby")
+  s.add_runtime_dependency("hash_diff")
+  s.add_runtime_dependency("httparty")
+  s.add_runtime_dependency("jwt")
+  s.add_runtime_dependency("oj")
+  s.add_runtime_dependency("openssl")
+  s.add_runtime_dependency("securerandom")
+  s.add_runtime_dependency("sorbet-runtime")
+  s.add_runtime_dependency("zeitwerk", "~> 2.5")
 
-  s.add_development_dependency("mocha", ">= 1.4.0")
-  s.add_development_dependency("webmock")
-  s.add_development_dependency("minitest", ">= 5.14")
+  s.add_development_dependency("pry-byebug")
   s.add_development_dependency("rake")
-  s.add_development_dependency("timecop")
+  s.add_development_dependency("rubocop")
   s.add_development_dependency("rubocop-shopify")
-  s.add_development_dependency("pry")
-  s.add_development_dependency("pry-byebug")
+  s.add_development_dependency("rubocop-sorbet")
+  s.add_development_dependency("ruby-lsp")
+  s.add_development_dependency("sorbet")
+  s.add_development_dependency("tapioca")
 end

data/sorbet/config

@@ -0,0 +1,3 @@
+--dir
+.
+--ignore=test/rest