shopify_api 9.5 → 10.0.0

data/lib/shopify_api/rest/base.rb

@@ -0,0 +1,318 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_support/inflector"
+require "hash_diff"
+
+module ShopifyAPI
+  module Rest
+    class Base
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      @has_one = T.let({}, T::Hash[Symbol, Class])
+      @has_many = T.let({}, T::Hash[Symbol, Class])
+      @paths = T.let([], T::Array[T::Hash[Symbol, T.any(T::Array[Symbol], String, Symbol)]])
+      @custom_prefix = T.let(nil, T.nilable(String))
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_accessor :original_state
+
+      sig { returns(Rest::BaseErrors) }
+      attr_reader :errors
+
+      sig do
+        params(
+          session: T.nilable(Auth::Session),
+          from_hash: T.nilable(T::Hash[Symbol, T.untyped]),
+        ).void
+      end
+      def initialize(session: nil, from_hash: nil)
+        @original_state = T.let({}, T::Hash[Symbol, T.untyped])
+        @custom_prefix = T.let(nil, T.nilable(String))
+        @forced_nils = T.let({}, T::Hash[String, T::Boolean])
+
+        session ||= ShopifyAPI::Context.active_session
+
+        client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
+
+        @session = T.let(T.must(session), Auth::Session)
+        @client = T.let(client, Clients::Rest::Admin)
+        @errors = T.let(Rest::BaseErrors.new, Rest::BaseErrors)
+
+        from_hash&.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :custom_prefix
+
+        sig do
+          params(
+            session: T.nilable(Auth::Session),
+            ids: T::Hash[Symbol, String],
+            params: T::Hash[Symbol, T.untyped],
+          ).returns(T::Array[Base])
+        end
+        def base_find(session: nil, ids: {}, params: {})
+          session ||= ShopifyAPI::Context.active_session
+
+          client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
+
+          path = T.must(get_path(http_method: :get, operation: :get, ids: ids))
+          response = client.get(path: path, query: params.compact)
+
+          instance_variable_get(:"@prev_page_info").value = response.prev_page_info
+          instance_variable_get(:"@next_page_info").value = response.next_page_info
+
+          create_instances_from_response(response: response, session: T.must(session))
+        end
+
+        sig { returns(String) }
+        def class_name
+          T.must(name).demodulize.underscore
+        end
+
+        sig { returns(String) }
+        def primary_key
+          "id"
+        end
+
+        sig { returns(String) }
+        def json_body_name
+          class_name.underscore
+        end
+
+        sig { returns(T.nilable(String)) }
+        def prev_page_info
+          instance_variable_get(:"@prev_page_info").value
+        end
+
+        sig { returns(T.nilable(String)) }
+        def next_page_info
+          instance_variable_get(:"@next_page_info").value
+        end
+
+        sig { returns(T::Boolean) }
+        def prev_page?
+          !instance_variable_get(:"@prev_page_info").value.nil?
+        end
+
+        sig { returns(T::Boolean) }
+        def next_page?
+          !instance_variable_get(:"@next_page_info").value.nil?
+        end
+
+        sig { params(attribute: Symbol).returns(T::Boolean) }
+        def has_many?(attribute)
+          @has_many.include?(attribute)
+        end
+
+        sig { params(attribute: Symbol).returns(T::Boolean) }
+        def has_one?(attribute)
+          @has_one.include?(attribute)
+        end
+
+        sig do
+          params(
+            http_method: Symbol,
+            operation: Symbol,
+            entity: T.nilable(Base),
+            ids: T::Hash[Symbol, T.any(Integer, String)]
+          ).returns(T.nilable(String))
+        end
+        def get_path(http_method:, operation:, entity: nil, ids: {})
+          match = T.let(nil, T.nilable(String))
+          max_ids = T.let(-1, Integer)
+          @paths.each do |path|
+            next if http_method != path[:http_method] || operation != path[:operation]
+
+            path_ids = T.cast(path[:ids], T::Array[Symbol])
+
+            url_ids = ids.transform_keys(&:to_sym)
+            path_ids.each do |id|
+              if url_ids[id].nil? && (entity_id = entity&.public_send(id))
+                url_ids[id] = entity_id
+              end
+            end
+
+            url_ids.compact!
+
+            # We haven't found all the required ids or we have a more specific match
+            next if !(path_ids - url_ids.keys).empty? || path_ids.length <= max_ids
+
+            max_ids = path_ids.length
+            match = T.cast(path[:path], String).gsub(/(<([^>]+)>)/) do
+              url_ids[T.unsafe(Regexp.last_match)[2].to_sym]
+            end
+          end
+
+          custom_prefix ? "#{T.must(custom_prefix).sub(%r{\A/}, "")}/#{match}" : match
+        end
+
+        sig do
+          params(
+            http_method: Symbol,
+            operation: T.any(String, Symbol),
+            session: T.nilable(Auth::Session),
+            ids: T::Hash[Symbol, String],
+            params: T::Hash[Symbol, T.untyped],
+            body: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+            entity: T.untyped,
+          ).returns(Clients::HttpResponse)
+        end
+        def request(http_method:, operation:, session:, ids: {}, params: {}, body: nil, entity: nil)
+          client = ShopifyAPI::Clients::Rest::Admin.new(session: session)
+
+          path = get_path(http_method: http_method, operation: operation.to_sym, ids: ids)
+
+          case http_method
+          when :get
+            client.get(path: T.must(path), query: params.compact)
+          when :post
+            client.post(path: T.must(path), query: params.compact, body: body || {})
+          when :put
+            client.put(path: T.must(path), query: params.compact, body: body || {})
+          when :delete
+            client.delete(path: T.must(path), query: params.compact)
+          else
+            raise Errors::InvalidHttpRequestError, "Invalid HTTP method: #{http_method}"
+          end
+        end
+
+        sig { params(response: Clients::HttpResponse, session: Auth::Session).returns(T::Array[Base]) }
+        def create_instances_from_response(response:, session:)
+          objects = []
+
+          body = T.cast(response.body, T::Hash[String, T.untyped])
+
+          if body.key?(class_name.pluralize) || (body.key?(class_name) && body[class_name].is_a?(Array))
+            (body[class_name.pluralize] || body[class_name]).each do |entry|
+              objects << create_instance(data: entry, session: session)
+            end
+          elsif body.key?(class_name)
+            objects << create_instance(data: body[class_name], session: session)
+          end
+
+          objects
+        end
+
+        sig do
+          params(data: T::Hash[String, T.untyped], session: Auth::Session, instance: T.nilable(Base)).returns(Base)
+        end
+        def create_instance(data:, session:, instance: nil)
+          instance ||= new(session: session)
+          instance.original_state = {}
+
+          unless data.empty?
+            # This retrieves all the setters on the resource and calls them with the data
+            instance_methods(false).select { |method| !method.to_s.include?("=") }.each do |attribute|
+              next unless data.key?(attribute.to_s)
+
+              if has_many?(attribute) && data[attribute.to_s]
+                attr_list = []
+                data[attribute.to_s].each do |element|
+                  attr_list << T.unsafe(@has_many[attribute]).create_instance(data: element, session: session)
+                end
+                instance.public_send("#{attribute}=", attr_list)
+              elsif has_one?(attribute) && data[attribute.to_s]
+                instance.public_send("#{attribute}=",
+                  T.unsafe(@has_one[attribute]).create_instance(data: data[attribute.to_s], session: session))
+              else
+                instance.public_send("#{attribute}=", data[attribute.to_s])
+                instance.original_state[attribute] = data[attribute.to_s]
+              end
+            end
+          end
+
+          instance
+        end
+      end
+
+      sig { params(meth_id: Symbol, val: T.untyped).void }
+      def method_missing(meth_id, val = nil)
+        match = meth_id.id2name.match(/([^=]+)=/)
+
+        return super unless match
+
+        var = match[1]
+
+        instance_variable_set("@#{var}", val)
+        @forced_nils[T.must(var)] = val.nil?
+      end
+
+      sig { params(meth_id: Symbol, args: T.untyped).void }
+      def respond_to_missing?(meth_id, *args)
+        str = meth_id.id2name
+        match = str.match(/([^=]+)=/)
+
+        match.nil? ? true : super
+      end
+
+      sig { returns(T::Hash[String, T.untyped]) }
+      def to_hash
+        hash = {}
+        instance_variables.each do |var|
+          next if [:"@original_state", :"@session", :"@client", :"@forced_nils", :"@errors"].include?(var)
+
+          attribute = var.to_s.delete("@").to_sym
+          if self.class.has_many?(attribute)
+            hash[attribute.to_s] = instance_variable_get(var).map(&:to_hash).to_a if instance_variable_get(var)
+          elsif self.class.has_one?(attribute)
+            element_hash = instance_variable_get(var)&.to_hash
+            hash[attribute.to_s] = element_hash if element_hash || @forced_nils[attribute.to_s]
+          elsif !instance_variable_get(var).nil? || @forced_nils[attribute.to_s]
+            hash[attribute.to_s] =
+              instance_variable_get(var)
+          end
+        end
+        hash
+      end
+
+      sig { params(params: T::Hash[T.untyped, T.untyped]).void }
+      def delete(params: {})
+        @client.delete(
+          path: T.must(self.class.get_path(http_method: :delete, operation: :delete, entity: self)),
+          query: params.compact
+        )
+      rescue ShopifyAPI::Errors::HttpResponseError => e
+        @errors.errors << e
+        raise
+      end
+
+      sig { void }
+      def save!
+        save(update_object: true)
+      end
+
+      sig { params(update_object: T::Boolean).void }
+      def save(update_object: false)
+        hash = HashDiff::Comparison.new(original_state, to_hash).left_diff
+        method = hash[self.class.primary_key] ? :put : :post
+
+        path = self.class.get_path(http_method: method, operation: method, entity: self)
+        if path.nil?
+          method = method == :post ? :put : :post
+          path = self.class.get_path(http_method: method, operation: method, entity: self)
+        end
+
+        response = @client.public_send(method, body: { self.class.json_body_name => hash }, path: path)
+
+        if update_object
+          self.class.create_instance(
+            data: response.body[self.class.class_name.downcase],
+            session: @session, instance: self
+          )
+        end
+      rescue ShopifyAPI::Errors::HttpResponseError => e
+        @errors.errors << e
+        raise
+      end
+    end
+  end
+end

