shopify_api 4.13.0 → 12.2.1

data/lib/shopify_api/auth/session.rb

@@ -0,0 +1,119 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Auth
+    class Session
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :state, :access_token
+
+      sig { returns(String) }
+      attr_accessor :shop
+
+      sig { returns(AuthScopes) }
+      attr_accessor :scope
+
+      sig { returns(T.nilable(AuthScopes)) }
+      attr_accessor :associated_user_scope
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :expires
+
+      sig { returns(T.nilable(AssociatedUser)) }
+      attr_accessor :associated_user
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :shopify_session_id
+
+      sig { returns(T::Boolean) }
+      def online?
+        @is_online
+      end
+
+      sig do
+        params(
+          shop: String,
+          id: T.nilable(String),
+          state: T.nilable(String),
+          access_token: T.nilable(String),
+          scope: T.any(T::Array[String], String),
+          associated_user_scope: T.nilable(T.any(T::Array[String], String)),
+          expires: T.nilable(Time),
+          is_online: T.nilable(T::Boolean),
+          associated_user: T.nilable(AssociatedUser),
+          shopify_session_id: T.nilable(String),
+        ).void
+      end
+      def initialize(shop:, id: nil, state: nil, access_token: "", scope: [], associated_user_scope: nil, expires: nil,
+        is_online: nil, associated_user: nil, shopify_session_id: nil)
+        @id = T.let(id || SecureRandom.uuid, String)
+        @shop = shop
+        @state = state
+        @access_token = access_token
+        @scope = T.let(AuthScopes.new(scope), AuthScopes)
+        @associated_user_scope = T.let(
+          associated_user_scope.nil? ? nil : AuthScopes.new(associated_user_scope), T.nilable(AuthScopes)
+        )
+        @expires = expires
+        @associated_user = associated_user
+        @is_online = T.let(is_online || !associated_user.nil?, T::Boolean)
+        @shopify_session_id = shopify_session_id
+      end
+
+      class << self
+        extend T::Sig
+
+        sig do
+          params(shop: String, access_token: String,
+            blk: T.proc.params(arg0: Session).returns(T.untyped)).returns(T.untyped)
+        end
+        def temp(shop:, access_token:, &blk)
+          original_session = Context.active_session
+          temp_session = Session.new(shop: shop, access_token: access_token)
+
+          begin
+            Context.activate_session(temp_session)
+            yield temp_session
+          ensure
+            Context.activate_session(original_session)
+          end
+        end
+
+        sig { params(str: String).returns(Session) }
+        def deserialize(str)
+          Oj.load(str)
+        end
+      end
+
+      sig { returns(String) }
+      def serialize
+        Oj.dump(self)
+      end
+
+      alias_method :eql?, :==
+      sig { params(other: T.nilable(Session)).returns(T::Boolean) }
+      def ==(other)
+        if other
+          (
+            id == other.id &&
+            shop == other.shop &&
+            state == other.state &&
+            scope == other.scope &&
+            associated_user_scope == other.associated_user_scope &&
+            (!(expires.nil? ^ other.expires.nil?) && (expires.nil? || expires.to_i == other.expires.to_i)) &&
+            online? == other.online? &&
+            associated_user == other.associated_user &&
+            shopify_session_id == other.shopify_session_id
+          )
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/auth/session_storage.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Auth
+    module SessionStorage
+      extend T::Sig
+      extend T::Helpers
+      interface!
+
+      sig do
+        abstract.params(session: Session)
+          .returns(T::Boolean)
+      end
+      def store_session(session); end
+
+      sig do
+        abstract.params(id: String)
+          .returns(T.nilable(Session))
+      end
+      def load_session(id); end
+
+      sig do
+        abstract.params(id: String)
+          .returns(T::Boolean)
+      end
+      def delete_session(id); end
+    end
+  end
+end

