Key takeaways

By the end of this tutorial, the reader will be able to understand:

• What database transactions are
• When to use database transactions
• How to use MongoDB's database transaction

Dependencies

1. Node.js (version >= 14.0)
2. MongoDB Atlas account
3. Code editor e.g. VSCode
4. Terminal or CMD
5. Postman

The concept called 'database transaction'

A database transaction is a unit of work performed within a database management system against a database that you want to treat as "a whole." A transaction generally represents any change in a database. Transactions in a database environment have two main purposes:

1. To keep a database consistent even in cases of system failure. When execution stop (either partially or completely, many operations upon a database remain uncompleted or unclear status.
2. To provide isolation between programs accessing a database concurrently.

In a database management system, a transaction is a single unit of logic or work, sometimes made up of multiple operations. Any logical calculation done in a consistent model in a database is known as a transaction. One example is a transfer from one bank account to another: the complete transaction requires subtracting the amount to be transferred from one account and adding that same amount to the other.

A database transaction has the following properties, referred to 'ACID':

1. Atomic: All the commands that make up the transaction are treated as a single unit or not treated at all.
2. Consistent: It must conform to existing constraints in the database.
3. Isolated: It must not affect other transactions.
4. Durable: It must get written to persistent storage.

A classical example is transferring money from one bank account to another. Money is debited from the source account and then credited to the destination account. The operation has to be fully completed else there will be a loss to either or both parties.

Database transaction in MongoDB

MongoDB added support for multi-document ACID transactions in version 4.0 in 2018 and extended that support for distributed multi-document ACID transactions in version 4.2 in 2019.

MongoDB's document model allows related data to be stored together in a single document. However, there are cases where true multi-document, multi-collection MongoDB transactions are the best choice.

MongoDB transactions work similarly to transactions in other databases. To use a transaction, start a MongoDB session through a driver. Then, use that session to execute your group of database operations. You can run any of the CRUD (create, read, update, and delete) operations across multiple documents, multiple collections, and multiple shards.

We'll be creating a simple application that performs typical banking transactions. Let's get into it!

Create your Mongo Atlas Account

Skip this if you're familiar with the subject.

1. Sign up on MongoDB Atlas.
2. Create a new project or use any existing project of your choice.
3. Create a database/cluster. Follow the prompt.

You should see something similar to this.

Click on Cluster -> Connect your application.

Copy the connection string and save it somewhere. It should look like this: mongodb+srv://<username>:<password>@cluster0.abcde.mongodb.net/myFirstDatabase?retryWrites=true&w=majority

Update <username> and <password> with the credentials you created.

Set up the starter code

Let's start by creating a new folder in any directory of your choice.

mkdir demo-wallet
cd demo-wallet

Let's set up our node app.

Run the command npm init and follow the prompt. You should have something like this in your package.json file.

Install the following packages

npm install dotenv express mongoose uuid

npm install nodemon --save-dev

Update the start script in package.json with this code.

//package.json

  "scripts": {
    "dev": "nodemon index",
    "start": "node index",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

Create a new file called .env and update accordingly. Credentials which are confidential are included here.

//.env

DATABASE_URL = mongodb+srv://<username>:<password>@cluster0.abcde.mongodb.net/myFirstDatabase?retryWrites=true&w=majority
PORT = 4000

Create an entry point index.js. The application will run starting from this point.

// index.js
const express = require('express');
const dotenv = require('dotenv');
const mongoose = require('mongoose');
dotenv.config();

const app = express();
app.use(express.json());

mongoose
  .connect(process.env.DATABASE_URL, {
    useNewUrlParser: true,
    useUnifiedTopology: true
  })
  .then(() => {
    console.log('Successfully connected to MongoDB!');
  })
  .catch((err) => {
    console.log('Unable to connect to MongoDB');
  });

const PORT = process.env.PORT || 4000;

app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

Start the server with the command npm run dev or nodemon index.

Create the models

Our application will only have 2 collections: Wallets and Transactions. Wallets store the accounts of all users while Transactions store all transactions performed by the users.

There is a 1-to-Many relationship between Wallets and Transactions. This means that a wallet can perform multiple transactions and multiple transactions can be tied to a single wallet account. The username will serve as the immutable field identifying a wallet.

Create a new folder called models and create 2 files; wallets.js & transactions.js.

// wallets.js
const mongoose =require('mongoose');

const walletSchema = new mongoose.Schema(
  {
    username: {
        type: String,
        required: true,
        trim: true,
        immutable: true,
        unique: true
    },
    balance: {
        type: mongoose.Decimal128,
        required: true,
        default: 0.00
    },

  },
  { timestamps: true }
);

const Wallets = mongoose.model('Wallets', walletSchema);
module.exports = Wallets;


// transactions.js
const mongoose =require('mongoose');

const transactionSchema = new mongoose.Schema(
  {
    trnxType: {
      type: String,
      required: true,
      enum: ['CR', 'DR']
    },
    purpose:{
      type: String,
      enum : ['deposit', 'transfer', 'reversal', 'withdrawal'],
      required: true
    },
    amount: {
      type: mongoose.Decimal128,
      required: true,
      default: 0.00
    },
    walletUsername: {
      type: String,
      ref: 'Wallets'
    },
    reference: { type: String, required: true },
    balanceBefore: {
      type: mongoose.Decimal128,
      required: true,
    },
    balanceAfter: {
      type: mongoose.Decimal128,
      required: true,
    },
    summary: { type: String, required: true },
    trnxSummary:{ type: String, required: true }
  },
  { timestamps: true }
);

const Transactions = mongoose.model('Transactions', transactionSchema);
module.exports = Transactions;

Explaining the fields:

• trnxType -> This represents the type of transactions performed on a wallet; either a credit or a debit.
• purpose -> What is the essence of the transaction? 'deposit', 'transfer', 'reversal', 'withdrawal' or 'reversal'
• amount -> The transaction amount in decimal
• walletUsername -> This is a foreign key that mapps to the username in the Wallet collection. It identifies the user to whom the transaction relates.
• reference -> This represents an identifier to the database transactions; both debit and credit leg of the transaction.
• balanceBefore -> This represents the wallet balance before the transaction occurred.
• balanceAfter -> This represents the wallet balance after the transaction occurred.
• summary -> This represents the message from the sender on the details or purpose of the transaction.
• trnxSummary -> This represents a summary of the entire transaction. It can include the reference, purpose, sender username, etc as is deemed fit.

The business logic; Wallets

For any new user onboarded, a wallet is created with a balance of 0 and no transaction. Create 2 new folders called controllers and routes. Create a wallets.js file in each folder.

We'll create Create operation on the Wallets collections.

// controllers/wallets.js
const Wallets = require('../models/wallets');

const createWallet = async (req, res) => {
    try{
        const {username}= req.body;

        const walletExists = await Wallets.findOne({username});
        if (walletExists){
            return res.status(409).json({
                status: false,
                message: 'Wallet already exists',
            })
        }

        const result = await Wallets.create({username});
        console.log(result)
        return res.status(201).json({
            status: true,
            message: 'Wallets created successfully',
            data: result
        })
    } catch (err) {
        return res.status(500).json({
            status: true,
            message: `Unable to create wallet. Please try again. \n Error: ${err}`
        })
    }
}

module.exports = { createWallet };

Now we add the routes so we can test the URLs in Postman

// routes/wallets.js
const express = require('express');
const router = express.Router();

const Wallets = require('../controllers/wallets');

router.post('/', Wallets.createWallet);

module.exports = router;

Update index.js to include these routes

const walletRoutes = require( './routes/wallets');
app.use('/api/wallets', walletRoutes);

Let's test the application and create 2 wallets.

The business logic; Transactions

According to the accounting principle of double-entry, for every debit entry, there must be a corresponding credit entry.

Create a folder called utils and a file called transactions.js

The 2 methods are debitAccount which will debit the sender and creditAccount which will credit the received. We begin by searching if the user exists; the sender in debitAccount() and the receiver in creditAccount. The amount to be transferred must be greated than the wallet balance of the sender. Once all checks pass, the wallet balance will be updated and the transactions recorded.

/**
 * @param {decimal128} amount - in decimal
 * @param {String} username
 * @param {String} purpose
 * @param {String} reference
 * @param {String} summary
 * @param {String} trnxSummary
 * @returns {object} custom response
*/

// utils/transactions.js
const Wallets = require('../models/wallets');
const Transactions = require('../models/transactions');

const creditAccount = async ({amount, username, purpose, reference, summary, trnxSummary, session}) => {
  const wallet = await Wallets.findOne({username});
  if (!wallet) {
    return {
      status: false,
      statusCode:404,
      message: `User ${username} doesn\'t exist`
    }
  };

  const updatedWallet = await Wallets.findOneAndUpdate({username}, { $inc: { balance: amount } }, {session});

  const transaction = await Transactions.create([{
    trnxType: 'CR',
    purpose,
    amount,
    username,
    reference,
    balanceBefore: Number(wallet.balance),
    balanceAfter: Number(wallet.balance) + Number(amount),
    summary,
    trnxSummary
  }], {session});

  console.log(`Credit successful`)
  return {
    status: true,
    statusCode:201,
    message: 'Credit successful',
    data: {updatedWallet, transaction}
  }
}

const debitAccount = async ({amount, username, purpose, reference, summary, trnxSummary, session}) => {
  const wallet = await Wallets.findOne({username});
  if (!wallet) {
    return {
      status: false,
      statusCode:404,
      message: `User ${username} doesn\'t exist`
    }
  };

  if (Number(wallet.balance) < amount) {
    return {
      status: false,
      statusCode:400,
      message: `User ${username} has insufficient balance`
    }
  }

  const updatedWallet = await Wallets.findOneAndUpdate({username}, { $inc: { balance: -amount } }, {session});
  const transaction = await Transactions.create([{
    trnxType: 'DR',
    purpose,
    amount,
    username,
    reference,
    balanceBefore: Number(wallet.balance),
    balanceAfter: Number(wallet.balance) - Number(amount),
    summary,
    trnxSummary
  }], {session});

  console.log(`Debit successful`);
  return {
    status: true,
    statusCode:201,
    message: 'Debit successful',
    data: {updatedWallet, transaction}
  }
}

module.exports = {
    creditAccount, debitAccount
};

Create a new file in the controllers folder called transactions.js. The main business logic will be executed here.

If the debit is successful but the credit is not successful is not, the entire transaction will be rolled back; the sender is credited with the amount.

For any error that occurs, all successful operations will be rolled back.

// controllers/transactions.js
const Transactions = require('../models/transactions');
const mongoose = require('mongoose');
const { v4 } = require('uuid');
const { creditAccount, debitAccount } = require( '../utils/transactions');

const transfer = async (req, res) => {
    const session = await mongoose.startSession();
    session.startTransaction()
    try {
        const { toUsername, fromUsername, amount, summary} = req.body;
        const reference = v4();
        if (!toUsername && !fromUsername && !amount && !summary) {
            return res.status(400).json({
                status: false,
                message: 'Please provide the following details: toUsername, fromUsername, amount, summary'
            })
        }

      const transferResult = await Promise.all([
        debitAccount(
          {amount, username:fromUsername, purpose:"transfer", reference, summary,
          trnxSummary: `TRFR TO: ${toUsername}. TRNX REF:${reference} `, session}),
        creditAccount(
          {amount, username:toUsername, purpose:"transfer", reference, summary,
          trnxSummary:`TRFR FROM: ${fromUsername}. TRNX REF:${reference} `, session})
      ]);

      const failedTxns = transferResult.filter((result) => result.status !== true);
      if (failedTxns.length) {
        const errors = failedTxns.map(a => a.message);
        await session.abortTransaction();
        return res.status(400).json({
            status: false,
            message: errors
        })
      }

      await session.commitTransaction();
      session.endSession();

      return res.status(201).json({
        status: true,
        message: 'Transfer successful'
    })
    } catch (err) {
        await session.abortTransaction();
        session.endSession();

        return res.status(500).json({
            status: false,
            message: `Unable to find perform transfer. Please try again. \n Error: ${err}`
        })
    }
}

module.exports = { transfer };

A reference is required to identify this unit of transaction. We use uuid to create this unique identifier.

const session = await mongoose.startSession(); session.startTransaction() is used to initialize a database transaction.

const transferResult = await Promise.all([...]) takes debitAccount() and creditAccount() as input promises and returns a single Promise that resolves to an array of the results.

When either or both methods return with an error, the errors have to be displayed to the user and the transaction aborted. The transferResult is filtered based on the status returned from the helper methods. There is an error the status is false. The error(s) is(are) extracted and stored in errors and returned to the user. The session is aborted and all operations rolled back.

If there are no errors, we commit the transaction, end the session and return a success response to the user.

In the catch block, the transaction is aborted and the session ended. Network failure is a reason the catch block will be executed. All transactions performed will be rolled back.

Let's create the routes and update the index.js file with it

// routes/transactions.js
const express = require('express');
const router = express.Router();

const Transactions = require('../controllers/transactions');

router.post('/transfer', Transactions.transfer);

module.exports = router;


// index.js
const transactionRoutes = require( './routes/transactions');
app.use('/api/transactions', transactionRoutes);

Test the application

Right now, all transactions will fail because the wallet balances are 0. Head over to MongoDB and manually update the balance of a wallet. This wallet will act as the sender.

Back to Postman. Let's test with a sender who exists and a recipient who doesn't exist. We expect to debit the sender and then try to credit the receiver but since the receiver doesn't exist, the debit on the sender is reversed. The balances of the 2 users should be as before the transaction is performed and the Transactions collection should be empty.

Check the console, you will see the Debit successful message. The debit leg was successful but the credit leg was not. The debit was reversed and the operation was aborted.

Let's try again with users who exist.

Now that you've learnt the basics, go ahead and try other transactions like reversals, withdrawals, deposits or other use cases.

NoSQL databases that support ACID transactions

MongoDB is not the only NoSQL database that supports ACID transactions. RavenDB, FaunaDB and FoundationDB are ACID compliant.

References

• What are ACID Transactions?
• ACID Transactions in NoSQL? RavenDB vs MongoDB
• How to Use MongoDB Transactions in Node.js

African App Launchpad AAL Cup 2021

IBM is collaborating with Information Technology Industry Development Authority (ITIDA) in its 3rd edition of the African Application Launchpad Cup (AAL Cup 2021) — to launch the "Africa for Creative Games and Digital Applications" competition. The competition aims to up-skill 10,000 African youth and support 100 startups in the field of applications and game development. Participants will get the chance to leverage IBM SMEs and train using the IBM Digital - Nation Africa platform. Selected winners will enjoy IBM mentorship opportunities and get the chance to deploy their solutions on IBM Cloud using the worldwide program "Startup with IBM".

Eligible African Countries- Egypt, Algeria, Angola, Cameroon, Chad, Comoros, Côte d'Ivoire, Democratic Republic of the Congo, Ghana, Libya, Madagascar, Malawi, Mauritania, Namibia, Niger, Rwanda, Senegal, South Africa, The Gambia, Nigeria, Togo and Uganda.

Read more about the program here

AU Digital and Innovation Fellowship

The fellowship program seeks highly competent tech innovators within the African continent to organs within the African Union Headquarters and organs as ‘resident fellows’ to understand the system within those organs; identify challenges within the system and propose solutions to these challenges. The fellows will be expected to co-create and build innovative tailor-made products and processes that improve the delivery of the African Union’s mandate especially in the context of good governance and citizens engagement. Additionally, the program will seek to facilitate conditions for building the internal capacity of the host African Union organs in the long term.

Read more about the program Here

Hacktoberfest

Hacktoberfest is a month-long celebration of open source software run by DigitalOcean. During the month of October, open-source software enthusiasts, beginners, and the developer community participate by contributing to open-source projects. It is open to everyone.

Read more about the program here

Additional Resource- Beginner's guide to Hacktoberfest 2021

Bridge To MassChallenge Nigeria 2021

Bridge to MassChallenge Nigeria is a national startup competition in partnership with the National Information Technology Development Agency that identifies and accelerates the top startups in Nigeria while connecting them to the MassChallenge global network. The program is focused on supporting early-stage startups across all industries that are based in Nigeria and interested in growing their business in the Nigerian market.

Read more about the program here

SCA Web Monetized Hackathon

As part of SheCodeAfrica's 5th Anniversary, Coil is sponsoring an Interledger and Web Monetization learning program. The hackathon is only open for female techies (SCA Community Members):

• Designers, Developers, Designers, Product Managers, and every other role
• People looking to explore new ideas, build new skills and learn about Interledger and Web Monetization
• Anyone who wants to learn about new advancements in open payments

Join the SheCodeAfrica community via this link to get started.

Read more about the program here

The Afriex virtual crypto/web3 Hackathon

The Afriex crypto/web3 hackathon is aimed at African developers to promote blockchain development on the continent By bringing together innovative minds, Afriex aims to build an enabling environment for blockchain developers on the continent. The event will last for 4 days and the Winning Team gets a grand prize of $1000 in crypto and a job offer or a chance to continue the project. (Form closes:6th October 2021.)

Read more about the program here

Registration form- Here

Mercury Hackathon 2021: All about NFTs

At the Mercury Hackathon 2021, we believe that the sky’s the limit in the world of blockchain and non-fungible tokens (NFTs). Join us on this 6-week online hackathon supported by Filecoin, IPFS & Flow that brings together some of the most talented creators around the world to innovate and redefine boundaries.

With up to USD $120,000 worth of FIL & FLOW tokens to be given out and 14 prize categories, participants can choose to build and develop projects spanning between NFTs and decentralized storage services. Wish to experience web3 storage, Estuary, Slate, or NFTstorage and beyond? Strap on, suit up & let's get building.

Read more about the program here

Red Brick Pre-accelerator Program

This is a 6-week 100% online program targeted at start-up founders.

The different premade modules of our online program will help you to validate your idea, find your customer and support your team growth. You have access to high-quality content & tools and will be in direct contact with experienced mentors and coaches.

Read more about the program here

TechonDemand Hackthon (FSI Fintech Challenge)

A Physical & Virtual Hackathon Event to address the dominance of cash transactions, manual processes, and access to financial services among retailers, micro, small and medium enterprises (MSMEs) as well as individuals in suburban parts of Nigeria including university communities and their environs.

Read more about the hackathon here

PyTorch Annual Hackathon 2021

The PyTorch Annual Hackathon is back in 2021 with all-new opportunities for you to get started or continue learning about PyTorch. Join the community to build innovative and impactful models, applications, and other projects that use AI responsibly.

What to Build: Build a project using PyTorch in one of the three categories:

• PyTorch Responsible AI Development Tools & Libraries
• Web and Mobile Applications powered by PyTorch
• PyTorch Developer Tools & Libraries

Read more about the hackathon here

AWS Graviton Hackathon

Build or migrate an application to Amazon EC2 instances powered by Arm-based AWS Graviton2 processors for a chance to win $10,000 cash and a trip to re:Invent 2021.

AWS Graviton processors are custom built by Amazon Web Services using 64-bit Arm Neoverse cores to deliver the best price-performance for your cloud workloads running in Amazon EC2. AWS Graviton2 are the latest generation Arm-based processors that power a range of general-purpose, compute-optimized, and memory-optimized EC2 instances

Read more about the hackathon here

Shell.ai Hackathon for Sustainable and Affordable Energy

Tackling climate change is an urgent challenge. Shell is transforming to become a net-zero emissions energy business by 2050, in step with society and our customers. We are exploring new opportunities to provide more low-carbon energy such as biofuels, hydrogen, charging for electric vehicles and electricity generated by solar and wind power. To achieve this, we are working collaboratively on unproven, early-stage ideas with the potential to impact the future of energy.

Help us harness the power of the sun and win monetary awards or funding for your project!

Read more about the hackathon here

Cover image Unsplah

That being established, let's take a deeper look into the subject.

What is stress?

A state of mental or emotional strain or tension resulting from adverse or demanding circumstances.

Physiological disturbance or damage caused to an organism by adverse circumstances.

(Oxford dictionary)

What causes stress?

1. Money: A popular saying goes, "If a man will not work, he shall not eat." Money is essential to survive. It's how we can afford certain pleasures of life or otherwise. It, however, is never enough because human needs are insatiable. Not having enough money to take care of essential needs is one of the major cause of stress around the world.
2. Being under a lot of pressure or work overload: Having too much work is known to cause stress. It's common for companies or employers to overload their staff with a lot of work in a bid to "reduce cost and optimize profit." This might work for a little while but the resulting effect is a reduction in efficiency or staff or high staff turnover.
3. Facing discrimination or harassment at work
4. Changes in the external environment: This can be explained using PESTEL Analysis. Changes outside your control have effects on activities you are involved in and cause favourable or unfavourable impact.
5. Underlying medical conditions
6. Traumatic event, such as a natural disaster, pandemic, theft or rape: The COVID-19 pandemic is a typical example. It stressed a lot of individuals and companies. Questions about survival, the long-term impact on lives, companies, the economy, socio-economic environment and other areas were raised.
7. Unrealistic expectations: No one is perfect. If you expect perfection at all times, you are bound to feel stressed as it is an impossible feat.
8. Big changes
9. Social discrimination

Impact of Stress

1. Constant fatigue
2. Depression
3. Medical conditions e.g. stroke, high blood pressure
4. Difficulty in sleeping
5. Unhappiness
6. Use of hard drugs or other illegal substances
7. Weight gain or loss

How to deal with Stress

A few of the ways to destress are:

1. Acknowledge that it is real and inevitable.
2. Speaking about what stresses you to friends, family or even a therapist.
3. Exercise and eat well.
4. Don't take on too much work. Delegate when you can.
5. Don't overthink. Some things are beyond your control.
6. Create a work-life balance strategy

Managing your stress can make a real difference to your health, both physical and mental health. It's therefore imperative to be conscious about the causes of stress that we face and act on them.

Resources

• Stress
• Stress statistics 2021: How common is stress and who’s most affected?
• Cover Image- Unsplash

Although the Nigerian government, in recent years, has placed restrictions on the importation of certain kinds of food, local farmers are still in stiff competition to meet up with the demands and taste of the Nigerian people.

In November 2020, a team of 4 (myself included) decided to address the concern around agriculture in the SauceCode Hackathon. You can read the UI/UX case study for this project here.

Note: I will be using the words investment and capital interchangeably.

Problem

The inability of farmers to easily access funds for their capital-intensive business which threatens its sustainability.

Solution

AgroFarm is a platform that connects farmers and customers together for the purpose of raising interest-bearing capital for farmers. This interest (or return on investment) will be shared between the service providers and the investors (customers) at an agreed rate.

Timeline

4 weeks

Tools and Technologies

• Node.js/Express
• PostgreSQL as database
• Sequelize ORM
• Dbdiagram.io for database schema design
• Paystack for payment processing
• Heroku for hosting
• Cloudinary for image storing
• Postman for API documentation

Database design process

After scoping out the basic features, I began to design the database using Dbdiagram.io. But before then, I asked myself some questions.

• Who are the users? Can they be divided into categories?
• Are there similar properties all users should possess? What distinct properties should each category of user possess?
• What information are farmers required to submit when making requests for capital?
• Can a farmer have multiple ongoing investments?
• Who determines the return on this capital? How will this be split?
• Who can approve a request for capital? Is there any form of pre-approval and what qualifies a farmer for that?
• When can customers see the investment requests and make payment?
• What platform will be used to process payment? How do they process payment? Where will the payments from customers be received and payments to farmers be made from? Will the processing fee be passed to customers? Do they support recurrent payments?
• What information about transactions will be recorded and at what point (initiating, or confirming success)?

In answering these questions, I came up with the schema as seen in Fig 1 below; creating tables and fields before creating the relationships between tables. I decided to use a relational (SQL) database (PostgreSQL) to create standardization, avoid duplication and data integrity, to mention a few. (You may argue that MongoDB provides for the following but NoSQL databases, in general, serves a purpose quite different from SQL databases).

Fig 1: Database schema

User flow

Users are categorized into 3- Customers, Farmers and Service provider.

Service Provider refers to the company providing the platform, and by extension, its staff. It is the middleman between the customers and farmers, liaising with both sides to ensure ease of use and smooth operations on the app. It can also approve or reject investment requests from farmers.

Farmers are the users who can make request for investment for their businesses.

Customers are the users who invest in approved and available farm businesses.

Fig 2: User flow for farmers

Tough times

This project was my first attempt at building an agritech solution. While thinking about the architecture, I had to think about what exactly was my expectation was concerning

• Wallet-enabled or not
• Saving customer's card details to make recurrent payments, if needed
• Accounting entries
• Whether or not to use a micro-service architecture, even though I was the only backend developer.

With the help of my mentor who works in the fintech sector, I was able to scope out what I wanted to achieve.

Lessons Learnt

1) No one starts a project without an objective. The design thinking (solution architecting) phase is key because it helps to:

• break down the overall objective into product features and work items.
• identify resources (people, technology, time) needed.
• identify the cost-benefit of the project.
• save time.

2) I learnt how to integrate into a payment processor. Read my article about integrating multiple payment processors here.

