Forem: Olasunkanmi Balogun

How I Built a Decentralized Crowdfunding App with Foundry(incl. unit tests)

Olasunkanmi Balogun — Mon, 09 Sep 2024 12:55:40 +0000

Recently, I completed the Foundry Solidity Smart Contract course by Patrick Collins. Throughout the course, I gained hands-on experience with generating randomness on blockchains using Chainlink VRF, working with ERC20s and NFTs, exploring DeFi, building upgradeable smart contracts, and diving into DAOs—all using the powerful tools provided by Foundry.

To cement some of the concepts I had learned, I decided to get my hands dirty by building a Crowdfunding dApp which will be discussed in this article.

This article will cover a range of beginner-friendly concepts, from using struct to define complex data types, utilizing mappings to store and access campaign data efficiently, and implementing require statements to enforce critical conditions and ensure contract integrity. You'll also learn how to send ETH to a function securely and declare custom error types in Solidity to handle exceptions. Additionally, I'll walk you through writing comprehensive tests in Solidity to validate your contract’s functionality.

Finally, we'll generate an RPC URL with Alchemy to interact with the blockchain seamlessly and explore how to deploy your contracts on the Sepolia testnet.

Better yet, we'll put all of this into practice using a real code editor—preferably VSCode.

Prerequisites

A solid understanding of fundamental blockchain concepts, particularly smart contracts, and their functionality.
Basic familiarity with Solidity for writing smart contracts, including key concepts such as functions, modifiers, events, and error handling (though I will briefly explain them throughout the article).
A working knowledge of Makefiles and their use in automating project setups.

When you're ready, let's dive in! 🚀

Foundry installation & project setup

Foundry is a comprehensive toolchain for smart contract development. It handles your dependencies, compiles your project, runs tests, deploys contracts, and enables interaction with the blockchain via the command line and Solidity scripts.

Note: If you're new to Foundry and using Windows, you'll need to use the WSL as your terminal, since Foundry doesn't currently support Powershell or the command prompt.

For first-time Foundry users, open your terminal and run the following command:

curl -L https://foundry.paradigm.xyz | bash

This will install Foundryup. Simply follow the on-screen instructions to make the Foundryup command available in your CLI.

Next, run the Foundryup command in your terminal. This will install the latest (nightly) precompiled binaries: forge, cast, anvil, and chisel.

Once installation is complete, open your code editor, navigate to your projects folder, and create a directory for the crowdfunding dApp project we're about to build. For this tutorial, I'll name mine crowdfunding-dApp.

Finally, to initialize a Foundry application, run the following command in your terminal:

forge init

If successful, your project structure should appear like this:

Inside the src folder, you'll find boilerplate code for a counter contract, with corresponding scripts and tests in the script and test folders. Delete these files so we can start our project from scratch.

This takes us to the next section.

Developing the Crowdfunding Smart Contract

Before diving into the implementation, let’s outline the key features of this project:

Create a function that allows users to launch campaigns with a specific funding goal and deadline. This function should revert with an error if the specified deadline is in the past.
Develop a function that enables donors to contribute to a campaign by sending funds to the campaign creator’s address. This function should revert with an error in the following scenarios:
- If the donor sends zero ETH.
- If the campaign’s deadline has already passed.
- If the campaign’s funding target has already been reached.

For each of these conditions, we’ll define custom errors.

To get started, create a new file in your src folder named crowdfunding.sol. This file will contain the smart contract code for our crowdfunding dApp.

Begin by pasting the following code, which specifies the Solidity version and defines the contract. Notice that we have also defined the custom errors we'll use throughout the contract:

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

contract Crowdfunding {
    error Crowdfunding__DeadlineMustBeInTheFuture();
    error Crowdfunding__CantSendZeroEth();
    error Crowdfunding__CampaignDeadlineElapsed();
    error Crowdfunding__TargetMetForCampaign();
}

Next, we’ll outline the campaign structure using the struct keyword and declare the necessary state variables. Inside the contract, add the following code:

struct Campaign {
    address owner;
    string title;
    string description;
    uint256 target;
    uint256 deadline;
    uint256 amountCollected;
    string image;
    address[] donators;
    uint256[] donations;
}

mapping(uint256 => Campaign) public campaigns;
uint256 public campaignId = 0;

In this snippet, we define a struct to represent each campaign, and we declare a mapping variable that links a uint256 type to the Campaign struct. If you’re familiar with JavaScript, you can think of a mapping as an object that stores data in key-value pairs.

Lastly, we introduced a campaignId variable, which will serve as the key for our mappings as we add new campaigns.

With this foundation in place, we’re ready to start creating the contract functions.

To begin, we'll create a function that allows users to launch a campaign. Add the following code snippet to your file. Comments have been included to clarify each part:

function createCampaign(
    address _owner,
    string memory _title,
    string memory _description,
    uint256 _target,
    uint256 _deadline,
) public returns (uint256) {
    Campaign storage campaign = campaigns[campaignId]; // Assign a key to the mapping

    if (_deadline < block.timestamp) {
        revert Crowdfunding__DeadlineMustBeInTheFuture();
    }
    // Populate the campaign details using the provided input
    campaign.owner = _owner;
    campaign.title = _title;
    campaign.description = _description;
    campaign.target = _target;
    campaign.deadline = _deadline;
    campaign.amountCollected = 0;

    campaignId++; // Increment the state value after a new campaign is added
    return campaignId - 1; // Return the index of the newly created campaign
}

The createCampaign function is designed to allow users to create new crowdfunding campaigns on the blockchain. It takes several parameters, including the campaign owner's address, the title and description of the campaign, the funding target, and the deadline for the campaign. The function first checks if the provided deadline is in the future; if it's not, the function reverts with an error, Crowdfunding__DeadlineMustBeInTheFuture(). If the deadline is valid, the function then stores the campaign details in a mapping using the current campaignId as the key.

After storing the campaign information, the function increments the campaignId to ensure each new campaign gets a unique identifier. It finally returns the id of the newly created campaign. This id can be used to reference the campaign for future actions, like making donations. The function essentially sets up the campaign's foundation, ensuring it has all the necessary information and a unique identifier for tracking.

Next, we'll implement the function for donating to the campaign. Add the below function to your contract.

function donateToCampaign(uint256 _campaignId) public payable {
        // revert if donor isnt sending anything
        if (msg.value <= 0) {
            revert Crowdfunding__CantSendZeroEth();
        }
        //  revert if deadline is in the past
        if (campaigns[_campaignId].deadline < block.timestamp) {
            revert Crowdfunding__CampaignDeadlineElapsed();
        }
        // revert if target is met
        if (campaigns[_campaignId].amountCollected == campaigns[_campaignId].target) {
            revert Crowdfunding__TargetMetForCampaign();
        }

        Campaign storage campaign = campaigns[_campaignId];

        uint256 remainingFundsNeeded = campaign.target - campaign.amountCollected;
        // Handle contributions based on the remaining funds needed
        // next code block optimized for CEI
        if (msg.value <= remainingFundsNeeded) {
            campaign.amountCollected += msg.value;
            campaign.donators.push(msg.sender);
            campaign.donations.push(msg.value);
            (bool callSuccess,) = payable(getCampaign(_campaignId).owner).call{value: msg.value}("");
            // reupdate state variables
            if (!callSuccess) {
                campaign.amountCollected -= msg.value;
                campaign.donators.pop();
                campaign.donations.pop();
            }
        } else {
            // Handle excess contributions and refunds
            uint256 excessAmount = msg.value - remainingFundsNeeded;
            uint256 amountToDonate = msg.value - excessAmount;

            // Refund the excess amount to the contributor
            payable(msg.sender).transfer(excessAmount);

            // Update the total contributions with the amount that was supposed to be donated
            campaign.amountCollected += amountToDonate;
            campaign.donators.push(msg.sender);
            campaign.donations.push(amountToDonate);
            (bool callSuccess,) = payable(getCampaign(_campaignId).owner).call{value: amountToDonate}("");
            if (!callSuccess) {
                campaign.amountCollected -= amountToDonate;
                campaign.donators.pop();
                campaign.donations.pop();
            }
        }
    }

function getCampaign(uint256 _campaignId) public view returns (Campaign memory) {
     return campaigns[_campaignId];
}

In the above code block, the donateToCampaign function is designed to facilitate secure contributions to a specific crowdfunding campaign on the blockchain. It first performs several checks to ensure the donation is valid: it verifies that the donor is sending a non-zero amount of ETH, ensures that the campaign’s deadline hasn’t passed, and confirms that the campaign hasn’t already met its funding target. If any of these conditions are not met, the function reverts the transaction, preventing the donation from going through.

Once the initial checks are passed, the function handles the donation by updating the campaign's total funds collected and recording the donor’s contribution. If the donation exceeds the amount needed to meet the campaign’s target, the excess is refunded to the donor, and only the necessary amount is added to the campaign’s funds. The function also attempts to transfer the donation directly to the campaign owner, and if this transfer fails, it reverts all state changes to maintain the integrity of the campaign’s data.

We also implemented a getter function, getCampaign, which allows users to view the details of any campaign using its unique id. It provides transparency by giving access to all relevant campaign information without altering any data on the blockchain. This ensures that potential donors or interested parties can easily check the status and details of a campaign before deciding to contribute.

To complete our contract, we’ll add two important getter functions: getDonators and getCampaigns. These functions are essential for retrieving key information about the campaigns and will be particularly useful when writing tests.

In your contract, include the following code:

function getDonators(uint256 _campaignId) public view returns (address[] memory) {
   return campaigns[_campaignId].donators;
}

function getCampaigns() public view returns (Campaign[] memory) {
    Campaign[] memory allCampaigns = new Campaign[](campaignId); // create a new array of length campaignId
    require(allCampaigns.length > 0, "No campaign has been created yet");
      for (uint256 i = 0; i < campaignId; i++) {
            allCampaigns[i] = campaigns[i];
       }
       return allCampaigns;
}

The getDonators function returns a list of all addresses that have donated to a specific campaign, allowing us to easily track contributors. The getCampaigns function, on the other hand, compiles all the campaigns into an array, providing a comprehensive view of every campaign created so far.

In the next section, we'll move on to writing tests for the contract.

Testing the Crowdfunding Smart Contract

In Foundry, each time a test is run, the contract is deployed on the local Anvil chain, typically through a setup configuration. This ensures that a new contract is deployed for each test, providing a clean state for every test case.

However, I like to separate the deployment logic from the tests themselves by implementing a deployment script independently of the tests—though this isn't strictly necessary. If this seems unclear now, don't worry—you’ll get more insights in the next sub-section.

Implementing the deploy script

First, create a new file in the script folder of your project and name it DeployCrowdfunding.s.sol. This follows the standard naming convention for script files and is where we'll write our deployment logic.

Paste the following code into it:

//  SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import {Script} from "forge-std/Script.sol";
import {Crowdfunding} from "../src/Crowdfunding.sol";

contract DeployCrowdfunding is Script {
    function run() external returns (Crowdfunding) {
        vm.startBroadcast();
        Crowdfunding crowdfunding = new Crowdfunding();
        vm.stopBroadcast();
        return crowdfunding;
    }
}

The script above begins by importing necessary modules, including the Script from forge-std, a standard utility for writing scripts in Foundry. The DeployCrowdfunding contract, which inherits the Script contract, defines a run function that is automatically executed when the script is run. Within this function, the deployment process is bracketed by vm.startBroadcast() and vm.stopBroadcast(), which signal the beginning and end of the broadcasted deployment on the blockchain. The Crowdfunding contract is then instantiated and deployed, and the resulting contract instance is returned.

With this, we have handled the deployment of the Crowdfunding contract, we can now go ahead to write tests.

Writing Tests

Here's a quick breakdown of the tests we will be writing; these tests will cover a range of scenarios to guarantee the robustness of our contract.

testCampaignCreationRevertsIfDeadlineIsNotInTheFuture: When a user attempts to create a campaign with a date that's in the past—this test ensures that such attempts are blocked, safeguarding against illogical campaign setups.
testCreateCampaign: This is the core test that verifies if a campaign can be successfully created. We'll check that all the campaign details, like the title, description, target, and deadline, are stored correctly and accessible through the contract.
testDonationRevertsWhenZeroEthIsDonated: This test ensures our contract correctly rejects any attempts to donate without sending ETH, preventing empty contributions from slipping through.
testDonationRevertsWhenDeadlinePasses: Donations should only be accepted within the campaign's active period. This test ensures that the contract stops accepting donations once the deadline has passed.
testDonationRevertsWhenTargetIsMet: When a campaign hits its target, there's no need for further contributions. This test verifies that the contract prevents overfunding and respects the campaign's goals.
testDonateToCampaign: Here, we'll ensure that donations are processed correctly—funds are received, campaign balances are updated, and the donor’s details are recorded accurately.
testReverseExcessAmountToSender: Sometimes, a donor might send more ETH than needed to reach the target. This test ensures that any excess funds are returned to the sender, maintaining fairness and transparency.

Each of these tests ensures that our crowdfunding platform works securely, and ultimately, as intended. Now, let's start implementing the test contract.

Navigate to the test folder and create a new file named CrowdfundingTests.t.sol, this follows the standard naming convention for test files. Paste the following code into the newly created file:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {Crowdfunding} from "../src/Crowdfunding.sol";
import {DeployCrowdfunding} from "../script/DeployCrowdfunding.s.sol";

contract CrowdfundingTests is Test {
}

Here, we've laid the foundation for our test suite. The Test contract from the Foundry standard library provides us with a range of tools to simulate blockchain transactions and verify that our contract behaves as expected.

We've also imported our Crowdfunding contract from the src folder, which will serve as the focus of our tests. Additionally, we imported the DeployCrowdfunding contract from the script folder to handle the deployment of our Crowdfunding contract when we run tests. Finally, we declared the CrowdfundingTests contract, which inherits the Test contract.

To effectively simulate the creation of a campaign and the process of making donations, we need to set up some initial parameters that will be used across our test functions. These parameters are crucial for mimicking real-world scenarios where multiple users interact with our contract.

Paste the code below inside the CrowdfundingTests contract.

Crowdfunding crowdFunding;
address owner = makeAddr("user");
address donor1 = makeAddr("donor1");
address donor2 = makeAddr("donor2");

uint256 campaignId;
string constant TITLE = "Help Fund My Project";
string constant DESCRIPTION = "A project that will change the world!";
uint256 constant TARGET = 5 ether;
uint256 deadline = block.timestamp + 7 days;

In the first line, we declared an instance of the Crowdfunding contract. This instance will allow us to directly interact with the contract’s external functions during our tests.

