payabli 1.0.1

data/lib/payabli/internal/types/type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Types
+      # @abstract
+      module Type
+        include Payabli::Internal::JSON::Serializable
+
+        # Coerces a value to this type
+        #
+        # @param value [unknown]
+        # @option strict [Boolean] If we should strictly coerce this value
+        def coerce(value, strict: strict?)
+          raise NotImplementedError
+        end
+
+        # Returns if strictness is on for this type, defaults to `false`
+        #
+        # @return [Boolean]
+        def strict?
+          @strict ||= false
+        end
+
+        # Enable strictness by default for this type
+        #
+        # @return [void]
+        def strict!
+          @strict = true
+          self
+        end
+      end
+    end
+  end
+end

data/lib/payabli/internal/types/union.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Types
+      # Define a union between two types
+      module Union
+        include Payabli::Internal::Types::Type
+
+        def members
+          @members ||= []
+        end
+
+        # Add a member to this union
+        #
+        # @param type [Object]
+        # @option key [Symbol, String]
+        # @return [void]
+        def member(type, key: nil)
+          members.push([key, Utils.wrap_type(type)])
+          self
+        end
+
+        def member?(type)
+          members.any? { |_key, type_fn| type == type_fn.call }
+        end
+
+        # Set the discriminant for this union
+        #
+        # @param key [Symbol, String]
+        # @return [void]
+        def discriminant(key)
+          @discriminant = key
+        end
+
+        # @api private
+        private def discriminated?
+          !@discriminant.nil?
+        end
+
+        # Resolves the type of a value to be one of the members
+        #
+        # @param value [Object]
+        # @return [Class]
+        private def resolve_member(value)
+          if discriminated? && value.is_a?(::Hash)
+            discriminant_value = value.fetch(@discriminant, nil)
+
+            return if discriminant_value.nil?
+
+            members.to_h[discriminant_value]&.call
+          else
+            # First try exact type matching
+            result = members.find do |_key, mem|
+              member_type = Utils.unwrap_type(mem)
+              value.is_a?(member_type)
+            end&.last&.call
+
+            return result if result
+
+            # For Hash values, try to coerce into Model member types
+            if value.is_a?(::Hash)
+              members.find do |_key, mem|
+                member_type = Utils.unwrap_type(mem)
+                # Check if member_type is a Model class
+                next unless member_type.is_a?(Class) && member_type <= Model
+
+                # Try to coerce the hash into this model type with strict mode
+                begin
+                  candidate = Utils.coerce(member_type, value, strict: true)
+
+                  # Validate that all required (non-optional) fields are present
+                  # This ensures undiscriminated unions properly distinguish between member types
+                  member_type.fields.each do |field_name, field|
+                    if candidate.instance_variable_get(:@data)[field_name].nil? && !field.optional
+                      raise Errors::TypeError,
+                            "Required field `#{field_name}` missing for union member #{member_type.name}"
+                    end
+                  end
+
+                  true
+                rescue Errors::TypeError
+                  false
+                end
+              end&.last&.call
+            end
+          end
+        end
+
+        def coerce(value, strict: strict?)
+          type = resolve_member(value)
+
+          unless type
+            return value unless strict
+
+            if discriminated?
+              raise Errors::TypeError,
+                    "value of type `#{value.class}` not member of union #{self}"
+            end
+
+            raise Errors::TypeError, "could not resolve to member of union #{self}"
+          end
+
+          Utils.coerce(type, value, strict: strict)
+        end
+      end
+    end
+  end
+end