3) Ask for help when you're stuck. If I didn't reach out to people I knew had solutions to the challenges I had, it would've taken a much longer time to break the phase of the implementation that needed it.

4) A challenge makes you better. My team ranked top 20 in the hackathon and I'm glad I decided to opt-in. I'm looking forward to more challenges and wins in the near future.

Image credits

Cover image and Fig 2 by Emmanuel Okononfua

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

JavaScript is my preferred programming language. In this article, I'll highlight a few of the reasons for my decision.

Easy to learn

JavaScript is easy to pick up and has a natural feel to it. Being a higher-level language, it abstracts away most of the complex details of the machine so you can focus on learning how to program. You can also start coding with JavaScript straight from your browser, before proceeding to set up any development environment to perform more complex activities.

Wide-span of use

Originally, JavaScript could only be run on web browsers. However, due to its popularity and the need to reduce the number of languages/tools developers need to learn to accomplish a task, the need to expand its area of application became very eminent. JavaScript can now be used in areas such as IoT, frontend, desktop, backend, mobile, machine learning and game app development.

Dynamic Typed

Unlike its static-type counterparts (e.g. Java, C#), JavaScript does not demand you declare data types before using the variables. It is smart enough to deduce them and execute commands at runtime. This flexibility can pose several (security) threats which can, however, be managed using best practices and packages that address such concerns e.g. Joi for Node.js.

Community and resources

Due to its popularity, there are vast communities and resources available targeting beginner to expert level developers. In my opinion, there are more tech conferences that speak on JavaScript as a language or its libraries/frameworks than any other language.

Async processing

JavaScript handles requests asynchronously. That means it does not wait for returns on a request before receiving another request. Instead, it logs the requests and delivers the response based on the execution time of each request (a request that takes a shorter time will be processed and returned faster than a request that takes a longer time).

Evolution and innovation

JavaScript frameworks, libraries and packages are released much more frequently than any other language. This is mainly driven by the open-source community which anyone can be a part of.

Resources to get started

• The ultimate and free JavaScript resources
• List of my favorite JavaScript resources🚀
• Ultimate JavaScript Resources That Every Programmer Should Know!!

Closing remarks

If you don't know JavaScript, what are you waiting for? Go ahead and explore the resources above. Good luck!

Despite supporting JavaScript, I believe it is important should consider the purpose and requirements of a project before deciding a language to use.

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

Low-quality laptop

I used this laptop while in university; I was very annoyed and irritated when I received it during the 3rd semester. It had a 40GB hard disk size, 1GB RAM, the processor, battery life, speed and just about everything was awful. After a while, I got over it. I decided to use the laptop to its maximum capacity. Every semester, I would uninstall the IDE for the previous language learned to give room to install a new one and replace the battery every year. I still don't understand how Visual Studio survived on it.

Despite the hell I faced with this laptop, my programming and general academic activities were not distorted. Sure, it hindered progress because it couldn't handle some things I wanted to explore deeply, I made the best use of what I had and came out with good grades. (Read more about this here).

Fast-forwarding to months after graduation, I got a better laptop because the one in the picture suddenly shutdown (You don't understand the joy that struck me when it happened). Now I look back and wonder how I survived with that crapy old Dell. But it taught me patience and perseverance. I can't go back to that laptop though.

Lessons:

1. The output of anything is more dependent on the person behind the machine than the machine itself.

Imposter Syndrome

(Source: Unsplash)

People in tech think this phrase is limited to them. They haven't met a newly trained make-up artist go for his/her first gig.

I was one of the few people in my class (back in uni) that really enjoyed programming. I was confident I knew things but at the same time, I didn't know a lot. I remember when I started learning Android development, I quickly updated my resume and LinkedIn skillset to include it. Twice I was asked about my level of competence in that skill but I couldn't defend it.

In 2019/20, I challenged myself to learn and practice more. I got exposed to people in the tech space and working in teams shed more light on best practices. During my first team project, I used a fake it till you make it approach. I also got a mentor.

Imposter syndrome makes you doubt yourself but that doubt should translate into growing your skills.

Lessons:

1. Start believing in yourself.
2. Practise makes perfect.
3. Ask questions in doubt and follow the right people.

Too many technologies to keep up with

Keeping up with the constant evolution in tech is not easy; it's not mandatory to pick up every new tool released but having knowledge of various tools gives you flexibility in what you can do and command.

In university, I explored Visual Basic -> C -> C++ -> Python -> C# -> HTML, CSS & JS -> PHP -> Java. I mainly used them to solve arithmetic problem but I took a deeper dive into the last 3 technologies.

After university, I started exploring Android, NodeJS and TypeScript. There's so much more I want to learn; learning gets exhausting. I've enrolled in many courses on Udemy, Coursera, Datacamp, Pluralsight, edX, API Academy and maybe a few more that I don't even remember. When I enrolled, I was "saving them for a rainy day" but I will never finish them.

The key thing is planning. I know I can't possibly learn 5 new technologies while trying to maintain a social life and working full-time in a short period. I don't want to be a mad scientist and lose my mind. I plan my learning path so as to maximise effort and get the best out of the learning process.

Lessons:

1. The road to your destination is never straightforward.
2. Seek help if you're stuck.
3. Working in a team is a great way to learn.
4. Plan your learning path and be realistic about the time you have.

Job rejections

You don't want to know how many jobs I've applied to and got rejected from since I graduated from the university because they're many. The majority were outright rejections, "you do not qualify", no response from some, didn't pass the tests or didn't get to the final stage for others. You'd think just finishing from schools means you're still "hot and fresh" and so you'll be rushed. Sadly, this doesn't favour every graduate.

Looking back, I realised that I didn't have enough knowledge base (but I was a fresh graduate. Was I supposed to have 10 years of experience?). I decided to be more purposeful about what I wanted and targetted them. I started blogging as another way to show my technical competence and got involved in communities where I met people who can vouch for me.

Lessons:

1. Build your skill and your network.
2. Be specific about where you want to be and work towards it.

Closing remarks

All the things I faced made me stronger and more confident. I wouldn't change anything because my challenges paved a way for me to see clearly what I want. If carbon has to be subjected to intense pressure, temperature and other factors to produce the beautiful diamond that you see today, humans as well have to go through a refining process to become the best versions of themselves.

Resources

Cover Image by Braden Collum on Unsplash

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

I decided I was going to study something computer-related at the university; at first, it was computer programming but that's not an actual first-degree field so I opted for Management Information System (a breed of computer science and business management).

The actual genesis

I wrote my first line of code in 2014; the typical Hello world, with Visual Basic. My university was very committed to growing the programming skills of its students. For the first 3 years, we did 1 or 2 programming languages per semester.

Visual Basic -> C -> C++ -> Python -> C# -> HTML, CSS & JS -> PHP -> Java

Seems like a lot, right? It actually was. It was a challenge but it was nice having to skim through them all to know what I would and won't like. I mainly explored Java, PHP, and HTML, CSS & JS.

After school

I resumed work the week following my convocation. I hoped to get into a programming role but I wasn't ready to face C# so I chose the Business Analysis path. I had to build a simple desktop calculator with C# before my confirmation. It was pretty sleek. I would've put the source code on Github but when I wrote the code, God and I both understood it, now, only God understands it.

Being a business analyst means being the bridge between the developers and the customers. I was (still am) in a position of thinking business-wise and thinking programming-wise; having a programming bias made it easier to break down requirements into the most minute scenarios. It really extended my analytical capabilities. The field is actually very good as it builds dual capacity. No one ever runs a company successfully without having a good business acumen; the earlier you can pick it up, the better for you. Business analysis is also one of the Top 10 Hard skills of 2020 by LinkedIn.

In 2019, I decided to rekindle my romance with programming by enrolling in the GADS and DevC (Andela + Facebook Developer Circle) programs for Android and web development respectively. I was introduced to Node.js by the latter and I am hopelessly in love with it. I also got myself a tech mentor.

In 2020, I participated in 3 remote internships and 1 hackathon. I integrated myself into so many tech communities and built networks, it's amazing. I also started blogging here on Hashnode because of Edidiong Asikpo and it's really pushed me to learn more and share. My first tech talk and Open Source contribution also happened this year.

I'd like to believe that my growth so far has been biased to business analysis, software development (backend), and technical writing, but that's not all I'm about.

Going forward

There's still so much to be done and I'm very committed to constant growth and exploits. Tech is my going concern. I would say I hope to be the next Mark Zuckerberg but I'd rather be the very best version of me.

Resources

Cover Image

If you like this article, feel free to comment and share. You can also reach out to me on Twitter / LinkedIn / Github

Ciao👋🏼

Handling payments for goods and services rendered back in the days was a very long and tedious process, prone to errors and time-consuming. Queuing at the bank or chasing customers to receive money is a job for the strong-minded and 'stress-tolerant'. As technology evolved over the years, the financial sector also joined the ride. Individuals and corporates can send and receive money from the comfort of their homes thus making life easier for everyone.

Payment service refers to any service provided by a financial institution to allow one person or organization to pay another for a product or service. In this article, we'll be looking at 3 payment service providers who operate in about 200 countries.

Code snipped will be shared however the full code can be found here.

Paystack

Paystack was founded in 2015 by 2 Nigerians but acquired by Stripe in October 2020. It provides online payment facilities to merchants and others by way of an API and a few lines of code. It supports the B2B and B2C business models, and thus a wide range of businesses. It currently has over 60,000 businesses using its services.

Paystack supports payment using debit cards, bank transfer, USSD, mobile money and visa QR. It currently operates in Nigeria, Ghana and South Africa, supporting the following currencies: NGN, USD, GH₵ and ZAR.

Pros

1. It is easy to integrate.
2. It supports various business models.
3. It provides customer support.
4. No set-up fees.
5. You can set up recurring payments.

Cons

1. It does not support cross-currency transactions.
2. Transaction settlement is T+1 (the day after the transaction). Settlement only occurs during the weekdays.

// Initialise transaction
app.post('/transaction', async(req, res)=>{   
      const paymentData = {
        email:'johndoe@gmail.com',
        amount:10000,  // In kobo
        reference: `ABDC-${Date.now()}`,
        metadata: {
            custom_fields: [
                {
                    full_name: 'John Doe',
                }
            ]
        }
    }

    const response = await axios.post('/transaction/initialize', { ...paymentData });
    const result =  response.data.data

    return res.json({result})
})

PayPal

Paypal is an electronic commerce company that facilitates payments between parties through online transfers. Users create an account on its platform, which is connected to their credit card or checking account. Users can send or receive payments to and from other PayPal accounts online or through the company's app.

PayPal offers payment services and solutions for both personal consumers and businesses. The company allows personal consumers to shop, make payments, and transfer money with relative ease. Users need an email address to sign up for an account and must provide a credit card, debit card, or bank account to complete the setup.

PayPal verifies all information to make sure the person setting up the account is the rightful owner before the service can be used. lt is available in over 200 countries and regions.

Pros

1. It is easy to integrate.
2. It supports various business models.
3. No set-up fees.
4. It offers its own credit card through Synchrony Bank. Approved applicants are supplied with MasterCards branded with the PayPal name.
5. Cross-currency transactions are supported.
6. You can create and send invoices right through your account.

Cons

1. Some transaction settlements are not real-time; differs between countries
2. PayPal can freeze accounts without warning. PayPal’s algorithm can sometimes detect suspicious behaviours in your account. And when that happens, PayPal can automatically freeze your account, along with the funds in the account.
3. There are hefty fees for chargebacks.
4. PayPal's Seller Protection policies do not cover digital goods.

// create order
app.post('/order', async(req, res)=>{
    const paymentData = {
      intent: "CAPTURE",  // CAPTURE or AUTHORIZE
      purchase_units: [
        {
          amount: {
            currency_code: "USD",
            value: "100.00"
          }
        }
      ]
    }

    const response = await axios.post('/v2/checkout/orders', { ...paymentData }, {...headers});
    const result = response.data
    return res.json({result})
})

eWay

eWay was launched in 1998. It is an omnichannel payment provider. The company processes secure credit card payments for merchants and works through eCommerce.

eWAY processes payments for over 26,000 businesses.

Supported platforms include Magento, Shopify, WooCommerce, BigCommerce, WP e-commerce, etc.

Pros

1. Built-in fraud prevention tool
2. Approved merchants don’t need a merchant account
3. No set-up fees
4. Transactions are risk-rated in real-time via the Beagle tool (a free plan)
5. APIs are secure and robust, thus eWay can be integrated with almost any website on the planet.

Cons

1. Their built-in fraud prevention tool has to be manually activated from your merchant account.
2. Only merchants with bank accounts based in Australia, New Zealand, Singapore, Hong Kong, Malaysia, and the UK can use eWay to receive payments.

// charge token customer
app.post('/transaction', async(req, res)=>{
    const paymentData = {
      "Customer": {
        "TokenCustomerID": 917758625852
      },
      "Payment": {
        "TotalAmount": 1000
      },
      "TransactionType": "Recurring"
    }

    const response = await client.createTransaction(rapid.Enum.Method.DIRECT, paymentData);
    const result = response.attributes;
    return res.json({result})
})

Contribution

If you notice a bug or would like to contribute, feel free to reach out to me or check out the Contribution section of the repo.

Conclusion

Payment service providers have made life easier for persons to conduct local and international businesses and receive payment. Now you have no excuse for not starting your business. Go ahead and practise what we've covered in this article, or explore from the hundreds of PSPs that exist.

Note All information is at the date of this publication (December 2020) as is subject to review with innovations from the various PSPs.

Resources

1. Paystack
2. Top 6 Payment Gateways for Online Businesses in Australia
3. PayPal
4. PayPal pros and cons

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

In 2020, I signed up on Hashnode and I got the chance to attend the first Technical Writing Bootcamp. It was a great experience and I met 4 amazing writers ( Catalin Pit, Omotola Shogunle, Tapas Adhikary & Victoria Lo ) who have helped shape & streamline my thoughts & expectations on technical writing.

Some of the points I picked up from the bootcamp include but are not limited to:

• Knowing your audience and writing to fit their needs.
• Discovering your writing style.
• Writing consistently.
• Branding your blog.
• Promoting your blog. There's no point in writing and not sharing your articles.
• Writing as a way of improving as a developer.
• Focusing on writing quality articles.

Your blog is your persona, a reflection of who you are and what you know.

Thanks to the speakers and the entire Hashnode team for providing this opportunity. The journey has only begun.

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

An object-relational mapper (ORM) is a code library that automates the transfer of data stored in the database into objects that are more commonly used and understandable in application code, so you don't use SQL. e.g. sequelize, typeORM, Pony, etc.

You have an article class, you want to retrieve all the articles with the title "ORM". With SQL, it would look like this:

const query = "SELECT * FROM article WHERE title='ORM';";
const data = await pool.query(query);

With an ORM library, it would look like this:

const data= await Article.findOne({
      where: { title: "ORM" },
    });

In this article, we will be creating a simple Article CRUD app, writing raw SQL queries to manipulate data.

Pre-requisite

The following should be installed on your computer:

1. PostgreSQL
2. Node.js
3. Postman

Database Set-Up

1) Launch SQL shell (psql)

2) Click on Enter after every line. Enter your password when prompted.