Next, we define addresses for the owner and two donors. The makeAddr function is a utility from the Foundry framework that generates Ethereum addresses for testing purposes. These addresses represent the different actors in our crowdfunding scenario, with the owner being the campaign creator and the donors being contributors to the campaign.

We then introduce a campaignId, which will store the unique identifier of the campaign created during the tests. This id is essential for referencing specific campaigns, especially when testing multiple campaign creations.

Lastly, we implement parameters needed to simulate a realistic campaign which are passed as arguments when creating a campaign.

With the initial setup complete, we can start writing our actual tests. However, before diving into the individual test cases, it's essential to configure a setUp function. This function, which we mentioned earlier, ensures that each test begins with a fresh and consistent state, making our testing process more reliable.

Paste the code snippet below into your CrowdfundingTest contract to configure the setup function.

function setUp() public {
   DeployCrowdfunding deployCrowdFunding = new DeployCrowdfunding();
   crowdFunding = deployCrowdFunding.run();
   vm.deal(owner, 10 ether);
   vm.deal(donor1, 5 ether);
   vm.deal(donor2, 5 ether);
}

The first line within the setUp function creates a new instance of the DeployCrowdfunding contract.

Next, we call the run function within the DeployCrowdfunding contract, which handles the actual deployment of the Crowdfunding contract as we implemented in the script.

The last three lines use a Foundry cheatcode to simulate funding the owner and donor addresses with specific amounts of ETH. The vm.deal function is used to assign these addresses a starting balance, ensuring that they have sufficient funds to participate in the campaign creation and donation processes during the tests.

With the foundational setup in place, it's time to start writing our tests. We'll begin with the first test on our list: testCampaignCreationRevertsIfDeadlineIsNotInTheFuture. This test is designed to ensure that the contract correctly handles scenarios where a campaign is created with a deadline that has already passed. The goal is to confirm that the contract will revert the transaction, preventing the creation of invalid campaigns.

To implement this test, paste the following code:

function testCampaignCreationRevertsIfDeadlineIsNotInTheFuture() public {
    vm.warp(block.timestamp + deadline + 1);
        vm.expectRevert(Crowdfunding.Crowdfunding__DeadlineMustBeInTheFuture.selector);
    vm.prank(owner);
    crowdFunding.createCampaign(owner, TITLE, DESCRIPTION, TARGET, deadline);
}

The test starts by using vm.warp(block.timestamp + deadline + 1);, which advances the blockchain's internal clock to a point just beyond the intended deadline. This simulates a scenario where the current time is already past the campaign's deadline. Learn more about vm.warp here.

Next, the vm.expectRevert(Crowdfunding.Crowdfunding__DeadlineMustBeInTheFuture.selector); line expects a revert when the next function is called. Specifically, it expects the revert reason to match the custom error Crowdfunding__DeadlineMustBeInTheFuture.

Finally, vm.prank(owner); simulates a transaction sent from the owner's address, followed by the call to crowdfunding.createCampaigns(owner, TITLE, DESCRIPTION, TARGET, deadline);. This line attempts to create a campaign with an expired deadline. Since the deadline is in the past, the contract should revert, confirming that our validation logic is working as intended.

Note: To check if every test runs successfully, run the following command in your terminal:

forge test

Since we have only written one test so far, a successful run will look like this:

The next test, testCreateCampaign, will simulate the behavior of the createCampaign function. Since creating a campaign and retrieving the campaignId will be necessary for several upcoming tests, let's streamline the process by creating a modifier that we can reuse throughout the test suite.

Add this modifier to your test contract:

modifier createCampaign() {
   vm.prank(owner);
   campaignId = crowdFunding.createCampaign(owner, TITLE, DESCRIPTION, TARGET, deadline);
   _;
 }

Above, we created a modifier named createCampaign that helps us automate the creation of a campaign by calling the createCampaign function with the predefined values owner, TITLE, DESCRIPTION, TARGET, and deadline. It uses vm.prank(owner) to simulate transactions as the owner account. The campaignId generated from this creation is then stored and can be reused in subsequent tests. Lastly, the _; in the modifier allows the test function to execute after the campaign is created.

Now that the modifier is in place, let's proceed with the actual testCreateCampaign function, which ensures that campaigns are created as expected. Add the following code:

function testCreateCampaign() public createCampaign {
    string memory campaignTitle = crowdFunding.getCampaign(campaignId).title;
    string memory campaignDescription = crowdFunding.getCampaign(campaignId).description;
    uint256 campaignTarget = crowdFunding.getCampaign(campaignId).target;
    uint256 campaignDeadline = crowdFunding.getCampaign(campaignId).deadline;
    uint256 campaignAmountCollected = crowdFunding.getCampaign(campaignId).amountCollected;

    assertEq(owner, owner);
    assertEq(campaignTitle, TITLE);
    assertEq(campaignDescription, DESCRIPTION);
    assertEq(campaignTarget, TARGET);
    assertEq(campaignDeadline, deadline);
    assertEq(campaignAmountCollected, 0);
}

As you'll notice, the function above uses the createCampaign modifier to create a campaign, ensuring that we don't manually repeat the process in every test.

It then retrieves the created campaign's details title, description, target, deadline, and amount collected using the getCampaign function defined in the Crowdfunding contract. Each of these values is stored in memory to be compared with the expected values (predefined in the test).

Finally, the assertEq statements verify that the campaign’s actual values match the expected inputs. The assertions ensure the owner is correct, confirm the title, description, target, and deadline match the provided values during creation, and lastly, verify that the initial amount collected is 0, as no donations have been made yet.

The next test we'll implement is the testDonationRevertsWhenZeroEthIsDonated; which ensures that zero eth isn't donated to a campaign. Here's the code you need to add to your test contract:

 function testDonationRevertsWhenZeroEthIsDonated() public createCampaign {
  vm.expectRevert(Crowdfunding.Crowdfunding__CantSendZeroEth.selector);
  // Donate to the campaign
  vm.prank(donor1);
  crowdFunding.donateToCampaign{value: 0}(campaignId);
}

You should already be acquainted with the Foundry cheatcodes used in this test from the first one. The main distinction here is that we're invoking the donateToCampaign function while sending zero ETH.

Now, let's proceed to the next test, testDonationRevertsWhenDeadlinePasses, which ensures that donations are rejected once the campaign deadline has expired.

Paste the following code in your contract to implement this:

function testDonationRevertsWhenDeadlinePasses() public createCampaign {
     vm.warp(block.timestamp + deadline + 1);
     vm.expectRevert();
     // Donate to the campaign
     vm.prank(donor1);
     crowdFunding.donateToCampaign{value: 2 ether}(campaignId);
}

In this case, donor1 is unable to send the 2 ether to the campaign owner because the campaign deadline has already passed.

Next up is the testDonationRevertsWhenTargetIsMet test, which checks that a donation is rejected once the campaign's funding target has been reached, as its name suggests.

Add the following code to implement this function:

function testDonationRevertsWhenTargetIsMet() public createCampaign {
   vm.prank(donor1);
   crowdFunding.donateToCampaign{value: 5 ether}(campaignId); 
   vm.expectRevert(Crowdfunding.Crowdfunding__TargetMetForCampaign.selector);
   vm.prank(donor2);
   crowdFunding.donateToCampaign{value: 1 ether}(campaignId);
}

In this test, we simulate two donors contributing to the same campaign. The first donor meets the campaign's funding target by sending the required amount of ETH. The second donor's attempt to donate should therefore trigger a revert since the target has already been reached.

That concludes the tests for the revert scenarios. Next, we'll move on to testing another core functionality of the contract with the testDonateToCampaign test. This test verifies that donations to a campaign are handled correctly. Below is the code that implements this:

function testDonateToCampaign() public createCampaign {
    // Donate to the campaign
    vm.prank(donor1);
    crowdFunding.donateToCampaign{value: 2 ether}(campaignId);

    // Validate campaign donation data
    uint256 campaignAmountCollected = crowdFunding.getCampaign(campaignId).amountCollected;
    uint256[] memory donations = crowdFunding.getCampaign(campaignId).donations;
    address[] memory donators = crowdFunding.getCampaign(campaignId).donators;

    assert(campaignAmountCollected == 2 ether);
    assertEq(donators.length, 1);
    assertEq(donations[0], 2 ether);
}

In this test, donor1 donates 2 ether to the campaign. We then validate that the campaign correctly tracks the amount collected, the donations made, and the donor's address. The assert statements ensure that 2 ether is properly reflected in the campaign's data, and that donor1 is listed as the sole contributor with the correct donation amount.

Next, we’ll test the contract's ability to return excess funds to the donor if they send more ether than is needed to meet the campaign’s target. The code below demonstrates how this is implemented:

function testReverseExcessAmountToSender() public createCampaign {
    vm.prank(donor1);
    crowdFunding.donateToCampaign{value: 2 ether}(campaignId);
    vm.prank(donor2);
    crowdFunding.donateToCampaign{value: 4 ether}(campaignId);
    assertEq(donor2.balance, 2 ether);
}

In this test, donor1 donates 2 ether to the campaign, and donor2 attempts to donate 4 ether. However, since the campaign only needs 2 more ether to meet its target, the contract should accept the necessary amount and return the extra 2 ether to donor2. The final assertEq statement verifies that donor2's balance reflects the excess ether refund. This ensures that the contract correctly handles over-contributions.

So far, we’ve tested the key functionalities of our contract. Now, to check how much of our code is covered by these tests, you can run the following command:

forge coverage

The output should resemble something like this:

As you can see, we've already covered a significant portion. However, if you'd like to dive deeper and challenge yourself, you can write additional tests, particularly for the getter functions in the contract.

The final step is deploying the smart contract, which will be discussed in the next section.

Deploying Your Contract Locally and on the Sepolia Testnet

With Foundry, you can deploy your contract either locally using anvil or directly on a testnet. In this section, I'll guide you through both deployment methods. We will manage both scenarios using a Makefile, so ensure that make is installed on your system.

Deploying on a Local Chain

For both local and testnet deployments, you'll need separate private keys and RPC URLs. In this subsection, I'll walk you through deploying the contract locally on a simulated blockchain.

