cpro-client 0.1.0

data/cpro-client.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/cpro/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cpro-client"
+  spec.version       = Cpro::VERSION
+  spec.authors       = ["Hôtentic"]
+  spec.email         = ["contact@hotentic.com"]
+
+  spec.summary       = "A ruby client for the Chorus Pro API"
+  spec.description   = "Client Ruby des API G2B de Chorus Pro (PPF) : authentification OAuth2 PISTE, " \
+                       "consultation de l'annuaire par SIRET ou SIREN, et dépôt de factures Factur-X."
+  spec.homepage      = "https://hotentic.com"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/hotentic/cpro-client"
+  spec.metadata["changelog_uri"] = "https://github.com/hotentic/cpro-client/releases"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 2.0"
+end

data/lib/cpro/account.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Cpro
+  class Account
+    attr_reader :login
+
+    def initialize(login:, password:)
+      raise ConfigurationError, "login est requis" if blank?(login)
+      raise ConfigurationError, "password est requis" if blank?(password)
+
+      @login = login.to_s
+      @password = password.to_s
+    end
+
+    def header_value
+      Base64.strict_encode64("#{login}:#{@password}")
+    end
+
+    def inspect
+      "#<#{self.class.name} login=#{login.inspect}>"
+    end
+    alias to_s inspect
+
+    private
+
+    def blank?(value)
+      value.nil? || value.to_s.empty?
+    end
+  end
+end