3) Create a database CREATE DATABASE node_pg_test;

4) Connect to the database

\c node_pg_test

5) Create article table

CREATE TABLE article(
 id SERIAL PRIMARY KEY, 
title TEXT NOT NULL, 
article TEXT NOT NULL, 
created_on TIMESTAMP DEFAULT CURRENT_TIMESTAMP);

Run \dt to check all the tables we have. That's all for our database. Let's head over to the text editor to write our code.

Project Structure

.env => Contains all the environment variables (e.g. PORT and database URL)

config.js=> Contains connection to the database.

controller.js=> Contains functions to handle specific operations.

index.js => The starting point that connects all parts of the app together.

route.js => Contains the routing for the endpoints.

Set-up your code and install the dependencies

1) Create a folder that you want to work in and cd into it

2) Run npm init -y. This will accept the default config.

3) Install all the required dependencies

npm install dotenv express pg
npm install -D nodemon

4) Update the start script in package.json

"scripts": {
    "start":"node index.js",
    "dev":"nodemon index.js"
  },

5) Create a .env file

// .env
//DATABASE_URL_FORMAT= postgresql://{user}:{password}@{host}:{port}/{database}
DATABASE_URL = postgresql://postgres:{password}@localhost:5432/pg_node_test

6) Filling in the blanks