data/lib/shopify_api/rest/base_errors.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ShopifyAPI
+  module Rest
+    class BaseErrors
+      extend T::Sig
+
+      sig { returns(T::Array[ShopifyAPI::Errors::HttpResponseError]) }
+      attr_accessor :errors
+
+      sig { void }
+      def initialize
+        @errors = T.let([], T::Array[ShopifyAPI::Errors::HttpResponseError])
+      end
+
+      sig { returns(String) }
+      def full_messages
+        @errors.join("\n")
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def codes
+        codes = []
+        @errors.each do |error|
+          codes << error.code
+        end
+        codes
+      end
+    end
+  end
+end

data/lib/shopify_api/rest/resources/2021_07/abandoned_checkout.rb

@@ -0,0 +1,186 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class AbandonedCheckout < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @abandoned_checkout_url = T.let(nil, T.nilable(String))
+      @billing_address = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @buyer_accepts_marketing = T.let(nil, T.nilable(T::Boolean))
+      @buyer_accepts_sms_marketing = T.let(nil, T.nilable(T::Boolean))
+      @cart_token = T.let(nil, T.nilable(String))
+      @closed_at = T.let(nil, T.nilable(String))
+      @completed_at = T.let(nil, T.nilable(String))
+      @created_at = T.let(nil, T.nilable(String))
+      @currency = T.let(nil, T.nilable(Currency))
+      @customer = T.let(nil, T.nilable(Customer))
+      @customer_locale = T.let(nil, T.nilable(String))
+      @device_id = T.let(nil, T.nilable(Integer))
+      @discount_codes = T.let(nil, T.nilable(T::Array[T.untyped]))
+      @email = T.let(nil, T.nilable(String))
+      @gateway = T.let(nil, T.nilable(String))
+      @id = T.let(nil, T.nilable(Integer))
+      @landing_site = T.let(nil, T.nilable(String))
+      @line_items = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @location_id = T.let(nil, T.nilable(Integer))
+      @note = T.let(nil, T.nilable(String))
+      @phone = T.let(nil, T.nilable(String))
+      @presentment_currency = T.let(nil, T.nilable(String))
+      @referring_site = T.let(nil, T.nilable(String))
+      @shipping_address = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @shipping_lines = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @sms_marketing_phone = T.let(nil, T.nilable(String))
+      @source_name = T.let(nil, T.nilable(String))
+      @subtotal_price = T.let(nil, T.nilable(String))
+      @tax_lines = T.let(nil, T.nilable(T::Hash[T.untyped, T.untyped]))
+      @taxes_included = T.let(nil, T.nilable(T::Boolean))
+      @token = T.let(nil, T.nilable(String))
+      @total_discounts = T.let(nil, T.nilable(String))
+      @total_duties = T.let(nil, T.nilable(String))
+      @total_line_items_price = T.let(nil, T.nilable(String))
+      @total_price = T.let(nil, T.nilable(String))
+      @total_tax = T.let(nil, T.nilable(String))
+      @total_weight = T.let(nil, T.nilable(Integer))
+      @updated_at = T.let(nil, T.nilable(String))
+      @user_id = T.let(nil, T.nilable(Integer))
+    end
+
+    @has_one = T.let({
+      currency: Currency,
+      customer: Customer
+    }, T::Hash[Symbol, Class])
+    @has_many = T.let({
+      discount_codes: DiscountCode
+    }, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :get, operation: :checkouts, ids: [], path: "checkouts.json"},
+      {http_method: :get, operation: :checkouts, ids: [], path: "checkouts.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :abandoned_checkout_url
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :billing_address
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :buyer_accepts_marketing
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :buyer_accepts_sms_marketing
+    sig { returns(T.nilable(String)) }
+    attr_reader :cart_token
+    sig { returns(T.nilable(String)) }
+    attr_reader :closed_at
+    sig { returns(T.nilable(String)) }
+    attr_reader :completed_at
+    sig { returns(T.nilable(String)) }
+    attr_reader :created_at
+    sig { returns(T.nilable(Currency)) }
+    attr_reader :currency
+    sig { returns(T.nilable(Customer)) }
+    attr_reader :customer
+    sig { returns(T.nilable(String)) }
+    attr_reader :customer_locale
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :device_id
+    sig { returns(T.nilable(T::Array[DiscountCode])) }
+    attr_reader :discount_codes
+    sig { returns(T.nilable(String)) }
+    attr_reader :email
+    sig { returns(T.nilable(String)) }
+    attr_reader :gateway
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(String)) }
+    attr_reader :landing_site
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :line_items
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :location_id
+    sig { returns(T.nilable(String)) }
+    attr_reader :note
+    sig { returns(T.nilable(String)) }
+    attr_reader :phone
+    sig { returns(T.nilable(String)) }
+    attr_reader :presentment_currency
+    sig { returns(T.nilable(String)) }
+    attr_reader :referring_site
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :shipping_address
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :shipping_lines
+    sig { returns(T.nilable(String)) }
+    attr_reader :sms_marketing_phone
+    sig { returns(T.nilable(String)) }
+    attr_reader :source_name
+    sig { returns(T.nilable(String)) }
+    attr_reader :subtotal_price
+    sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+    attr_reader :tax_lines
+    sig { returns(T.nilable(T::Boolean)) }
+    attr_reader :taxes_included
+    sig { returns(T.nilable(String)) }
+    attr_reader :token
+    sig { returns(T.nilable(String)) }
+    attr_reader :total_discounts
+    sig { returns(T.nilable(String)) }
+    attr_reader :total_duties
+    sig { returns(T.nilable(String)) }
+    attr_reader :total_line_items_price
+    sig { returns(T.nilable(String)) }
+    attr_reader :total_price
+    sig { returns(T.nilable(String)) }
+    attr_reader :total_tax
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :total_weight
+    sig { returns(T.nilable(String)) }
+    attr_reader :updated_at
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :user_id
+
+    class << self
+      sig do
+        params(
+          since_id: T.untyped,
+          created_at_min: T.untyped,
+          created_at_max: T.untyped,
+          updated_at_min: T.untyped,
+          updated_at_max: T.untyped,
+          status: T.untyped,
+          limit: T.untyped,
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T.untyped)
+      end
+      def checkouts(
+        since_id: nil,
+        created_at_min: nil,
+        created_at_max: nil,
+        updated_at_min: nil,
+        updated_at_max: nil,
+        status: nil,
+        limit: nil,
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        request(
+          http_method: :get,
+          operation: :checkouts,
+          session: session,
+          ids: {},
+          params: {since_id: since_id, created_at_min: created_at_min, created_at_max: created_at_max, updated_at_min: updated_at_min, updated_at_max: updated_at_max, status: status, limit: limit}.merge(kwargs).compact,
+          body: {},
+          entity: nil,
+        )
+      end
+
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_07/access_scope.rb

@@ -0,0 +1,54 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class AccessScope < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @handle = T.let(nil, T.nilable(String))
+      @access_scopes = T.let(nil, T.nilable(T::Array[T.untyped]))
+    end
+
+    @has_one = T.let({}, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @custom_prefix = T.let("/admin/oauth", T.nilable(String))
+    @paths = T.let([
+      {http_method: :get, operation: :get, ids: [], path: "access_scopes.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :handle
+    sig { returns(T.nilable(T::Array[T::Hash[T.untyped, T.untyped]])) }
+    attr_reader :access_scopes
+
+    class << self
+      sig do
+        params(
+          session: Auth::Session,
+          kwargs: T.untyped
+        ).returns(T::Array[AccessScope])
+      end
+      def all(
+        session: ShopifyAPI::Context.active_session,
+        **kwargs
+      )
+        response = base_find(
+          session: session,
+          ids: {},
+          params: {}.merge(kwargs).compact,
+        )
+
+        T.cast(response, T::Array[AccessScope])
+      end
+
+    end
+
+  end
+end

data/lib/shopify_api/rest/resources/2021_07/android_pay_key.rb

@@ -0,0 +1,73 @@
+# typed: false
+# frozen_string_literal: true
+
+module ShopifyAPI
+  class AndroidPayKey < ShopifyAPI::Rest::Base
+    extend T::Sig
+
+    @prev_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+    @next_page_info = T.let(Concurrent::ThreadLocalVar.new { nil }, Concurrent::ThreadLocalVar)
+
+    sig { params(session: T.nilable(ShopifyAPI::Auth::Session)).void }
+    def initialize(session: ShopifyAPI::Context.active_session)
+      super(session: session)
+
+      @id = T.let(nil, T.nilable(Integer))
+      @public_key = T.let(nil, T.nilable(String))
+    end
+
+    @has_one = T.let({}, T::Hash[Symbol, Class])
+    @has_many = T.let({}, T::Hash[Symbol, Class])
+    @paths = T.let([
+      {http_method: :delete, operation: :delete, ids: [:id], path: "android_pay_keys/<id>.json"},
+      {http_method: :get, operation: :get, ids: [:id], path: "android_pay_keys/<id>.json"},
+      {http_method: :post, operation: :post, ids: [], path: "android_pay_keys.json"}
+    ], T::Array[T::Hash[String, T.any(T::Array[Symbol], String, Symbol)]])
+
+    sig { returns(T.nilable(Integer)) }
+    attr_reader :id
+    sig { returns(T.nilable(String)) }
+    attr_reader :public_key
+
+    class << self
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.nilable(AndroidPayKey))
+      end
+      def find(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        result = base_find(
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+        T.cast(result[0], T.nilable(AndroidPayKey))
+      end
+
+      sig do
+        params(
+          id: T.any(Integer, String),
+          session: Auth::Session
+        ).returns(T.untyped)
+      end
+      def delete(
+        id:,
+        session: ShopifyAPI::Context.active_session
+      )
+        request(
+          http_method: :delete,
+          operation: :delete,
+          session: session,
+          ids: {id: id},
+          params: {},
+        )
+      end
+
+    end
+
+  end
+end