Maak Aangepaste Event-Driven Integraties met Externe API's zoals Stripe, SendGrid of Twilio
description
Helpt gebruikers bij het bouwen van efficiënte, realtime integraties die dynamisch reageren op externe events, wat zorgt voor betere responsiviteit en automatisering dan eenvoudige API polling. Deze prompt begeleidt gebruikers bij het veilig verwerken van webhooks en het ontwerpen van aangepaste workflows, met praktische voorbeelden om de implementatie te versnellen.
prompt
Help me een aangepaste event-driven integratie te maken met de externe dienst: <Naam van de externe dienst>. Beschrijf welke evenementtypes ik kan abonneren en hoe ik webhook payloads veilig kan ve ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een overzicht en voorbeeldimplementatie voor een event-driven integratie met Stripe in jouw Node.js backend met PostgreSQL:
**1. Stripe Webhook evenementenabonnementen**
Stripe biedt diverse evenementtypes die je kunt gebruiken om je systeem te activeren of bij te werken. Enkele belangrijke gebeurtenissen:
- `payment_intent.succeeded`: Betaling succesvol
- `payment_intent.payment_failed`: Betaling mislukt
- `customer.created`: Nieuwe klant
- `invoice.paid`: Factuur betaald
- `charge.refunded`: Terugbetaling
- `checkout.session.completed`: Checkout sessie afgerond
Meer events vind je in de [Stripe API-documentatie](https://stripe.com/docs/api/events/types).
**2. Webhook payload veilig verwerken**
- Gebruik de Stripe SDK om de payload te valideren met het webhook secret.
- Verifieer de handtekening (`Stripe-Signature` header).
- Verwerk alleen geldige en bekende events.
**3. Voorbeeldcode in Node.js**
```javascript
const express = require('express');
const bodyParser = require('body-parser');
const Stripe = require('stripe');
const { Client } = require('pg');
const app = express();
const stripe = Stripe('YOUR_STRIPE_SECRET_KEY');
const endpointSecret = 'YOUR_STRIPE_WEBHOOK_SECRET';
// PostgreSQL client setup
const dbClient = new Client({
connectionString: 'postgresql://user:password@localhost:5432/mydb',
});
dbClient.connect();
// Middleware om raw body te krijgen voor Stripe verificatie
app.use(bodyParser.raw({ type: 'application/json' }));
app.post('/webhook', async (req, res) => {
const sig = req.headers['stripe-signature'];
let event;
try {
event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
} catch (err) {
console.log(`Webhook error: ${err.message}`);
return res.status(400).send(`Webhook error: ${err.message}`);
}
// Afhankelijk van het event type
switch (event.type) {
case 'payment_intent.succeeded':
const paymentIntent = event.data.object;
await handlePaymentSucceeded(paymentIntent);
break;
case 'invoice.paid':
const invoice = event.data.object;
await handleInvoicePaid(invoice);
break;
case 'checkout.session.completed':
const session = event.data.object;
await handleCheckoutSession(session);
break;
// Voeg meer cases toe indien nodig
default:
console.log(`Onbekend event type: ${event.type}`);
}
res.json({ received: true });
});
// Voorbeeldfunctie: Betaling geslaagd verwerken
async function handlePaymentSucceeded(paymentIntent) {
const { id, amount_received, customer } = paymentIntent;
// Bijwerken van je database, bijvoorbeeld:
await dbClient.query(
'UPDATE bestellingen SET status=$1 WHERE stripe_payment_intent_id=$2',
['betaald', id]
);
}
// Voorbeeldfunctie: Factuur betaald verwerken
async function handleInvoicePaid(invoice) {
const { id, customer, amount_paid } = invoice;
// Voorbeeld: update orderstatus
await dbClient.query(
'UPDATE bestellingen SET status=$1 WHERE stripe_invoice_id=$2',
['factuur_betaald', id]
);
}
// Voorbeeldfunctie: Checkout sessie afgerond
async function handleCheckoutSession(session) {
const { id, customer, amount_total } = session;
// Bijvoorbeeld: maak nieuwe bestelling aan
await dbClient.query(
'INSERT INTO bestellingen (stripe_session_id, klant_id, bedrag, status) VALUES ($1, $2, $3, $4)',
[id, customer, amount_total, 'voltooid']
);
}
app.listen(3000, () => console.log('Webhook listener draait op poort 3000'));
```
**4. Realtime bijwerken en workflows activeren**
- Gebruik de webhook events om direct je database bij te werken.
- Voor gepersonaliseerde workflows, trigger bijvoorbeeld een interne API of een background job (bijvoorbeeld met Node.js queues of serverless functies).
- Je kunt bijvoorbeeld na een `payment_intent.succeeded` event een e-mail sturen, een order aanmaken, of een externe service activeren.
**5. Samenvatting**
- Abonneer je op relevante Stripe events via je webhook endpoint.
- Verifieer en valideer payloads altijd.
- Verwerk events direct in je database en activeer workflows op basis van eventtype.
- Gebruik bijvoorbeeld `payment_intent.succeeded` voor succesvolle betalingen.
Mocht je meer hulp nodig hebben bij specifieke workflows of configuraties, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Zeker, ik help je met een event-driven Stripe integratie in Node.js. Hier is een complete handleiding:
## 1. Stripe Webhook Events Abonneren
### Belangrijke Event Types voor Abonnement:
```javascript
// Aanbevolen events voor verschillende use cases
const STRIPE_EVENTS = [
// Betaling gerelateerd
'payment_intent.succeeded',
'payment_intent.payment_failed',
'charge.succeeded',
'charge.failed',
'charge.refunded',
// Abonnementen
'customer.subscription.created',
'customer.subscription.updated',
'customer.subscription.deleted',
// Klanten
'customer.created',
'customer.updated',
'customer.deleted',
// Producten & Prijzen
'product.created',
'product.updated',
'price.created',
'price.updated'
];
```
## 2. Veilige Webhook Verwerking
### Webhook Endpoint Setup:
```javascript
const express = require('express');
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
const router = express.Router();
// Webhook endpoint
router.post('/webhook', express.raw({type: 'application/json'}), async (req, res) => {
const sig = req.headers['stripe-signature'];
const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
let event;
try {
// Verifieer de webhook signature
event = stripe.webhooks.constructEvent(req.body, sig, webhookSecret);
} catch (err) {
console.log(`⚠️ Webhook signature verification failed.`, err.message);
return res.status(400).send(`Webhook Error: ${err.message}`);
}
// Verwerk het event
try {
await handleStripeEvent(event);
res.json({received: true});
} catch (error) {
console.error('Error processing webhook:', error);
res.status(500).json({error: 'Webhook processing failed'});
}
});
```
## 3. Event Handler Implementatie
### Database Schema (PostgreSQL):
```sql
-- Webhook events logging
CREATE TABLE stripe_webhook_events (
id SERIAL PRIMARY KEY,
event_id VARCHAR(255) UNIQUE NOT NULL,
type VARCHAR(255) NOT NULL,
data JSONB NOT NULL,
processed BOOLEAN DEFAULT FALSE,
processing_error TEXT,
created_at TIMESTAMP DEFAULT NOW()
);
-- Gebruikers/betalingen tabel
CREATE TABLE users (
id SERIAL PRIMARY KEY,
stripe_customer_id VARCHAR(255) UNIQUE,
email VARCHAR(255) NOT NULL,
subscription_status VARCHAR(50) DEFAULT 'inactive',
created_at TIMESTAMP DEFAULT NOW()
);
CREATE TABLE payments (
id SERIAL PRIMARY KEY,
user_id INTEGER REFERENCES users(id),
stripe_payment_intent_id VARCHAR(255) UNIQUE,
amount INTEGER NOT NULL,
currency VARCHAR(3) DEFAULT 'eur',
status VARCHAR(50) NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
);
```
### Event Handler Service:
```javascript
const { Pool } = require('pg');
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
});
class StripeEventHandler {
async handleStripeEvent(event) {
// Voorkom duplicate processing
const existingEvent = await this.checkDuplicateEvent(event.id);
if (existingEvent) {
console.log(`Event ${event.id} already processed`);
return;
}
// Log het event
await this.logEvent(event);
// Route naar specifieke handler
switch (event.type) {
case 'payment_intent.succeeded':
await this.handlePaymentSuccess(event);
break;
case 'customer.subscription.created':
await this.handleSubscriptionCreated(event);
break;
case 'invoice.payment_failed':
await this.handlePaymentFailed(event);
break;
default:
console.log(`Unhandled event type: ${event.type}`);
}
// Markeer als verwerkt
await this.markEventProcessed(event.id);
}
async handlePaymentSuccess(event) {
const paymentIntent = event.data.object;
try {
await pool.query('BEGIN');
// Update gebruiker status
await pool.query(
`UPDATE users SET subscription_status = $1
WHERE stripe_customer_id = $2`,
['active', paymentIntent.customer]
);
// Log betaling
await pool.query(
`INSERT INTO payments (user_id, stripe_payment_intent_id, amount, status)
SELECT id, $1, $2, $3 FROM users WHERE stripe_customer_id = $4`,
[paymentIntent.id, paymentIntent.amount, 'succeeded', paymentIntent.customer]
);
// Activeer workflow - stuur email, update analytics, etc.
await this.triggerPostPaymentWorkflow(paymentIntent);
await pool.query('COMMIT');
console.log(`Payment ${paymentIntent.id} processed successfully`);
} catch (error) {
await pool.query('ROLLBACK');
throw error;
}
}
async handleSubscriptionCreated(event) {
const subscription = event.data.object;
// Update gebruiker subscription details
await pool.query(
`UPDATE users SET subscription_status = $1
WHERE stripe_customer_id = $2`,
[subscription.status, subscription.customer]
);
// Activeer onboarding workflow
await this.triggerOnboardingWorkflow(subscription);
}
async triggerPostPaymentWorkflow(paymentIntent) {
// Voorbeeld: Stuur confirmation email
await this.sendConfirmationEmail(paymentIntent);
// Update analytics
await this.updateAnalytics(paymentIntent);
// Unlock premium features
await this.unlockPremiumFeatures(paymentIntent.customer);
}
async triggerOnboardingWorkflow(subscription) {
// Stuur welcome email
await this.sendWelcomeEmail(subscription.customer);
// Plan follow-up task
await this.scheduleFollowUp(subscription.customer);
}
// Database helper methods
async checkDuplicateEvent(eventId) {
const result = await pool.query(
'SELECT id FROM stripe_webhook_events WHERE event_id = $1 AND processed = true',
[eventId]
);
return result.rows[0];
}
async logEvent(event) {
await pool.query(
'INSERT INTO stripe_webhook_events (event_id, type, data) VALUES ($1, $2, $3)',
[event.id, event.type, JSON.stringify(event)]
);
}
async markEventProcessed(eventId) {
await pool.query(
'UPDATE stripe_webhook_events SET processed = true WHERE event_id = $1',
[eventId]
);
}
}
module.exports = new StripeEventHandler();
```
## 4. Configuratie en Environment Variabelen
### .env Bestand:
```env
STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...
STRIPE_PUBLISHABLE_KEY=pk_test_...
DATABASE_URL=postgresql://username:password@localhost:5432/yourdb
NODE_ENV=development
```
### Package.json Dependencies:
```json
{
"dependencies": {
"express": "^4.18.0",
"stripe": "^12.0.0",
"pg": "^8.8.0",
"dotenv": "^16.0.0"
}
}
```
## 5. Real-time Systeem Updates
### WebSocket Integratie (optioneel):
```javascript
// Voor real-time UI updates
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });
// Broadcast payment updates naar connected clients
async function broadcastPaymentUpdate(userId, paymentData) {
wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN && client.userId === userId) {
client.send(JSON.stringify({
type: 'PAYMENT_UPDATE',
data: paymentData
}));
}
});
}
```
## 6. Error Handling en Retry Logic
```javascript
async function safeEventProcessing(event) {
const maxRetries = 3;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
await handleStripeEvent(event);
break;
} catch (error) {
if (attempt === maxRetries) {
await this.logProcessingError(event.id, error);
// Alert developers via email/Slack
await this.sendAlert(`Event ${event.id} failed after ${maxRetries} attempts`);
}
// Exponential backoff
await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
}
}
}
```
## 7. Stripe CLI voor Lokale Ontwikkeling
```bash
# Installeer Stripe CLI
stripe login
stripe listen --forward-to localhost:3000/webhook
# Test events genereren
stripe trigger payment_intent.succeeded
```
Deze implementatie biedt:
- ✅ Veilige webhook verwerking met signature verificatie
- ✅ Duplicate event preventie
- ✅ Database transacties voor data consistentie
- ✅ Uitbreidbare event handlers
- ✅ Workflow automatisering
- ✅ Robuuste error handling
- ✅ Real-time systeem updates
Pas de event handlers aan op basis van je specifieke business logic en workflow requirements!