// index.js
const express = require("express");
const app = express();
const bodyParser = require("body-parser");
const dotenv = require('dotenv')
const articleRouter = require("./route");

dotenv.config();

app.use(bodyParser.json());
app.use(
  bodyParser.urlencoded({
    extended: true
  })
);

const port =  process.env.PORT || 3000

app.listen(port,() =>{
    console.log('Node.js listening... ' + port);
})
app.use("/articles", articleRouter);

//config.js
const Pool = require("pg").Pool;
const dotenv = require("dotenv");
dotenv.config();

const pool = new Pool({
  connectionString: process.env.DATABASE_URL
});

pool.on("connect", () => {
  console.log("connected to the db");
});

module.exports = {
  pool
};

// controller.js
const { pool } = require("./config");

const getArticles = async (req, res, next) => {
  try {
    const data = await pool.query(
      "SELECT * FROM article ORDER BY created_on DESC;"
    );

    if (data.rowCount == 0) 
      return res.status(404).send("No article exists");

    return res.status(200).json({
      status:200, 
      message: "All articles:", 
      data:data.rows
    });
  } catch (error) {
    return next(error);
  }
};

const createArticle = async (req, res, next) => {
    const { title, article } = req.body;
    const query =
      "INSERT INTO article(title, article)  VALUES($1, $2) RETURNING *;";
    const values = [title, article];
    try{
      const data = await pool.query(query, values);

      return res.status(201).json({
        status:201, 
        message: "Article added successfully", 
        data: data.rows
      });
    } catch (error) {
      return next(error);
    }
  };

