payabli 1.0.1

data/lib/payabli/import/client.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Import
+    class Client
+      # @param client [Payabli::Internal::Http::RawClient]
+      #
+      # @return [Payabli::Import::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Import a list of bills from a CSV file. See the [Import Guide](/developers/developer-guides/bills-add#import-bills) for more help and an example file.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [void]
+      #
+      # @return [Payabli::Types::PayabliApiResponseImport]
+      def import_bills(request_options: {}, **params)
+        body = Internal::Multipart::FormData.new
+
+        body.add_part(params[:file].to_form_data_part(name: "file")) if params[:file]
+
+        _request = Payabli::Internal::Multipart::Request.new(
+          method: POST,
+          path: "Import/billsForm/#{params[:entry]}",
+          body: body
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Types::PayabliApiResponseImport.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Import a list of customers from a CSV file. See the [Import Guide](/developers/developer-guides/entities-customers#import-customers) for more help and example files.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [void]
+      #
+      # @return [Payabli::Types::PayabliApiResponseImport]
+      def import_customer(request_options: {}, **params)
+        body = Internal::Multipart::FormData.new
+
+        body.add_part(params[:file].to_form_data_part(name: "file")) if params[:file]
+
+        _request = Payabli::Internal::Multipart::Request.new(
+          method: POST,
+          path: "Import/customersForm/#{params[:entry]}",
+          body: body
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Types::PayabliApiResponseImport.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Import a list of vendors from a CSV file. See the [Import Guide](/developers/developer-guides/entities-vendors#import-vendors) for more help and example files.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [void]
+      #
+      # @return [Payabli::Types::PayabliApiResponseImport]
+      def import_vendor(request_options: {}, **params)
+        body = Internal::Multipart::FormData.new
+
+        body.add_part(params[:file].to_form_data_part(name: "file")) if params[:file]
+
+        _request = Payabli::Internal::Multipart::Request.new(
+          method: POST,
+          path: "Import/vendorsForm/#{params[:entry]}",
+          body: body
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Types::PayabliApiResponseImport.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/payabli/import/types/import_bills_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Import
+    module Types
+      class ImportBillsRequest < Internal::Types::Model
+        field :entry, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/payabli/import/types/import_customer_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Import
+    module Types
+      class ImportCustomerRequest < Internal::Types::Model
+        field :entry, -> { String }, optional: false, nullable: false
+        field :replace_existing, -> { Integer }, optional: true, nullable: false, api_name: "replaceExisting"
+      end
+    end
+  end
+end

data/lib/payabli/import/types/import_vendor_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Import
+    module Types
+      class ImportVendorRequest < Internal::Types::Model
+        field :entry, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/payabli/internal/errors/constraint_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Errors
+      class ConstraintError < StandardError
+      end
+    end
+  end
+end

data/lib/payabli/internal/errors/type_error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Errors
+      class TypeError < StandardError
+      end
+    end
+  end
+end

data/lib/payabli/internal/http/base_request.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Http
+      # @api private
+      class BaseRequest
+        attr_reader :base_url, :path, :method, :headers, :query, :request_options
+
+        # @param base_url [String] The base URL for the request
+        # @param path [String] The path for the request
+        # @param method [String] The HTTP method for the request (:get, :post, etc.)
+        # @param headers [Hash] Additional headers for the request (optional)
+        # @param query [Hash] Query parameters for the request (optional)
+        # @param request_options [Payabli::RequestOptions, Hash{Symbol=>Object}, nil]
+        def initialize(base_url:, path:, method:, headers: {}, query: {}, request_options: {})
+          @base_url = base_url
+          @path = path
+          @method = method
+          @headers = headers
+          @query = query
+          @request_options = request_options
+        end
+
+        # Child classes should implement:
+        # - encode_headers: Returns the encoded HTTP request headers.
+        # - encode_body: Returns the encoded HTTP request body.
+      end
+    end
+  end
+end

data/lib/payabli/internal/http/raw_client.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Http
+      # @api private
+      class RawClient
+        # @param base_url [String] The base url for the request.
+        # @param max_retries [Integer] The number of times to retry a failed request, defaults to 2.
+        # @param timeout [Float] The timeout for the request, defaults to 60.0 seconds.
+        # @param headers [Hash] The headers for the request.
+        def initialize(base_url:, max_retries: 2, timeout: 60.0, headers: {})
+          @base_url = base_url
+          @max_retries = max_retries
+          @timeout = timeout
+          @default_headers = {
+            "X-Fern-Language": "Ruby",
+            "X-Fern-SDK-Name": "payabli",
+            "X-Fern-SDK-Version": "0.0.1"
+          }.merge(headers)
+        end
+
+        # @param request [Payabli::Internal::Http::BaseRequest] The HTTP request.
+        # @return [HTTP::Response] The HTTP response.
+        def send(request)
+          url = build_url(request)
+
+          http_request = build_http_request(
+            url:,
+            method: request.method,
+            headers: request.encode_headers,
+            body: request.encode_body
+          )
+
+          conn = connect(url)
+          conn.open_timeout = @timeout
+          conn.read_timeout = @timeout
+          conn.write_timeout = @timeout
+          conn.continue_timeout = @timeout
+
+          conn.request(http_request)
+          # begin
+          #   conn.request(http_request)
+          # rescue StandardError => e
+          #   raise HttpError, "HTTP request failed: #{e.message}"
+          # end
+        end
+
+        # @param request [Payabli::Internal::Http::BaseRequest] The HTTP request.
+        # @return [URI::Generic] The URL.
+        def build_url(request)
+          path = request.path.start_with?("/") ? request.path[1..] : request.path
+          url = "#{@base_url.chomp("/")}/#{path}"
+          url = "#{url}?#{encode_query(request.query)}" if request.query&.any?
+          URI.parse(url)
+        end
+
+        # @param url [URI::Generic] The url to the resource.
+        # @param method [String] The HTTP method to use.
+        # @param headers [Hash] The headers for the request.
+        # @param body [String, nil] The body for the request.
+        # @return [HTTP::Request] The HTTP request.
+        def build_http_request(url:, method:, headers: {}, body: nil)
+          request = Net::HTTPGenericRequest.new(
+            method,
+            !body.nil?,
+            method != "HEAD",
+            url
+          )
+
+          request_headers = @default_headers.merge(headers)
+          request_headers.each { |name, value| request[name] = value }
+          request.body = body if body
+
+          request
+        end
+
+        # @param query [Hash] The query for the request.
+        # @return [String, nil] The encoded query.
+        def encode_query(query)
+          query.to_h.empty? ? nil : URI.encode_www_form(query)
+        end
+
+        # @param url [URI::Generic] The url to connect to.
+        # @return [Net::HTTP] The HTTP connection.
+        def connect(url)
+          is_https = (url.scheme == "https")
+
+          port = if url.port
+                   url.port
+                 elsif is_https
+                   Net::HTTP.https_default_port
+                 else
+                   Net::HTTP.http_default_port
+                 end
+
+          http = Net::HTTP.new(url.host, port)
+          http.use_ssl = is_https
+          http.max_retries = 0
+          http
+        end
+      end
+    end
+  end
+end

data/lib/payabli/internal/iterators/cursor_item_iterator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    class CursorItemIterator < ItemIterator
+      # Instantiates a CursorItemIterator, an Enumerable class which wraps calls to a cursor-based paginated API and yields individual items from it.
+      #
+      # @param initial_cursor [String] The initial cursor to use when iterating, if any.
+      # @param cursor_field [Symbol] The field in API responses to extract the next cursor from.
+      # @param item_field [Symbol] The field in API responses to extract the items to iterate over.
+      # @param block [Proc] A block which is responsible for receiving a cursor to use and returning the given page from the API.
+      # @return [Payabli::Internal::CursorItemIterator]
+      def initialize(initial_cursor:, cursor_field:, item_field:, &block)
+        @item_field = item_field
+        @page_iterator = CursorPageIterator.new(initial_cursor:, cursor_field:, &block)
+        @page = nil
+      end
+
+      # Returns the CursorPageIterator mediating access to the underlying API.
+      #
+      # @return [Payabli::Internal::CursorPageIterator]
+      def pages
+        @page_iterator
+      end
+    end
+  end
+end

data/lib/payabli/internal/iterators/cursor_page_iterator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    class CursorPageIterator
+      include Enumerable
+
+      # Instantiates a CursorPageIterator, an Enumerable class which wraps calls to a cursor-based paginated API and yields pages of items.
+      #
+      # @param initial_cursor [String] The initial cursor to use when iterating, if any.
+      # @param cursor_field [Symbol] The name of the field in API responses to extract the next cursor from.
+      # @param block [Proc] A block which is responsible for receiving a cursor to use and returning the given page from the API.
+      # @return [Payabli::Internal::CursorPageIterator]
+      def initialize(initial_cursor:, cursor_field:, &block)
+        @need_initial_load = initial_cursor.nil?
+        @cursor = initial_cursor
+        @cursor_field = cursor_field
+        @get_next_page = block
+      end
+
+      # Iterates over each page returned by the API.
+      #
+      # @param block [Proc] The block which each retrieved page is yielded to.
+      # @return [NilClass]
+      def each(&block)
+        while (page = get_next)
+          block.call(page)
+        end
+      end
+
+      # Whether another page will be available from the API.
+      #
+      # @return [Boolean]
+      def has_next?
+        @need_initial_load || !@cursor.nil?
+      end
+
+      # Retrieves the next page from the API.
+      #
+      # @return [Boolean]
+      def get_next
+        return if !@need_initial_load && @cursor.nil?
+
+        @need_initial_load = false
+        next_page = @get_next_page.call(@cursor)
+        @cursor = next_page.send(@cursor_field)
+        next_page
+      end
+    end
+  end
+end

data/lib/payabli/internal/iterators/item_iterator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    class ItemIterator
+      include Enumerable
+
+      # Iterates over each item returned by the API.
+      #
+      # @param block [Proc] The block which each retrieved item is yielded to.
+      # @return [NilClass]
+      def each(&block)
+        while (item = get_next)
+          block.call(item)
+        end
+      end
+
+      # Whether another item will be available from the API.
+      #
+      # @return [Boolean]
+      def has_next?
+        load_next_page if @page.nil?
+        return false if @page.nil?
+
+        return true if any_items_in_cached_page
+
+        load_next_page
+        any_items_in_cached_page
+      end
+
+      # Retrieves the next item from the API.
+      def get_next
+        item = next_item_from_cached_page
+        return item if item
+
+        load_next_page
+        next_item_from_cached_page
+      end
+
+      private
+
+      def next_item_from_cached_page
+        return unless @page
+
+        @page.send(@item_field).shift
+      end
+
+      def any_items_in_cached_page
+        return false unless @page
+
+        !@page.send(@item_field).empty?
+      end
+
+      def load_next_page
+        @page = @page_iterator.get_next
+      end
+    end
+  end
+end

data/lib/payabli/internal/iterators/offset_item_iterator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    class OffsetItemIterator < ItemIterator
+      # Instantiates an OffsetItemIterator, an Enumerable class which wraps calls to an offset-based paginated API and yields the individual items from it.
+      #
+      # @param initial_page [Integer] The initial page or offset to start from when iterating.
+      # @param item_field [Symbol] The name of the field in API responses to extract the items to iterate over.
+      # @param has_next_field [Symbol] The name of the field in API responses containing a boolean of whether another page exists.
+      # @param step [Boolean] If true, treats the page number as a true offset (i.e. increments the page number by the number of items returned from each call rather than just 1)
+      # @param block [Proc] A block which is responsible for receiving a page number to use and returning the given page from the API.
+      #
+      # @return [Payabli::Internal::OffsetItemIterator]
+      def initialize(initial_page:, item_field:, has_next_field:, step:, &block)
+        @item_field = item_field
+        @page_iterator = OffsetPageIterator.new(initial_page:, item_field:, has_next_field:, step:, &block)
+        @page = nil
+      end
+
+      # Returns the OffsetPageIterator that is mediating access to the underlying API.
+      #
+      # @return [Payabli::Internal::OffsetPageIterator]
+      def pages
+        @page_iterator
+      end
+    end
+  end
+end

data/lib/payabli/internal/iterators/offset_page_iterator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    class OffsetPageIterator
+      include Enumerable
+
+      # Instantiates an OffsetPageIterator, an Enumerable class which wraps calls to an offset-based paginated API and yields pages of items from it.
+      #
+      # @param initial_page [Integer] The initial page to use when iterating, if any.
+      # @param item_field [Symbol] The field to pull the list of items to iterate over.
+      # @param has_next_field [Symbol] The field to pull the boolean of whether a next page exists from, if any.
+      # @param step [Boolean] If true, treats the page number as a true offset (i.e. increments the page number by the number of items returned from each call rather than just 1)
+      # @param block [Proc] A block which is responsible for receiving a page number to use and returning the given page from the API.
+      # @return [Payabli::Internal::OffsetPageIterator]
+      def initialize(initial_page:, item_field:, has_next_field:, step:, &block)
+        @page_number = initial_page || (step ? 0 : 1)
+        @item_field = item_field
+        @has_next_field = has_next_field
+        @step = step
+        @get_next_page = block
+
+        # A cache of whether the API has another page, if it gives us that information...
+        @next_page = nil
+        # ...or the actual next page, preloaded, if it doesn't.
+        @has_next_page = nil
+      end
+
+      # Iterates over each page returned by the API.
+      #
+      # @param block [Proc] The block which each retrieved page is yielded to.
+      # @return [NilClass]
+      def each(&block)
+        while (page = get_next)
+          block.call(page)
+        end
+      end
+
+      # Whether another page will be available from the API.
+      #
+      # @return [Boolean]
+      def has_next?
+        return @has_next_page unless @has_next_page.nil?
+        return true if @next_page
+
+        next_page = @get_next_page.call(@page_number)
+        next_page_items = next_page&.send(@item_field)
+        if next_page_items.nil? || next_page_items.empty?
+          @has_next_page = false
+        else
+          @next_page = next_page
+          true
+        end
+      end
+
+      # Returns the next page from the API.
+      def get_next
+        return nil if @page_number.nil?
+
+        if @next_page
+          this_page = @next_page
+          @next_page = nil
+        else
+          this_page = @get_next_page.call(@page_number)
+        end
+
+        @has_next_page = this_page&.send(@has_next_field) if @has_next_field
+
+        items = this_page.send(@item_field)
+        if items.nil? || items.empty?
+          @page_number = nil
+          return nil
+        elsif @step
+          @page_number += items.length
+        else
+          @page_number += 1
+        end
+
+        this_page
+      end
+    end
+  end
+end

data/lib/payabli/internal/json/request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module JSON
+      # @api private
+      class Request < Payabli::Internal::Http::BaseRequest
+        attr_reader :body
+
+        # @param base_url [String] The base URL for the request
+        # @param path [String] The path for the request
+        # @param method [Symbol] The HTTP method for the request (:get, :post, etc.)
+        # @param headers [Hash] Additional headers for the request (optional)
+        # @param query [Hash] Query parameters for the request (optional)
+        # @param body [Object, nil] The JSON request body (optional)
+        # @param request_options [Payabli::RequestOptions, Hash{Symbol=>Object}, nil]
+        def initialize(base_url:, path:, method:, headers: {}, query: {}, body: nil, request_options: {})
+          super(base_url:, path:, method:, headers:, query:, request_options:)
+
+          @body = body
+        end
+
+        # @return [Hash] The encoded HTTP request headers.
+        def encode_headers
+          {
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          }.merge(@headers)
+        end
+
+        # @return [String, nil] The encoded HTTP request body.
+        def encode_body
+          @body.nil? ? nil : ::JSON.generate(@body)
+        end
+      end
+    end
+  end
+end

data/lib/payabli/internal/json/serializable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module JSON
+      module Serializable
+        # Loads data from JSON into its deserialized form
+        #
+        # @param str [String] Raw JSON to load into an object
+        # @return [Object]
+        def load(str)
+          raise NotImplementedError
+        end
+
+        # Dumps data from its deserialized form into JSON
+        #
+        # @param value [Object] The deserialized value
+        # @return [String]
+        def dump(value)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end