Droits de Fonctions de Fonctionnalité

​

Ce qui est livré

• Lors de l’achat, la concession est créée et passe directement à delivered. Il n’y a pas de phase pending, pas d’action du client, et pas de moyen pour que la livraison échoue.
• La concession transporte une charge utile typée feature : { "feature_type": "boolean", "feature_id": "advanced_reports" }. Votre application lit feature_id pour décider ce qu’il faut débloquer.
• L’annulation, le remboursement ou la révocation manuelle déplace la concession vers revoked, et votre application voit la fonction disparaître.

​

Créer une fonction de fonctionnalité

1

Open Entitlements

Dans votre tableau de bord Dodo Payments, allez à Droits et cliquez sur + pour commencer un nouveau droit, puis choisissez Fonctions de Fonctionnalité.

2

Name the flag

Donnez à la fonction un Nom d’Affichage pour votre tableau de bord, un ID de Fonctionnalité que votre application vérifiera (le tableau de bord en suggère un à partir du nom), et une Description pour que votre équipe sache ce qu’elle contrôle.

3

Optionally add metadata

Basculez Meta Data pour attacher une configuration clé-valeur — limites, noms de niveaux, quotas — qui est livrée à votre application en même temps que la fonction. Voir Attacher des limites avec des métadonnées.

4

Confirm

Cliquez sur Confirmer. La fonction apparaît dans votre liste de droits, prête à attacher à des produits.

​

Attacher à un produit

​

Configuration requise

​

Créer via API

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env['DODO_PAYMENTS_API_KEY'],
  environment: 'test_mode',
});

const entitlement = await client.entitlements.create({
  name: 'Advanced Reports',
  integration_type: 'feature_flag',
  integration_config: {
    feature_type: 'boolean',
    feature_id: 'advanced_reports',
  },
  metadata: {
    tier: 'pro',
    monthly_report_limit: 100,
  },
});

client.entitlements.create(
    name="Advanced Reports",
    integration_type="feature_flag",
    integration_config={
        "feature_type": "boolean",
        "feature_id": "advanced_reports",
    },
    metadata={
        "tier": "pro",
        "monthly_report_limit": 100,
    },
)

client.Entitlements.New(ctx, dodopayments.EntitlementNewParams{
  Name:            dodopayments.F("Advanced Reports"),
  IntegrationType: dodopayments.F(dodopayments.EntitlementIntegrationTypeFeatureFlag),
  IntegrationConfig: dodopayments.F[dodopayments.IntegrationConfigUnionParam](
    dodopayments.IntegrationConfigFeatureFlagConfigParam{
      FeatureType: dodopayments.F(dodopayments.FeatureTypeBoolean),
      FeatureID:   dodopayments.F("advanced_reports"),
    },
  ),
})

​

Attacher des limites avec des métadonnées

• Modifier ultérieurement les métadonnées du droit n’affecte que les futures concessions. Les clients conservent les limites avec lesquelles ils ont acheté.
• L’instantané est renvoyé sur chaque concession sous son champ metadata, donc un appel API vous donne à la fois la fonction et sa configuration.

​

Vérifier les fonctionnalités d’un client

const features = new Map<string, Record<string, unknown>>();

for await (const grant of client.customers.listEntitlementGrants('cus_abc123', {
  integration_type: 'feature_flag',
  status: 'Delivered',
})) {
  if (grant.feature) {
    features.set(grant.feature.feature_id, grant.metadata ?? {});
  }
}

if (features.has('advanced_reports')) {
  const limit = features.get('advanced_reports')?.monthly_report_limit;
  // unlock the dashboard, enforce the limit
}

page = client.customers.list_entitlement_grants(
    customer_id="cus_abc123",
    integration_type="feature_flag",
    status="Delivered",
)

features = {
    grant.feature.feature_id: grant.metadata
    for grant in page.items
    if grant.feature
}

if "advanced_reports" in features:
    limit = features["advanced_reports"].get("monthly_report_limit")

page, _ := client.Customers.ListEntitlementGrants(
  ctx, "cus_abc123",
  dodopayments.CustomerListEntitlementGrantsParams{
    IntegrationType: dodopayments.F("feature_flag"),
    Status:          dodopayments.F("Delivered"),
  },
)

features := map[string]bool{}
for _, grant := range page.Items {
  if grant.Feature.FeatureID != "" {
    features[grant.Feature.FeatureID] = true
  }
}

​

Cycle de vie

​

Webhooks

• entitlement_grant.created — arrive déjà delivered avec la charge utile feature. Activez la fonctionnalité.
• entitlement_grant.delivered — s’exécute lorsqu’une concession précédemment révoquée est restaurée. Réactivez la fonctionnalité.
• entitlement_grant.revoked — accès retiré. Désactivez la fonctionnalité et vérifiez revocation_reason pour décider de votre messagerie.

app.post('/webhooks/dodo', async (req, res) => {
  const event = req.body;

  if (event.type.startsWith('entitlement_grant.') && event.data.feature) {
    const { customer_id, feature } = event.data;
    const enabled = event.type !== 'entitlement_grant.revoked';

    await db.customerFeatures.upsert({
      customerId: customer_id,
      featureId: feature.feature_id,
      enabled,
      config: event.data.metadata ?? {},
    });
  }

  res.sendStatus(200);
});

​

Exemple : Pro plan débloque les rapports avancés

1. Créez la fonction. feature_id: advanced_reports with metadata { "tier": "pro", "monthly_report_limit": 100 }.
2. Attachez-la à votre produit d’abonnement Pro Plan.
3. Un client s’abonne. Dodo Payments crée une concession delivered et déclenche entitlement_grant.created ; votre gestionnaire de webhook active advanced_reports pour le client avec une limite de 100.
4. Votre application contrôle la fonctionnalité. Lors du chargement du tableau de bord, vérifiez l’ensemble des fonctionnalités en cache (ou appelez listEntitlementGrants) et affichez l’onglet des rapports uniquement lorsque advanced_reports est présent.
5. Le client annule. Dodo Payments révoque la concession et déclenche entitlement_grant.revoked ; votre gestionnaire désactive la fonctionnalité. Si le client récupère plus tard via la relance, entitlement_grant.delivered la rétablit — aucun changement de code n’est nécessaire.

​

Meilleures pratiques

• Utilisez des ids de fonctionnalité stables en snake_case. Votre code d’application vérifie ces chaînes ; en renommer une est un changement de rupture des deux côtés.
• Une fonction par capacité. Préférez advanced_reports + api_access en tant que deux droits plutôt qu’une seule pro_bundle — les révocations et les mélanges de plans restent propres.
• Gérez l’état à partir des webhooks, vérifiez avec l’API. Les webhooks maintiennent votre base de données à jour ; le point de terminaison de la liste est la source de vérité pour les tâches de réconciliation et les ratés de cache.
• Traitez revoked comme immédiat. Une fonction révoquée signifie que le client ne paie plus pour la fonctionnalité. Vérifiez à la prochaine requête, pas à la prochaine session.
• Placez les limites dans les métadonnées, pas dans le code. Changer un quota ne nécessite alors que de modifier le droit — les nouveaux clients le récupèrent automatiquement tandis que les concessions existantes conservent leur instantané acheté.