const getArticleById = async (req, res, next) => {
    const id = parseInt(req.params.id);
    const query = "SELECT * FROM article WHERE id=$1;";
    const value = [id];

    try {
      const data = await pool.query(query, value);

      if (data.rowCount == 0) return res.status(404).send("No article exists");

      return res.status(200).json({
        status:200, 
        message: "Article:", 
        data: data.rows
      })
    } catch (error) {
      return next(error);
    }
  };

  const updateArticle = async (req, res, next) => {
    const id = parseInt(req.params.id);
    const { title, article} = req.body;

    const query =
      "UPDATE article SET title=$1, article=$2 WHERE id=$3 RETURNING *;";
    const value = [title, article, id];

    try {
      const data = await pool.query(query, value);

      if (data.rowCount == 0) return res.status(404).send("Article does not exist");

      return res.status(200).json({
        status:200, 
        message: "Article updated successfully ", 
        data: data.rows
      })
    } catch (error) {
      return next(error);
    }
  };

  const deleteArticle = async (req, res, next) => {
    const id = parseInt(req.params.id);
    const value = [id];
    const query = "DELETE FROM article WHERE id=$1;";

    try {      
      const data = await pool.query(query, value);

      if (data.rowCount == 0) return res.status(404).send("Article does not exist");

      return res.status(200).json({
        status:200, 
        message: "Article deleted successfully"
      })
    } catch (error) {
      return next(error);
    } 
  };

  module.exports = {
    getArticles,
    createArticle,
    getArticleById,
    updateArticle,
    deleteArticle
  };