To begin, open your terminal and run the anvil command. This will generate a list of private keys and a localhost URL (typically https://localhost:8545), which will serve as your RPC URL for the local deployment.

Once you have your private key and RPC URL, create a Makefile in the root folder of your project. At this stage, your project folder structure should look something like this:

Now, paste the following into your Makefile:

-include .env

DEFAULT_ANVIL_KEY := your-anvil-private-key

# Default deployment uses anvil
NETWORK_ARGS := --rpc-url http://localhost:8545 --private-key $(DEFAULT_ANVIL_KEY) --broadcast

deploy:
    @forge script script/DeployCrowdfunding.s.sol:DeployCrowdfunding $(NETWORK_ARGS)

Make sure to replace your-anvil-private-key with one of the private keys generated by anvil.

To deploy the contract, run the following command in your terminal:

make deploy

If the deployment is successful, the output will look something like this:

Deploying to the Sepolia Testnet

Note: To deploy on a testnet, you'll need a virtual wallet like Metamask.

For deployment to the Sepolia testnet, you'll need to generate your private key and RPC URL. You can follow the steps in this guide to set everything up.

After following the guide, you should have:

Created an account on Alchemy,
Set up an app and obtained an API key,
Added Sepolia testnet ETH to your wallet using a faucet,
Integrated your virtual wallet (such as Metamask) with your Alchemy project.

In addition, if you don't already have an account on Etherscan, create one and retrieve your API key from the "API keys" page. This will allow for contract verification post-deployment. Once these steps are completed, you're ready to proceed.

Now, in your project's root directory, create a .env file and add the following key-value pairs:

SEPOLIA_RPC_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
ETHERSCAN_API_KEY = "your-etherscan-api-key"
PRIVATE_KEY = "your-metamask-private-key"

Storing these values in the .env file helps keep sensitive data secure and prevents exposing it during deployment. Also, make sure the .env file is added to your .gitignore to avoid accidentally pushing confidential details to a public repository like GitHub.

Next, you'll need to update your Makefile to allow deployment to a testnet, such as Sepolia. This will enable switching between local and testnet environments seamlessly.

Update your Makefile as follows:

-include .env

DEFAULT_ANVIL_KEY := your-anvil-private-key

# Default deployment on anvil
NETWORK_ARGS := --rpc-url http://localhost:8545 --private-key $(DEFAULT_ANVIL_KEY) --broadcast

# Condition to deploy on Sepolia
ifeq ($(findstring --network sepolia,$(ARGS)),--network sepolia)
    NETWORK_ARGS := --rpc-url $(SEPOLIA_RPC_URL) --private-key $(PRIVATE_KEY) --broadcast --verify --etherscan-api-key $(ETHERSCAN_API_KEY) -vvvv
endif

deploy:
    @forge script script/DeployCrowdfunding.s.sol:DeployCrowdfunding $(NETWORK_ARGS)

To deploy your contract on the Sepolia testnet, use the following command:

make deploy ARGS="--network sepolia"

This setup allows for easy switching between deploying locally using anvil or deploying to a testnet like Sepolia.

If you have sufficient ETH, the contract should deploy successfully. You’ll then be able to view the deployment details on your Alchemy dashboard. Additionally, once you paste the contract address into Etherscan, you should see that it has been successfully verified.

Conclusion

We've reached the end of this article, where I’ve walked you through the entire process of building, testing, and deploying a crowdfunding smart contract using Solidity, Foundry, and Makefiles. From deploying locally on anvil to pushing the contract to a testnet like Sepolia, you've learned how to set up a complete development and testing environment to ensure your contract operates securely and efficiently.

You can access the source code for this project here. If you have any suggestions or improvements, feel free to submit a PR or reach out via email at olasunkanmiibalogun@gmail.com. You can also connect with me on LinkedIn.

This article is part of my ongoing journey to landing my first role in the blockchain space. I’ll continue documenting what I build and learn along the way, so stay tuned for more content. Let’s keep building! 👊

Navigating Content Management With OneEntry

Olasunkanmi Balogun — Mon, 29 Jan 2024 13:56:29 +0000

A headless CMS provides you with the flexibility to reuse your content on an unlimited number of channels. With an API, you can easily interact with your content wherever you want, regardless of the tech stack of your body (the front-end).

However, as much as there are many headless providers, navigating the complexities of these tools often requires technical expertise that not all users possess. Also, many existing systems rely on third-party plugins, leaving developers vulnerable to sudden dysfunction or lack of support.

Fortunately, with OneEntry, you don’t have to worry about these shortcomings. In this article, we’ll dive into OneEntry, exploring its benefits and features, including how it helps tackle these shortcomings to redefine content management without the need for technical intricacies.

What Is OneEntry, and Why Should You Use It?

OneEntry is a unique solution for the most convenient content development, creation, and management. It enables you to easily port content to any platform: websites, mobile apps, commercial electronic devices (info panels, advertising boards, eMenu, etc.)

One main benefit of OneEntry is that, unlike systems heavily reliant on third-party plugins, OneEntry integrates all its business logic related to content management within a simple control panel.

So, how does it work? In the next section, we will explore some of its core features.

How it works

OneEntry offers its features in the following ways:

One important feature to note about OneEntry is that, unlike systems heavily reliant on third-party plugins, OneEntry integrates all its business logic related to content management within a simple control panel.
Its robust security feature for APIs, particularly protecting APIs through the use of mTLS certificates, ensures a high level of safety and reliability. Additionally, OneEntry offers an alternative layer of protection with the option for token security. You can easily manage advanced security measures, including API protection with mTLS certificates and token options, through the centralized and user-friendly OneEntry Personal Account.
OneEntry operates on an attribute-based system, allowing you to structure and organize content without the need for technical expertise. Creating attributes is straightforward, and the system seamlessly integrates relationship logic.

You can effortlessly manage these attributes through the user-friendly admin panel, as seen in the image below. As you can see in the image below, you can conduct actions such as editing, adding, or deleting attributes within ongoing projects, all without requiring advanced technical knowledge.
It also provides attribute validators in the admin panel, empowering you to validate data fields seamlessly. This feature enhances the system's flexibility, ensuring the accuracy and reliability of data within the attributes.
It offers an innovative approach to expanding page content through the use of "blocks". This allows you to dynamically enhance and customize your pages by adding various content blocks. Whether it's text, images, or other elements, the block-based system provides a flexible and intuitive way to create engaging and dynamic content, allowing you to tailor your pages according to your specific needs and preferences.
OneEntry facilitates content storage in multiple languages, offering a versatile solution for diverse linguistic needs. You have the flexibility to add new languages seamlessly, ensuring that your content is accessible to a global audience. This enhances the system's adaptability and inclusivity, making it easy to create multilingual, diverse content within the OneEntry platform:
Form operations in OneEntry streamline the process of capturing and managing data. You can effortlessly create, customize, and deploy forms, tailoring them to your specific requirements. This feature simplifies data collection and provides tools for efficient form handling, including submission tracking, data validation, and the ability to customize form behavior.
OneEntry's menu module stands out for its flexibility in configuring app menus. You can easily tailor the navigation structure to meet your specific app requirements, providing a seamless and user-friendly experience. This module empowers developers to create a customized and intuitive menu system, enhancing the overall usability and navigation of their applications within the OneEntry platform.
OneEntry provides a flexible system for setting administrators' rights, allowing users to tailor and customize permissions according to specific needs. This feature empowers administrators to allocate access levels and responsibilities with precision, ensuring a secure and well-organized management structure. Users can easily adapt the system to their unique requirements, making OneEntry a versatile solution for efficiently managing administrative rights within projects.
Lastly, OneEntry's technical support stands out for its multilingual capabilities. Developers can seamlessly communicate in their native language when submitting requests, and the support team responds in the same language. This makes it easy for efficient and effective collaboration.

Overall, the OneEntry team is constantly working on adding new modules and functionalities to the system. as seen in the dashboard below:

Key Takeaways

Throughout this article, we talked about how OneEntry transcends traditional content management expectations by offering a user-friendly experience that caters to both technical and non-technical users. However, it doesn’t end here. If you want to learn more about OneEntry and Headless CMS as a whole, there are plenty of tutorials on OneEntry's YouTube channel for working with the system.

📊 How To Display An In-App Survey In Next.js 13 With Supabase And Formbricks 🤝🛠️

Olasunkanmi Balogun — Sat, 21 Oct 2023 12:01:53 +0000

Once a user has successfully completed the signup process for your application, you might consider initiating an onboarding segmentation survey for your users right away. This approach enables you to gain a deeper understanding of your users.

TL;DR

In this article, you'll discover the process of implementing authentication and protected routes using Supabase. Following that, you'll explore how to effortlessly integrate an onboarding segmentation survey into your application.

When you are ready, let's dive in.

Overview

In this article, you will learn how to:

Implement authentication and protected routes with Supabase
Implement an in-app onboarding segmentation survey with Formbricks.

1. How to implement authentication in Next.js 13 with Supabase

If you are unfamiliar with Supabase, it is an open-source alternative to Firebase. Among its array of products, one of the key features we will delve into is its authentication feature.

We'll start by signing in to the dashboard to create a project. Your dashboard looks this if you have not created a project before:

Next, go ahead and create your project by clicking the new project button. Name your project however you want; I'll name mine Auth-with-inapp-survey for the purpose of this article.

Hit the create new project button when you are done, your new project will then appear on your dashboard, this way:

With your project successfully created, the next step is to set up your Next.js project. Supabase simplifies this process by offering a pre-configured Next.js project with Supabase-auth, TypeScript, and Tailwind CSS. To create this project, run the following command in your terminal:

npx create-next-app -e with-supabase auth-with-inapp-survey

This command will set up your Next.js project, integrating it with Supabase-auth and the necessary configurations. Although Tailwind CSS is included, for the purposes of this article, we don't need to use it.

The advantage of creating a Next.js project that comes pre-configured with Supabase is that it streamlines the authentication setup for you. This includes setting up functionalities like sign-up, sign-in, log-out, and even a login page, as illustrated in the image below:

Pretty cool right :face_with_cowboy_hat:

All you need to do is duplicate the .env.local.example file within your project using the following command:

cp .env.local.example .env.local

Then, recover your supabase URL and Anon key from your project's API settings.

NEXT_PUBLIC_SUPABASE_URL=<your-supabase-url>
NEXT_PUBLIC_SUPABASE_ANON_KEY=<your-supabase-anon-key>

Launch your application, and it will start on your localhost at port 3000. Your home page will display the following content, and it also includes a link to the pre-configured login page.

Although for this tutorial I would prefer to set my login page as the home page - the index page. If you also share this preference, follow these steps:

Clear the content on the index page and paste the content from the login page into it.
Move the messages.tsx file from your login folder to the components folder. Once this is done, you can safely delete the login folder.
However, there are a few more adjustments required in your auth files to adapt to the new route since the login route now serves as the index page.

In the sign-up/route.ts, make the following modification:

// Rest of your code
    export async function POST(request: Request) {
  // Rest of your code
  if (error) {
    return NextResponse.redirect(
      `${requestUrl.origin}?error=Could not authenticate user`,
      {
        // A 301 status is required to redirect from a POST to a GET route
        status: 301,
      }
    );
  }

  return NextResponse.redirect(
    `${requestUrl.origin}?message=Check email to continue the sign-in process`,
    {
      // A 301 status is required to redirect from a POST to a GET route
      status: 301,
    }
  );
 }

In the sign-out/route.ts:

// Rest of the code
export async function POST(request: Request) {
  // Rest of the code
  return NextResponse.redirect(`${requestUrl.origin}`, {
    // A 301 status is required to redirect from a POST to a GET route
    status: 301,
  });
}

In the sign-in/route.ts:

// Rest of the code
export async function POST(request: Request) {
  // Rest of the code
  if (error) {
    return NextResponse.redirect(
      `${requestUrl.origin}?error=Could not authenticate user`,
      {
        // A 301 status is required to redirect from a POST to a GET route
        status: 301,
      }
    );
  }
  return NextResponse.redirect(`${requestUrl.origin}/dashboard`, {
    // A 301 status is required to redirect from a POST to a GET route
    status: 301,
  });
}

Note that in the sign-in route, we redirected to the dashboard page in the return statement, although we won't implement a dashboard page for this tutorial. This just ensures that the user is directed to the dashboard page after the sign-in process is completed.

Finally, in the callback/route.ts:

// Rest of the code
export async function GET(request: Request) {
  // Rest of the code
  // URL to redirect to after the sign-in process completes
  return NextResponse.redirect(`${requestUrl.origin}/onboarding`);

After a user attempts to sign-up on the app, the user will have to confirm his email. Upon successful email confirmation, the user will be automatically redirected to the URL specified in the return statement of the callback function which is the onboarding page.

These modifications will align your authentication routes with the new setup where the login page serves as the initial page.

Now that we've completed these steps, let's proceed with implementing our onboarding page.

To create the onboarding page, navigate to the root app directory, and follow the structure depicted below:

Before we move on to implement the in-app survey, it's essential to ensure that our onboarding page is protected before a user signs up. After all, what's authentication without protected routes, right?

Fortunately, Supabase provides a straightforward solution for handling this with server components.

Within your page.tsx file for the onboarding page, insert the following code:

import LogoutButton from "@/components/LogoutButton";
import { createServerComponentClient } from "@supabase/auth-helpers-nextjs";
import { cookies } from "next/headers";
import { redirect } from "next/navigation";

export default async function Onboarding() {
  const supabase = createServerComponentClient({ cookies });
  const {
    data: { session },
  } = await supabase.auth.getSession();

  if (!session) {
    redirect("/");
  }

  return (
    <div>
      <LogoutButton />
      <p>Hello</p>
    </div>
  );
}

In this code, we create a new Supabase client using createServerComponentClient, which takes cookies as a parameter. This client is then assigned to the variable supabase.

Note: We use cookies to store user sessions as opposed to localStorage in server components because you can't access localStorage in server components. Kudos to Supabase for this solution! 👍

The subsequent code block:

const { data: { session },} = await supabase.auth.getSession();

is used to check if a user session exists. If a session exists, the user can access the onboarding page without any issues. However, if the session is absent, the if statement will be triggered, redirecting the user back to the login page.

I've also imported the logoutButton component into this page in case you want to explore how the sign-in/sign-out process works.

Now, let's focus on implementing our onboarding segmentation survey in the onboarding page. This way, users will encounter it right after signing up. The following section will provide a step-by-step guide on how to do this.

How to implement an in-app onboarding segmentation survey with Formbricks.

Thanks to Formbricks, we do not have to build this from scratch 👏

Formbricks: The only open-source solution for in-app surveys

Formbricks is an open-source survey software that helps businesses create and send different kinds of in-app surveys. Formbricks is easy to use and integrates with any web, mobile, or desktop application. Support us by giving us a star, it helps us build our community.

P.S: Formbricks is offering swag for Hacktoberfest, and you also have the opportunity to win a Macbook Air! Come and participate!

Moving forward, here's a concise preview of the steps we're about to cover:

Start by registering an account on the Formbricks platform.
Customize your onboarding survey according to your preferences.
Seamlessly integrate Formbricks into your application.
Incorporate your in-app onboarding survey.

1. Customize your onboarding survey

Upon creating your account on Formbricks, you'll be directed to your dashboard, where you'll find a variety of survey templates. For this tutorial, select the onboarding segmentation survey template as that's what we'll be using.

Next, you'll be taken to a page where you can edit and tailor this survey to meet your specific requirements. Here, you'll encounter three pre-customized question cards, and you have the option to add more questions if necessary.

It's important to note that any modifications made to each question card are instantly reflected in the preview.

Once you've completed your question editing, navigate to the "Settings" tab located adjacent to the "Questions" tab. In this section, you can configure the survey to align with your specific needs.

For the "How to Ask" card, ensure that the web app option is selected.

Another crucial configuration is the survey trigger. Here, you'll define how and when you want your survey to be triggered. To align with the flow of our project and display the survey whenever a user reaches the onboarding page we've implemented, we will choose to trigger the survey only when a user navigates to the onboarding page.

To set up this process, begin by selecting the dropdown and choosing the "Add action" option. This action will trigger a modal to appear:

Complete the fields in the modal as illustrated below. Feel free to customize these details according to your preferences:

Please note that in this step, we need to select the "Page URL" option, which allows us to specify the URL where the survey should be displayed. As shown, I've filled the URL field with https:localhost:3000/onboarding.

Once you've provided the necessary information, click the "Track Action" button and then select the option from the dropdown:

Another card to note is the "styling" card. This card enables you to style your survey to align with your UI requirements.

Upon completing the setup, click the "Publish" button located at the top right corner of the page. This action will redirect you to a page displaying your survey analytics.

Next, we will delve into how to establish a connection between your web app and Formbricks.

Connecting Your Web App and Formbricks

In the settings page, navigate to the "setup checklist" tab found in the sidebar. This page contains all the necessary steps for connecting your web app to Formbricks.

You'll also notice a widget status that informs you whether your app has been successfully connected or not. At this point, since it hasn't been connected, it will be displayed like this:

To establish the connection, follow these steps:

Install the Formbrick widget in your web application using the following command:

   npm install @formbricks/js --save

Create a client component, formbricks.tsx, in the root app folder, and insert the following code into it:

   "use client";
   import formbricks from "@formbricks/js";
   import { usePathname, useSearchParams } from "next/navigation";
   import { useEffect } from "react";

   export default function FormbricksProvider() {
     const pathname = usePathname();
     const searchParams = useSearchParams();

     useEffect(() => {
       formbricks.init({
         environmentId: "<environment-id>",
         apiHost: "https://app.formbricks.com",
         debug: true, // remove when in production
       });
     }, []);

     useEffect(() => {
       formbricks?.registerRouteChange();
     }, [pathname, searchParams]);

     return null;
   }

The value of your environmentId can be obtained from your setup checklist page. I've intentionally omitted it here as it's meant to remain private.

Finally, in your app/layout.tsx file, import the formbricks.tsx file and render it as shown below:

   import FormbricksProvider from './formbricks'

   export default function RootLayout({
     children,
   }: {
     children: React.ReactNode
   }) {
     return (
       <html lang="en">
         <FormbricksProvider /> {/* Render here */}
         <body>
           {/* Rest of the code here */}
         </body>
       </html>
     )
   }

Upon restarting your web app, the status indicator will be updated to the following:

Additionally, you'll see in your console that your app has successfully been connected to Formbricks.

You can now test this by attempting to sign up for your app. When you click the sign-up button, you will receive a notification that a mail has been sent to your email address for verification.

Upon verification, you will be redirected to the 'onboarding' page as intended. There, your onboarding segmentation survey will appear just as we've implemented:

And there you have it, you've learned how straightforward it is to segment your users using Formbricks.

Final Notes

Throughout this article, you've gained insights into:

Implementing authentication and protected routes with Supabase.
Integrating an onboarding segmentation survey into your web app with Formbricks.

You can access the code for this project here.

Additionally, don't forget to support us by giving us a star ⭐!

📊🔍Measure Your Product-Market Fit With Formbricks' In-App Product-Market Fit Survey 📏📈

Olasunkanmi Balogun — Fri, 13 Oct 2023 17:55:51 +0000

By gauging your startup's product-market fit (PMF), you can determine whether your venture has successfully created a product that resonates with users' preferences and needs.

TL;DR

In this tutorial, you'll learn how to integrate an in-app PMF survey in your Next.js application with Formbricks. It has been built to suit your needs with best practices just like Superhuman.

Formbricks: The Only Open-Source Solution For In-App PMF Surveys

Formbricks is an open-source survey software that helps businesses create and send in-app PMF surveys. Formbricks is easy to use and integrates with any web, mobile, or desktop application. Support us by giving us a star. 😉

Now, before we delve into integrating our PMF survey into our application, let's first create a template for how our survey should appear in our app. We will create this template within the Formbricks cloud platform.

Here's a brief about the steps we'll cover moving forward:

Register an account on the Formbricks platform.
Customize your PMF survey to suit your preferences.
Seamlessly integrate Formbricks into your application.
Implement your in-app PMF survey.

1. Create an account on the Formbricks platform - It's free

Formbricks offers you the choice to either self-host or take the simpler path by registering an account on the Formbricks Cloud platform. For this tutorial will opt for the cloud platform.

Once you have completed the signup and the onboarding procedures, you will be navigated to your dashboard.

Your dashboard should look like this:

If everything has proceeded smoothly up to this stage, let's continue to create and customize our PMF survey 🚀

2. How to create and customize your PMF survey

Within the "For you" feed, you may not come across the PMF survey card among the available templates. In such cases, simply click the "Product Experience" filter button, where you'll discover the PMF survey featuring two distinct templates: one resembling the superhuman template and the other being rather short.

Choose the one that aligns best with your requirements. However, for the sake of this article, I'll opt for the superhuman template.

However, on selecting the one with the superhuman template, you'll be navigated to a page that contains six different question cards (you can choose to add more if you like), and a Thank you card which will be displayed at the end of the survey.

You can also choose to edit each of the questions if you like by clicking on whichever question card you want to edit. It's worth noting that you changes is reflected in the preview real-time.

As an example, in the second question card, you can choose the next question to be displayed based on which answer was submitted with the logic jumps.

In the above image, I have modified my logic to skip to the fourth question card if the "Not at all disappointed" option was selected in the survey instead of normally navigating to the third question.

Once you've completed modifying your questions, navigate to the Settings tab, located right next to the Questions tab. In this section, you can configure your survey according to your preferences.

For the "How to Ask" segment, select the web app choice, since our intention is to integrate it into a web application:

You may get a note in orange that hints you haven't connected with our app yet. It looks like this:

I didn't encounter this notification because I had previously connected Formbricks to an application. However, no need to worry! I'll guide you through overcoming this issue in a subsequent section.

Now, moving on to the Survey Trigger section, this is where you'll configure how you'd like your survey to be triggered in your app.

You can select however you want to trigger your survey in your app when you click the select field.

Perhaps you want to trigger the survey when a user visits a particular URL, this option isn't available in the dropdown. Instead click the "Add Action" option, this will pop-up a modal.

In the above dropdown, I have filled up the required fields to achieve our aim to trigger the survey when a user visits a particular URL.

Regarding the URL for displaying the survey within our app, I've configured the condition to trigger when the browser's URL contains https://localhost:3000/dashboard. This is based on the fact that I'll be using my development server, which initiates on localhost:3000.

However, feel free to select any URL of your preference. Just keep in mind that using an invalid URL will result in an error message stating "your survey will not be shown."

When you are done, click the Track Action button, the action should now be available in the dropdown. Click the dropdown again to select it.

Once you hit the publish button at the top right corner, you will be navigated to your PMF survey dashboard. Here, you'll be notified that you have not connected Formbricks to your app.

Hit the connect button, this will direct you to the Setup checklist page.

3. Setup Checklist: Integrate Formbricks Widget Into Your Application

Since we haven't connected our application to Formbricks Cloud, the widget status indicator will display on your screen like this:

To connect our app with the cloud, we'll have to dive into our code editor 🚀

To streamline this section, I'll assume that your Next.js application is already up and running, allowing us to get straight to the specifics.

To start, install the Formbricks package into our app with the following command:

npm install @formbricks/js --save

Next, navigate to the _app.js file and paste the following code in it:

import formbricks from "@formbricks/js";
import { useEffect } from "react";
import { useRouter } from "next/router";

if (typeof window !== "undefined") {
  formbricks.init({
    environmentId: "<your environment id>" ,
    apiHost: "https://app.formbricks.com", 
    debug: true,
  });
}

export default function App({ Component, pageProps }) {
  const router = useRouter();

  useEffect(() => {
    // Connect next.js router to Formbricks
    const handleRouteChange = formbricks?.registerRouteChange;
    router.events.on("routeChangeComplete", handleRouteChange);

    return () => {
      router.events.off("routeChangeComplete", handleRouteChange);
    };
  }, []);

  return <Component {...pageProps} />
}

The environmentId property has been intentionally omitted in the if statement. In actual practice, this value is private and unique to each user. You can retrieve your environmentId from Step 2 of the setup checklist page. Copy and paste the value into the appropriate variable as seen in the image below:

Having done this, the widget status indicator should have been updated to this:

Also, you should see that your PMF survey has been fetched in your browser's console:

If everything works well to this point, let's go ahead to trigger the PMF survey in our app.

4. Trigger Your In-app PMF Survey

I'll navigate to the dashboard page from my app's index page. Hence, I'll implement a link to the dashboard page in my index page as seen below:

import Head from "next/head";
import Link from "next/link";

export default function Home() {
  return (
    <>
      <Head>
        <title>Formbricks PMF Survey</title>
        <meta name="description" content="Generated by create next app" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <main>
        {/* link to dashboard */}
        <Link href="/dashboard">Nav To Dashboard</Link> 
      </main>
    </>
  );
}

When I click on the link, the page navigates to the dashboard and triggers the survey according to how we implemented the trigger on the Formbricks platform:

And there you have it, you have successfully implemented your in-app PMF survey.

If you desire a more personalized survey, maybe to harmonize with the colors in your UI, we offer a solution for this in the "Look and Feel" section of the settings page. Feel free to dive in and tailor the survey to your liking 🎨

Conclusion

So far, you learned how to:

connect Formbricks Cloud to your app
create a PMF with the best template possible (superhuman)
utilize Formbricks to seamlessly integrate an in-app PMF survey
Customize your survey to your taste

With this solution, you are just on the right track to measure your PMF in no time. 🚀 👊

To help us keep this articles coming, don't forget to give us a star on Github. 😉

Thank you for reading!

🔥 How To Get Juicy User Insights With In-App Pre-Churn Survey In Next.js With Formbricks 💡💬

Olasunkanmi Balogun — Fri, 22 Sep 2023 12:03:34 +0000

Churn surveys are a valuable tool for businesses, especially app-based businesses, to understand why customers are leaving their service. By asking customers why they are churning, businesses can identify areas where they can improve their product or service to prevent future churn. An example of such surveys can be seen below:

Imagine being able to anticipate user departures before they happen, giving you a chance to address concerns, tailor your offerings, and ultimately, boost user loyalty. This is where the power of pre-churn surveys comes into play, revolutionizing the way businesses interact with their users.

TL;DR

In this article, you will learn how to get juicy user insights with in-app pre-churn surveys in your Next.js application using Formbricks.

Formbricks: The Only Open-Source Solution For Pre-Churn Surveys

Formbricks is an open-source survey software that can help businesses create and send in-app pre-churn surveys. Formbricks is easy to use and integrates with any web, mobile, or desktop application. Support us by giving us a star. 😉

How To Craft A Churn Survey With Formbricks

In this section, I will guide you systematically through the process of crafting a churn survey for your application. Here's an overview of the steps we'll cover:

Create a complimentary Formbricks cloud account.
Construct your churn survey utilizing the Formbricks platform.
Seamlessly integrate Formbricks into your application.
Put theory into practice by implementing your in-app survey.

1. Create an account on Formbricks - It's Free

When utilizing Formbricks, you have the flexibility to either opt for self-hosting if you prefer, or take the more straightforward path by registering on our platform.

Upon completing the signup process and swiftly navigating through the onboarding procedures, you will find yourself on your dashboard, which will be presented in a layout similar to this:

Following this, it's time to construct your churn survey 🛠️

2. Craft your churn survey

Navigate to your dashboard and select the churn survey template:

You'll be navigated to a page that looks like this:

This is your canvas for refining survey questions. Keep in mind that your edits on the left side reflect in real-time in the preview.

Once you've refined the questions to your liking, proceed to the Settings tab adjacent to the Questions tab. This is where you can fine-tune your survey's configuration.

For the "How to Ask" segment, opt for the web app choice, given your intention to integrate it into your web application:

There's a note in orange that hints we haven't connected with our app yet. No sweat! We'll get back to it, let's get our other survey configuration right first!

Another essential aspect within the Settings tab is the Survey Trigger section. As its name implies, this settings is for what will trigger the survey in your app.

When you click on the select field, a dropdown will appear, presenting you with a range of options. In case none of these options align with your preferences, you can introduce a personalized trigger by selecting the "Add action" choice. This will prompt a modal to appear:

From the available options, feel free to make your selection. However, for the context of this article, I'll demonstrate using the inner text option.

Once you've chosen your preference within this modal, proceed to save your choice by clicking the "Track Action" button. Subsequently, revisit the dropdown and select the newly added option.

Now, proceed to click the "Publish" button located in the upper right corner.

This action will direct you to the Summary page, where you'll gain access to your survey analytics. Additionally, you'll receive a prompt to install the Formbricks widget, enabling you to establish a connection between your survey and your application.

Click on it to navigate to the setup checklist page.

3. Setup Checklist: Installing The Formbricks Widget

On the setup checklist page, you'll come across a widget status indicator. This indicator informs us whether our application has been linked to Formbricks Cloud or not. Since we haven't yet established the connection at this juncture, you will observe the following display on your screen:

This is the point where we'll have to get our hands dirty and dive into our app code editor. 😃 🚀

I assume you already have your Next.js application up and running, so we're set to hit the ground running!

Note: I'll be using the Next.js pages dir moving forward.

We'll start by installing Formbricks accross our app with the following command:

npm install @formbricks/js --save

Afterwards, navigate to the _app.js component and modify the code as seen below:

import formbricks from "@formbricks/js";
import { useEffect } from "react";
import { useRouter } from "next/router";

if (typeof window !== "undefined") {
  formbricks.init({
    environmentId: "<your environment id>" ,
    apiHost: "https://app.formbricks.com", 
    debug: true,
  });
}

export default function App({ Component, pageProps }) {
  const router = useRouter();

  useEffect(() => {
    // Connect next.js router to Formbricks
    const handleRouteChange = formbricks?.registerRouteChange;
    router.events.on("routeChangeComplete", handleRouteChange);

    return () => {
      router.events.off("routeChangeComplete", handleRouteChange);
    };
  }, []);

  return <Component {...pageProps} />
}

Pay attention to the if statement before the component definition. It makes sure that the widget is only initialized if this component is rendered in a browser.

For this tutorial's sake, the environmentId property has been intentionally omitted. In actual practice, this value is private and unique to each user. You can retrieve your environmentId from Step 2 of the setup checklist page. Copy and paste the value into the appropriate variable as depicted below:

Following this, the widget status indicator in the Setup checklist page should have been updated to this after reloading your app 🎉:

Your web browser's console should also display the following logs, confirming the establishment of the connection:

Now that we've verified the connection between your app and Formbricks Cloud, we can proceed to implement the survey trigger.

4. How to trigger the Formbricks pre-churn survey

As a quick reminder, we configured a trigger based on the button's inner text, "Cancel Subscription."

With that in mind, feel free to incorporate the button with the designated inner text wherever you see fit. I'll demonstrate the implementation in my index.js file:

import Head from "next/head";

export default function Home() {
  return (
    <>
      <Head>
        <title>Formbricks Churn Survey</title>
        <meta name="description" content="Generated by create next app" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <main>
        {/* survey trigger */}
        <button>Cancel Subscription</button>
      </main>
    </>
  );
}

On my home page, the survey can now be triggered after clicking the button:

Congratulations! You have effectively integrated your churn survey into your app! 🎉

Furthermore, you have the flexibility to customize the placement and appearance of the survey in your application. To achieve this, navigate to the settings page within your Formbricks account and select the "Look & Feel" option from the sidebar.

As an illustration, if you prefer your survey to appear at the center of your web application, scroll down to the "In-app survey placement" section and opt for the "Centered Modal" choice. After adjusting it to your liking, the modal should now appear like this:

If the placement doesn't reflect immediately, try restarting your app. 😉

Finally, you can effortlessly access your survey analytics and view responses on the Formbricks platform. Simply click on the survey you've crafted to explore these valuable insights.

Conclusion

So far, you've learnt how to:

connect Formbricks Cloud to your app
Easily create an in-app Churn Survey with Formbricks
How to view your survey analytics on Formbricks

From now on, the world of in-app pre-churn survey is yours. Go ahead and prevent that churn 💪 😁

To help us keep this articles coming, kindly give us a star on Github. 😉

Thank you for reading!

💻 A Technical Interview Project: Building a Lending-as-a-Service Application 🏦

Olasunkanmi Balogun — Thu, 29 Jun 2023 17:40:56 +0000

I recently completed a technical interview with a lending-as-a-service company. The interview required me to build four pages with TypeScript, React, and SCSS for styling.

Although, unfortunately I didn't obtain the position, but since it's a large project (which I personally think is gross for the first stage of a technical interview) I'm committed to sharing what I learned. In this article, I'll walk you through the features I implemented and how I implemented them. I hope this article will be helpful to other frontend developers who are preparing for technical interviews.

PS: I'm still open for a frontend developer role. If you're hiring for a frontend role, please reach out to me. I'd love to learn more about the opportunity.

Note that, this article will focus on the features implemented, with little to no discussion of the styling.

TL;DR

The following is a brief overview of the pages and features implemented in the project:

Login page: I used Firebase for authentication and implemented protected routes with React Router, even though it wasn't required.
List of users page: This page pulls data from a mock API with 500 records using Axios and Axios Interceptors.
User details page: This page was required to use local storage or indexedDB to store and retrieve user details. I chose to use localStorage.

The end product of the pages implemented should look like this:

This article shall be a complete overhaul from the ground up, with no stone unturned. I will start with the login page, and discuss how the user is navigated to the dashboard. From there, I will also explore the features implemented in the users page, and finally, we shall reach the user details page, where the user journey ends.

When you are ready, let's dive in.

How I Set My Project Up

I Set Up My React + TypeScript Project With Vite

To kickstart my project swiftly, I opted for Vite as my project initializer, and I highly recommend you do the same if you haven't been using Vite. Initializing a TypeScript + React project with Vite is effortless with just one command:

npm create vite@latest interview-project -- --template react-ts

How I Set Up Firebase For Authentication

I decided to utilize Firebase for authentication for this app although it wasn't a requirement.

The fact that I also wanted to implement a protected route functionality for all authenticated pages also played a role in my decision. This feature will be discussed in a later section.

In this section, I will briefly guide you through the process of how I set it up.

Generally, to use Firebase, you need to create and register your project on the platform, which I did.

Following this, I installed Firebase in my project and created a components folder. Inside this folder, I created a file named firebaseConfig.ts to store my configuration details and establish a connection between my app and Firebase like this:

import { initializeApp } from "firebase/app";
import { getAuth } from "firebase/auth";

const firebaseConfig = {
  //firebase config
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);// connect firebase
export const auth = getAuth(app)

If you are new to Firebase and are interested in learning more about it, check out the official documentation here.

File Structure

I established a pages directory to contain the various pages of the application.

Within the previously created components directory, I created subdirectories with names corresponding to the folders within the pages directory. This organizational structure allows for convenient grouping of relevant components within each page-specific folder.

Furthermore, I added a styles folder in the src directory to centralize all the styles for my pages. Additionally, an utils folder was created within the src directory to store files responsible for handling API requests.

I had adopted this file structure during my time at my previous job.

In the end, the folder structure looked like this:

- project
  - src
    - components    
      - dashboard
      - common
      - user-details
      - users     
      - login
      - firebaseConfig.ts
    - pages
      - Login.tsx
      - Users.tsx
      - User-details.tsx
    - styles
    - utils
      - request-adapter.ts
      - requests.ts
    - main.tsx
  - public
  - package.json

I'll now walk you through each page and files if necessary in the next section.

Page Routing In The `main.tsx` File

The powerful React Router was employed for seamless page routing, not like there are numerous alternatives available lol. If you are new to React Router or uncertain about its benefits, I recommend checking out its documentation here for further insights.

Once React Router is installed, I implemented the routes in the main.tsx file as seen in the code snippet below.

I had not used React Router in a while due to the fact that I have been writing a lot of Nextjs these days. As a result, I was taken aback by the new syntax when revisiting it. If you're in a similar situation where you haven't kept up with the updates, note that an updated version, 6.4, has been released with fresh syntax and features. I recommend referring to the documentation to stay updated and informed.

import React from 'react'
import ReactDOM from 'react-dom/client'
import './App.scss';
import {
  createBrowserRouter,
  RouterProvider,
} from "react-router-dom";
import Login from './pages/Login-Auth.tsx';
import Users from './pages/Users.tsx';
import UserDetails from './pages/User-details.tsx';

const router = createBrowserRouter([

  {
    path: "/",
    element: <Login/>
  },

  {
    path: "/dashboard/users",
    element: <Users/>
  },

  {
    path: "/dashboard/users/:id",
    element: <UserDetails/>
  },
]);

ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
  <React.StrictMode>
    <RouterProvider router={router}/>
  </React.StrictMode>,
)

How I Implemented Features

Starting Off With Authentication In The Log In Page 🚀

For the sign-in method, Firebase enables you to use different sign-in providers, ranging from email and password provider to Google provider and so on... For the authentication of this app, I employed the email and password provider since the email and password input fields were provided and required.

Here's how I implemented the feature:

import { createUserWithEmailAndPassword, signInWithEmailAndPassword } from "firebase/auth";
import {  useNavigate } from 'react-router-dom'
import { auth } from '../components/login-auth/firebaseConfig';

export default function Login() {

  const navigate = useNavigate()
  const [ email, setEmail ] = useState<string>('');
  const [ password, setPassword ] = useState<string>('')
  const [ signUp, setSignUp ] = useState<boolean>(true)
  const [ helperText, setHelperText ] = useState<string>('')
  const [ hide, setHide ] = useState<boolean>(false)

  const handleSignUp = (e: React.FormEvent<HTMLButtonElement> ) => {
    e.preventDefault()
    createUserWithEmailAndPassword(auth, email, password)
     .then(() => {
      setHelperText('Congrats!, you can now Sign In')
      setTimeout(() => setHelperText(''), 2000)
      setSignUp(!signUp)
      setError(false)
     }) 
   .catch((error) => {
    const errorCode = error.code;
    const errorMessage = error.message;
    setError(true)
    console.log(errorCode, errorMessage)
   });
 }

  const handleSignIn = (e: React.FormEvent<HTMLButtonElement>) => {
    e.preventDefault()
    signInWithEmailAndPassword(auth, email, password)
    .then(() => {
      setError(false)
      navigate('/dashboard/users')
      sessionStorage.setItem('auth', JSON.stringify(auth))
     })
   .catch((error) => {
   const errorCode = error.code;
   (errorCode === 'auth/user-not-found!') ?
    setHelperText('Email is not registered!') :
    setHelperText('Invalid password')
    setError(true)
    setTimeout(() => setHelperText(''), 2000)
  });
}
}

return (
       <form>
            <div>
            <h1>Welcome!</h1>
            <p>Enter details to {signUp ? "login" : 'sign up'}.</p>   
            <div>
            <p className={`${error ? 'error' : 'success'}`}>{helperText}</p>
              <div>
              <Input type='email' placeholder={'Email'} value={email} onChange={setEmail}/>
              </div>
              <div>
              <Input type={hide ? "password" : 'text'} placeholder={'Password'} value={password} onChange={setPassword}/>
              <span onClick={() => setHide(!hide)}>{hide ? "Show": "Hide"}</span>
              </div>
            </div>
              <p>Forgot Password?</p>
              <p>Don't have an account? <span onClick={() => setSignUp(!signUp)}>Sign Up</span></p>
               <button type='submit' onClick={!signUp ? handleSignUp : handleSignIn}>           
                 signUp ? ' Log In' : ' Sign Up'
               </button>
            </div>
          </form>
)

I implemented two functions in the code block above: handleSignIn and handleSignUp.

As their names imply, the handleSignin function handles the sign in process, while the latter handles that of the sign up. If the requirements of each function are met, the code in their .then block runs, if not, the error is caught in the .catch block.

Note that once the code in the .then block in the handleSignIn function runs, an auth object is saved in the sessionStorage of the browser. This will be used when implementing the protected routes feature. More details on this in the authenticated pages section.

I introduced the signUp state to regulate which of the functions executes in the proper scenario. When a user hits the sign up text in the form beneath the Forgot Password text, the signUp state is updated. The highlighted code below demonstrates how this is done:

 <p>Don't have an account? <span onClick={() => setSignUp(!signUp)}>Sign Up</span></p>

As I mentioned in earlier, this state is used to toggle the functions that get invoked when the button in the form element is clicked. That is, if a user is new and just wants to sign up, the handleSignUp function is triggered, otherwise, if it is an already existing user who wants to log in, the log in function is triggered.

This also controls the text that renders in the button.

You can see how this is implemented in the highlighted code below:

   <button type='submit' onClick={!signUp ? handleSignUp : handleSignIn}>           
                 signUp ? ' Log In' : ' Sign Up'
  </button>

The purpose of the signUp state wasn't limited to just the function and text of the button as it also updates the text below the Welcome header:

<p>Enter details to {signUp ? "login" : 'sign up'}.</p>

See video below for an illustration of this scenario.

On To The Authenticated Pages 🚶

Before I started off with the authenticated pages - the user and the user-details page; I thought the implementation of the protected routes feature seemed to make sense after the authentication procedure was finished.

As mentioned earlier, upon successful sign-in, an auth object is stored in the user's browser sessionStorage temporarily. I chose sessionStorage for this purpose because it retains data only for the duration of the session, deleting it when the browser is closed.

With the auth variable now appropriately stored in sessionStorage, I proceeded to implement the protected route feature. To accomplish this, I created a Page.tsx file within the common folder of the dashboard, as indicated in the file structure section, and implemented the feature as follows:

import Navbar from "./Navbar";
import Sidebar from "./Sidebar";
import { useState } from 'react';
import { Navigate } from "react-router-dom";

type PageProps = {
   children: React.ReactNode,
}

export default function Page ({children }: PageProps) {

    const authFromSessionStorage = sessionStorage.getItem('auth')

    return (
        <>
        {  
        (!authFromSessionStorage) ? 
        <Navigate to='/' replace={true}/> :
        (
        <>
        <Navbar/>
        <Sidebar/>
        <div>
            {children}
        </div>
        </>
    )} // navigate to log in page if user isn't authenticated
        </>
    )
}

Since the Page component will wrap around all authenticated pages, which share the navbar and sidebar components, I decided to include those components within it. This explains their inclusion in the code block. Here's an example of how I wrapped this component around an authenticated page component:

// users.tsx

export default function Users() {

    return (
     <Page>
      <div>
      // rest of the page content here
      </div>
     </Page>
    )
}

Following this implementation, when an unauthenticated user attempts to access an authenticated page, they will be redirected to the sign-in page to authenticate themselves.

Navigating To The Users' Page 👥

This page requires candidates to pull data from a mock API and populate it in form of a table as seen in the image above.

After pulling the data, candidates are to also implement a feature to paginate the data gotten from the API just below the table:

Since the number of users gotten from this API is 100, I decided to paginate the data in multiples of 20, 50, and 100. At the end the feature looks like this:

Moving on, in the request-adapter.ts file created in the utils folder ( see folder structure section ), I created an instance of Axios with Axios.create and assigned it to a variable request. This instance also includes a base URL and timeout configuration. I also added a response interceptor to handle successful responses and errors, finally the instance is exported for use in other parts of the application:

import axios from "axios";

const request = axios.create({
    baseURL: "https://6270020422c706a0ae70b72c.mockapi.io/lendsqr/api/v1/",
    timeout: 30000,
  });

  request.interceptors.response.use(
    (response) => {
      return response;
    },
    ({ response }) => {
      return Promise.reject(response);
    }
  );

  export default request;

Following this, the request variable is imported from the request-adapter module.

Then, a getUsers function which it uses the request instance to make a GET request to the /users endpoint is defined.

import request from "./request-adapter"

export const getUsers = () => request.get('/users')

By calling the getUsers, the Axios instance will send a GET request to the complete URL formed by combining the base URL from the instance's configuration and the /users endpoint.

The getUsers function is exported, making it available for other modules to import and use. This function can now be called in the users' page where it will initiate a GET request to retrieve the users' data from the specified endpoint.

Next, I implemented the markup for the table that displays the users. I created a Table.tsx file in the users folder situated in the components folder for this purpose.

Here's how the markup looks like:


type TableProps<T extends object> = {
    users: T
} // users is a generic of type object just as in he Users component

export default function Table<T extends object>({ users }: TableProps<T[]>) {
    return (

        <section>
        <table>
         <thead>
         <tr>
           <th>
             <div>
            <p>Organization</p> 
             </div>
           </th>
           <th>
           <div>
            <p>Username</p> 

            </div>    
           </th>
           <th>
           <div>
            <p>Email</p> 
           </div>
           </th>
           <th>
             <div>
            <p>Phone Number</p> 

             </div>
           </th>
           <th>
             <div>
            <p>Date Joined</p> 
             </div>
           </th>
           <th>
             <div>
             <p>Status</p>    
             </div>
           </th>
         </tr>
         </thead>
         <tbody>
         // list of users will be here
         </tbody>
        </table>
        </section>
}

Notice the custom type TableProp defined. This type is a generic type whose parameter extends an object and assigned to the users property, this ensures that the users property accepts any type of object. After the users endpoint is called, the body of the table will be implemented and populated.

After implementing the Table component, I created another component in the users folder for the pagination feature just below the table and named it PaginatedItems.tsx. The pagination feature was not just implemented in this component though, I also made the call to the users endpoint and rendered the Table component inside this component. I will explain why.

This was done mostly because I used react-paginate library to implement the pagination feature. This library needs to have access with the data you want to paginate directly - the users data gotten from the API, in order to interact with it.

I'll now walk you through the pagination and Table implementation step-by-step.

Firstly, I defined the component and fetched the data from the API:

import { useState, useEffect, useCallback } from "react";
import { getUsers } from "../../../utils/requests";
import { AxiosResponse } from "axios"

export default function PaginatedItems<T extends object>() {

  const [ users, setUsers ] = useState<T[]>([]);
  const fetchData = useCallback(() => {
     getUsers()
    .then(({data} : AxiosResponse<T[]>) => { 
      setUsers(data)  
    })
    .catch(err => console.log(err))
  }, []);

    useEffect(() => {
        fetchData()
      }, [])
  return (
     // code markup here
  )
}

I then went on to develop the pagination feature after implementing and obtaining the component. The npm website's instruction of how to use the react-paginate module was sufficient for its integration. The following code snippet was included in the component:

import { useState, useEffect, useCallback } from "react";
import { getUsers } from "../../../utils/requests";
import { AxiosResponse } from "axios"

type DropdownProps = {  
    setItemsPerPage: React.Dispatch<React.SetStateAction<number>>
}

export function DropdownFilter({setItemsPerPage } : DropdownProps) {

    return (
        <div>
          <p onClick={() => setItemsPerPage(20)}>20</p>   
          <p onClick={() => setItemsPerPage(50)}>50</p>   
          <p onClick={() => setItemsPerPage(100)}>100</p>   
        </div>
    )
}
export default function PaginatedItems<T extends object>() {

  const [ currentItems, setCurrentItems ] = useState<T[]>([]);
  const [ itemsPerPage, setItemsPerPage ] = useState<number>(50);
  const [ pageCount, setPageCount ] = useState<number>(0);
  const [ itemOffset, setItemOffset ] = useState<number>(0);

      useEffect(() => {
      if(users){
          const endOffset = itemOffset + itemsPerPage;
          setCurrentItems(users.slice(itemOffset, endOffset));
          setPageCount(Math.ceil(users.length / itemsPerPage));
      }
    }, [users, itemOffset, itemsPerPage]);

    // Invoke when user clicks to request another page.
    const handlePageClick = (event: { selected : number}) => { //since we just need the selected property
     if(currentItems) {
         const newOffset = event.selected * itemsPerPage % users.length;
         setItemOffset(newOffset);
     }
    };
return (
      <>
      {
      (currentItems.length > 0) && (
        <>
          <Table users={currentItems} />

          <div>

            <div>
            <p>Showing</p>
            <div 
            onClick={() => setShowDropdown(!showDropdown)}
            >
             <p>{itemsPerPage}</p> 
             <img src={dropdown} alt='dropdown icon'/>
             <DropdownFilter 
             setItemsPerPage={setItemsPerPage}
             className={showDropdown ? 'active' : ''}/>
            </div>
            <p>out of {users.length}</p>
            </div>

           <ReactPaginate
            nextLabel={<Button src={right}/>}
            onPageChange={handlePageClick}
            pageRangeDisplayed={3}
            marginPagesDisplayed={2}
            pageCount={pageCount}
            previousLabel={<Button src={left}/>}
            pageClassName="page-item"
            pageLinkClassName="page-link"
            previousClassName="page-item"
            previousLinkClassName="page-link"
            nextClassName="page-item"
            nextLinkClassName="page-link"
            breakLabel="..."
            breakClassName="page-item"
            breakLinkClassName="page-link"
            containerClassName="pagination"
            activeClassName="active"
            renderOnZeroPageCount={null}
            />
          </div>
        </>
      )}
      </>
    )}

The code provided shows the implementation of a paginated table component. The PaginatedItems component manages the state for displaying a specific number of items per page and calculating the necessary pagination parameters.

The DropdownFilter component renders a dropdown menu with options for setting the number of items per page. When an option is clicked, the setItemsPerPage function is called to update the itemsPerPage state in the PaginatedItems component.

Inside the PaginatedItems component, the useEffect hook is used to update the currentItems state and calculate the pageCount whenever the users, itemOffset, or itemsPerPage dependencies change. The currentItems state is updated by slicing the users array based on the current itemOffset and itemsPerPage values.

The handlePageClick function is invoked when the user clicks on a page in the pagination component (ReactPaginate). It calculates the new itemOffset based on the selected page and updates the state accordingly.

The PaginatedItems component also renders the Table component with the currentItems as the users prop, showing the table with the paginated data.

Additionally, there are UI elements for displaying the current page's range and the total number of users. The ReactPaginate component handles the pagination rendering and interaction based on the provided parameters.

After passing the data to the Table component, I populated the body of the table with the data.

import { useState } from "react";

type TableProps<T extends object> = {
  users: T;
}; // users is a generic of type object just as in he Users component

type User = {
  [key: string]: any;
}; //use index signature for type checking individual objects in the users array.

export default function Table<T extends object>({ users }: TableProps<T[]>) {
  const [activeId, setActiveId] = useState<string>("");

  return (
    <section>
      <table>
        <thead>
          <tr>
            <th>
              <div>
                <p>Organization</p>
              </div>
            </th>
            <th>
              <div>
                <p>Username</p>
              </div>
            </th>
            <th>
              <div>
                <p>Email</p>
              </div>
            </th>
            <th>
              <div>
                <p>Phone Number</p>
              </div>
            </th>
            <th>
              <div>
                <p>Date Joined</p>
              </div>
            </th>
            <th>
              <div>
                <p>Status</p>
              </div>
            </th>
          </tr>
        </thead>
        <tbody>
          {users.map((user: User) => {
            const { id, orgName, userName, email, phoneNumber, createdAt } =
              user;
            const date = new Date(createdAt);
            const formattedDate = date.toLocaleString("en-NG", {
              month: "short",
              day: "numeric",
              year: "numeric",
              hour: "numeric",
              minute: "numeric",
              hour12: true,
            });

            return (
              <tr key={id} className="tr-body">
                <td>{orgName}</td>
                <td>{userName}</td>
                <td>{email}</td>
                <td>{phoneNumber}</td>
                <td>{formattedDate}</td>
                <td>Inactive</td>
              </tr>
            );
          })}
        </tbody>
      </table>
    </section>
  );
}

Next, the table needs a dropdown for each user, it will be triggered on clicking the ellipsis on the extreme right of the table. The dropdown should look like:

Clicking the view details text should navigate to the user details page. I created a Dropdown.tsx file in the users folder of the component folder where I implemented the functionality like this:

import { Link } from "react-router-dom";

type DropdownProps = {
  id: string;
  toggleDropdown: {
    activeId: string;
    setActiveId: React.Dispatch<React.SetStateAction<string>>;
  };
};

export default function Dropdown({ id, toggleDropdown }: DropdownProps) {
  const { activeId, setActiveId } = toggleDropdown;

  return (
    <ul
      onMouseEnter={() => setActiveId(id)}
      onMouseLeave={() => setActiveId("")}
      className={`${id === activeId ? "show" : ""} dropdown`}
    >
      <Link
        style={{
          textDecoration: "none",
        }}
        to={`/dashboard/users/${id}`}
      >
        <li>
          <img src={viewDetails} alt="view icon" />
          <p>View Details</p>
        </li>
      </Link>
      <li>
        <img src={blacklist} alt="view icon" />
        <p>Blacklist User</p>
      </li>
      <li>
        <img src={activate} alt="view icon" />
        <p>Activate User</p>
      </li>
    </ul>
  );
}

Inside the component, an unordered list (<ul>) is rendered. The className of the <ul> element is conditionally set based on whether the id matches the activeId. If they match, the show class ( which makes the dropdown visible ) is added to the element, otherwise it remains empty.

The <ul> element has two event handlers: onMouseEnter and onMouseLeave. When the mouse enters the element, the setActiveId function is called with the id as the argument, setting it as the activeId. When the mouse leaves the element, the setActiveId function is called with an empty string, clearing the activeId.

Inside the <ul> element, there are three list items (<li>) representing the dropdown options. The first list item contains a Link component that wraps the content. The Link component is used to create a clickable link that navigates to a specific URL. The to prop of the Link component is set to /dashboard/users/${id}, which dynamically generates the URL based on the id prop. This means that clicking on this option will navigate to the user details page for the corresponding id.

This component is then imported to the table component and included it in the last element of the table like this:

<td>
  <div>
    <p className="status">Inactive</p>
    <img
      src={ellipsis}
      alt="ellipsis icon"
      onMouseEnter={() => setActiveId(id)}
    />
    <Dropdown id={id} toggleDropdown={{ activeId, setActiveId }} />
  </div>
</td>;

The end product of the dropdown looks like this:

Finally, I rendered the PaginatedItems component in the users component created in the page folder. Ofcourse, wrapped around the page component initially discussed.

import PaginatedItems from "../components/dashboard/users/PaginatedItems"

export default function Users() {

    return (
     <Page>
      <PaginatedItems/>
     </Page>
    )
}

If you have been with me up to this point, congratulations on surviving this wild ride through the User page. Grab yourself a virtual cookie and take a well-deserved break! But hold on tight because in the next section, we'll be diving into the thrilling world of each user details, where we'll uncover secrets, unravel mysteries, and navigate through the intricacies of individual user profiles.

Journey's End: The User Details Page

Fortunately, unlike the users page, the user page only requires implementing the data fetching and UI populating functions. However, there is an interesting twist. Once a user's information has been accessed, it needs to be saved in either the indexedDB or localStorage. The purpose of this storage is to avoid unnecessary network queries. If the user details data is already present in the localStorage, we can simply retrieve it from there instead of making additional network requests.

To get started, I defined the route to the endpoint that calls a user's details in the requests.ts file, located in the utils folder, similar to how I did it for the users endpoint:

export const getUserById = (id: string) => request.get(`/users/${id}`);

This endpoint requires including the id of each user in its query. Fortunately, with React Router, we can extract this id from the URL once we have navigated to the user details page. Stay tuned for more exciting details!

Moving on, I created a file in the pages folder and named it User-details.tsx where I imported the previously defined endpoint for it to be called with the id. This id will be gotten from the URL with useParams provided by react-router and passed to the API route as seen below:

import Page from "../components/dashboard/common/Page";
import { useParams } from "react-router-dom";
import { getUserById } from "../utils/requests";
import { useEffect, useState } from 'react';

export default function UserDetails():JSX.Element {

 const [ user, setUser ] = useState<{[key: string]: any}>();

 const { id } = useParams(); //get id from URL

  return (
  //markup here
  )
}

Following this, I implemented the functionality to fetch and save to localStorage in the fetchUserDetails function included in the code snippet below:

import Page from "../components/dashboard/common/Page";
import { useParams } from "react-router-dom";
import { getUserById } from "../utils/requests";
import { useEffect, useState } from "react";

export default function UserDetails(): JSX.Element {
  const [user, setUser] = useState<{ [key: string]: any }>();
  const { id } = useParams();

  const fetchUserDetails = (): void => {
    const usersFromLocalStorage = localStorage.getItem("users");
    if (usersFromLocalStorage) {
      const users: { [key: string]: any }[] = JSON.parse(usersFromLocalStorage);
      const user = users.find((u: { [key: string]: any }) => u.id === id);
      if (user) {
        setUser(user);
      } else {
        getUserById(id!)
          .then(({ data }: AxiosResponse<{ [key: string]: any }>) => {
            users.push(data);
            localStorage.setItem("users", JSON.stringify(users));
            setUser(data);
          })
          .catch((err) => console.log(err));
      }
    } else {
      getUserById(id!)
        .then(({ data }: AxiosResponse<{ [key: string]: any }>) => {
          const users = [data];
          localStorage.setItem("users", JSON.stringify(users));
          setUser(data);
        })
        .catch((err) => console.log(err));
    }
  };

  useEffect(() => {
    fetchUserDetails();
  }, [id]);

  return (
  <Page>
  // UI population code here
  </Page>
  )
}

In the UserDetails component, the fetchUserDetails function is responsible for fetching and setting the user details. It first checks if the users property exists in the localStorage. If it does, it searches for a user with a matching id and sets the user state accordingly.

If no matching user is found, a fresh API call is made using getUserById and the retrieved data is added to the users array in the localStorage. The user state is then set with the fetched data.

In the case where the users property does not exist in the localStorage, a fresh API call is made to retrieve the user details. The retrieved data is stored in the users array in the localStorage, and the user state is set with the fetched data.

After the fetchUserDetails function is executed, the UI is populated with the relevant user details.

And thus, our adventurous quest through the intricate realm of user details comes to a triumphant end.

Conclusion

Well, despite my best efforts, one might think they would at least get a chance to proceed to the next stage, right? 😀 However, to my surprise, I received a rejection without the interviewer even signing into the app. Imagine finding out this tidbit from my Firebase Console! Life has a way of throwing unexpected twists in our coding journeys.

But fear not, my dear readers, for our shared adventure has not been in vain. I extend my deepest appreciation for your unwavering support and for joining me through the lines of code, the challenges, and the triumphs. 👊 Together, we have explored the intricacies of building an admin dashboard, overcoming obstacles along the way.

If you're curious to see the fruits of our labor, you can find the live site here, ready to be explored. For those interested in diving into the code, it awaits you on GitHub here.

Now, as I embark on new opportunities, I want to let you know that I'm still open to exploring frontend developer roles. If you or anyone you know is seeking a dedicated and passionate developer, please reach out to me via email at olasunkanmiibalogun@gmail.com. I'm eager to learn more about exciting opportunities that lie ahead.

Thank you once again for being part of this coding journey. Until we meet again in the realm of knowledge and exploration, may your code be bug-free and your programming endeavors be filled with joy and success. Happy coding!

How To Use TypeScript Interfaces For Better Code Organization And Readability

Olasunkanmi Balogun — Sat, 18 Feb 2023 15:10:44 +0000

TypeScript is an add-on for JavaScript. That is, it includes more features and improvements such as syntax for types. TypeScript runs with a compile-time type checker hence you can avoid or debug errors faster when you add types to your code. According to its official website, it is a strongly typed programming language that builds on JavaScript, giving you better tooling at any scale.

In TypeScript, there are several ways to represent objects, one of those ways includes interfaces. An interface controls the property names an object can have, this means that when an object implements an interface, the object conforms to the rules specified by the interface.

Interfaces can help achieve code organization and readability which is crucial for maintaining, collaborating, reusing, and optimizing your codebase. In this article, we'll discuss:

Importance Of Interfaces
Syntax And Basic Use Cases Of Interfaces
- Syntax
- Basic Use Cases
Conclusion

Importance Of Interfaces

Interfaces provide a range of benefits, from improving code consistency and readability to facilitating reuse and catching errors early in the development process. In this section, we'll discuss a few importance of using interfaces in your TypeScript code.

Enforce consistency: Interfaces let you define a common set of properties and methods that objects must implement, ensuring that the structure and behavior of objects of a given type are the same.
Facilitate documentation: Interfaces serve as a place to document the expected properties and methods of an object.
Improve Readability: By providing the expected structure of an object, including its properties, methods, and types, interfaces make code easier to read especially when working with complex codebases or collaborating with other developers.
Catch errors early: Enforcing strict type-checking at compile time, interfaces help catch errors before they make it to production. This can save time, effort, and cost.
Code Reusability: Since interfaces allow you to define custom types that can be used in place of built-in types like number and string, it can ensure that code is more reusable thereby reducing duplication and also make the code modular - this means you can export and import it.

Syntax And Basic Use Cases Of Interfaces

In this section, we'll get started with interfaces in TypeScript. It's important to understand their syntax and basic use cases - defining and implementing interfaces, and how to use them to enforce type safety in your code.

NOTE: To follow along with the code snippets provided, you can use the official TypeScript playground.

Syntax

Interfaces are defined using the interface keyword followed by its name, then the body of the interface in curly braces. Here's an example of an interface.

interface User {
firstName: string;
lastName: string;
}

We defined an interface and named it User, it has properties firstName and lastName, both of which are of type string.

We can now use the User interface as a natural data type.

interface User {
firstName: string;
lastName: string;
}

//define object that conforms to the specification of interface User

const user: User = {
  firstName: 'John',
  lastName: 'Doe'
}

Objects using the User interface as their type must have the same properties(the keys in the object), as specified in the User interface. If a property is optional, it can be omitted. If one of the properties is missing or if its value isn't the same data type specified in the interface, then the compiler will throw an error. Hence we cannot add extra fields that are not defined in the interface to the object.

Let's try to add a new property that was not initially defined in the interface and see what happens:

interface User {
firstName: string;
lastName: string;
}

const user: User = {
  firstName: 'John',
  lastName: 'Doe',
  id:'123' //new property
}

The above code will cause the TypeScript compiler to throw an error 2322, since the id property was not initially declared in the interface:

Type '{ firstName: string; lastName: string; id: string; }' is not assignable to type 'User'.
Object literal may only specify known properties, and 'id' does not exist in type 'User'.(2322)

Basic Use Cases

Now that we already know how interfaces are defined, let's discuss a few use cases.

Use Case: Optional Properties

To make a property optional as discussed earlier, you append ? to its name as seen below:


interface User {
firstName: string;
lastName: string;
id?: string; //id can now be omitted and the compiler won't throw any errors
}

const user: User = {
  firstName: 'John',
  lastName: 'Doe',  
}

Use Case: Read-only Properties

In cases where we want to make a property read-only in an interface, we include the readonly keyword before the name of the property:

interface User {
firstName: string;
lastName: string;
id?: string;
readonly dbid: number; 
}

const user: User = {
    firstName: 'John',
    lastName: 'Doe',
    dbid: 22
}

After dbid's first assignment in the user object, it cannot be reassigned again. Using the readonly keyword with a property means the property cannot be modified after its first assignment. You can think of its behavior as the same as the const keyword in JavaScript. Hence, the code below will throw an error 2540:

interface User {
firstName: string;
lastName: string;
id?: string;
readonly dbid: number; 
}

const user: User = {
    firstName: 'John',
    lastName: 'Doe',
    dbid: 22
}

user.dbid = 4;

Error message:

Cannot assign to 'dbid' because it is a read-only property.(2540)

Use Case: Extending Other Types

When creating new interfaces, we can extend our interfaces so they include properties from other interfaces or types. This way you can extract interfaces that contain the same properties and use them as components for other interfaces.

From the User interface in previous examples, let's define a new interface Admin that also contains the firstName and lastName properties but also contains a new property role. We can simply extend the Admin interface from the User interface.

See code example below:


interface User {
firstName: string;
lastName: string;
id?: string;
readonly dbid: number; 
}

interface Admin extends User {
   role: 'admin' | 'user' | 'developer' 
}

const admin: Admin = {
    firstName: 'John',
    lastName: 'Doe',
    dbid: 22,
    role: 'admin'
}

The Admin interface now inherits the properties of the interface User and also includes its own property role. It's just as if we did:


interface Admin {
firstName: string;
lastName: string;
id?: string;
readonly dbid: number; 
role: 'admin' | 'user' | 'developer' 
}

Extending an interface is not just limited to other interfaces. They can extend from any object type like normal types, and also classes.

Use Case: Function Types

We can use interfaces to describe function types. That is, we can define the expected parameter type and expected return type of a function in an interface.

See code example below:

interface AddFunction {
  (a: number, b: number): number;
}

const add: AddFunc = (a, b) => {
  return a + b;
}

We defined an interface AddFunction that describes how the parameters and return value of any function that utilizes the interface should look like. You see that after we declared the interface, we didn't need to specify the parameter and return type in the add function anymore.

Note: The names of the parameters in our function do not need to match the ones defined in our function type.

Use Cases: Index Signatures

Index signatures are a way of defining the shape of an object with dynamic property names or when the properties of an object are not known yet.

In the code below, we'll see how we can define an index signature for an object whose properties we don't know yet:

interface Score {
  [key: string]: number;
}

const score: Score = {
  score1: 1,
  score2: 2,
  score3: 3
}

In the above example, we defined an interface Score that has an index signature. The key is a string, and the value is a number. This simply means that any object(like the score object above), that utilizes the interface must have its keys as type string and values as type number.

Conclusion

While we've discussed some common use cases of interfaces, you should not that there are many more use cases of interfaces in TypeScript. Whether you're working on a large codebase with multiple developers or you just want to improve the quality of your own code, interfaces can be a valuable tool to have in your knowledge base.

If you're interested in learning more about interfaces in TypeScript, you can explore the documentation and start experimenting with different use cases.

In conclusion, interfaces are a powerful feature of TypeScript that can provide a range of benefits, from improving code consistency and readability to facilitating reuse and catching errors earlier in the development process. By enforcing consistent types across a codebase, interfaces can help ensure that code is easier to read and understand, more modular and reusable, and less error-prone.

If you have any questions, feel free to ask them in the comment section.

How To Unit Test React Applications with Jest: A Beginner's Guide

Olasunkanmi Balogun — Thu, 09 Feb 2023 15:34:20 +0000

Testing plays a crucial part in ensuring the quality and reliability of your code. With the right knowledge of testing, its methods, and tools, you can ensure your code matches the requirements and is bug-free.

Testing is a critical aspect of software development, yet it is frequently overlooked and undervalued despite its vital role in ensuring the quality and reliability of applications. Testing is important because it helps identify bugs before a software product is released to its end users.

In this article, we'll cover what you need to know about unit testing, getting started with unit testing in your React applications using Jest, from setting up Jest in your project to writing tests.

What Is Unit Testing And Why Is It Important?
Performing Unit Tests With Jest In React
Mocking Functions With Jest
Snapshot Testing With Jest
Conclusion

What Is Unit Testing And Why Is It Important?

Unit testing is an aspect of the overall testing process in software development. It focuses on individual units of an application such as functions, objects, procedures, and so on. The primary purpose of unit tests is to ensure that each unit performs as expected.

From the definition above, we can deduce that unit testing in React is the testing of individual React components.

Why Is It Important?

Below are some important reasons why we need unit tests.

Unit tests help to set the standard for coding requirements; writing tests while implementing a feature, for example, gives us an idea of how the implementation should be written.
It prevents developers push bugs to production as it is always mostly detected in the development phase.
Unit testing simplifies the debugging process.
Cost-effective - It is cheaper to fix bugs way before a later stage, let's say after it has been pushed to production.

Performing Unit Tests With Jest In React

Jest is a JavaScript testing framework designed to ensure the correctness of any JavaScript codebase. It allows you to write tests with an approachable, familiar, and feature-rich API that gives you results quickly.

-Jest Core Team

Jest in itself is not a library but a framework, it even has a CLI tool that you can use with the command line. Its official website emphasizes its focus on simplicity and that's due to its zero config setup. You can start using it as soon as you install it.

Setup

Create a new React app

Open your terminal and create a new React app using the command below

npx create-react-app unit-testing-tutorial

Install Jest using your favorite package manager

When you use cra(create-react-app) to create a new React project, it has built-in support for Jest, hence we do not have to install it manually. Hence, the only thing you need to do is install react-test-renderer for rendering snapshots which will also be covered in this article. You can install it with the command below.

with npm

npm install --save-dev react-test-renderer

with yarn

yarn add --dev react-test-renderer

Otherwise, if you are not using cra, you have to install it manually with your favorite package manager with the command below.

with npm

npm install --save-dev jest react-test-renderer

with yarn

yarn add --dev jest react-test-renderer

Next, add the following code to your package.json file

{
  "scripts": {
    "test": "jest"

Testing A React Component

If you used cra to create your React app, a App.test.js file would have been created for you by default for testing the App.js component. To play around, you can run a sample test with the npm run test command on your terminal to see how testing works.

In the following steps, we'll get started with testing our own React component with Jest.

Step 1: Create a Component

Let's create a component and call it MyFirstTest, which simply renders hello with the name passed to its prop.

import React from "react";

function MyFirstTest({ name }) {
    return (
    <h1>Hello {name}!</h1>
    )
}

export default MyFirstTest;

Step 2: Create A Test File

Next, we'll create a test file in the same directory as the component and use the extension .test.js. The .test.js extension lets Jest know that this is a test file.

The test will check if our component is rendered with the correct name passed to it as a prop. The unit test for our component MyFirstTest can then be written as seen below:

import { render } from '@testing-library/react';
import MyFirstTest from './MyFirstTest';

test('renders the component with the correct name passed as prop', () => {

  const { getByText } = render(<MyFirstTest name="Peter"/>);
  const textElement = getByText(/Hello Peter!/i);
  expect(textElement).toBeInTheDocument();

});

We can describe the above test as:

We define a test case with the test function provided by Jest. The function takes a string that explains what the test is going to do as its first argument and the second argument is a callback function that implements the test logic.
Inside the callback function, the first thing we do is render the component we want to test with the render function. The render function returns an object that contains a lot of useful functions that can be used to interact with the rendered component.
From these functions, we utilize the getByText function. This function searches through the rendered component to find an element that contains the text "Hello Peter".

NOTE: The /i at the end of the string /Hello Peter!/i was used to indicate case insensitivity. Hence, "/i" matches the string "Hello Peter" regardless of the case. i.e HeLLo PETER will still match.

If the component is appropriately rendered, then the element exists in the virtual DOM. We use the expect function which gives us access to many matchers (like toBeInTheDocument()) to assert that the element is in the virtual DOM. If it asserts that it's present, the test will pass. Else, the test fails.
Run the test with npm run test command. Your test result should look like the image below.

Mocking Functions With Jest

When a function is mocked, it means a sample or epitome of that function is created as a replacement for that function for the purpose of testing. Its purpose is to verify its result or behavior in a predictable environment.

Jest provides several ways we can perform mocking including jest.fn(), which we can use to ensure predictable results. With jest.fn() we can create a sample(mock function) that can be used to replace the original function for testing purposes. The mock function can then be configured to return specific values or throw new errors. By mocking functions, we can confirm that components are using functions as expected. Let's look at an example of how to mock a function using jest.fn() in the following steps.

Create a file math.js and copy the following code.

//math.js
export const add = (a, b) => a + b;

Create another file add.js and import the add function from the math.js file and copy the code below. This way we don't have to worry about the implementation of how the addition is done in the math.js file.

import { add } from './math.js';

export const doAdd = (a, b) => add(a, b);

Create a test file add.test.js and import all exports from the add.js file as math. This is so they can be accessible in a math object.

import * as math from './add';

test('adds numbers passed as argument', () => {
const sum = math.doAdd(1, 2);
expect(sum).toBe(3);
});

In the code above, we assign the math.add function which adds the two parameters passed to it to the variable sum. We then use the expect method which gives us access to the toBe() matcher to assert that the result of the sum is 3.

Your test result should look like this after running the test file

Snapshot Testing With Jest

Snapshot testing is used when you want to catch unexpected changes in your UI. It is a technique used when the output of a test is being compared against a previously captured snapshot of the expected result to ensure consistency. The test passes if the output of the function matches the previously captured snapshot, if it doesn't, the test fails. In the following steps, we'll see how snapshot tests work by testing a button component.

Create a component and name it button.js and copy the following code

export default function Button() {
    return(
        <button>
            Click Me
        </button>
    )
}

Create a test file button.test.js and copy the following code.

import React from 'react';
import renderer from 'react-test-renderer';
import Button from './Button';

test('Button should match its snapshot', () => {
  const button = renderer.create(<Button />).toJSON();
  expect(button).toMatchSnapshot();
});

In the code above:

We import the renderer method from the react-test-renderer library that we installed earlier. We then use the renderer.create method to render the component.
After rendering, the toJSON() method is called to create a plain JavaScript object that represents the component and its children which is then saved to the variable button.
We then use the expect and toMatchSnapshot functions to compare the button with a saved snapshot.
On testing the file, a __snapshot__ folder is automatically created where snapshots are stored for comparison. You can think of it as where your history of snapshots is stored.

Your test result should look like this after you run your test:

If there are any changes later(after the first snapshot was taken), Jest will throw an error and ask if you want to update the snapshot.

As a codebase evolves, Snapshot tests are often used in conjunction with unit tests to ensure that the output of a function remains consistent over time.

Conclusion

In conclusion, we see that unit testing is a critical aspect of software development that helps to ensure the quality and reliability of our code. It is an efficient way to validate that individual units of code work as intended, reducing the chances of us pushing bugs to production. So far, we have learned about Jest, how we can mock a function with Jest, and how to test using snapshots. Jest has a lot of other features that were not mentioned here, be sure to get your hands dirty. With the right understanding and use of these tools, we can make our testing process more effective and save time.

Maximizing Performance: A deep dive into React re-renders and how to optimize your components

Olasunkanmi Balogun — Fri, 27 Jan 2023 14:57:04 +0000

React is a powerful tool for building complex user interfaces, but as the size of your application grows, so do the performance issues. One of the most common performance issues developers encounter is unnecessary re-renders caused by a component's state or props changing too many times. In this article, we will take a deep dive into React re-renders, and explore techniques for maximizing the performance of your components. From understanding when and why a component re-renders, to implementing best practices such as React.memo, this article will provide you with the knowledge you need to optimize the performance of your React applications, we'll explore the intricacies of React re-renders and reveal how to make your components perform at their best. Let's embark on this adventure together and uncover the secrets of creating high-performing React applications.

Importance Of Performance In React.
Understanding React Re-renders.
Common Antipatterns And Best Practices To Improve Performance.

Importance Of Performance In React

React is one of the most popular front-end libraries, and as it's widely used in building dynamic and interactive web applications, it's crucial to ensure that the performance of React applications is optimized to provide a smooth and responsive user experience. Performance is an important part of any application and poor performance can lead to slow page load times, laggy user interactions, slow development time, insecurity, and a poor overall user experience.

Understanding React Re-renders

When thinking about a React application's performance, there are two stages we should really be concerned about, they are:

The initial render stage which generally happens when the component appears on the screen.

The re-render stage which is the second or subsequent render that happens after the component is already on the screen. Re-renders happen when there's an update in a React's components state. An update can occur as a result of a user's interaction with the site or a component making asynchronous requests.

Re-renders can take a toll on an application's performance if there are too many unnecessary re-renders. Sparingly, unnecessary re-renders are not a problem since React engines are very fast and can deal with re-renders without being noticeable. However, an application more than adequately re-rendering could result in performance issues such as laggy user interactions as aforementioned, or even break the app completely. Let's take a look at some reasons that could cause re-renders in React. A component re-renders when:

When State Updates
When Parent Component re-renders
When Props Update

When State Updates

When the state of a component is updated, the component re-renders itself to reflect the update made to the state. Let's take a look at the code illustration below

See practical example on CodeSandbox.

In the above example, when the button is clicked, state is updated. Hence, causing the whole component to re-render.

When Parent Component Re-renders

Naturally, when the parent of a component re-renders i.e when its state is updated, it causes a not memoized child component to also re-render whether its props have changed or not.

See practical example on CodeSandbox..

We saw on the console that the child component also re-renders even when the prop, name, doesn't change.

When Props Update

Re-render due to props update only matters when memoization methods such as React.memo are used. That way, child component re-renders are restricted to only when its prop values update.

Common Antipatterns And Best Practices To Improve Performance

We will now explore the common antipatterns that developers make when working with React that can lead to unnecessary re-renders in a React application, we will also look at best practices for optimizing the performance of React components, and tips for identifying and preventing unnecessary re-renders. Let's dive in...

Preventing Re-renders With Compartmentalization

Compartmentalization is the practice of breaking down a complex component into smaller, more manageable components.

Apart from the fact that this helps to improve the code's maintainability and reusability and makes it easier to think about the component's behavior, this can also help us prevent unnecessary re-renders. Let's see how...

See how compartmentalization can help prevent unnecessary re-renders on CodeSandbox.

We see how by compartmentalization, the compartmentalized component prevents the re-rendering of the whole component, thereby preventing random component from re-rendering every time the button is clicked.

Nested Components

It is generally bad practice to nest components. Nesting components in another component can make your app really slow.

Assuming there is an update in the state of the parent component causing it to re-render, the nested component doesn't just re-render with the parent but also re-mounts i.e React destroys the component and then re-create it all over again from scratch. This is a process that is going to be slower than a normal re-render given the circumstances. Assuming the nested component makes a request to an API with useEffect without any dependency, then the function will be triggered every time the parent re-renders. This can cause bugs you don't want.

See a practical on CodeSandbox

In order to prevent this, child components should be written separately to avoid being left in a performance hole.

Passing Children As Props

Passing children as props is somewhat like the concept of compartmentalization afore explained. The difference is that the component that updates the state is extracted and is used to wrap the child component which is passed to it as children. That way, the parent component sees the children as props, therefore child components won't be re-rendered.

See practical example on CodeSandbox

Preventing Re-renders With `React.memo` And `useMemo`

As your React application grows in complexity, it is important to optimize components to prevent performance issues.React.memo helps us to ensure that a component re-renders only when necessary. React.memo is a higher-order component that allows us to wrap functional components and only re-render them when their props have changed.

See practical example on CodeSandbox..

However, note that interestingly, if the child component has a prop that is not a primitive type (i.e if they are not strings, numbers, or boolean) then memoizing your component with React.memo alone won't be enough to prevent your component from re-rendering even though its prop has not changed unfortunately. Check out Alex Sidorenko's article to read more as to why this is. Fortunately, there is a way we can work around this and that's where useMemo comes in handy. With useMemo hook you can memoize the non-primitive prop to prevent the component from re-rendering unless the prop updates.

See practical example on CodeSandbox.

Improving Performance Of Lists

One of the most important aspects of working with lists in React is using keys. Keys are unique identifiers that help React keep track of which items in a list have been added, removed, or moved.

The algorithm for the re-render phase of lists using keys in React involves generating "before" and "after" snapshots of the elements, identifying existing elements to be re-used, using the "key" attribute to match items with the same "before" and "after" key and defaulting to using sibling indexes as the key if none is provided, unmounting items that no longer exist, creating new items, and updating existing items.

Without keys or appropriate use of keys, React will have a hard time determining which elements have changed, resulting in unnecessary re-renders, unnecessary re-mounts, and poor performance. However, we should not just provide keys just for the sake of providing keys to the list, it doesn't guarantee the improvement of performance in lists.

We will now discuss what's considered best practice and what's considered an antipattern.

Index As Key

It is okay to use the index of the array as key, however, this depends on if the array is constantly being modified or not i.e they are static. Generally, It is considered best practice to provide strings that are consistent between re-renders as keys. Learn more about this here.

See practical example for static list on CodeSandbox

See practical example for dynamic list on CodeSandbox

Random values as key

Providing random values as key is a very big performance killer given how the algorithm to re-render lists in React works. Rather than the items just re-rendering on every state update, React re-mounts the items all over again. This can really slow down our app.

See practical example on CodeSandbox

Conclusion

In conclusion, maximizing performance in React is crucial for creating smooth and responsive user experiences. By understanding the re-render process and using techniques such as React.memo and useMemo, as well as implementing strategies like using keys appropriately to avoid unnecessary re-renders, you can ensure that your React applications run at optimal speed. Remember to also keep an eye out for common antipatterns and to constantly monitor and test your application's performance. With the knowledge and techniques discussed in this article, you can take your React development skills to the next level and create high-performing, efficient applications.

Closures in JavaScript

Olasunkanmi Balogun — Sun, 13 Feb 2022 12:47:13 +0000

In my last post, we talked about scope in JavaScript and how functions can be inside of functions. In this article, we will talk about closures and how it is related to scope.

I have come to realize that some of us JavaScript devs use closures without even realizing it, funny eh?.

How closures work in JavaScript can be quite difficult to grasp, but I will try my best to take it step by step in this article. But first, let's know what closures are.

What is a closure?

A closure allows access(of variables) from an inner function to a parent function. Consider the code below:

We see in the above code, how that function innerFunc has access to the variable a which was declared in the outer function func. We can therefore call function innerFunc a closure.

Note that outer functions cannot have access to variables in their inner functions.

In line 9 of the code above, we called the function func and assigned it to a variable inner which makes it a function we can later call in the next line. This was done like this because calling the function directly without assigning it to a variable will only just return the innerFunc function which is not reusable.

In line 10, we see how that function inner returns 7.

Now that we have seen a practical example of a closure. Let's get into how closures work in JavaScript.

How do closures work?

Well, for us to really understand how closures work in JavaScript, we have to first understand some of the basics of how JavaScript works(more on that in a future article). There are two important concept in JavaScript that we have to know.

The Execution Context
The Lexical Environment

1. The Execution Context

An execution context refers to an environment where JavaScript code is executed. Talk about functions, variables in functions etc. Two codes can be run in the execution context.

The global code: When a global code is executed, it is executed in global context.
The function code: When a function code is executed, it is executed in the function context.

A collection of active execution context forms an execution stack or a call stack.

For example, we'll assume an execution stack as an array before we continue.

EStack = [];

The stack is pushed every time we call a new function.

When you are running a global code, the stack array contains the global code which looks like this:

EStack = [ globalContext ];

When it encounters a function call, the function goes to the top of the stack, the stack then looks like this.

EStack = [
functionContext
globalContext
]

After the function code completes, it gets popped off from the stack. The stack then looks like this.

EStack = [
globalContext
]

The global context is usually at the bottom of the stack.

The Lexical Environment

As the execution context executes the global and function code, it creates a lexical environment where it stores all the variables defined in that function.

The environment record(inner environment) and the reference to the outer environment record are all contained in the lexical environment.

Let's see how the concept of a lexical environment looks like.

lexicalEnvironment = {
  environmentRecord: {
    <identifier> : <value>, //inner environment record
    <identifier> : <value>  //inner environment record 
  }
  outer: < Reference to the parent environment > //outer environment record

Now, let's understand the illustration above with a code snippet.

let a = 3;

function func() {
  let b = 4;  
}
func();

As the code above is run, a global execution context is created for the global code and a function execution context is created for the function code where a lexical environment that stores variables and functions is also created.

Let's tackle what's happening in the global execution context.

globalLexicalEnvironment = {
  environmentRecord: {
      a    : 3,
      func : < reference to function object >
  }
  outer: null
}

We see from the above illustration that the outer environment record is set to null. This is because a global code is the outermost scope of a program. Therefore it has no outer lexical environment.

Like for the global code above, an execution context is also created for the function code. Only that this is a function execution context. The function lexical environment will look like this:

functionLexicalEnvironment = {
  environmentRecord: {
      b    : 4,
  }
  outer: <globalLexicalEnvironment>
}

We see that the outer environment is set to the global lexical environment because the function is wrapped inside the global scope.

Remember, when we were explaining the environment context above we said that after a function code has been run, its function execution context gets popped off from stack. The case isn't the same for its lexical environment though, as it may or may not get popped off on condition of whether it is being referenced by an inner environment or not. Understanding this plays a big role in how closures work.

Below, we are going to see such condition where it doesn't get popped off.

Consider the code below:

function firstFunc() {
  let a = 3;

  return function secondFunc() {
    let b = 4;
    return a + b;
  };
}

In the code snippet above, the execution context of the function firstFunc will be popped off from the stack but its lexical environment won't because it's variable a is being referenced by it's inner function secondFunc. Thus, the lexical environment of the firstFunc and secondFunc will look like this respectively:

firstFuncLexicalEnvironment = {
  environmentRecord: {
    a:  3,
    SecondFunc : < reference to function object >
  }
  outer: <globalLexicalEnvironment>
}

secondFuncLexicalEnvironment = {
  environmentRecord: {
    b : 4,
  }
  outer: <firstFuncLexicalEnvironment>
}

We see in the secondFunc lexical environment that the outer environment it references is the firstFunc function. This is because secondFunc references a variable a which is not defined in its scope. Noticing that secondFunc references a variable that is not defined in it's scope, the JavaScript engine looks into the outer environment which is firstFunc in this case, and then finds the variable a. Then 7(a + b) is returned.

If the lexical environment of the firstFunc is also popped off as it's execution context, we will get an error that says a is not defined.

Conclusion

Now that we have come to the end of the article, let's review what we learnt so far.

We learnt about

Closures,
How closures work,
The Execution Context and the lexical Environment.

I hope that from this article, you have been able to get an understanding of how closures work in JavaScript.

If you have any questions, feel free to ask them in the comment section. Until next time, XOXO.

Understanding scope in JavaScript

Olasunkanmi Balogun — Mon, 31 Jan 2022 03:11:56 +0000

In this article, we are going to talk about an important concept of JavaScript called scope. You will learn about how scope in JavaScript works, and global variables and how they relate to scope.

Let's dive in!

What is scope in JavaScript?

Scope simply means variable access, that is "What variable do I have access to when my code runs?". By default in JavaScript,
we are in the root scope, alias the window object. Let's visualize what we are talking about here.

Assume we write and run a function in your browser console, call it func as shown below;

 function func() {
  console.log('func');
}

...and then call the window object, by just typing window on the console, you see that your function func has been added to the window object. As shown in the image below:

So, we see now that while working in the browser, the window is the root scope, the parent scope.

Now, what if we define a function func, then define a variable a inside it and try to console.log(a) outside the function, what do we get? Well, let's see for ourselves...

Hmnnnn... so we got an error which says a is not defined, let's get a hang of what's happening here. Variable a is defined, but within the function func, right. Variable 'a' therefore is limited to that function's scope(within the curly braces of the function). That is, it cannot be used outside of that scope. The only way to correct the given error is to console.log(a) inside the function's scope.

We see from the illustration above that a is now logged on the console.

Global variables and Scope

Global variables are variables that are declared in the global scope. That is, they are declared in the root scope, which means they are present in the window object like we saw previously.

What does this mean?

This means that they can be accessed from anywhere in the JavaScript program, even if they were not declared in the scope of an entirely new function(a child scope).

Suppose we have a variable a declared outside of a function func, the variable a can be used as a variable, and even modified in a child scope function func.
Let's visualize what we have just learned.

We see how that the global variable can be accessed and used by child scopes in the above illustration.

Next, let's see how the global variable can be modified by child scopes.

We see how that variable a has been modified globally, not just in the function, after the function was called, and from that instant, a is equal to 13.

Conclusion

We do have many more scenarios of using parent scopes inside of child scopes, like functions inside of functions, but that is beyond the scope of this article.

Recap

In this article, you read about

Root scope and how that by default we are in the root scope, the window object in JavaScript.
How that declaring variables inside of a function is limited to that function.
Global variables and how you can use them in child scopes.

If you have any questions, feel free to ask in the comments section. Until next time, XOXO.

Forem: Olasunkanmi Balogun

How I Built a Decentralized Crowdfunding App with Foundry(incl. unit tests)

Prerequisites

Foundry installation & project setup

Developing the Crowdfunding Smart Contract

Testing the Crowdfunding Smart Contract

Implementing the deploy script

Writing Tests

Deploying Your Contract Locally and on the Sepolia Testnet

Deploying on a Local Chain

Deploying to the Sepolia Testnet

Conclusion

Navigating Content Management With OneEntry

What Is OneEntry, and Why Should You Use It?

How it works

Key Takeaways

📊 How To Display An In-App Survey In Next.js 13 With Supabase And Formbricks 🤝🛠️

TL;DR

Overview

1. How to implement authentication in Next.js 13 with Supabase

How to implement an in-app onboarding segmentation survey with Formbricks.

Formbricks: The only open-source solution for in-app surveys

1. Customize your onboarding survey

Connecting Your Web App and Formbricks

Final Notes

📊🔍Measure Your Product-Market Fit With Formbricks' In-App Product-Market Fit Survey 📏📈

TL;DR

Formbricks: The Only Open-Source Solution For In-App PMF Surveys

1. Create an account on the Formbricks platform - It's free

2. How to create and customize your PMF survey

3. Setup Checklist: Integrate Formbricks Widget Into Your Application

4. Trigger Your In-app PMF Survey

Conclusion

🔥 How To Get Juicy User Insights With In-App Pre-Churn Survey In Next.js With Formbricks 💡💬

TL;DR

Formbricks: The Only Open-Source Solution For Pre-Churn Surveys

How To Craft A Churn Survey With Formbricks

1. Create an account on Formbricks - It's Free

2. Craft your churn survey

3. Setup Checklist: Installing The Formbricks Widget

4. How to trigger the Formbricks pre-churn survey

Conclusion

💻 A Technical Interview Project: Building a Lending-as-a-Service Application 🏦

TL;DR

How I Set My Project Up

I Set Up My React + TypeScript Project With Vite

How I Set Up Firebase For Authentication

File Structure

Page Routing In The main.tsx File

How I Implemented Features

Starting Off With Authentication In The Log In Page 🚀

On To The Authenticated Pages 🚶

Navigating To The Users' Page 👥

Journey's End: The User Details Page

Conclusion

How To Use TypeScript Interfaces For Better Code Organization And Readability

Importance Of Interfaces

Syntax And Basic Use Cases Of Interfaces

Syntax

Basic Use Cases

Use Case: Optional Properties

Use Case: Read-only Properties

Use Case: Extending Other Types

Use Case: Function Types

Use Cases: Index Signatures

Conclusion

How To Unit Test React Applications with Jest: A Beginner's Guide

Table of Contents

What Is Unit Testing And Why Is It Important?

Why Is It Important?

Performing Unit Tests With Jest In React

Setup

Testing A React Component

Mocking Functions With Jest

Snapshot Testing With Jest

Conclusion

Maximizing Performance: A deep dive into React re-renders and how to optimize your components

Table of Contents

Importance Of Performance In React

Understanding React Re-renders

Page Routing In The `main.tsx` File

Preventing Re-renders With `React.memo` And `useMemo`