DEV Community: Rishad Omar

Javascript - Handling reject in a Promise

Rishad Omar — Wed, 01 Nov 2023 03:46:57 +0000

To demonstrate that reject does not halt processing I wrote this trivial example.

function wait(seconds) {
    return new Promise((resolve, reject) => {
        if (seconds == null || seconds == 5) {
            console.log('Before reject');
            reject('Please supply number not equal to 5');
            console.log('After reject');
        }
        setTimeout(() => {
            resolve('Done');
        }, seconds * 1000);
    });
}

It's a function that returns a Promise.
If the seconds specified is 5, then the expected behavior is to reject and not wait.
Any other value, I expect it to wait the specified time.

This is how I call my function:

wait(seconds)
    .then(() => {
        console.log('Successfully completed test');
    })
    .catch((error) => {
        console.error('Error in test', error);
    });

Here is my output when running the function:

Test 1

With a value of seconds = 7
The wait function behaves as expected. It waits 7 seconds and resolves.

Successfully completed test

Test 2

With a value of seconds = 5
The wait function does not behave as expected. It waited 5 seconds!

Before reject
After reject
Error in test Please supply number not equal to 5

I didn't expect the "After reject" and I didn't expect it to wait the 5 seconds.
To correct this add a return statement after the reject.

function wait(seconds) {
    return new Promise((resolve, reject) => {
        if (seconds == null || seconds == 5) {
            reject('Please supply number not equal to 5');
            return; // Do not continue
        }
        setTimeout(() => {
            resolve('Done');
        }, seconds * 1000);
    });
}

Now re-executing test 2 above produces:

Error in test Please supply number not equal to 5

And there was no wait which is the expected behavior.

Optimizing Code Organization for Payment Gateway Integration on AWS Lambda

Rishad Omar — Thu, 19 Oct 2023 05:48:17 +0000

Introduction

In a recent project, I integrated a payment gateway API into an application hosted on AWS Lambda cloud functions, powered by Node.js. This experience led me to develop a streamlined and organized code structure, and I'm excited to share my insights with you. While the examples I'll provide in this article won't cover every API implementation, they'll certainly serve as a solid foundation to illustrate the concept.

Implementation

Three files: (which you can organize to suit your structure)

payment.js (AWS Lambda interface)

'use strict';

const {
    getPlans,
    createCustomer,
} = require('./paystackApi');

const { handleSuccess, handleError } = require('./responseHandlers');

module.exports.paymentPlans = (event, context, callback) => {
    getPlans()
        .then((data) => {
            handleSuccess(data, callback);
        })
        .catch((error) => {
            handleError(error, callback);
        });
};

module.exports.createPaymentCustomer = (event, context, callback) => {
    const body = JSON.parse(event.body);
    const email = body.email;
    const first_name = body.first_name;
    const last_name = body.last_name;
    const phone = body.phone;

    if (email === undefined || first_name === undefined || last_name === undefined || phone === undefined) {
        handleError('Invalid request. Missing email or first_name or last_name or phone', callback);
        return;
    }

    createCustomer({ email: email, first_name: first_name, last_name: last_name, phone: phone })
        .then((data) => {
            handleSuccess(data, callback);
        })
        .catch((error) => {
            handleError(error, callback);
        });
};

paystackApi.js (API requests and any logic to do with your API)

const fetch = require('node-fetch');
const process = require('process');

const PAYSTACK_BASE_URL = 'https://api.paystack.co';
const NUMBER_OF_TRIAL_DAYS = 7;

const getSecretKey = () => {
    const secretKey = process.env.PAYSTACK_SECRET_KEY;
    if (!secretKey) {
        throw new Error('PAYSTACK_SECRET_KEY environment variable is not set');
    }
    return secretKey;
};

/**
 * Get available configured plans
 */