// route.js
const express = require("express");
const router = express.Router();
const {
  getArticles,
  createArticle,
  getArticleById,
  updateArticle,
  deleteArticle
} = require("./controller");

router
    .post("/", createArticle)
    .get("/", getArticles);
router.get("/:id", getArticleById);
router.patch("/:id", updateArticle);
router.delete("/:id", deleteArticle);

module.exports = router;

Let's start the development server using npm run dev and test in Postman. The base URL is http://localhost:4000/articles

Conclusion

Although using ORMs makes life much easier and your code cleaner, being able to write SQL queries is a very essential skill. Writing SQL queries makes using ORMs more understandable. Simple and complex data manipulation can be done using SQL.

Resources

1) Connect To a PostgreSQL Database Server

2) PostgreSQL CREATE DATABASE with Example

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

In this article, we'll be exploring TMDB in Node.js.

Before we being any coding, let's take a look at the TMDB API Documentation. There are dozens of categories available to us- movies, companies, TV series, reviews, etc. Is there anything they don't have? Take a moment and explore the documentation to have a good idea of what you can build with it.

Pre-requisite

1) TMDB account. Register for an API key as you would need it.

2) Postman

Now that that's set-up. Let's get to it.

Install the required dependencies

Let's install express, dotenv, axios and nodemon