data/lib/cpro/archive.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+require "stringio"
+require "zlib"
+
+module Cpro
+  # Le PPF n'accepte les flux qu'au format tar.gz, y compris pour une facture unique
+  # (Spécifications externes Chorus Pro v6.1, §3.2.3).
+  module Archive
+    FILE_MODE = 0o644
+
+    def self.gzip(entries)
+      raise ArgumentError, "au moins une entrée est requise" if entries.empty?
+
+      compress(tar(entries))
+    end
+
+    def self.tar(entries)
+      buffer = StringIO.new(+"".b)
+      Gem::Package::TarWriter.new(buffer) do |writer|
+        entries.each do |entry|
+          content = entry.fetch(:content).to_s.b
+          writer.add_file(entry.fetch(:name), FILE_MODE) { |io| io.write(content) }
+        end
+      end
+      buffer.string
+    end
+
+    def self.compress(content)
+      buffer = StringIO.new(+"".b)
+      Zlib::GzipWriter.wrap(buffer) { |gz| gz.write(content) }
+      buffer.string
+    end
+
+    def self.entries(archive)
+      Zlib::GzipReader.wrap(StringIO.new(archive)) do |gz|
+        Gem::Package::TarReader.new(StringIO.new(gz.read)).map do |entry|
+          { name: entry.full_name, content: entry.read.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/cpro/auth/token.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Cpro
+  module Auth
+    class Token
+      # Marge de renouvellement anticipé, pour absorber la latence réseau et la dérive d'horloge.
+      EXPIRY_MARGIN = 60
+      DEFAULT_LIFETIME = 3600
+
+      attr_reader :value, :expires_at
+
+      def self.from_response(body, now: Time.now)
+        payload = body.is_a?(Hash) ? body : {}
+        value = payload["access_token"]
+        raise AuthenticationError.new("réponse PISTE sans access_token", body: body) if value.nil? || value.empty?
+
+        lifetime = (payload["expires_in"] || DEFAULT_LIFETIME).to_i
+        new(value: value, expires_at: now + lifetime)
+      end
+
+      def initialize(value:, expires_at:)
+        @value = value
+        @expires_at = expires_at
+      end
+
+      def expired?(now: Time.now)
+        now >= (expires_at - EXPIRY_MARGIN)
+      end
+
+      def inspect
+        "#<#{self.class.name} expires_at=#{expires_at.inspect}>"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/cpro/auth/token_provider.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Cpro
+  module Auth
+    class TokenProvider
+      def initialize(configuration)
+        @configuration = configuration
+        @mutex = Mutex.new
+        @token = nil
+      end
+
+      def token
+        @mutex.synchronize do
+          @token = fetch if @token.nil? || @token.expired?
+          @token
+        end
+      end
+
+      def invalidate!
+        @mutex.synchronize { @token = nil }
+      end
+
+      private
+
+      attr_reader :configuration
+
+      def fetch
+        configuration.validate!
+        response = connection.post(configuration.token_url) { |request| request.body = credentials }
+        Token.from_response(response.body)
+      rescue ApiError => e
+        raise e if e.is_a?(AuthenticationError)
+
+        raise AuthenticationError.new("échec de l'obtention du jeton PISTE : #{e.message}",
+                                      status: e.status, body: e.body, correlation_id: e.correlation_id)
+      end
+
+      def credentials
+        {
+          grant_type: "client_credentials",
+          client_id: configuration.client_id,
+          client_secret: configuration.client_secret,
+          scope: configuration.scope
+        }
+      end
+
+      def connection
+        @connection ||= Faraday.new do |faraday|
+          faraday.request :url_encoded
+          faraday.use Middleware::RaiseError
+          faraday.response :json, content_type: /\bjson$/
+          faraday.options.timeout = configuration.timeout
+          faraday.options.open_timeout = configuration.open_timeout
+          faraday.adapter configuration.adapter
+        end
+      end
+    end
+  end
+end

data/lib/cpro/cdv/message.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+
+module Cpro
+  module Cdv
+    # Construit un message de cycle de vie au format CDAR D22B, conforme à l'Annexe A de la norme
+    # AFNOR XP Z12-012 (feuillet « CDV FE - CDAR »).
+    #
+    # L'ordre des éléments suit celui du feuillet, qui liste les données dans l'ordre du schéma :
+    # faute de XSD dans les documents disponibles, c'est le meilleur signal dont on dispose.
+    class Message
+      # Relevés du XSD CDAR D22B (CrossDomainAcknowledgementAndResponse_100pD22B.xsd).
+      NAMESPACES = {
+        "xmlns:rsm" => "urn:un:unece:uncefact:data:standard:CrossDomainAcknowledgementAndResponse:100",
+        "xmlns:ram" => "urn:un:unece:uncefact:data:standard:ReusableAggregateBusinessInformationEntity:100",
+        "xmlns:qdt" => "urn:un:unece:uncefact:data:standard:QualifiedDataType:100",
+        "xmlns:udt" => "urn:un:unece:uncefact:data:standard:UnqualifiedDataType:100"
+      }.freeze
+
+      PROFIL = "urn.cpro.gouv.fr:1p0:CDV:invoice" # MDT-3, BR-FR-CDV-02
+      PROCESSUS = "REGULATED"                            # MDT-2, BR-FR-CDV-CL-01
+      SCHEME_SIRET = "0009"                              # ICD 6523
+      ROLE_VENDEUR = "SE"                                # BR-FR-CDV-CL-02/03/07
+      ROLE_ACHETEUR = "BY"                               # BR-FR-CDV-CL-04
+      SCHEME_ADRESSAGE = "0225"                          # EAS : adresse annuaire national, MDT-73-1
+      FORMAT_DATE_HEURE = "204"                          # UNTDID 2379 : AAAAMMJJHHMMSS
+      FORMAT_DATE = "102"                                # AAAAMMJJ
+      TYPE_MONTANT_ENCAISSE = "MEN"                      # MDT-207, BR-FR-CDV-14
+      # MDT-97, règle G7.14 : URN du type d'objet sur lequel porte le cycle de vie.
+      TYPE_REFERENCE_FACTURE = "urn.cpro.gouv.fr:1p0:CDV:einvoicingF2"
+
+      attr_reader :facture, :statut
+
+      def initialize(facture:, statut:, emetteur: nil, destinataire: nil, motif: nil,
+                     montant: nil, taux_tva: nil, identifiant: nil, horodatage: nil,
+                     type_reference: TYPE_REFERENCE_FACTURE, raison_sociale_emetteur: nil,
+                     raison_sociale_destinataire: nil, adressage_destinataire: nil)
+        @facture = facture
+        @statut = Statut[statut]
+        @emetteur = emetteur || facture.siret_vendeur
+        @raison_sociale_emetteur = raison_sociale_emetteur || facture.raison_sociale_vendeur
+        @destinataire = destinataire || facture.siret_acheteur
+        @raison_sociale_destinataire = raison_sociale_destinataire || facture.raison_sociale_acheteur
+        @adressage_destinataire = adressage_destinataire || facture.id_adressage_acheteur
+        @motif = motif
+        @montant = montant
+        @taux_tva = taux_tva
+        @type_reference = type_reference
+        @identifiant = identifiant
+        @horodatage = horodatage
+        valider!
+      end
+
+      def identifiant
+        @identifiant ||= "CDV-#{facture.numero}-#{@statut.code}"
+      end
+
+      def horodatage
+        @horodatage ||= Time.now.utc
+      end
+
+      def to_xml
+        document = REXML::Document.new
+        document << REXML::XMLDecl.new("1.0", "UTF-8")
+        racine = document.add_element("rsm:CrossDomainAcknowledgementAndResponse", NAMESPACES)
+        contexte(racine)
+        document_echange(racine)
+        accuse(racine)
+
+        rendu = +""
+        REXML::Formatters::Pretty.new(2).tap { |f| f.compact = true }.write(document, rendu)
+        "#{rendu}\n"
+      end
+
+      def nom_fichier
+        "#{identifiant}.xml"
+      end
+
+      private
+
+      # Les manques sont accumulés puis levés d'un bloc : un appelant à qui il manque trois données
+      # préfère les voir toutes que de les découvrir une par une.
+      def valider!
+        manquants = manques
+        return if manquants.empty?
+
+        raise ArgumentError, "CDV #{@statut} incomplet, il manque : #{manquants.join(", ")}"
+      end
+
+      def manques
+        donnees_requises.merge(donnees_conditionnelles).select { |_, manquant| manquant }.keys
+      end
+
+      def donnees_requises
+        {
+          "le numéro de facture (MDT-87)" => blank?(facture.numero),
+          "le SIRET de l'émetteur (MDT-19)" => blank?(@emetteur),
+          "la date d'émission de la facture (MDT-100)" => facture.date_emission.nil?,
+          "la raison sociale de l'émetteur (MDT-20, G7.46)" => blank?(@raison_sociale_emetteur)
+        }
+      end
+
+      def donnees_conditionnelles
+        {
+          "l'identifiant d'adressage du destinataire (MDT-73, BR-FR-CDV-08)" =>
+            !blank?(@destinataire) && blank?(@adressage_destinataire),
+          "un motif de statut (MDT-113)" => @statut.motif_requis? && blank?(@motif),
+          "un motif admis pour ce statut #{@statut.motifs_admis&.join(", ")} (BR-FR-CDV-CL-09)" =>
+            !blank?(@motif) && !@statut.motif_admis?(@motif),
+          "un montant et un taux de TVA (BR-FR-CDV-14)" => montant_manquant?
+        }
+      end
+
+      def montant_manquant?
+        @statut.montant_requis? && (@montant.nil? || @taux_tva.nil?)
+      end
+
+      def contexte(parent)
+        contexte = parent.add_element("rsm:ExchangedDocumentContext")
+        contexte.add_element("ram:BusinessProcessSpecifiedDocumentContextParameter")
+                .add_element("ram:ID").add_text(PROCESSUS)
+        contexte.add_element("ram:GuidelineSpecifiedDocumentContextParameter")
+                .add_element("ram:ID").add_text(PROFIL)
+      end
+
+      def document_echange(parent)
+        echange = parent.add_element("rsm:ExchangedDocument")
+        echange.add_element("ram:ID").add_text(identifiant)
+        echange.add_element("ram:Name").add_text("Cycle de vie #{@statut}")
+        horodate(echange.add_element("ram:IssueDateTime"), horodatage)
+        emettrice(echange.add_element("ram:SenderTradeParty"))
+        emettrice(echange.add_element("ram:IssuerTradeParty"))
+        return if blank?(@destinataire)
+
+        destinataire(echange.add_element("ram:RecipientTradeParty"))
+      end
+
+      # BR-FR-CDV-08 : le rôle du destinataire n'étant ni WK ni DFH, son adresse électronique est
+      # obligatoire. C'est l'identifiant d'adressage de l'annuaire de la facturation.
+      def destinataire(noeud)
+        partie(noeud, @destinataire, ROLE_ACHETEUR, @raison_sociale_destinataire)
+        noeud.add_element("ram:URIUniversalCommunication")
+             .add_element("ram:URIID", "schemeID" => SCHEME_ADRESSAGE)
+             .add_text(@adressage_destinataire.to_s)
+      end
+
+      def accuse(parent)
+        accuse = parent.add_element("rsm:AcknowledgementDocument")
+        accuse.add_element("ram:MultipleReferencesIndicator")
+              .add_element("udt:Indicator").add_text("false")
+        accuse.add_element("ram:TypeCode").add_text(@statut.phase)
+        horodate(accuse.add_element("ram:IssueDateTime"), horodatage)
+        reference(accuse.add_element("ram:ReferenceReferencedDocument"))
+      end
+
+      def reference(reference)
+        objet_reference(reference)
+        statut_reference(reference)
+      end
+
+      # Identification de la facture sur laquelle porte le CDV. L'ordre suit la séquence du XSD
+      # (ReferencedDocumentType), qui diffère de celui du feuillet de la norme.
+      def objet_reference(reference)
+        reference.add_element("ram:IssuerAssignedID").add_text(facture.numero)
+        reference.add_element("ram:StatusCode").add_text(@statut.untdid)
+        reference.add_element("ram:TypeCode").add_text(facture.code_type.to_s)
+        horodate(reference.add_element("ram:ReceiptDateTime"), date_reception)
+      end
+
+      def statut_reference(reference)
+        type_reference(reference)
+        date(reference.add_element("ram:FormattedIssueDateTime"), facture.date_emission)
+        reference.add_element("ram:ProcessConditionCode").add_text(@statut.code)
+        emettrice(reference.add_element("ram:IssuerTradeParty"))
+        detail_statut(reference.add_element("ram:SpecifiedDocumentStatus"))
+      end
+
+      # MDT-97, obligatoire, mais sa liste de codes renvoie à l'annexe 7 des spécifications
+      # externes, absente des documents disponibles : la valeur doit être fournie par l'appelant.
+      def type_reference(reference)
+        return if blank?(@type_reference)
+
+        reference.add_element("ram:ReferenceTypeCode").add_text(@type_reference.to_s)
+      end
+
+      def detail_statut(detail)
+        detail.add_element("ram:ReasonCode").add_text(@motif.to_s) unless blank?(@motif)
+        detail.add_element("ram:SequenceNumeric").add_text("1")
+        return unless @statut.montant_requis?
+
+        caracteristique = detail.add_element("ram:SpecifiedDocumentCharacteristic")
+        caracteristique.add_element("ram:TypeCode").add_text(TYPE_MONTANT_ENCAISSE)
+        caracteristique.add_element("ram:ValueAmount").add_text(format("%.2f", @montant))
+        caracteristique.add_element("ram:ValuePercent").add_text(format("%.2f", @taux_tva))
+      end
+
+      def emettrice(noeud)
+        partie(noeud, @emetteur, ROLE_VENDEUR, @raison_sociale_emetteur)
+      end
+
+      # G7.46 : la raison sociale est obligatoire dès lors que le rôle n'est ni WK ni DFH.
+      def partie(noeud, identifiant, role, raison_sociale)
+        noeud.add_element("ram:GlobalID", "schemeID" => SCHEME_SIRET).add_text(identifiant.to_s)
+        noeud.add_element("ram:Name").add_text(raison_sociale.to_s) unless blank?(raison_sociale)
+        noeud.add_element("ram:RoleCode").add_text(role)
+      end
+
+      def horodate(noeud, instant)
+        noeud.add_element("udt:DateTimeString", "format" => FORMAT_DATE_HEURE)
+             .add_text(instant.utc.strftime("%Y%m%d%H%M%S"))
+      end
+
+      def date(noeud, jour)
+        noeud.add_element("qdt:DateTimeString", "format" => FORMAT_DATE)
+             .add_text(jour.strftime("%Y%m%d"))
+      end
+
+      # MDT-95 : date de réception de l'objet, soit pour l'émetteur la date du statut « Déposée ».
+      def date_reception
+        depot = facture.historique.find { |changement| changement.statut == "DEPOSEE" }
+        depot&.date || facture.date_statut || horodatage
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end

data/lib/cpro/cdv/statut.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Cpro
+  module Cdv
+    # Catalogue des statuts qu'un émetteur peut poser sur sa propre facture en G2B, d'après
+    # l'annexe « Correspondance codes interfaces / CDV / statuts » de Chorus Pro (feuillet G2B).
+    # Tous relèvent de la phase Traitement, d'où MDT-77 = 23.
+    class Statut
+      PHASE_TRAITEMENT = "23"
+
+      # untdid : code UNTDID 1373 attendu en MDT-88 (BR-FR-CDV-CL-05).
+      # motif   : MDT-113 obligatoire (BR-FR-CDV-15).
+      # montant : bloc MDG-43 requis avec MDT-207 = MEN (BR-FR-CDV-14).
+      CATALOGUE = {
+        approuvee: { code: "205", untdid: "1", obligatoire: false },
+        completee: { code: "209", untdid: "37", obligatoire: false },
+        refusee: { code: "210", untdid: "50", obligatoire: true, motif: true },
+        encaissee: { code: "212", untdid: "47", obligatoire: true, montant: true },
+        visee: { code: "214", untdid: "5", obligatoire: false },
+        annulee: { code: "220", untdid: "5", obligatoire: false },
+        changement_de_compte_a_payer: { code: "227", untdid: "5", obligatoire: false }
+      }.freeze
+
+      # Listes fermées des motifs admis par statut, relevées du Schematron BR-FR-CDV
+      # (BR-FR-CDV-CL-09). Le PPF rejette tout autre code.
+      MOTIFS = {
+        "210" => %w[TX_TVA_ERR MONTANTTOTAL_ERR CALCUL_ERR NON_CONFORME DOUBLON DEST_ERR TRANSAC_INC
+                    EMMET_INC CONTRAT_TERM DOUBLE_FACT CMD_ERR ADR_ERR REF_CT_ABSENT].freeze
+      }.freeze
+
+      attr_reader :nom, :code, :untdid
+
+      def self.[](nom)
+        definition = CATALOGUE[nom.to_s.downcase.to_sym]
+        return new(nom.to_s.downcase.to_sym, definition) if definition
+
+        raise ArgumentError,
+              "statut inconnu : #{nom.inspect} (attendus : #{CATALOGUE.keys.join(", ")})"
+      end
+
+      def initialize(nom, definition)
+        @nom = nom
+        @code = definition.fetch(:code)
+        @untdid = definition.fetch(:untdid)
+        @definition = definition
+      end
+
+      # Nil lorsque la norme ne restreint pas les motifs pour ce statut.
+      def motifs_admis
+        MOTIFS[code]
+      end
+
+      def motif_admis?(motif)
+        admis = motifs_admis
+        admis.nil? || admis.include?(motif.to_s)
+      end
+
+      def motif_requis?
+        @definition.fetch(:motif, false)
+      end
+
+      def montant_requis?
+        @definition.fetch(:montant, false)
+      end
+
+      # Statut dont l'émission est obligatoire au titre de la réforme.
+      def obligatoire?
+        @definition.fetch(:obligatoire)
+      end
+
+      def phase
+        PHASE_TRAITEMENT
+      end
+
+      def to_s
+        nom.to_s
+      end
+    end
+  end
+end

data/lib/cpro/client.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cpro
+  class Client
+    ANNUAIRE_PATH = "/g2b/annuaire/v1"
+    FLUX_PATH = "/g2b/flux/v1"
+    FACTURES_PATH = "/g2b/factures/v1"
+
+    attr_reader :configuration, :account
+
+    def initialize(configuration = Cpro.configuration, account: nil, token_provider: nil, connections: nil)
+      @configuration = configuration
+      @account = account || configuration.account
+      @token_provider = token_provider || configuration.token_provider
+      @connections = connections || {}
+    end
+
+    def with_account(account)
+      self.class.new(configuration, account: account, token_provider: token_provider, connections: connections)
+    end
+
+    def annuaire
+      @annuaire ||= Resources::Annuaire.new(self, connection_for(ANNUAIRE_PATH))
+    end
+
+    def flux
+      @flux ||= Resources::Flux.new(self, connection_for(FLUX_PATH))
+    end
+
+    def factures
+      @factures ||= Resources::Factures.new(self, connection_for(FACTURES_PATH))
+    end
+
+    protected
+
+    attr_reader :token_provider, :connections
+
+    private
+
+    def connection_for(base_path)
+      connections[base_path] ||= Connection.build(configuration, token_provider, base_path)
+    end
+  end
+end

data/lib/cpro/configuration.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Cpro
+  class Configuration
+    ENVIRONMENTS = {
+      sandbox: {
+        api_host: "https://sandbox-api.piste.gouv.fr",
+        token_url: "https://sandbox-oauth.piste.gouv.fr/api/oauth/token"
+      },
+      production: {
+        api_host: "https://api.piste.gouv.fr",
+        token_url: "https://oauth.piste.gouv.fr/api/oauth/token"
+      }
+    }.freeze
+
+    DEFAULT_SCOPE = "openid"
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_OPEN_TIMEOUT = 10
+
+    attr_accessor :account, :timeout, :open_timeout, :logger, :adapter
+    attr_reader :environment, :client_id, :client_secret, :scope
+
+    def initialize
+      @environment = :sandbox
+      @scope = DEFAULT_SCOPE
+      @timeout = DEFAULT_TIMEOUT
+      @open_timeout = DEFAULT_OPEN_TIMEOUT
+      @adapter = Faraday.default_adapter
+      @token_provider = nil
+    end
+
+    def token_provider
+      @token_provider ||= Auth::TokenProvider.new(self)
+    end
+
+    def environment=(name)
+      environment = name.to_sym
+      unless ENVIRONMENTS.key?(environment)
+        raise ConfigurationError,
+              "environnement inconnu : #{name.inspect} (attendus : #{ENVIRONMENTS.keys.join(", ")})"
+      end
+
+      @environment = environment
+      discard_token!
+    end
+
+    def client_id=(value)
+      @client_id = value
+      discard_token!
+    end
+
+    def client_secret=(value)
+      @client_secret = value
+      discard_token!
+    end
+
+    def scope=(value)
+      @scope = value
+      discard_token!
+    end
+
+    def api_host
+      ENVIRONMENTS.fetch(environment).fetch(:api_host)
+    end
+
+    def token_url
+      ENVIRONMENTS.fetch(environment).fetch(:token_url)
+    end
+
+    def validate!
+      raise ConfigurationError, "client_id est requis" if blank?(client_id)
+      raise ConfigurationError, "client_secret est requis" if blank?(client_secret)
+
+      self
+    end
+
+    private
+
+    # Le fournisseur est conservé pour que les clients déjà construits voient les nouveaux
+    # identifiants ; seul le jeton en cache est jeté.
+    def discard_token!
+      @token_provider&.invalidate!
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+  end
+end

data/lib/cpro/connection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Cpro
+  module Connection
+    # Middlewares ordering matters here
+    def self.build(configuration, token_provider, base_path)
+      Faraday.new(url: "#{configuration.api_host}#{base_path}/") do |faraday|
+        faraday.request :json
+        faraday.use Middleware::Authentication, token_provider: token_provider
+        faraday.use Middleware::RaiseError
+        faraday.response :json, content_type: /\bjson$/
+        faraday.response :logger, configuration.logger if configuration.logger
+        faraday.options.timeout = configuration.timeout
+        faraday.options.open_timeout = configuration.open_timeout
+        faraday.adapter configuration.adapter
+      end
+    end
+  end
+end