conexa 0.1.0 → 0.2.0

data/lib/conexa/model.rb

@@ -15,16 +15,18 @@ module Conexa
   #
   # == Primary Key
   #
-  # Each resource needs primary_key_attribute for :id alias and operations
-  # that require the resource ID (destroy, save, fetch, etc.):
+  # Each resource declares primary_key_attribute, which defines #id and the
+  # operations that need the resource ID (destroy, save, fetch, etc.):
   #
   #   class Charge < Model
   #     primary_key_attribute :charge_id
   #   end
   #
-  #   charge.id         # => 123 (alias for charge_id)
   #   charge.charge_id  # => 123
   #   charge.chargeId   # => 123 (camelCase alias for backwards compat)
+  #   charge.id         # => 123 — the resource's own key, falling back to a
+  #                     #    plain "id" attribute, which is what write endpoints
+  #                     #    return and what Model#create reads back
   #
   # == Why explicit primary_key_attribute?
   #
@@ -34,17 +36,38 @@ module Conexa
   #
   class Model < ConexaObject
     def create
-      set_primary_key Conexa::Request.post(self.class.show_url, params: to_hash).call(class_name).attributes['id']
+      created = Conexa::Request.post(self.class.show_url, params: to_hash).call(class_name)
+
+      # A create that answers with no usable body leaves us nothing to identify
+      # the new record by, so there is nothing to re-fetch. Returning the local
+      # object is honest; raising NoMethodError from `nil.attributes` was not.
+      return self unless created.respond_to?(:attributes)
+
+      set_primary_key created.attributes['id']
       fetch
     end
 
     def save
+      # #destroy has always guarded this; #save did not, so an object with no id
+      # silently issued `PATCH /customer/` instead of failing fast.
+      raise RequestError.new('Invalid ID') unless id.present?
+
       update Conexa::Request.patch(self.class.show_url(primary_key), params: unsaved_attributes).call(class_name)
       self
     end
 
     def fetch
-      update self.class.find(primary_key)
+      fetched = self.class.find(primary_key)
+
+      # #update ignores anything with no attributes, which is right for a write
+      # that answers with no body — but a *refresh* that comes back empty must
+      # not quietly leave stale values in place reporting success.
+      unless fetched.respond_to?(:attributes)
+        raise ResponseError.new({ url: self.class.show_url(primary_key) }, nil,
+                                "a API respondeu sem corpo: nada para atualizar")
+      end
+
+      update fetched
       self
     end
 
@@ -75,10 +98,10 @@ module Conexa
     end
 
     class << self
-      # DSL for primary key attribute with :id alias
+      # DSL for the primary key attribute
       # @example
       #   primary_key_attribute :charge_id
-      #   # Generates: charge_id method + chargeId alias + id alias
+      #   # Generates: charge_id + chargeId alias + #id (with an "id" fallback)
       def primary_key_attribute(snake_name)
         camel_name = Util.camelize_str(snake_name.to_s)
 
@@ -87,7 +110,14 @@ module Conexa
         end
 
         alias_method camel_name.to_sym, snake_name
-        alias_method :id, snake_name
+
+        # Not an alias: #id has to keep Model#id's documented fallback to a plain
+        # "id" attribute. Write endpoints answer with {"id": N} rather than the
+        # resource's own key — Model#create depends on exactly that — so aliasing
+        # #id straight to #charge_id silently made the fallback dead code.
+        define_method(:id) do
+          @attributes[snake_name.to_s] || @attributes["id"]
+        end
       end
 
       def create(*args)
@@ -95,19 +125,32 @@ module Conexa
       end
 
       def find_by_id(id, **options)
+        # Surrounding whitespace is a copy-paste artefact, not a different id —
+        # strip it rather than failing. Anything still unusable in a URL is caught
+        # by Request#full_api_url and raised as a RequestError.
+        id = id.to_s.strip if id.is_a?(String)
         raise RequestError.new('Invalid ID') unless id.present?
+
         Conexa::Request.get(show_url(id), params: options).call underscored_class_name
       end
       alias :find :find_by_id
 
       def find_by(params = Hash.new, page = nil, size = nil)
+        # extract_page_size_or_params always returns limit/offset now, and
+        # validates them, so there is no page/size left here to guard.
         params = extract_page_size_or_params(page, size, **params)