//.env
MOVIE_DB_API_KEY=

app.js
const express = require('express');
const dotenv = require('dotenv');
const axios = require('axios');

dotenv.config();

const app = express();

const server = app.listen(4000, () => {
  console.log(`Server listening on port ${server.address().port}`);
});

app.get('/', (_, res)=>{
    res.send('hi')
})

In package.json, update your start script, add "dev": "nodemon app.js" Run npm run dev to start the app.

Head over to postman and make a request to http://localhost:4000/. If you get Hi as your response, you're good.

Exploring Popular Movies

This API is used to get a list of the current popular movies on TMDb. This list updates daily.

Add the below to app.js

/**
 * Fetch popular movies from TMDB
 *  @returns {Array} movies
 */
const fetchMovies = async (page) => {
    try {
      let result;
      await axios
        .get(
          `https://api.themoviedb.org/3/movie/popular?api_key=${process.env.MOVIE_DB_API_KEY}&page=${page}`
        )
        .then((response) => {
          result = response.data.results;
        })
        .catch((error) => {
          console.log(error);
        });
      return result;
    } catch (error) {
      console.error(error);
    }
  };

app.get('/movies', async (req, res, next)=>{
    try {
        const {page} = req.query;
        const data = await fetchMovies(page);

        return res.status(200).json({
          status:200,
          message: `${data.length} movies found`, 
          data
        })
      } catch (err) {
        return next(err);
      }
})

We created fetchMovies(page) to interface with TMDB endpoint and get the movies. The endpoint returns a list of things, some of which we don't need, therefore, we specified only what we want to return to the user result = response.data.results;. Then we call the method in our /movies route.

The page query parameter is optional but the result will default to page 1 if removed. Each page returns 20 movies and there are 1,000 pages.

Let's try it in Postman.

Exploring Genres

This endpoint gets the list of official genres for movies.

//app.js
/**
 * Fetch genres from the moviedb.org
 *  @returns {Array} list of genres
 */
const fetchGenres = async (page) => {
    try {
      let result;
      await axios
        .get(
          `https://api.themoviedb.org/3/genre/movie/list?api_key=${process.env.MOVIE_DB_API_KEY}`
        )
        .then((response) => {   
          result = response.data.genres;
        })
        .catch((error) => {
          console.log(error);
        });
      return result;
    } catch (error) {
      console.error(error);
    }
  };
// Get Genres
app.get('/genres', async (req, res, next)=>{
    try {
        const data = await fetchGenres();

        return res.status(200).json({
          status:200,
          message: `${data.length} genres found`, 
          data
        })
      } catch (err) {
        return next(err);
      }
})

Let's try it in Postman.

What's next?

Not that you have an introduction to TMDB, go ahead and integrate to more endpoints, create your own application that requires TMDB.

Resources

TMDB API Documentation

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

Using regex can be confusing. As such, it's important to know your expectation before attempting to implement it. Regexr is an online tool to evaluate regex. Open this in another tab while following through this article.

Building blocks of regex

A) Expression Pattern: Brackets are used to find a range of characters.

B) Metacharacter: Metacharacters are characters with a special meaning.

C) Quantifiers: Define quantities.

Some examples

"123".search(/^[a-zA-Z]+$/) // false=> Capital and small letters required
"AaBbCc".search(/^[a-zA-Z]+$/) // true 

"123".search(/./) // true => Any character
"123".search(/^[0-9]{10}/) // false=> Numbers with a count of 3`

"1234567890".search(/^[0-9]{10}/) // true => Numbers with a count of 10

"01-01-2020".search(/^(0?[1-9]|[12][0-9]|3[01])[\/\-](0?[1-9]|1[012])[\/\-]\d{4}$/) // true => Date format: dd-mm-yyyy or dd/mm/yyyy

