Stripe

Stripe est une plateforme de traitement des paiements en ligne destinée aux entreprises sur Internet. L’intégration de Stripe permet à votre application de gérer les transactions, les abonnements et les données financières en toute sécurité.

Étapes de configuration

Après avoir sélectionné Stripe dans la liste des intégrations, une fenêtre de configuration s’affiche. Vous devez fournir les identifiants suivants depuis votre tableau de bord Stripe pour établir la connexion :

1. Clé secrète

Saisie : Saisissez votre clé secrète Stripe privée (généralement préfixée par sk_) dans le champ Secret Key. Cette clé permet au backend d’authentifier les requêtes sécurisées.

2. Clé publiable

Saisie : Saisissez votre clé publiable Stripe publique (généralement préfixée par pk_) dans le champ Publishable Key. Cette clé sert à l’implémentation côté front.

3. Environnement

Saisie : Sélectionnez le contexte d’environnement approprié dans le menu déroulant (par ex. Test pour le développement / le bac à sable ou Production pour le traitement en direct).

Finalisation de la connexion

Une fois les clés et l’environnement configurés :

Vérifiez la barre d’état (elle affiche actuellement Non connecté).
Cliquez sur le bouton noir Ajouter en bas à droite pour enregistrer les identifiants et activer l’intégration de paiement.

Configuration de l’intégration Stripe

Référence de l’API d’intégration Stripe

Gestion de la configuration
Gestion des clients
Intentions de paiement
Abonnements
Produits et tarifs
Factures
Remboursements
Sessions Checkout
Sessions du portail de facturation
Moyens de paiement
Événements webhook
Pagination
Gestion des erreurs

Gestion de la configuration

configureStripe

Crée une nouvelle configuration Stripe pour le projet et l’environnement.

Mutation :

mutation ConfigureStripe (
  $input: ConfigureStripeInput!
) {
  configureStripe (
    input: $input
  ) {
    id
    publishableKey
    webhookUrl
  }
}

Entrée :

input ConfigureStripeInput {
  secretKey: String!          # Clé secrète Stripe (sk_test_... ou sk_live_...)
  publishableKey: String!    # Clé publiable Stripe (pk_test_... ou pk_live_...)
  environment: StripeEnvironment!  # TEST ou LIVE
  webhookSecret: String      # Secret de signature webhook (facultatif)
}

Réponse :

type ConfigureStripePayload {
  id: ID!                    # ID de configuration
  publishableKey: String!    # Clé publiable
  webhookUrl: String!        # URL webhook générée
}

Exemple :

{
  "input": {
    "secretKey": "sk_test_...",
    "publishableKey": "pk_test_...",
    "environment": "TEST",
    "webhookSecret": "whsec_..."
  }
}

Remarques :

La clé secrète est chiffrée avec AES-256-GCM avant stockage
Une seule configuration par combinaison projet / environnement
Renvoie une erreur si la configuration existe déjà

updateStripeConfig

Met à jour une configuration Stripe existante.

Mutation :

mutation UpdateStripeConfig (
  $input: UpdateStripeConfigInput!
) {
  updateStripeConfig (
    input: $input
  ) {
    id
    publishableKey
    webhookUrl
  }
}

Entrée :

input UpdateStripeConfigInput {
  secretKey: String          # Facultatif
  publishableKey: String     # Facultatif
  environment: StripeEnvironment  # Facultatif
  webhookSecret: String      # Facultatif
}

Réponse :

type UpdateStripeConfigPayload {
  id: ID!
  publishableKey: String!
  webhookUrl: String!
}

Remarques :

Tous les champs sont facultatifs
Seuls les champs fournis sont mis à jour
La clé secrète est chiffrée si elle est fournie

Gestion des clients

stripe_customer

Récupère un client par son identifiant.

Requête :

query stripe_customer{
  stripe_customer(
    id: "cus_Ts..."
  )
  {
    id
    name
    email
    phone
    description
    metadata
    object
    createdAt
  }
}

stripe_customers

Liste les clients avec pagination et filtrage optionnel.

