Create payment
With wabe, you have the ability to create payments either by using official adapters or by creating your own. You can then access it in the controllers object or create create payment with the default graphql mutation createPayment
.
// With controller
const fn = async (context: WabeContext<any>) => {
await context.wabe.controllers.payment.createPayment({
cancelUrl: 'https://example.com/cancel',
successUrl: 'https://example.com/success',
customerEmail: 'john.doe@example.com',
paymentMode: PaymentMode.Subscription,
// Compute the taxe automatically or not
automaticTax: true,
recurringInterval: 'month',
products: [{ name: 'MacBook Pro', unitAmount: 100, quantity: 1 }],
})
}
// With graphql mutation
input CreatePaymentInput {
customerEmail: Email
paymentMode: PaymentMode!
successUrl: String!
cancelUrl: String!
products: [CreatePaymentProductInput]!
automaticTax: Boolean
recurringInterval: PaymentReccuringInterval
}
"""
Create a payment with the payment provider. Returns the url to redirect the user to pay
"""
createPayment(input: CreatePaymentInput!): String
Cancel subscription
You can cancel a subscription by using the default graphql mutation cancelSubscription
.
With controller :
const fn = async (context: WabeContext<any>) => {
await context.wabe.controllers.payment.cancelSubscription({
email: 'john.doe@example.com',
})
}
With GraphQL mutation :
input CancelSubscriptionInput {
email: Email!
}
"""
Cancel a subscription
"""
cancelSubscription(input: CancelSubscriptionInput!): String
Get invoices
You can get the invoices of a customer by using the default graphql query getInvoices
.
With controller :
const fn = async (context: WabeContext<any>) => {
const invoices = await context.wabe.controllers.payment.getInvoices({
email: 'john.doe@example.com',
})
}
With GraphQL query :
input GetInvoicesInput {
email: Email!
}
"""
Get invoices of a customer
"""
getInvoices(input: GetInvoicesInput!): [Invoice]!
Webhooks
Wabe offers the ability to create webhooks for payments. The webhooks are created automatically when you initialize the payment adapter. For the moment we only support two callbacks, one for successful payments and one for failed payments. You can for example do something like sending a welcome email after each successful payment.
import { Wabe, Currency } from "wabe";
import { StripeAdapter } from "wabe-stripe";
const run = async () => {
const wabe = new Wabe({
// ... others config fields
publicUrl: 'https://you-app.com',
payment: {
adapter: new StripeAdapter('YOU_STRIPE_SECRET_KEY'),
currency: Currency.USD,
supportedPaymentMethods: ['card', 'paypal'],
onPaymentSucceed: async (options) => {
// Do something with the options
},
onPaymentFailed: async (options) => {
// Do something with the options
},
},
});
await wabe.start();
};
await run();
Stripe adapter
You can easily initialize an adapter like this by passing your API key as a parameter to the adapter.
import { Wabe, Currency } from "wabe";
import { StripeAdapter } from "wabe-stripe";
const run = async () => {
const wabe = new Wabe({
// ... others config fields
payment: {
adapter: new StripeAdapter('YOU_STRIPE_SECRET_KEY'),
currency: Currency.USD,
supportedPaymentMethods: ['card', 'paypal'],
},
});
await wabe.start();
};
await run();
Create your own adapter
You can create your own adapter (for other payment providers) implementing the interface PaymentAdapter
:
export type CreateCustomerOptions = {
customerName?: string
customerEmail: string
customerPhone?: string
address: Address
paymentMethod: PaymentMethod
}
export type CreatePaymentOptions = {
currency: Currency
customerEmail: string
products: Array<Product>
paymentMethod: Array<PaymentMethod>
paymentMode: PaymentMode
successUrl: string
cancelUrl: string
automaticTax?: boolean
recurringInterval?: 'month' | 'year'
}
export type CancelSubscriptionOptions = {
email: string
}
export type GetInvoicesOptions = {
email: string
}
export interface PaymentAdapter {
/**
* Create a customer
* @param options CreateCustomerOptions
* @returns The customer email
*/
createCustomer: (options: CreateCustomerOptions) => Promise<string>
/**
* Create a payment
* @param options CreatePaymentOptions
* @returns The payment url
*/
createPayment: (options: CreatePaymentOptions) => Promise<string>
/**
* Cancel a subscription
* @param options The customer email to cancel the subscription
*/
cancelSubscription: (options: CancelSubscriptionOptions) => Promise<void>
/**
* Get invoices
* @param options The customer email to get the invoices
* @returns The invoices of a customer
*/
getInvoices: (options: GetInvoicesOptions) => Promise<Invoice[]>
}