data/lib/shopify_api/auth.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Auth
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      sig { params(host: T.nilable(String)).returns(String) }
+      def embedded_app_url(host)
+        unless Context.setup?
+          raise Errors::ContextNotSetupError, "ShopifyAPI::Context not setup, please call ShopifyAPI::Context.setup"
+        end
+
+        unless host
+          raise Errors::MissingRequiredArgumentError, "host argument is required"
+        end
+
+        decoded_host = Base64.decode64(host)
+        "https://#{decoded_host}/apps/#{Context.api_key}"
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/graphql/admin.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    module Graphql
+      class Admin < Client
+        sig { params(session: T.nilable(Auth::Session)).void }
+        def initialize(session:)
+          super(session: session, base_path: "/admin/api")
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/graphql/client.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    module Graphql
+      class Client
+        extend T::Sig
+
+        sig { params(session: T.nilable(Auth::Session), base_path: String).void }
+        def initialize(session:, base_path:)
+          @http_client = T.let(HttpClient.new(session: session, base_path: base_path), HttpClient)
+        end
+
+        sig do
+          params(
+            query: String,
+            variables: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: Integer,
+          ).returns(HttpResponse)
+        end
+        def query(query:, variables: nil, headers: nil, tries: 1)
+          body = { query: query, variables: variables }
+          @http_client.request(
+            HttpRequest.new(
+              http_method: :post,
+              path: "#{Context.api_version}/graphql.json",
+              body: body,
+              query: nil,
+              extra_headers: headers,
+              body_type: "application/json",
+              tries: tries,
+            ),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/graphql/storefront.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    module Graphql
+      class Storefront < Client
+        sig { params(shop: String, storefront_access_token: String).void }
+        def initialize(shop, storefront_access_token)
+          session = Auth::Session.new(
+            id: shop,
+            shop: shop,
+            access_token: "",
+            is_online: false,
+          )
+          super(session: session, base_path: "/api")
+          @storefront_access_token = storefront_access_token
+        end
+
+        sig do
+          params(
+            query: String,
+            variables: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: Integer,
+          ).returns(HttpResponse)
+        end
+        def query(query:, variables: nil, headers: {}, tries: 1)
+          T.must(headers).merge!({ "X-Shopify-Storefront-Access-Token": @storefront_access_token })
+          super(query: query, variables: variables, headers: headers, tries: tries)
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/http_client.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    class HttpClient
+      extend T::Sig
+
+      RETRY_WAIT_TIME = 1
+
+      sig { params(base_path: String, session: T.nilable(Auth::Session)).void }
+      def initialize(base_path:, session: nil)
+        session ||= Context.active_session
+        raise Errors::NoActiveSessionError, "No passed or active session" unless session
+
+        @base_uri = T.let("https://#{session.shop}", String)
+        @base_uri_and_path = T.let("#{@base_uri}#{base_path}", String)
+
+        user_agent_prefix = Context.user_agent_prefix.nil? ? "" : "#{Context.user_agent_prefix} | "
+
+        @headers = T.let({
+          "User-Agent": "#{user_agent_prefix}Shopify API Library v#{VERSION} | Ruby #{RUBY_VERSION}",
+          "Accept": "application/json",
+        }, T::Hash[T.any(Symbol, String), T.untyped])
+
+        unless session.access_token.nil? || T.must(session.access_token).empty?
+          @headers["X-Shopify-Access-Token"] = T.cast(session.access_token, String)
+        end
+      end
+
+      sig { params(request: HttpRequest).returns(HttpResponse) }
+      def request(request)
+        request.verify
+
+        headers = @headers
+        headers["Content-Type"] = T.must(request.body_type) if request.body_type
+        headers = headers.merge(T.must(request.extra_headers)) if request.extra_headers
+
+        tries = 0
+        response = HttpResponse.new(code: 0, headers: {}, body: "")
+        while tries < request.tries
+          tries += 1
+          res = T.cast(HTTParty.send(
+            request.http_method,
+            request_url(request),
+            headers: headers,
+            query: request.query,
+            body: request.body.class == Hash ? T.unsafe(request.body).to_json : request.body,
+          ), HTTParty::Response)
+
+          body = res.body.empty? ? {} : JSON.parse(res.body)
+          response = HttpResponse.new(code: res.code.to_i, headers: res.headers.to_h, body: body)
+
+          if response.headers["x-shopify-api-deprecated-reason"]
+            reason = T.must(response.headers["x-shopify-api-deprecated-reason"])[0]
+            Context.logger.warn("Deprecated request to Shopify API at #{request.path}, received reason: #{reason}")
+          end
+
+          break if response.ok?
+
+          error_messages = []
+          error_messages << response.body["errors"] if response.body["errors"]
+
+          if response.headers["x-request-id"]
+            id = T.must(response.headers["x-request-id"])[0]
+            error_messages << "If you report this error, please include this id: #{id}."
+          end
+
+          error_message = error_messages.join("\n")
+
+          unless [429, 500].include?(response.code)
+            raise ShopifyAPI::Errors::HttpResponseError.new(code: response.code.to_i), error_message
+          end
+
+          if tries == request.tries
+            raise ShopifyAPI::Errors::HttpResponseError.new(code: response.code), error_message if request.tries == 1
+
+            raise ShopifyAPI::Errors::MaxHttpRetriesExceededError.new(code: response.code),
+              "Exceeded maximum retry count of #{request.tries}. Last message: #{error_message}"
+          end
+
+          if response.code == 500 || response.headers["retry-after"].nil?
+            sleep(RETRY_WAIT_TIME)
+          else
+            sleep(T.must(response.headers["retry-after"])[0].to_i)
+          end
+        end
+
+        response
+      end
+
+      protected
+
+      sig { params(request: HttpRequest).returns(String) }
+      def request_url(request)
+        "#{@base_uri_and_path}/#{request.path}"
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/http_request.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    class HttpRequest < T::Struct
+      extend T::Sig
+
+      prop :http_method, Symbol
+      prop :path, String
+      prop :body, T.nilable(T.any(T::Hash[T.any(Symbol, String), T.untyped], String))
+      prop :body_type, T.nilable(String)
+      prop :query, T.nilable(T::Hash[T.any(Symbol, String), T.untyped])
+      prop :extra_headers, T.nilable(T::Hash[T.any(Symbol, String), T.untyped])
+      prop :tries, Integer, default: 1
+
+      sig { void }
+      def verify
+        unless [:get, :delete, :put, :post].include?(http_method)
+          raise ShopifyAPI::Errors::InvalidHttpRequestError, "Invalid Http method #{http_method}."
+        end
+
+        if body && !body_type
+          raise ShopifyAPI::Errors::InvalidHttpRequestError, "Cannot set a body without also setting body_type."
+        end
+
+        return unless [:put, :post].include?(http_method)
+
+        unless  body
+          raise ShopifyAPI::Errors::InvalidHttpRequestError, "Cannot use #{http_method} without specifying data."
+        end
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/http_response.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    class HttpResponse
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :code
+
+      sig { returns(T::Hash[String, T::Array[String]]) }
+      attr_reader :headers
+
+      sig { returns(T.any(T::Hash[String, T.untyped], String)) }
+      attr_reader :body
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :prev_page_info, :next_page_info
+
+      sig do
+        params(
+          code: Integer,
+          headers: T::Hash[String, T::Array[String]],
+          body: T.any(T::Hash[String, T.untyped], String),
+        ).void
+      end
+      def initialize(code:, headers:, body:)
+        @code = code
+        @headers = headers
+        @body = body
+
+        @prev_page_info = T.let(nil, T.nilable(String))
+        @next_page_info = T.let(nil, T.nilable(String))
+        @prev_page_info, @next_page_info = parse_link_header
+      end
+
+      sig { returns(T::Boolean) }
+      def ok?
+        code >= 200 && code <= 299
+      end
+
+      private
+
+      sig { returns(T::Array[T.nilable(String)]) }
+      def parse_link_header
+        return [nil, nil] if @headers["link"].nil?
+
+        page_info = {}
+        T.must(T.must(@headers["link"])[0]).split(",").each do |link|
+          rel = T.must(link.match(/rel="(.*?)"/))[1]
+          url = T.must(T.must(link.match(/<(.*?)>/))[1])
+
+          T.must(URI.parse(url).query).split("&").each do |param|
+            if param.split("=")[0] == "page_info"
+              page_info[rel] = param.split("=")[1]
+              break
+            end
+          end
+        end
+
+        [page_info["previous"], page_info["next"]]
+      end
+    end
+  end
+end

data/lib/shopify_api/clients/rest/admin.rb

@@ -0,0 +1,118 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Clients
+    module Rest
+      class Admin < HttpClient
+        extend T::Sig
+
+        sig { params(session: T.nilable(Auth::Session)).void }
+        def initialize(session: nil)
+          super(session: session, base_path: "/admin/api/#{Context.api_version}")
+        end
+
+        sig do
+          params(
+            path: String,
+            body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: T.nilable(Integer),
+          ).returns(HttpResponse)
+        end
+        def get(path:, body: nil, query: nil, headers: nil, tries: 1)
+          request(
+            make_request(http_method: :get, path: path, body: body, query: query, headers: headers,
+              tries: T.must(tries)),
+          )
+        end
+
+        sig do
+          params(
+            path: String,
+            body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: T.nilable(Integer),
+          ).returns(HttpResponse)
+        end
+        def delete(path:, body: nil, query: nil, headers: nil, tries: 1)
+          request(
+            make_request(http_method: :delete, path: path, body: body, query: query, headers: headers,
+              tries: T.must(tries)),
+          )
+        end
+
+        sig do
+          params(
+            path: String,
+            body: T::Hash[T.any(Symbol, String), T.untyped],
+            query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: T.nilable(Integer),
+          ).returns(HttpResponse)
+        end
+        def put(path:, body:, query: nil, headers: nil, tries: 1)
+          request(
+            make_request(http_method: :put, path: path, body: body, query: query, headers: headers,
+              tries: T.must(tries)),
+          )
+        end
+
+        sig do
+          params(
+            path: String,
+            body: T::Hash[T.any(Symbol, String), T.untyped],
+            query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: T.nilable(Integer),
+          ).returns(HttpResponse)
+        end
+        def post(path:, body:, query: nil, headers: nil, tries: 1)
+          request(
+            make_request(http_method: :post, path: path, body: body, query: query, headers: headers,
+              tries: T.must(tries)),
+          )
+        end
+
+        protected
+
+        sig { params(request: HttpRequest).returns(String) }
+        def request_url(request)
+          request_path = request.path.sub(%r/\A\//, "").sub(/\.json\z/, "") + ".json"
+
+          if request_path.start_with?("admin/")
+            "#{@base_uri}/#{request_path}"
+          else
+            "#{@base_uri_and_path}/#{request_path}"
+          end
+        end
+
+        private
+
+        sig do
+          params(
+            http_method: Symbol,
+            path: String,
+            body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            query: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            headers: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            tries: Integer,
+          ).returns(HttpRequest)
+        end
+        def make_request(http_method:, path:, body:, query:, headers:, tries:)
+          HttpRequest.new(
+            http_method: http_method,
+            path: path,
+            body: body,
+            query: query,
+            extra_headers: headers,
+            body_type: body.nil? ? nil : "application/json",
+            tries: tries,
+          )
+        end
+      end
+    end
+  end
+end