Requête :

query stripe_customers (
  $first: Int,
  $after: String,
  $customerId: String
) {
  stripe_customers (
    first: $first,
    after: $after,
    customerId: $customerId
  ) {
    edges {
      node {
        id
        name
        email
        phone
        description
        createdAt
      }
      cursor
    }
    pageInfo {
      hasNextPage
      hasPreviousPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
customerId : filtrer par identifiant client (facultatif)

stripe_createCustomer

Crée un nouveau client.

Mutation :

mutation stripe_createCustomer {
  stripe_createCustomer (
    input: {
      name: "Customer",
      email: "example@archie.com",
      phone: "+573001230001",
      description: "Description Example"
      metadata: {
        data1: "Example data1",
        data2: "Example data2"
      }
    }
  )
  {
    id
    name
    email
    phone
    description
    metadata
    object
    createdAt
  }
}

stripe_updateCustomer

Met à jour un client existant.

Mutation :

mutation stripe_updateCustomer {
  stripe_updateCustomer(
    id: "cus_Ts...",
    input: {
      name: "Customer",
      email: "example@archie.com",
      phone: "+573001230001",
      description:"Description Example",
      metadata: {
        data1: "Example data1 updated",
        data2: "Example data2 updated"
      }
    }
  )
  {
    id
    name
    email
    phone
    description
    metadata
    object
    createdAt
  }
}

Remarques :

Tous les champs sont facultatifs
Seuls les champs fournis sont mis à jour

stripe_deleteCustomer

Supprime un client.

Mutation :

mutation stripe_deleteCustomer {
  stripe_deleteCustomer (
    id: "cus_Ts...")
}

Réponse :

Renvoie true en cas de succès
Renvoie une erreur si le client est introuvable

Intentions de paiement

stripe_paymentIntent

Récupère une intention de paiement par son identifiant.

Requête :

query stripe_paymentIntent {
  stripe_paymentIntent (
    id: "pi_3Su..."
  )
  {
    id
    customerId
    paymentMethodId
    currency
    amount
    status
    metadata
    object
    clientSecret
    createdAt
  }
}

stripe_paymentIntents

Liste les intentions de paiement avec pagination et filtrage optionnel.

Requête :

query stripe_paymentIntents (
  $first: Int,
  $after: String,
  $customerId: String
) {
  stripe_paymentIntents (
    first: $first,
    after: $after,
    customerId: $customerId
  ) {
    edges {
      node {
        id
        customerId
        paymentMethodId
        currency
        amount
        status
        metadata
        object
        clientSecret
        createdAt
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
customerId : filtrer par identifiant client (facultatif)

stripe_createPaymentIntent

Crée une nouvelle intention de paiement.

Mutation :

mutation stripe_createPaymentIntent {
  stripe_createPaymentIntent (
    input: {
      amount: 12.35,
      currency: "usd",
      customerId: "cus_Ts...",
      paymentMethodId: "pm_1Su...",
      automaticPaymentMethods: true
    }
  )
  {
    id
    customerId
    paymentMethodId
    currency
    amount
    status
    metadata
    object
    clientSecret
    createdAt
  }
}

Remarques :

clientSecret est renvoyé pour la confirmation côté front
Utilisez automaticPaymentMethods: true pour l’intégration Stripe.js

stripe_updatePaymentIntent

Met à jour une intention de paiement avant confirmation.

Mutation :

mutation stripe_updatePaymentIntent{
  stripe_updatePaymentIntent(
    id: "pi_3S...",
    input: {
      amount: 36.92,
      currency: "usd",
      paymentMethodId: "pm_1Su..."
      metadata:{
        data1: "Example data1"
      }
    }
  ) {
    id
    customerId
    paymentMethodId
    currency
    amount
    status
    metadata
    object
    clientSecret
    createdAt
  }
}

Remarques :

Ne peut être mise à jour qu’avant confirmation
Tous les champs sont facultatifs

stripe_confirmPaymentIntent

Confirme une intention de paiement.

Mutation :

mutation stripe_confirmPaymentIntent{
  stripe_confirmPaymentIntent(
    id: "pi_3Su..."
    input: {
      paymentMethodId: "pm_1Su...",
      returnUrl: "http://localhost:3000/successful-payment"
    }
  ) {
    id
    customerId
    paymentMethodId
    currency
    amount
    status
    metadata
    object
    clientSecret
    createdAt
  }
}

Remarques :

Nécessaire pour finaliser le paiement
Peut nécessiter une authentification 3D Secure
Renvoie le statut mis à jour (succeeded, requires_action, etc.)

stripe_cancelPaymentIntent

Annule une intention de paiement.

Mutation :

mutation stripe_cancelPaymentIntent {
  stripe_cancelPaymentIntent(
    id: "pi_3Su..."
  ) {
    id
    customerId
    paymentMethodId
    currency
    amount
    status
    metadata
    object
    clientSecret
    createdAt
  }
}

Remarques :

Ne peut annuler que les intentions qui ne sont ni réussies ni annulées
Le statut passe à « canceled »

Abonnements

stripe_subscription

Récupère un abonnement par son identifiant.

Requête :

query stripe_subscription {
  stripe_subscription(id: "sub_1Su...") {
    id
    customerId
    status
    currentPeriodStart
    currentPeriodEnd
    createdAt
    cancelAtPeriodEnd
    metadata
    object
    items {
      data {
        id
        priceId
        quantity
      }
    }
  }
}

stripe_subscriptions

Liste les abonnements avec pagination et filtrage optionnel.

Requête :

query stripe_subscriptions (
  $first: Int,
  $after: String,
  $customerId: String
) {
  stripe_subscriptions (
    first: $first,
    after: $after,
    customerId: $customerId
  ) {
    edges {
      node {
        id
        customerId
        status
        currentPeriodStart
        currentPeriodEnd
        createdAt
        cancelAtPeriodEnd
        metadata
        object
        items {
          data {
            id
            priceId
            quantity
          }
        }
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
customerId : filtrer par identifiant client (facultatif)
status : filtrer par statut (facultatif)

stripe_createSubscription

Crée un nouvel abonnement.

Mutation :

mutation stripe_createSubscription {
  stripe_createSubscription (
    input: {
      customerId: "cus_TsQ...",
      items: {
        priceId: "price_1Su...",
        quantity: 1
      },
      metadata: {
        data1: "Example data1"
      },
      trialPeriodDays: 0
    }
  ) {
    id
    customerId
    status
    currentPeriodStart
    currentPeriodEnd
    createdAt
    cancelAtPeriodEnd
    metadata
    object
    items {
      data {
        id
        priceId
        quantity
      }
    }
  }
}

Remarques :

paymentBehavior peut être « default_incomplete » pour les abonnements nécessitant un moyen de paiement
La période d’essai est en jours
La dernière facture et l’intention de paiement sont automatiquement développées

stripe_updateSubscription

Met à jour un abonnement existant.

Mutation :

mutation stripe_updateSubscription {
  stripe_updateSubscription(
    id: "sub_1Sv..."
    input: {
      cancelAtPeriodEnd: false
      metadata: {
        data2: "Example data2"
      }
    }
  ) {
    id
    customerId
    status
    currentPeriodStart
    currentPeriodEnd
    createdAt
    cancelAtPeriodEnd
    metadata
    object
    items {
      data {
        id
        priceId
        quantity
      }
    }
  }
}

stripe_cancelSubscription

Résilie un abonnement.

Mutation :

mutation stripe_cancelSubscription {
  stripe_cancelSubscription (
    cancelAtPeriodEnd: true,
    id: "sub_1Sv..."
  ) {
    id
    customerId
    status
    currentPeriodStart
    currentPeriodEnd
    createdAt
    cancelAtPeriodEnd
    metadata
    object
    items {
      data {
        id
        priceId
        quantity
      }
    }
  }
}

Paramètres :

id : identifiant d’abonnement (obligatoire)
cancelAtPeriodEnd : si vrai, résiliation en fin de période ; si faux, résiliation immédiate (défaut : faux)

Remarques :

Résiliation immédiate : l’abonnement se termine maintenant
Résiliation en fin de période : l’abonnement continue jusqu’à la fin de la période en cours

Produits et tarifs

stripe_products

Liste les produits avec pagination.

Requête :

query stripe_products (
  $first: Int,
  $after: String
) {
  stripe_products (
    first: $first,
    after: $after
  ) {
    edges {
      node {
        id
        name
        description
        active
        metadata
        object
        createdAt
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

stripe_createProduct

Crée un nouveau produit.

Mutation :

mutation stripe_createProduct {
  stripe_createProduct (
    input: {
      name: "Product 01",
      description: "Description product 01",
      metadata: {
        data1: "Example data1"
      }
    }
  ) {
    id
    name
    description
    active
    metadata
    object
    createdAt
  }
}

stripe_prices

Liste les tarifs avec pagination et filtrage optionnel.

Requête :

query stripe_prices (
  $first: Int,
  $after: String,
  $productId: String
) {
  stripe_prices (
    first: $first,
    after: $after,
    productId: $productId
  ) {
    edges {
      node {
        id
        productId
        active
        currency
        unitAmount
        object
        metadata
        createdAt
        recurring {
          interval
          intervalCount
        }
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
productId : filtrer par identifiant de produit (facultatif)

stripe_createPrice

Crée un nouveau tarif.

Mutation :

mutation stripe_createPrice {
  stripe_createPrice (
    input: {
      productId: "prod_Tst...",
      unitAmount: 25.85,
      currency: "usd",
      recurring: {
        interval: "month",
        intervalCount: 1
      },
      metadata: {
        data1: "Example data1"
      }
    }
  ) {
    id
    productId
    currency
    unitAmount
    active
    object
    createdAt
    metadata
    recurring {
      interval
      intervalCount
    }
  }
}

Remarques :

Omettre recurring pour les tarifs ponctuels
interval doit être l’un de : « day », « week », « month », « year »

Factures

stripe_invoice

Récupère une facture par son identifiant.

Requête :

query stripe_invoice {
  stripe_invoice (
    id: "in_1Su..."
  ) {
    id
    customerId
    subscriptionId
    currency
    amountPaid
    amountDue
    status
    object
    metadata
    createdAt
    lineItems {
      data {
        id
        description
        currency
        amount
        quantity
      }
    }
  }
}

Remarques :

L’identifiant d’abonnement est renseigné via expansion d’API lorsque disponible

stripe_invoices

Liste les factures avec pagination et filtrage optionnel.

Requête :

query stripe_invoices (
  $first: Int,
  $after: String,
  $customerId: String,
  $status: String
) {
  stripe_invoices (
    first: $first,
    after: $after,
    customerId: $customerId,
    status: $status
  ) {
    edges {
      node {
        id
        customerId
        subscriptionId
        currency
        amountPaid
        amountDue
        status
        object
        metadata
        createdAt
        lineItems {
          data {
            id
            description
            currency
            amount
            quantity
          }
        }
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
customerId : filtrer par identifiant client (facultatif)
status : filtrer par statut (facultatif)

stripe_payInvoice

Règle une facture par programmation.

Mutation :

mutation stripe_payInvoice {
  stripe_payInvoice (
    id: "in_1Sv..."
  ) {
    id
    customerId
    subscriptionId
    currency
    amountPaid
    amountDue
    status
    object
    metadata
    createdAt
    lineItems {
      data {
        id
        description
        currency
        amount
        quantity
      }
    }
  }
}

Remarques :

Tente de payer la facture avec le moyen de paiement par défaut du client
Renvoie une erreur si le paiement échoue
Met à jour le statut de la facture à « paid » en cas de succès

Remboursements

stripe_refunds

Liste les remboursements avec pagination et filtrage optionnel.

Requête :

query  stripe_refunds (
  $first: Int,
  $after: String,
  $paymentIntentId: String
)  {
  stripe_refunds (
    first: $first,
    after: $after,
    paymentIntentId: $paymentIntentId
  ) {
    edges {
      node {
        id
        paymentIntentId
        reason
        status
        currency
        amount
        metadata
        object
        createdAt
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
paymentIntentId : filtrer par identifiant d’intention de paiement (facultatif)

stripe_createRefund

Crée un remboursement pour une intention de paiement.

Mutation :

mutation stripe_createRefund {
  stripe_createRefund (
    input: {
      paymentIntentId: "pi_3Sv...",
      amount: 200,
      reason: "requested_by_customer"
    }
  ) {
    id
    reason
    paymentIntentId
    status
    currency
    amount
    object
    metadata
    createdAt
  }
}

Remarques :

Omettre amount pour un remboursement intégral
reason peut être : « duplicate », « fraudulent », « requested_by_customer »
Le statut du remboursement commence en « pending » puis passe à « succeeded » ou « failed »

Sessions Checkout

stripe_createCheckoutSession

Crée une session Stripe Checkout pour des paiements uniques ou des abonnements. Renvoie une URL qui redirige les clients vers la page de paiement hébergée par Stripe.

Mutation :

mutation CreateCheckoutSession($input: StripeCreateCheckoutSessionInput!) {
  stripe_createCheckoutSession(input: $input) {
    id
    url
    customerId
    customerEmail
    paymentIntentId
    subscriptionId
    mode
    status
    currency
    amountTotal
    metadata
    createdAt
  }
}

Entrée :

input StripeCreateCheckoutSessionInput {
  customerId: String              # ID client Stripe existant (facultatif)
  customerEmail: String            # Courriel du client pour les nouveaux clients (facultatif)
  mode: String!                   # « payment » pour ponctuel ou « subscription » pour récurrent
  successUrl: String!             # URL de redirection après paiement réussi
  cancelUrl: String!              # URL de redirection si le client annule
  lineItems: [StripeCheckoutSessionLineItemInput!]!  # Articles à acheter
  paymentMethodTypes: [String!]    # Moyens de paiement autorisés (facultatif)
  metadata: Map                    # Métadonnées personnalisées (facultatif)
}

input StripeCheckoutSessionLineItemInput {
  priceId: String      # ID de tarif Stripe (pour les tarifs existants)
  quantity: Int!        # Quantité d’articles
  amount: Float         # Montant personnalisé en dollars (paiements uniques)
  currency: String      # Code devise (obligatoire si montant fourni)
}

Réponse :

type StripeCheckoutSession {
  id: ID!                    # ID de session
  object: String!            # « checkout.session »
  url: String!              # URL de redirection pour le client
  customerId: String        # ID client (si le client existe)
  customerEmail: String     # Courriel du client
  paymentIntentId: String   # ID d’intention de paiement (paiements uniques)
  subscriptionId: String    # ID d’abonnement (abonnements)
  mode: String!             # « payment » ou « subscription »
  status: String!            # Statut de la session
  currency: String          # Code devise
  amountTotal: Float        # Montant total en dollars
  metadata: Map             # Métadonnées personnalisées
  createdAt: Time!          # Horodatage de création
}

Exemple — paiement unique :

{
  "input": {
    "mode": "payment",
    "successUrl": "https://example.com/success",
    "cancelUrl": "https://example.com/cancel",
    "lineItems": [
      {
        "priceId": "price_1234567890",
        "quantity": 1
      }
    ]
  }
}

Exemple — paiement unique avec montant personnalisé :

{
  "input": {
    "mode": "payment",
    "customerEmail": "customer@example.com",
    "successUrl": "https://example.com/success",
    "cancelUrl": "https://example.com/cancel",
    "lineItems": [
      {
        "amount": 29.99,
        "currency": "usd",
        "quantity": 1
      }
    ]
  }
}

Exemple — abonnement :

{
  "input": {
    "mode": "subscription",
    "customerId": "cus_1234567890",
    "successUrl": "https://example.com/success",
    "cancelUrl": "https://example.com/cancel",
    "lineItems": [
      {
        "priceId": "price_monthly_subscription",
        "quantity": 1
      }
    ]
  }
}

Remarques :

Le champ url contient l’URL de redirection vers laquelle les clients doivent être envoyés
Pour les paiements uniques, utilisez mode: "payment" et fournissez soit priceId, soit amount + currency
Pour les abonnements, utilisez mode: "subscription" et fournissez priceId (doit être un tarif récurrent)
Fournissez customerId ou customerEmail, mais pas les deux
paymentMethodTypes peut inclure : « card », « us_bank_account », « link », etc.
Les sessions expirent après 24 heures si elles ne sont pas finalisées

Sessions du portail de facturation

stripe_createBillingPortalSession

Crée une session Stripe Billing Portal permettant aux clients de gérer leurs abonnements, moyens de paiement et informations de facturation via le portail hébergé par Stripe.

Mutation :

mutation CreateBillingPortalSession($input: StripeCreateBillingPortalSessionInput!) {
  stripe_createBillingPortalSession(input: $input) {
    id
    url
    customerId
    returnUrl
    createdAt
  }
}

Entrée :

input StripeCreateBillingPortalSessionInput {
  customerId: String!      # ID client Stripe (obligatoire)
  returnUrl: String!       # URL de redirection après sortie du portail par le client
  configuration: String    # ID de configuration du portail (facultatif)
}

Réponse :

type StripeBillingPortalSession {
  id: ID!            # ID de session
  object: String!    # « billing_portal.session »
  url: String!       # URL de redirection pour le client
  customerId: String!  # ID client
  returnUrl: String   # URL de retour
  createdAt: Time!   # Horodatage de création
}

Exemple :

{
  "input": {
    "customerId": "cus_1234567890",
    "returnUrl": "https://example.com/account"
  }
}

Remarques :

Le champ url contient l’URL de redirection vers laquelle les clients doivent être envoyés
La session du portail est de courte durée et expire après utilisation
Les clients peuvent gérer les abonnements, mettre à jour les moyens de paiement, consulter les factures et mettre à jour les informations de facturation
Les fonctionnalités du portail sont configurées dans le tableau de bord Stripe
Si configuration n’est pas fourni, la configuration par défaut du portail est utilisée
Le portail n’affiche que les abonnements et factures du client indiqué

Moyens de paiement

stripe_paymentMethods

Liste les moyens de paiement avec pagination et filtrage optionnel.

Requête :

query stripe_paymentMethods (
  $first: Int,
  $after: String,
  $customerId: String
) {
  stripe_paymentMethods(
    first: $first,
    after: $after,
    customerId: $customerId
  ) {
    edges {
      node {
        id
        customerId
        type
        object
        metadata
        createdAt
        card {
          brand
          expMonth
          expYear
          last4
        }
      }
      cursor
    }
    pageInfo {
      hasPreviousPage
      hasNextPage
      startCursor
      endCursor
    }
  }
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination
customerId : filtrer par identifiant client (facultatif)

Remarques :

Seules des informations de carte sûres sont renvoyées (last4, marque, expiration)
Les numéros de carte complets ne sont jamais exposés

stripe_attachPaymentMethod

Associe un moyen de paiement à un client.

Mutation :

mutation stripe_attachPaymentMethod {
  stripe_attachPaymentMethod (
    id: "pm_1Sv...",
    input: {
      customerId: "cus_Ts4..."
    }
  ) {
    id
    customerId
    type
    card {
      brand
      expMonth
      expYear
      last4
    }
    metadata
    object
    createdAt
  }
}

Remarques :

Le moyen de paiement doit d’abord être créé (généralement via Stripe.js)
Les moyens de paiement associés peuvent servir pour les abonnements et les paiements

stripe_detachPaymentMethod

Détache un moyen de paiement d’un client.

Mutation :

mutation stripe_detachPaymentMethod {
  stripe_detachPaymentMethod (
    id: "pm_1Sv..."
  ) {
    id
    customerId
    type
    card {
      brand
      expYear
      expMonth
      last4
    }
    metadata
    object
    createdAt
  }
}

Remarques :

Les moyens de paiement détachés ne peuvent plus être utilisés pour les paiements
Renvoie le moyen de paiement avec customerId à null

Événements webhook

stripe_webhookEvents

Liste les événements webhook reçus par le service.

Requête :

query ListWebhookEvents (
  $first: Int,
  $after: String
) {
  stripe_webhookEvents (
    first: $first,
    after: $after
  ) {
    edges {
      node {
        id
        type
        data
        processed
        createdAt
      }
      cursor
    }
    pageInfo {
      hasNextPage
      hasPreviousPage
      endCursor
    }
  }
}

Réponse :

type StripeWebhookEvent {
  id: ID!
  type: String!              # Type d’événement (ex. « payment_intent.succeeded »)
  data: String!              # Chaîne JSON des données d’événement
  processed: Boolean!        # Indique si l’événement a été traité
  createdAt: Time!
}

Paramètres :

first : nombre d’éléments à renvoyer (défaut : 10)
after : curseur pour la pagination

Remarques :

Les événements sont reçus automatiquement via le point de terminaison webhook
Les événements sont stockés après vérification de la signature
Le champ data contient la charge utile complète de l’événement sous forme de chaîne JSON

Pagination

Toutes les requêtes de liste prennent en charge la pagination par curseur selon le modèle de connexion Relay.

PageInfo

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

Exemple d’utilisation

query ListCustomers (
  $first: Int,
  $after: String
) {
  stripe_customers (
    first: $first,
    after: $after
  ) {
    edges {
      node {
        id
        email
      }
      cursor
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}

Flux de pagination :

Requête initiale : first: 10, after: null
Utilisez pageInfo.endCursor de la réponse comme after dans la requête suivante
Vérifiez hasNextPage pour savoir s’il existe d’autres pages

Valeurs par défaut :

first : vaut 10 par défaut si non fourni
after : commence au début si non fourni

Gestion des erreurs

Toutes les opérations renvoient des erreurs GraphQL avec des messages compréhensibles. Les erreurs sont mappées à partir des erreurs de l’API Stripe pour fournir un retour clair.

Scénarios d’erreur courants

Erreurs de configuration :

400 : format de clés Stripe invalide
404 : projet ou configuration introuvable
400 : la configuration existe déjà

Erreurs client :

404 : client introuvable
400 : données client invalides

Erreurs d’intention de paiement :

404 : intention de paiement introuvable
400 : montant ou devise invalide
402 : paiement échoué (carte refusée, fonds insuffisants, etc.)

Erreurs d’abonnement :

404 : abonnement introuvable
400 : paramètres d’abonnement invalides
400 : impossible de mettre à jour un abonnement annulé

Codes d’erreur Stripe : Les codes d’erreur Stripe courants sont mappés vers des messages compréhensibles :

card_declined : « Votre carte a été refusée »
insufficient_funds : « Fonds insuffisants »
invalid_number : « Numéro de carte invalide »
expired_card : « Carte expirée »
incorrect_cvc : « Code CVC incorrect »

Format de réponse d’erreur

{
  "errors": [
    {
      "message": "Client introuvable",
      "extensions": {
        "code": "NOT_FOUND",
        "stripeErrorCode": "resource_missing"
      }
    }
  ],
  "data": null
}

Types de données

StripeEnvironment

enum StripeEnvironment {
  TEST  # Mode test
  LIVE  # Mode production
}

Scalaire Map

Le type scalaire Map représente une table clé-valeur où :

les clés sont des chaînes
les valeurs peuvent être des chaînes, des nombres, des booléens ou des tables imbriquées
utilisé pour les champs de métadonnées

Exemple :

{
  "metadata": {
    "order_id": "12345",
    "user_id": "67890",
    "premium": true
  }
}

Scalaire Time

Le type scalaire Time représente des horodatages au format ISO 8601.

Exemple : "2025-11-16T00:28:48.081Z"