"Password1!".search(/^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!_`,/@#\-"=:;~<>'\$%\^&\*\?\|\+\(\)\[\]\{}\.])(?=.{8,})/) //true => Password of 8 characters including numbers, letters and symbols

Note: Using .search() produces a 0 or -1 result. 0 represents true while -1 represents false.

What’s Next

Now that you've gotten a taste of regular expressions, you can try them on your own, delving into more complicated patterns.

Resources

• Java Regular Expression
• Regex: From beginner to BEST on your team in one blog 👑

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

Cloudinary is an end-to-end image- and video management solution for websites and mobile apps, covering everything from image and video uploads, storage, manipulations, optimizations to delivery.

In this article, we'll be uploading images to Cloudinary in a node.js/express.js application.

Pre-requisite

1. Cloudinary account
2. Node.js installed on your computer
3. Postman installed on your computer

Cloudinary configuration

Login to your Cloudinary account. On your dashboard are 3 configurations- Cloud name, Api key and Api Secret. Copy these (into a .txt file or sticky notes) as you will need them shortly.

Install the dependencies and start coding

1) Create a folder to work with. Run npm init -y. This will accept the default config.

2) Install the following dependencies- cloudinary, express, dotenv and express-fileupload

npm install cloudinary express dotenv express-fileupload

3) Create an index.js file which is our starting point, cloudinary.js file to contain the Cloudinary config and upload function, and .env file to contain the environment configs.

4) Copy the Cloudinary configs from your .txt file or sticky note and insert them in the .env file as seen below.

CLOUDINARY_NAME= insert_your_name
CLOUDINARY_API_KEY = insert_your_api_key
CLOUDINARY_API_SECRET = insert_your_api_secret

5) Connect your app to Cloudinary.

// cloudinary.js
const dotenv = require('dotenv');
const cloudinary = require('cloudinary').v2;

dotenv.config();

cloudinary.config({
  cloud_name: process.env.CLOUDINARY_NAME,
  api_key: process.env.CLOUDINARY_API_KEY,
  api_secret: process.env.CLOUDINARY_API_SECRET
});

const upload = async (file) => {
  const image = await cloudinary.uploader.upload(
    file,
    (result) => result
  );
  return image;
};

module.exports = { upload };

In lines 6-8, we connected our app to cloudinary.

The upload function that handles uploading the images to cloudinary. It's good practice to have a single function that you can reuse.

You can also upload the images into a specific folder;

const image = await cloudinary.uploader.upload(
    file,
    { folder: 'Test' },
    (result) => result
  );

6) Let's make use of our upload function

// app.js
const express = require('express');
const fileUpload = require("express-fileupload");
const { upload } = require('./cloudinary')

const app = express();
app.use(
    fileUpload({
      useTempFiles: true
    })
);

app.listen(3000, () => {
    console.log('Server listening on port 3000')
})

app.post('/upload', async (req, res)=>{
    if (!req.files) return res.send('Please upload an image');

    const {image} = req.files;
    const cloudFile = await upload(image.tempFilePath);
    console.log(cloudFile)

    res.status(201).json({
        message:'Image uploaded successfully',
        imageUrl:cloudFile.url
    })
})

You can specify the file type that you want to support.

const fileTypes = ['image/jpeg', 'image/png', 'image/jpg'];
if (!fileTypes.includes(image.mimetype)) return res.send('Image formats supported: JPG, PNG, JPEG');

You can also limit the size of the image to be uploaded.

const imageSize = 1024;
if (image.size / 1024 > imageSize) return res.send(`Image size should be less than ${imageSize}kb`);

By default, the image size is in bytes. To convert to kb, divide the image by 1024.

Let's add the 2 options above into our route

app.post('/upload', async (req, res)=>{
if (!req.files) return res.send('Please upload an image')

    const {image} = req.files;
    const fileTypes = ['image/jpeg', 'image/png', 'image/jpg'];
    const imageSize = 1024;    

    if (!fileTypes.includes(image.mimetype)) return res.send('Image formats supported: JPG, PNG, JPEG');  

    if (image.size / 1024 > imageSize) return res.send(`Image size should be less than ${imageSize}kb`);

    const cloudFile = await upload(image.tempFilePath);
    console.log(cloudFile)

    return res.status(201).json({
        message:'Image uploaded successfully',
        imageUrl:cloudFile.url
    })
})

Let's test

Run your app, typing node index.js in the terminal.

Launch Postman and make a POST request with the url- http://127.0.0.1:3000/upload.

We will test with 4 scenarios, trying to upload

1) Without an image

2) A file larger than 1024kb (1MB)

3) A file not of type png, jpg nor jpeg

4) An image less than or equal to 1024kb

If you notice, a new folder called tmp has been created in the root directory. This folder temporarily stores files uploaded. Cloudinary picks up the image via its file path before hosting on its server.

Now, let's head over to Cloudinary and see our image.

Conclusion

Cloudinary is a powerful tool that does much more than what we have covered in this article. I challenge you to go further and explore what more the tool has to offer.

Resources

1. Node.js SDK

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼

So, what is recursion?

Recursion is an iteration technique where a function calls itself. It's applicable when you need to call the same function repeatedly with different parameters from within a loop.

Search for Recursion on google and you get this. Now, click against the suggested recursion.

What happens? You're redirected to the same page. That's recursion with a sense of humour.

Recursion vs Loop

Let's take a look at 2 scenarios

Scenario A- Loop

const pow = (x,n)=>{
  let result = 1;

  for (let i = 0; i < n; i++) {
    result *= x;
  }
  return result;
}

console.log( pow(2, 3) ); // 8

Scenario B- Recursion

const pow = (x,n)=>{
  if (n == 1) {
    return x;
  } else {
    return x * pow(x, n - 1);
  }
}
console.log( pow(2, 3) ); // 8

What do you note between these 2 scenarios? In scenario A, we loop over the variables i.e instructions are repeatedly executed while in scenario B, the function calls itself.

To calculate pow(2, 3) the recursive steps are as below:

pow(2, 3) = 2 pow(2, 2) => 2 4 = 8

pow(2, 2) = 2 pow(2, 1) => 2 2 = 4

pow(2, 1) = 2

Recursion reduces a function call to a simpler one until the result is gotten.

It's essential to define a breakpoint (n==1 as in the example above) else your function will run indefinitely.

Differences between Recursion and Loops

1. Time: Recursion is more time consuming than loops.
2. Usage: Recursion is used when code size needs to be small, and time complexity is not an issue. A loop is used when time complexity needs to be measured against the code size.
3. Termination: Recursive function is terminated when there is no function call. A loop is terminated when the condition for the iterator ceases to be satisfied.

Application of Recursion

1. Fractal maths
2. Sorting
3. Traversing the nodes of complex or non-linear data structure
4. File trees

Conclusion

Recursion is a powerful technique and is the most direct way to solve a complex problem. However, due to its shortcomings, we will need to be very careful about how and where we apply recursion.

References

1. Recursion in Functional JavaScript
2. Understanding Recursion Using Real-World Examples
3. Difference between Recursion and Iteration
4. Recursion and stack

If you like this article, feel free to comment and share. You can also reach out to me on Twitter | LinkedIn | Github

Ciao👋🏼