DEV Community: Akrem Chabchoub

Top mistakes to avoid when integrating stripe

Akrem Chabchoub — Fri, 24 May 2024 09:44:46 +0000

Integrating Stripe into your application can streamline your payment processes, but it's essential to be aware of potential pitfalls and best practices. Here are some common mistakes and advice to help you navigate the integration smoothly.

1. Managing Webhooks Order

Webhooks are a way for Stripe to communicate with your system by sending webhook events. However, webhook events do not guarantee order delivery. It’s essential to implement logic in your system to handle the order of events correctly. This prevents potential issues that can arise from processing out-of-order events.

For example, when dealing with subscriptions, Stripe might send you the update event before the create event, causing an error since you will try to update something in your system that does not exist yet. To handle this scenario, you can add logic in your update event to check for the subscription's existence. If it's not present, retrieve it directly from Stripe, then update it.

2. How To Reduce Latency When Working with Stripe's APIs

Latency issues can arise when dealing with Stripe’s APIs. For example, fetching customer invoices from Stripe can be a slow operation. To mitigate this, consider storing or caching common data within your system. This approach reduces the need for repeated API calls and improves performance.

3. Invoice Links Expire After 30 Days

As you start storing invoices in your database, be aware that the PDF link of the invoice will expire after 30 days. To manage this, you can create a cron job to update the invoices or check the link's validity when retrieving invoices for the user. If the link has expired, get the updated link from Stripe and update it in your database.

Click for more info in Stripe docs.

4. Ensuring You Start with Live Mode In Production

Stripe has two modes: live (production) and test (development).

Sometimes, you might start your production app and begin accepting users even when the app isn't fully finished (especially for startups), thinking you can fix things later. However, when working with Stripe, you cannot switch all your test mode data to live mode (except for a few items). This will be a nightmare for you as a developer when you try to migrate the data. So, you should start your production with live mode from day one.

Bonus: go-live check list by stripe

5. Unsuccessful Payments Due to Account Freshness

Sometimes, payments fail because the account is new, and your website hasn't yet been recognized by payment systems. This issue usually resolves itself over time as your site gains more credibility. Communicate this to your customers to manage their expectations.

6. Handling Changes in Payment Methods

Payment networks can change payment method details (card number, expiration year, expiration month) at any time. Since you may store payment methods in your database, it’s crucial to stay updated by listening to the automatically_updated_payment_method Stripe webhook. This webhook provides the latest data to keep your records up to date.

7. Managing Complex Plan Features

If your plans (offers) include complex features, add custom fields in your database rather than relying heavily on the plan’s metadata, which is limited. Custom fields provide greater flexibility and scalability for your application.

Conclusion

Integrating Stripe into your application offers a streamlined payment process, but it comes with its own set of challenges. By understanding and addressing these common mistakes, you can ensure a smoother and more efficient integration. With these best practices, you can enhance your application's functionality and provide a better user experience.

Happy coding!

How to add auto-reloading in Golang projects with Nodemon: A Developer's Guide

Akrem Chabchoub — Sun, 24 Mar 2024 04:24:17 +0000

Are you a Go developer transitioning from the Node.js ecosystem? If so, you're probably familiar with nodemon, a popular tool for automatic live reloading during development. This article guides you through using nodemon to achieve a similar workflow in your Go projects.

Getting Started: Installing Node.js

Before diving into the world of automatic reloading for Go, let's ensure you have Node.js installed. Node.js serves as the backbone for Nodemon's functionality. Head over to the official Node.js website and follow the simple installation instructions.

Installing Nodemon Globally

Once you've got Node.js up and running, the next step is to install Nodemon globally. Open your terminal and execute the following command:

sudo npm install -g nodemon

Nodemon, a utility that monitors for changes in your code and automatically restarts the server, will now be accessible across your system.

Implementing Nodemon in Your Go Project

Now comes the exciting part – integrating Nodemon into your Go project. Let's break down the process step by step:

Choose Your Go File: Identify the main Go file in your project. For the sake of this guide, we'll refer to it as main.go. However, feel free to adjust the filename according to your project's structure.

Executing Nodemon: In your terminal, execute the following command to leverage Nodemon:

nodemon --exec go run main.go --signal SIGTERM

Note: Remember, the main.go file mentioned here is just an example. Feel free to substitute it with the appropriate filename based on your project setup.

In conclusion, incorporating Nodemon into your Go projects revolutionizes the way you approach development. With its automatic reloading capabilities, you'll enjoy a smoother, more efficient coding experience from start to finish

How to pretty print json with golang ?

Akrem Chabchoub — Sun, 13 Aug 2023 08:44:56 +0000

As you know by default in Go you will use fmt to print json data, this is ok but the data will be not beuatiful in the terminal, take this util function to print your json data in a pretty format:

// PrettyPrintData takes a single argument 'data' of any type (interface{}).
func PrettyPrintData(data interface{}) {
    // Convert data to pretty-printed JSON.
    if prettyOutput, err := json.MarshalIndent(data, "", "  "); err == nil {
        fmt.Println(string(prettyOutput))
    } else {
        // Handle error
    }
}

This is how it will look in the terminal:

Before:

{"id":1,"name":"John","address":{"city":"New York","zipcode":"10001"},"friends":[{"name":"Mike"},{"name":"Anna"}]}

After:

{
    "id": 1,
    "name": "John",
    "address": {
        "city": "New York",
        "zipcode": "10001"
    },
    "friends": [
        {
            "name": "Mike"
        },
        {
            "name": "Anna"
        }
    ]
}

I hope this will help you, and thanks for reading.