data/lib/payabli/internal/types/unknown.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Types
+      module Unknown
+        include Payabli::Internal::Types::Type
+
+        def coerce(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/payabli/internal/types/utils.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Internal
+    module Types
+      # Utilities for dealing with and checking types
+      module Utils
+        # Wraps a type into a type function
+        #
+        # @param type [Proc, Object]
+        # @return [Proc]
+        def self.wrap_type(type)
+          case type
+          when Proc
+            type
+          else
+            -> { type }
+          end
+        end
+
+        # Resolves a type or type function into a type
+        #
+        # @param type [Proc, Object]
+        # @return [Object]
+        def self.unwrap_type(type)
+          type.is_a?(Proc) ? type.call : type
+        end
+
+        def self.coerce(target, value, strict: false) # rubocop:disable Metrics/CyclomaticComplexity
+          type = unwrap_type(target)
+
+          case type
+          in Array
+            case value
+            when ::Array
+              return type.coerce(value, strict: strict)
+            when Set, ::Hash
+              return coerce(type, value.to_a)
+            end
+          in Hash
+            case value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            when ::Array
+              return coerce(type, value.to_h)
+            end
+          in ->(t) { t <= NilClass }
+            return nil
+          in ->(t) { t <= String }
+            case value
+            when String, Symbol, Numeric, TrueClass, FalseClass
+              return value.to_s
+            end
+          in ->(t) { t <= Symbol }
+            case value
+            when Symbol, String
+              return value.to_sym
+            end
+          in ->(t) { t <= Integer }
+            case value
+            when Numeric, String, Time
+              return value.to_i
+            end
+          in ->(t) { t <= Float }
+            case value
+            when Numeric, Time, String
+              return value.to_f
+            end
+          in ->(t) { t <= Model }
+            case value
+            when type
+              return value
+            when ::Hash
+              return type.coerce(value, strict: strict)
+            end
+          in Module
+            case type
+            in ->(t) { t.singleton_class.included_modules.include?(Enum) }
+              return type.coerce(value, strict: strict)
+            in ->(t) { t.singleton_class.included_modules.include?(Union) }
+              return type.coerce(value, strict: strict)
+            else
+              value
+            end
+          else
+            value
+          end
+
+          raise Errors::TypeError, "cannot coerce value of type `#{value.class}` to `#{target}`" if strict
+
+          value
+        end
+
+        def self.symbolize_keys(hash)
+          hash.transform_keys(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/payabli/invoice/client.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Invoice
+    class Client
+      # @param client [Payabli::Internal::Http::RawClient]
+      #
+      # @return [Payabli::Invoice::Client]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Creates an invoice in an entrypoint.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Payabli::Invoice::Types::InvoiceDataRequest]
+      #
+      # @return [Payabli::Invoice::Types::InvoiceResponseWithoutData]
+      def add_invoice(request_options: {}, **params)
+        _path_param_names = %i[entry]
+        _body = params.except(*_path_param_names)
+
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[force_customer_creation]
+        _query = {}
+        _query["forceCustomerCreation"] = params[:force_customer_creation] if params.key?(:force_customer_creation)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "POST",
+          path: "Invoice/#{params[:entry]}",
+          query: _query,
+          body: Payabli::Invoice::Types::InvoiceDataRequest.new(_body).to_h
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::InvoiceResponseWithoutData.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Deletes an invoice that's attached to a file.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::InvoiceResponseWithoutData]
+      def delete_attached_from_invoice(request_options: {}, **params)
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "DELETE",
+          path: "Invoice/attachedFileFromInvoice/#{params[:id_invoice]}/#{params[:filename]}"
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::InvoiceResponseWithoutData.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Deletes a single invoice from an entrypoint.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::InvoiceResponseWithoutData]
+      def delete_invoice(request_options: {}, **params)
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "DELETE",
+          path: "Invoice/#{params[:id_invoice]}"
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::InvoiceResponseWithoutData.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Updates details for a single invoice in an entrypoint.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Payabli::Invoice::Types::InvoiceDataRequest]
+      #
+      # @return [Payabli::Invoice::Types::InvoiceResponseWithoutData]
+      def edit_invoice(request_options: {}, **params)
+        _path_param_names = %i[id_invoice]
+        _body = params.except(*_path_param_names)
+
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[force_customer_creation]
+        _query = {}
+        _query["forceCustomerCreation"] = params[:force_customer_creation] if params.key?(:force_customer_creation)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "PUT",
+          path: "Invoice/#{params[:id_invoice]}",
+          query: _query,
+          body: Payabli::Invoice::Types::InvoiceDataRequest.new(_body).to_h
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::InvoiceResponseWithoutData.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Retrieves a file attached to an invoice.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Types::FileContent]
+      def get_attached_file_from_invoice(request_options: {}, **params)
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[return_object]
+        _query = {}
+        _query["returnObject"] = params[:return_object] if params.key?(:return_object)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Invoice/attachedFileFromInvoice/#{params[:id_invoice]}/#{params[:filename]}",
+          query: _query
+        )
+        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::FileContent.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Retrieves a single invoice by ID.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::GetInvoiceRecord]
+      def get_invoice(request_options: {}, **params)
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Invoice/#{params[:id_invoice]}"
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::GetInvoiceRecord.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Retrieves the next available invoice number for a paypoint.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::InvoiceNumberResponse]
+      def get_invoice_number(request_options: {}, **params)
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Invoice/getNumber/#{params[:entry]}"
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::InvoiceNumberResponse.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Returns a list of invoices for an entrypoint. Use filters to limit results. Include the `exportFormat` query parameter to return the results as a file instead of a JSON response.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::QueryInvoiceResponse]
+      def list_invoices(request_options: {}, **params)
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[export_format from_record limit_record parameters sort_by]
+        _query = {}
+        _query["exportFormat"] = params[:export_format] if params.key?(:export_format)
+        _query["fromRecord"] = params[:from_record] if params.key?(:from_record)
+        _query["limitRecord"] = params[:limit_record] if params.key?(:limit_record)
+        _query["parameters"] = params[:parameters] if params.key?(:parameters)
+        _query["sortBy"] = params[:sort_by] if params.key?(:sort_by)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Query/invoices/#{params[:entry]}",
+          query: _query
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::QueryInvoiceResponse.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Returns a list of invoices for an org. Use filters to limit results. Include the `exportFormat` query parameter to return the results as a file instead of a JSON response.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::QueryInvoiceResponse]
+      def list_invoices_org(request_options: {}, **params)
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[export_format from_record limit_record parameters sort_by]
+        _query = {}
+        _query["exportFormat"] = params[:export_format] if params.key?(:export_format)
+        _query["fromRecord"] = params[:from_record] if params.key?(:from_record)
+        _query["limitRecord"] = params[:limit_record] if params.key?(:limit_record)
+        _query["parameters"] = params[:parameters] if params.key?(:parameters)
+        _query["sortBy"] = params[:sort_by] if params.key?(:sort_by)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Query/invoices/org/#{params[:org_id]}",
+          query: _query
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::QueryInvoiceResponse.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Sends an invoice from an entrypoint via email.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Payabli::Invoice::Types::SendInvoiceResponse]
+      def send_invoice(request_options: {}, **params)
+        params = Payabli::Internal::Types::Utils.symbolize_keys(params)
+        _query_param_names = %i[attachfile mail_2]
+        _query = {}
+        _query["attachfile"] = params[:attachfile] if params.key?(:attachfile)
+        _query["mail2"] = params[:mail_2] if params.key?(:mail_2)
+        params = params.except(*_query_param_names)
+
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Invoice/send/#{params[:id_invoice]}",
+          query: _query
+        )
+        begin
+          _response = @client.send(_request)
+        rescue Net::HTTPRequestTimeout
+          raise Payabli::Errors::TimeoutError
+        end
+        code = _response.code.to_i
+        if code.between?(200, 299)
+          Payabli::Invoice::Types::SendInvoiceResponse.load(_response.body)
+        else
+          error_class = Payabli::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(_response.body, code: code)
+        end
+      end
+
+      # Export a single invoice in PDF format.
+      #
+      # @param request_options [Payabli::RequestOptions]
+      #
+      # @param params [Hash[untyped, untyped]]
+      #
+      # @return [Hash[String, Hash[String, Object]]]
+      def get_invoice_pdf(request_options: {}, **params)
+        _request = Payabli::Internal::JSON::Request.new(
+          base_url: request_options[:base_url] || Payabli::Environment::SANDBOX,
+          method: "GET",
+          path: "Export/invoicePdf/#{params[:id_invoice]}"
+        )
+        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::File.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/invoice/types/add_invoice_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Invoice
+    module Types
+      class AddInvoiceRequest < Internal::Types::Model
+        field :entry, -> { String }, optional: false, nullable: false
+        field :force_customer_creation, lambda {
+          Internal::Types::Boolean
+        }, optional: true, nullable: false, api_name: "forceCustomerCreation"
+        field :idempotency_key, -> { String }, optional: true, nullable: false, api_name: "idempotencyKey"
+        field :body, -> { Payabli::Invoice::Types::InvoiceDataRequest }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/payabli/invoice/types/edit_invoice_request.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Invoice
+    module Types
+      class EditInvoiceRequest < Internal::Types::Model
+        field :id_invoice, -> { Integer }, optional: false, nullable: false, api_name: "idInvoice"
+        field :force_customer_creation, lambda {
+          Internal::Types::Boolean
+        }, optional: true, nullable: false, api_name: "forceCustomerCreation"
+        field :body, -> { Payabli::Invoice::Types::InvoiceDataRequest }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/payabli/invoice/types/get_attached_file_from_invoice_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Payabli
+  module Invoice
+    module Types
+      class GetAttachedFileFromInvoiceRequest < Internal::Types::Model
+        field :id_invoice, -> { Integer }, optional: false, nullable: false, api_name: "idInvoice"
+        field :filename, -> { String }, optional: false, nullable: false
+        field :return_object, -> { Internal::Types::Boolean }, optional: true, nullable: false, api_name: "returnObject"
+      end
+    end
+  end
+end