const getPlans = () => {
    return new Promise(async (resolve, reject) => {
        const secretKey = getSecretKey();

        try {
            const response = await fetch(`${PAYSTACK_BASE_URL}/plan`, {
                method: 'GET',
                headers: {
                    Authorization: `Bearer ${secretKey}`,
                },
            });

            if (!response.ok) {
                const errorData = await response.json();
                reject(errorData.message);
                return;
            }

            const responseData = await response.json();
            const plans = [];
            responseData.data.forEach((plan) => {
                plans.push({
                    id: plan.id,
                    plan_code: plan.plan_code,
                    domain: plan.domain,
                    name: plan.name,
                    description: plan.description,
                    currency: plan.currency,
                    amount: plan.amount,
                    interval: plan.interval,
                    is_deleted: plan.is_deleted,
                    is_archived: plan.is_archived,
                });
            });
            resolve(plans);
        } catch (error) {
            console.log('Error in getting plans: ', error);
            reject(error);
        }
    });
};

/**
 * Register a new customer
 * CustomerDetails is on object with the following expected fields:
 *  email
 *  first_name
 *  last_name
 *  phone
 */
const createCustomer = (customerDetails) => {
    return new Promise(async (resolve, reject) => {
        const secretKey = getSecretKey();

        if (
            !customerDetails.email ||
            !customerDetails.first_name ||
            !customerDetails.last_name ||
            !customerDetails.phone
        ) {
            reject('Invalid customer details');
        }

        try {
            const response = await fetch(`${PAYSTACK_BASE_URL}/customer`, {
                method: 'POST',
                headers: {
                    Authorization: `Bearer ${secretKey}`,
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify(customerDetails),
            });

            if (!response.ok) {
                const errorData = await response.json();
                reject(errorData.message);
                return;
            }

            const responseData = await response.json();
            resolve(responseData.data);
        } catch (error) {
            reject(error);
        }
    });
};

responseHandlers.js (useful functions to be used to respond to a Lambda request)

module.exports.handleError = (error, callback) => {
    let errorMessage = 'An error occurred while processing the request.';
    if (error instanceof Error) {
        errorMessage = error.message;
    } else if (typeof error === 'string') {
        errorMessage = error;
    }
    console.error(error);
    callback(null, {
        statusCode: 500,
        headers: {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Credentials': true,
        },
        body: JSON.stringify({ message: errorMessage }),
    });
};

module.exports.handleSuccess = (data, callback) => {
    const response = {
        statusCode: 200,
        headers: {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Credentials': true,
        },
        body: JSON.stringify(data, null, 4),
    };
    callback(null, response);
};

Conclusion

Consider taking your code organization to the next level by breaking down these files into smaller, more modular units. This approach offers several notable advantages:

Enhanced Testability: By breaking down the code, individual components, like "paystackApi.js," become more testable and can be used independently, even outside of the Lambda functionality.
Improved Maintainability: A clean separation of code into smaller units makes it easier to work with, code, and debug, which ultimately simplifies the maintenance process.

Taking these steps toward code organization can lead to a more robust and efficient development process.

Thanks

Image by lucabravo on Freepik

Github copilot for helping code the responses

ChatGPT for cleanin up my intro and conclusion

Continuously Test your APIs using TAPI

Rishad Omar — Sun, 19 Dec 2021 10:28:38 +0000

What are APIs

APIs are used extensively in Programming.
I see APIs as Requests and Questions
For example: Hey system, add this new contact to your database.
Here are the details:
Name: Joe Bloggs
DOB: 19890811

And the system replies: Successfully added
Or maybe Unsuccessful adding new contact. The contact number is missing.

APIs use many formats and underlying architectures to make such requests and receive responses.
This project focuses on APIs that use the REST format.

What happens when the API changes

For example: in the above case the API no longer returns DOB, but instead returns DateOfBirth.
Your application depends on receiving DOB. And so, it no longer behaves as expected since the API has changed.

Tapi is the tool to address this. It does not fix the problem, but Tapi makes you aware of the change so that you can act on it.

Other useful API tools: Swagger & Postman

A developer will build APIs and document the APIs available for other programs to call.
Swagger is a useful tool used to document the APIs

Developers who use APIs find it useful to test the APIs before coding it into their programs.
Postman is a useful tool that allows you to do that.

Tapi has drawn ideas from these 2 tools.

What is Tapi

While the above tools are useful and indepensible to developers, Tapi is a tool to help test APIs continuously.
Tapi is a react app which you can clone on your own server or a dev machine.
(No coding experience is necessary)
Then, create a folder with API requests and expected responses.
Use Tapi to execute the APIs and compare the responses with your expected responses.
A test succeeds if the response is equal'ish to the expected response.
Equal'ish because some fields (that you specify) may be ignored. For example, generated unique IDs or datetime stamps.

Tapi utilises a react app to provide a GUI to the tests.
Tapi also uses cypress to run these tests hands free.

Get started with a sample API set

Expects the following to be installed:

node (version > 12)
npm
react (version 17.*)
No coding experience is necessary but some basic knowledge of reading and writing JSON files is required.

git clone https://github.com/rishadomar/tapi.git
cd tapi
npm install
rm -rf cypress/* # Clean up sample projects. Tapi will generate Test scripts for you.
rm -f public/all-apis.json public/settings.json cypress/integration/* # A regular clean to run before switching data sources
npm run extractAllApis example # "example" is a the sample folder of data. You can specify the folder that contains your API specs.
npm run generateCypressTests example
npm start # Run the GUI. Test your APIs manually
npm run cypress:open # Run a GUI and execute your tests hands-free!
$(npm bin)/cypress run # Run on the console with no GUI. Typically, this is added to your CI/CD.

Create your own API data files

Look at the example folder included in this repo to see some examples.

cd PATH_TO_YOUR_DATA_FOLDER
Create settings.json

{
    "BASE_URL": "https://...",
    "ANY_OTHER_VARIABLE_KEY": "SOME VALUE"
}

Add folders with API files in each folder
Example of an API file:

{
    "api": "${BASE_URL}/user/invoices/${PREVIOUS_RESULT.1-registerUser._id?key=${KEY_FROM_SETTINGS}&offset=0&limit=20",
    "method": "GET",
    "headers": { "Accept": "application/json" },
    "description": "Get the first 20 invoices of specified user",
    "expectedResponse": {
        "user": {
            "userId": "*",
            "userName": "Joe Bloggs"
        },
        "invoices": [
            {
                "date": "*",
                "amount": "123.98"
            },
            {
                "date": "*",
                "amount": "565.88"
            }
        ]
    }
}

Some things to note:

1) The "*" in userId means that you don't care what the value of the userId is. Typically, this will be different
each time a user is created.

2) ${KEY_FROM_SETTINGS} is a value specified in the settings.json.

3) ${PREVIOUS_RESULT.1-registerUser._id is a value returned by a previous request. The name of the previous request is 1-registerUser
and the response contained a value "_id".
This implies that the sequence the tests are run is significant. Name your tests with a number to sequence them appropriately.

Cypress dashboard (optional)

Login and register with Cypress
Create a new project and copy the key and projectId provided
Add a cypress.json in the root of the project and add the projectId

{
    "projectId": "<CYPRESS_PROJECT_ID_HERE>",
    "component": {
        "testFiles": "**/*.test.{js,ts,jsx,tsx}",
        "componentFolder": "src"
    }
}

$(npm bin)/cypress run --record --key <CYPRESS_KEY_HERE>
Or run a specific spec by adding:
    --spec "cypress/integration/Chat_spec.js"
To view in dashboard: https://dashboard.cypress.io/projects/<CYPRESS_PROJECT_ID_HERE>/runs

Use Tapi for Free

Tapi is a community project. Use it for free.
If you do make changes consider pushing back the changes via a Pull Request.
Otherwise, add issues or contact me for changes. rishadomar@gmail.com

Coming up

View diffs color coded
Be able to Login, then run APIs as authenticated user
Show error on failure of an execute. Like: 500 reason: xxxx