-        raise RequestError.new('Invalid page size') if (!params.key?(:limit)) && (params[:page] < 1 or params[:size] < 1)
 
-        Conexa::Request.get(url, params: params).call(
+        result = Conexa::Request.get(url, params: params).call(
           underscored_class_name,
           query_context: { resource_class: self, params: params }
         )
+
+        # A listing always answers with a Result, as the READMEs promise. Without
+        # this, an empty body yielded nil and a bare-array body yielded an Array,
+        # so `.data` / `.pagination` / `.next_page` blew up far from the cause.
+        return result if result.is_a?(Conexa::Result)
+
+        Conexa::Result.new("data" => Array(result), "pagination" => nil)
       end
       alias :find_by_hash :find_by
 
@@ -166,11 +209,31 @@ module Conexa
           return params
         end
 
-        # Explicit legacy pagination (page/size) — deprecated
+        # Legacy pagination (page/size) — deprecated, and broken upstream.
+        #
+        # The API validates `page` and then ignores it, always returning the
+        # first page with offset 0 and hasNext true, so a loop over `page` never
+        # terminates and silently re-yields the same batch. Converting to
+        # limit/offset fixes existing callers instead of leaving them with
+        # plausible wrong answers.
         if params.key?(:page) || params.key?(:size) || page_val.is_a?(Integer)
-          warn "DEPRECATION WARNING: O modelo antigo de paginação (page/size) será removido em 01 de agosto de 2026. Utilize limit e offset."
-          params[:page] ||= page_val || 1
-          params[:size] ||= size_val || 100
+          page = params.delete(:page) || page_val || 1
+          size = params.delete(:size) || size_val || 100
+
+          unless page.is_a?(Integer) && page.positive?
+            raise RequestError, "page must be a positive integer"
+          end
+          unless size.is_a?(Integer) && size.positive?
+            raise RequestError, "size must be a positive integer"
+          end
+
+          warn "DEPRECATION WARNING: page/size foi substituído por limit/offset e será " \
+               "removido em conexa 0.3.0. A API v2 valida `page` e depois o ignora, " \
+               "devolvendo sempre a primeira página; os valores foram convertidos para " \
+               "limit=#{size}, offset=#{(page - 1) * size}."
+
+          params[:limit]  = size
+          params[:offset] = (page - 1) * size
           return params
         end
 

data/lib/conexa/object.rb

@@ -65,19 +65,40 @@ module Conexa
     end
 
     protected
+    # Merge a response into this object.
+    #
+    # Anything that carries no attributes is a no-op rather than an error. A
+    # write may answer with no body (Request#call then yields nil), with `{}`, or
+    # — for the top-level-array shape Request#run explicitly handles — with an
+    # Array or a scalar, which ConexaObject.convert passes straight through.
+    # None of those can update an object, and none of them should raise a bare
+    # NoMethodError at the caller: that is the failure this release exists to
+    # remove.
+    #
+    # The empty case matters beyond the crash. `removed_attributes` deletes every
+    # key absent from the incoming hash, which is right for a full refresh and
+    # destructive for a write that answers `{}` — that used to wipe the object,
+    # primary key included, and report success.
     def update(attributes)
-      removed_attributes = @attributes.keys - attributes.to_hash.keys
+      return self unless attributes.respond_to?(:to_hash)
+
+      incoming = attributes.to_hash
+      return self if incoming.empty?
+
+      removed_attributes = @attributes.keys - incoming.keys
 
       removed_attributes.each do |key|
         @attributes.delete key
       end
 
-      attributes.each do |key, value|
+      incoming.each do |key, value|
         key = Util.to_snake_case(key.to_s)
 
         @attributes[key] = ConexaObject.convert(value, Util.singularize(key))
         @unsaved_attributes.delete key
       end
+
+      self
     end
 
     def to_hash_value(value, type)
@@ -120,7 +141,7 @@ module Conexa
     end
 
     class << self
-      def convert(response, resource_name = nil, client_key=nil)
+      def convert(response, resource_name = nil)
         case response
         when Array
           response.map{ |i| convert i, resource_name }

data/lib/conexa/request.rb

@@ -23,15 +23,57 @@ module Conexa
         @auth       = options[:auth]        || false
     end
 
+    # Verbs allowed while Conexa.read_only? — GET, plus authentication, without
+    # which read-only mode could not obtain a token in the first place.
+    READ_METHODS = %w(GET).freeze
+
+    # The authentication exemption is tied to these paths, not to the caller's
+    # `auth:` flag. `Request.auth` is public, so trusting the flag alone let any
+    # write opt out of the guard with `Request.auth("/charge/settle/1", …)`.
+    AUTH_PATHS = %w(/auth).freeze
+
     def run
-      response = RestClient::Request.execute request_params
+      enforce_read_only!
 
-      response = MultiJson.decode response.body
-      return {data: response.dig("data") || response, pagination: response.dig("pagination")}
+      response = RestClient::Request.execute request_params
 
+      # A successful write may answer with no body at all: PATCH /charge/settle/:id
+      # documents 204 + empty body as its success response, and
+      # PATCH /contract/end/:id answers 200 with one. With the Oj adapter,
+      # MultiJson.decode("") returns nil *without* raising ParseError, so the
+      # nil has to be caught here rather than in a rescue.
+      body = response.body.to_s
+      return {} if body.strip.empty?
+
+      decoded = MultiJson.decode(body)
+      return {} if decoded.nil?
+
+      # A top-level array (some list endpoints) has no #dig(String).
+      return {data: decoded, pagination: nil} unless decoded.is_a?(Hash)
+
+      {data: decoded["data"] || decoded, pagination: decoded["pagination"]}
+
+      # Connection-level failures first. These subclass RestClient::Exception, so
+      # listing them after it made them unreachable — Ruby matches rescue clauses
+      # top-down. The broad clause then tried to decode their (nil) http_body and
+      # raised NoMethodError instead of the documented ConnectionError.
+      #
+      # All of these carry no response, so there is nothing to classify: they are
+      # failures to reach the API, not answers from it. Note that a real HTTP 408
+      # is RestClient::RequestTimeout, a *superclass* of Exceptions::Timeout, so
+      # it correctly stays in the response taxonomy below.
+      rescue SocketError, RestClient::ServerBrokeConnection,
+             RestClient::SSLCertificateNotVerified,
+             RestClient::Exceptions::Timeout => error
+        raise Conexa::ConnectionError.new error
       rescue RestClient::Exception => error
         begin
-          parsed_error = MultiJson.decode error.http_body
+          # nil for an error carrying no body; MultiJson.decode(nil) returns nil
+          # rather than raising, so the guard has to be here. An error body that
+          # decodes to an array or a scalar has no #[](String) either, and used
+          # to raise TypeError from inside this handler.
+          parsed_error = MultiJson.decode(error.http_body.to_s)
+          parsed_error = {} unless parsed_error.is_a?(Hash)
 
           if error.is_a? RestClient::ResourceNotFound
             if parsed_error['message']
@@ -41,7 +83,8 @@ module Conexa
             end
           else
             if parsed_error['message']
-              raise Conexa::ResponseError.new(request_params, error, parsed_error['message'] + "=> Erros: "+ parsed_error['errors'].to_s)
+              raise Conexa::ResponseError.new(request_params, error,
+                                              describe_api_error(parsed_error), parsed_error)
             else
               raise Conexa::ValidationError.new parsed_error
             end
@@ -50,13 +93,40 @@ module Conexa
           raise Conexa::ResponseError.new(request_params, error)
         end
       rescue MultiJson::ParseError
-        return {} if response.code == 204
-
+        # Only genuinely malformed JSON reaches here — empty and null bodies are
+        # handled above, for every status.
         raise Conexa::ResponseError.new(request_params, response)
-      rescue SocketError
-        raise Conexa::ConnectionError.new $!
-      rescue RestClient::ServerBrokeConnection
-        raise Conexa::ConnectionError.new $!
+    end
+
+    # The API's `message` plus its `errors`, rendered as prose.
+    #
+    # This used to be `message + "=> Erros: " + errors.to_s`, which appended a
+    # dangling "=> Erros: " to the 75 documented responses that carry no `errors`
+    # array, and dumped Ruby's `#inspect` of an array of hashes for the ones that
+    # do. ResponseError#api_error_messages already normalises both shapes.
+    def describe_api_error(parsed_error)
+      message = parsed_error['message'].to_s
+      details = Conexa::ResponseError.new({}, nil, nil, parsed_error).api_error_messages
+      return message if details.empty?
+
+      "#{message} — #{details.join("; ")}"
+    end
+
+    # @raise [Conexa::ReadOnlyError] when a mutating verb is attempted while
+    #   Conexa.read_only? — checked before the request is executed, so nothing
+    #   reaches the tenant.
+    def enforce_read_only!
+      return unless Conexa.read_only?
+      return if READ_METHODS.include?(method.to_s.upcase)
+      return if @auth && AUTH_PATHS.include?(path)
+
+      # Deliberately `path`, not `full_api_url`: the latter validates the URL and
+      # can raise RequestError, which would win over this one purely because the
+      # message is interpolated first. Read-only is a policy — it applies whatever
+      # the path looks like.
+      raise Conexa::ReadOnlyError,
+            "Conexa is in read-only mode: refusing #{method.to_s.upcase} #{path}. " \
+            "Unset config.read_only (or CONEXA_READ_ONLY) to allow writes."
     end
 
     def call(resource_name, query_context: nil)
@@ -120,6 +190,15 @@ module Conexa
         url += '?' + URI.encode_www_form(query)
       end
 
+      # An unusable path (a stray space in an id, say) would otherwise surface as
+      # URI::InvalidURIError from inside RestClient — outside Conexa::ConexaError,
+      # so no caller could rescue it meaningfully.
+      begin
+        URI.parse(url)
+      rescue URI::InvalidURIError
+        raise Conexa::RequestError, "Invalid request path: #{path.inspect}"
+      end
+
       url
     end
   end

data/lib/conexa/resources/charge.rb

@@ -48,10 +48,21 @@ module Conexa
     end
 
     # Settle (pay) this charge
-    # @param params [Hash] optional payment details
+    #
+    # Moves money and, on a configured tenant, issues an NF-e. Not safe to retry
+    # blindly: a second attempt on a settled charge answers 422 CHARGE_11.
+    #
+    # The API answers 204 with an empty body on success.
+    #
+    # @param params [Hash] settlement details
+    # @option params [String] :settlement_date required, yyyy-MM-dd
+    # @option params [Hash] :receiving_method required, {id:, installments_quantity:}
+    # @option params [Integer] :account_id required
+    # @option params [Float] :paid_amount defaults to the charge amount, without interest
+    # @option params [Boolean] :send_email defaults to false
     # @return [self]
     def settle(params = {})
-      Conexa::Request.post(self.class.show_url("settle", primary_key), params: params).call(class_name)
+      Conexa::Request.patch(self.class.show_url("settle", primary_key), params: params).call(class_name)
       self
     end
 

data/lib/conexa/resources/company.rb

@@ -1,7 +1,26 @@
 # frozen_string_literal: true
 
 module Conexa
-  class Company  < Model
+  # Company resource (Empresa / unidade)
+  #
+  # @example List companies
+  #   Conexa::Company.all(limit: 50)
+  #
+  # @example Find a company
+  #   Conexa::Company.find(3)
+  class Company < Model
+    class << self
+      # Model#url pluralizes by appending "s", which yields "/companys" and 404s.
+      # Any resource with an irregular English plural has to override this — see
+      # spec/contract/api_contract_spec.rb, which checks every resource's URL
+      # against the published collection.
+      def url(*params)
+        ["/companies", *params].join '/'
+      end
 
+      def show_url(*params)
+        ["/company", *params].join '/'
+      end
+    end
   end
 end

data/lib/conexa/resources/contract.rb

@@ -3,16 +3,62 @@
 module Conexa
   # Contract resource for recurring billing contracts
   #
-  # @example Create a contract
-  #   contract = Conexa::Contract.create(
-  #     customer_id: 127,
-  #     plan_id: 5,
-  #     start_date: '2024-01-01',
-  #     payment_day: 10
+  # == Creating a contract
+  #
+  # Required: +plan_id+, +customer_id+, +payment_frequency+ (+monthly+,
+  # +bimonthly+, +quarterly+, +semester+ or +yearly+) and +start_date+.
+  #
+  #   Conexa::Contract.create(
+  #     plan_id: 5, customer_id: 127,
+  #     payment_frequency: 'monthly', start_date: '2026-01-01'
   #   )
   #
+  # === +due_day+ is conditionally required *and* conditionally forbidden
+  #
+  # Required on a customer's **first** contract (or when they use automatic
+  # invoicing); **rejected** on every later one, which inherits the customer's
+  # +defaultDueDay+:
+  #
+  #   422 CONTRACT_RECURRING_SALE_10
+  #   "The due day can not be informed for customers who already have a contract"
+  #
+  # Code that always sends +due_day+ works at onboarding and fails forever after.
+  # Read the code off the exception rather than the message:
+  #
+  #   rescue Conexa::ResponseError => e
+  #     retry_without_due_day if e.api_error_codes.include?('CONTRACT_RECURRING_SALE_10')
+  #   end
+  #
+  # === Creating, charging and settling in one call
+  #
+  # +generate_sales: 'firstOccurrenceSettleRetroactive'+ also generates *and
+  # settles* retroactive charges, and then requires +expense_settlement+. It
+  # replaces a three-call sequence in which each step can fail on its own.
+  #
+  #   Conexa::Contract.create(
+  #     plan_id: 5, customer_id: 127,
+  #     payment_frequency: 'monthly', start_date: '2026-01-01',
+  #     generate_sales: 'firstOccurrenceSettleRetroactive',
+  #     expense_settlement: { receiving_method_id: 53, account_id: 1 }
+  #   )
+  #
+  # Other documented values: +firstOccurrence+ (default), +currentOccurrence+,
+  # +nextOccurrence+.
+  #
+  # === Other documented fields
+  #
+  # +end_date+, +first_due_date+ (required when the customer uses automatic
+  # invoicing), +fidelity_date+, +amount+, +discount_value+, +seller_id+,
+  # +contract_summary+, +notes+, +membership_fee+, +nfse_description+,
+  # +prorata_type+ (+startOfMonth+ / +notCalculate+ / +perDueDate+), +refund+
+  # (an explicit +nil+ opts out even when the plan configures one),
+  # +complementary_services+ (array), +extra_fields+ (array).
+  #
+  # +cost_center_id+ is *not* accepted on create — it 400s — even though it is
+  # present when the contract is read back.
+  #
   # @example End a contract
-  #   Conexa::Contract.end_contract(456, end_date: '2024-12-31')
+  #   Conexa::Contract.set_end_date(456, date: '2026-12-31')
   #
   # @!attribute [r] contract_id
   #   @return [Integer] Contract ID (also accessible as #id)
@@ -48,21 +94,49 @@ module Conexa
       status == 'ended' || status == 'cancelled'
     end
 
-    # End/terminate this contract
-    # @param params [Hash] options including :end_date, :reason
+    # Set this contract's end date — closing it, or amending an existing closure.
+    #
+    # The endpoint is documented as "encerra um contrato ativo **ou atualiza a
+    # data de encerramento**": it both closes and amends, and a future date on an
+    # already-closed contract **reopens** it. `end_contract` is kept as an alias,
+    # but the name understates what the call does.
+    #
+    # A contract cannot be closed retroactively past a day that already has
+    # invoiced sales (422 CONTRACT_RECURRING_SALE_23).
+    #
+    # The API may answer with an empty body on success.
+    #
+    # @param params [Hash]
+    # @option params [String] :date required, yyyy-MM-dd — the closing date
+    # @option params [Integer] :reason_id closing-reason id, from
+    #   Listagem de Contratos > Outros Cadastros > Motivo de Encerramento de Contrato
+    # @option params [Boolean] :unlink_customer unlinks DDRs, mailboxes, extensions
+    #   and recurring sales. Requires date <= today and no other active contracts;
+    #   ends *all* the customer's recurring sales and cancels their uninvoiced sales.
+    # @option params [String] :end_date deprecated alias for +:date+
     # @return [self]
-    def end_contract(params = {})
-      Conexa::Request.post(self.class.show_url("end", primary_key), params: params).call(class_name)
+    def set_end_date(params = {})
+      params = self.class.normalize_end_params(params)
+      Conexa::Request.patch(self.class.show_url("end", primary_key), params: params).call(class_name)
       self
     end
+    alias_method :end_contract, :set_end_date
 
     class << self
-      # End a contract by ID
+      # Set a contract's end date by ID
+      # @see #set_end_date
       # @param id [Integer, String] contract ID
-      # @param params [Hash] options including :end_date, :reason
       # @return [Contract]
-      def end_contract(id, params = {})
-        find(id).end_contract(params)
+      def set_end_date(id, params = {})
+        find(id).set_end_date(params)
+      end
+      alias_method :end_contract, :set_end_date
+
+      # @deprecated Use {Conexa::Util.normalize_end_date_param}, which both "end"
+      #   endpoints share.
+      # @api private
+      def normalize_end_params(params)
+        Util.normalize_end_date_param(params)
       end
 
       # Create contract with custom product items

data/lib/conexa/resources/credit_card.rb

@@ -1,9 +1,49 @@
 # frozen_string_literal: true
 
 module Conexa
+  # Credit card, registered against the customer through Cielo.
+  #
+  # **Write-only.** API v2 exposes `POST /creditCard` and nothing else — the card
+  # number and CVC live encrypted at Cielo, not in Conexa, so there is nothing to
+  # read back. Verified against a live tenant on 2026-08-12:
+  #
+  #   GET /creditCard      => 404 "Unable to resolve the request"
+  #   GET /creditCard/:id  => 404 "unable to find the requested action \"view\""
+  #
+  # Neither is the "does not exist or you have no permission to access it"
+  # wording the API uses for a resource an account cannot see, and the collection
+  # documents a 403 for authorization — so this is the shape of the API, not a
+  # feature switched off for one tenant.
+  #
+  # `#save` and `#destroy` are left in place but are **undocumented and
+  # unverified**: the collection describes only `POST`, and the documented
+  # behaviour of `default:` and `enable_recurring:` — re-registering a card
+  # changes which one is default, or turns recurrence off — reads as if there is
+  # no update path at all. They were not probed, because probing them means
+  # writing. Treat a 404 from either as expected rather than as a bug.
+  #
+  # @example Register a card
+  #   Conexa::CreditCard.create(
+  #     customer_id: 127, number: '4111111111111111',
+  #     expiration_date: '12/26', cvc: '123', name: 'JOAO DA SILVA',
+  #     default: true, enable_recurring: true
+  #   )
   class CreditCard < Model
     primary_key_attribute :credit_card_id
 
+    NO_READ = "a API v2 não expõe leitura de cartão de crédito: só " \
+              "POST /creditCard é documentado, e GET /creditCard[/:id] responde 404. " \
+              "Os dados do cartão ficam na Cielo, não no Conexa."
+
+    # Model#create re-fetches the created record to pick up server-side defaults.
+    # There is no read here, so the id from the response is all there is.
+    # @return [self]
+    def create
+      created = Conexa::Request.post(self.class.show_url, params: to_hash).call(class_name)
+      set_primary_key created.attributes['id'] if created.respond_to?(:attributes)
+      self
+    end
+
     class << self
       def url(*params)
         ["/creditCard", *params].join '/'
@@ -12,6 +52,12 @@ module Conexa
       def show_url(*params)
         ["/creditCard", *params].join '/'
       end
+
+      # Every read name Model provides, refused with an explanation rather than
+      # left to return a bare Conexa::NotFound that reads as "no such card".
+      %i[all where find find_by find_by_hash find_by_id].each do |name|
+        define_method(name) { |*, **| raise RequestError, NO_READ }
+      end
     end
   end
 end

data/lib/conexa/resources/customer.rb

@@ -71,22 +71,40 @@ module Conexa
       Address.new(@attributes['address'])
     end
 
+    # List persons (requesters) for this customer
+    # @return [Result] List of persons
+    def persons
+      Conexa::Person.all(customer_id: id, limit: 100)
+    end
+
+    # List contracts for this customer
+    # @return [Result] List of contracts
+    def contracts
+      Conexa::Contract.all(customer_id: [id], limit: 100)
+    end
+
+    # List charges for this customer
+    # @return [Result] List of charges
+    def charges
+      Conexa::Charge.all(customer_id: [id], limit: 100)
+    end
+
     class << self
-      # List persons (requesters) for a customer
+      # List persons (requesters) for a customer without fetching the customer first
       # @param customer_id [Integer] Customer ID
       # @return [Result] List of persons
       def persons(customer_id)
         Conexa::Person.all(customer_id: customer_id, limit: 100)
       end
 
-      # List contracts for a customer
+      # List contracts for a customer without fetching the customer first
       # @param customer_id [Integer] Customer ID
       # @return [Result] List of contracts
       def contracts(customer_id)
         Conexa::Contract.all(customer_id: [customer_id], limit: 100)
       end
 
-      # List charges for a customer
+      # List charges for a customer without fetching the customer first
       # @param customer_id [Integer] Customer ID
       # @return [Result] List of charges
       def charges(customer_id)