Forem: Damilare Agba

Exploring Web3, DeFi, NFTs, and DAOs: The Future of Digital Innovation.

Damilare Agba — Tue, 04 Apr 2023 18:40:09 +0000

The world of cryptocurrency and blockchain technology has undergone tremendous growth and transformation over the past few years. The introduction of Web3, decentralized finance (DeFi), non-fungible tokens (NFTs), and decentralized autonomous organizations (DAOs) have paved the way for a new era of innovation and disruption. These technologies are changing the way we think about ownership, financial transactions, and governance, and they have the potential to revolutionize industries beyond the crypto world. In this article, we will explore what web3, DeFi, NFTs, and DAOs are, and how they are shaping the future of our digital landscape.

Are you ready to dive into the future of the internet? Let's start with the basics:

What is Web3?

In essence, Web3 is a movement towards a more decentralized web. It is the next generation of the internet that's all about decentralization, privacy, and user ownership. In a nutshell, it's a whole new way of thinking about the internet, where users have control over their data and can interact with applications and services without relying on centralized authorities.

With Web3, you can use decentralized apps (dApps) that run on blockchain technology. This means that your data is stored on a distributed network instead of being held by a single company or organization. You can participate in decentralized finance (DeFi) to earn interest on your crypto holdings or use non-fungible tokens (NFTs) to buy and sell unique digital assets like art or music.

Web3 is an exciting frontier that promises to transform the way we interact with the internet. It's a more user-centric, secure, and transparent internet that puts power back in the hands of the people. So, get ready to explore this new world and see what Web3 has in store for us!

Now, let's explore some of the most popular Web3 applications that are shaking up traditional business models. Decentralized finance (DeFi), non-fungible tokens (NFTs), and decentralized autonomous organizations (DAOs) are three areas that have made waves in recent years.

Understanding Decentralized Finance (DeFi)

Decentralized finance, commonly known as DeFi, has gained significant traction recently as one of the most popular Web3 applications. Simply put, DeFi aims to build a more accessible, transparent, and permissionless financial system using blockchain technology.

One of the main advantages of DeFi is its ability to remove intermediaries, such as banks, from financial transactions. This means that users can lend and borrow money, trade assets, and earn interest without relying on traditional financial institutions.

There are several DeFi applications that users can utilize, including decentralized exchanges (DEXs), lending platforms, stablecoins, and yield farming. DEXs like Uniswap and Sushiswap enable users to trade cryptocurrencies without going through a centralized exchange. Lending platforms like Aave and Compound allow users to lend and borrow cryptocurrencies at competitive interest rates. Stablecoins like DAI and USDC are cryptocurrencies that are pegged to the value of a fiat currency, like the US dollar, providing stability for users who want to hold cryptocurrency without being exposed to its volatility. Yield farming allows users to earn interest on their cryptocurrency holdings by lending them to DeFi platforms.

However, DeFi is not without its challenges. One of the biggest challenges is security. Due to the decentralized nature of DeFi, there have been several high-profile hacks and exploits in the past. Therefore, DeFi platforms must prioritize security and employ strict auditing processes to protect users' funds.

Despite its challenges, DeFi has the potential to revolutionize the financial industry by making it more accessible, transparent, and inclusive. As DeFi continues to grow and mature, we can expect to see more innovative solutions that disrupt traditional financial systems.

🤷🏼‍♂️ Non-Fungible Tokens (NFTs)

Non-fungible tokens, commonly known as NFTs, have taken the art world by storm in recent years. However, their potential extends far beyond just digital art.

NFTs are unique digital assets that represent ownership of a particular item, whether it be an image, video, or even a tweet. Unlike traditional digital assets like MP3s or JPEGs, NFTs cannot be duplicated, making them truly one-of-a-kind. This uniqueness has led to a surge in interest from collectors and investors.

Platforms like OpenSea and Rarible provide users with a marketplace for buying and selling NFTs. Recently, high-profile NFT sales include Beeple's "The First 5000 Days" NFT, which sold for $69 million at auction.

NFTs have the potential to disrupt a wide range of industries, from music to gaming to real estate. For example, musicians can use NFTs to sell ownership of their music, giving fans a new way to support their favorite artists. In the gaming industry, NFTs can be used to represent in-game assets, making it easier for players to buy, sell, and trade items. In real estate, NFTs can be used to represent ownership of physical properties, making it easier and more efficient to buy and sell properties.

However, NFTs are not without their controversies. Some critics argue that NFTs are environmentally unfriendly due to the high energy consumption required to mint them. Additionally, there are concerns about the bubble-like nature of NFT prices, with some NFTs selling for millions of dollars.

Despite these concerns, NFTs can potentially create new business models and revenue streams in a wide range of industries. As more companies and individuals explore the potential of NFTs, we can expect to see more innovative solutions that utilize this exciting Web3 technology.

What are Decentralized Autonomous Organizations (DAOs)

Decentralized autonomous organizations (DAOs) are community-run organizations that use blockchain technology to make their decision-making processes transparent and resistant to corruption. In a DAO, decisions are made through a decentralized voting process, where token holders can propose and vote on changes to the organization.

DAOs have the potential to revolutionize traditional organizations by removing the need for a centralized authority to make decisions. Instead, decisions are made collectively by the community, creating a more democratic and transparent system. This can lead to greater accountability, as decision-makers are held responsible by the community they represent.

One of the most popular DAOs is MakerDAO, a decentralized lending platform that allows users to propose and vote on changes to the platform. The platform operates through the use of a stablecoin called DAI, which is pegged to the value of the US dollar. Users can borrow DAI by collateralizing their crypto assets and paying the loan with interest.

Gitcoin is another popular DAO that operates as a platform for funding community-driven open-source projects. Gitcoin allows developers to earn cryptocurrency for their contributions to open-source projects, with users voting on which projects to fund.

One of the key benefits of DAOs is their transparency. All transactions and decisions are recorded on a public blockchain, making it easy to audit and verify the organization's operations. This transparency also makes DAOs resistant to corruption, as decision-makers cannot act in their own self-interest without being held accountable by the community.

However, DAOs also face challenges, such as the risk of majority attacks, where large token holders can manipulate the voting process to their advantage. There is also a lack of legal clarity around DAOs, as they operate in a regulatory gray area.

Despite these challenges, DAOs have the potential to revolutionize the way organizations are run. By creating more democratic and transparent decision-making processes, DAOs can empower communities to take control of their own governance and create systems that are resistant to corruption and censorship. As the technology behind DAOs continues to develop, it will be exciting to see the impact they will have on the future of organizations and society.

Conclusion

The emergence of DeFi, NFTs, and DAOs presents new opportunities for innovation and disruption in industries that have traditionally been controlled by centralized authorities. With these new Web3 applications, individuals have greater control over their data, more access to financial systems, and greater opportunities to participate in community-driven organizations.

However, these disruptions also pose challenges for traditional businesses that may be slow to adapt to these new technologies. As decentralized systems become more widely adopted, businesses that rely on centralized control and authority may struggle to keep up with the pace of innovation. To remain relevant, traditional businesses must embrace the decentralized future and find ways to incorporate Web3 applications into their existing business models.

In conclusion, building a decentralized future using Web3 applications represents a new era of innovation and disruption. As a Web3 engineer, I am excited to be part of this exciting time and to see how these new technologies will shape the future of business and society.

A simple introduction to GraphQL with ExpressJs and Docker

Damilare Agba — Tue, 31 Jan 2023 20:11:07 +0000

What is GraphQL

GraphQL is a specification for writing queries for APIs and a runtime for fulfilling those queries to already existing data. It is built around the HTTP protocol and defines how to send and receive resources from a server.

With GraphQL, you do not need to create multiple endpoints to request data like you would usually do when creating REST endpoints. You are provided with one singular endpoint which returns the required data based on the queries you send to the endpoint.

REST vs GraphQL

Imagine you are building a CMS (a content management system) and you have two tables in your database; user and posts. Below, you will see how both REST and GraphQL will handle a situation where you need to get all the posts for each user in your application.

REST

When using REST, you would first need to make a request to a first endpoint (e.g /users) which queries the user model to get a list of all the users in the db. After doing this, you can extract the id of each user before making another request to a second endpoint (e.g /users/posts) which returns all the posts created by that user. This means that you would have to make n number of calls to the /users/posts endpoint, n being the number of users in your application.

Also note that the response from the /users endpoint might contain other user information apart from the id like name, date of birth, location, age, etc which you do not really need in this context. This also applies to the /users/posts endpoint. This ultimately means that you get to make requests to endpoints more that you need to and that might slow down the application.

GraphQL

With GraphQL, you only need to create a single query which contains the exact data that you need. In this context, you tell it that you need all the users (their names only) and all posts created by each user (title only) by creating a query like the one below

query{
  users{
    name
    posts{
      title
    }
  }
}

After creating the query, you send it to your GraphQL server which parses the query and returns the the appropriate data as defined in the query. Here, you get exactly what you need from a single endpoint, nothing more, nothing less. This greatly improves your application in many ways.

In a nutshell

In a nutshell, GraphQL gives us everything a REST API can do like CRUD functionalities, error handling, etc. It however improves on it by reducing the number of requests made, nesting data based on simple organized queries, which makes the whole server run faster and more optimized.

Express + GraphQL

Let us make a handy template for getting started with GraphQL applications. You'll first need to setup a simple Express application using GraphQL. You then add some functionalities to the application so you can see some of the features GraphQL has to offer by yourselves.

To get started, you create a basic express server by running the command below;

% npm init --yes

This generates a package.json file which contains information about your application, and other information like the application dependencies and how to run it.

You need to install your application dependencies by running the commands below which adds them to your package.json file;

% npm i express express-graphql graphql

These dependencies allows you to start up an express server, connect your expresses server to graphql (express-graphql) and also provides the GraphQL functionalities you need (graphql).

You'll also install nodemon to help restart your server when any file changes, and add a dev script to your package.json file.

% npm i --save-dev nodemon

package.js

{ "scripts":
  {  "dev": "nodemon index.js"}
}

PostgreSQL + Docker

After this is done, you'll set up a postgreSQL database using docker-compose and populate it with some users and posts so you can test your application. To do this, you'll create a docker-compose.yml file which will contain the configurations for the postgres service you'll be using. You can set that up by adding the folling lines to the docker-compose file

version: '3.8'
services:
  postgres:
    image: postgres:13-alpine
    ports:
      - 5432:5432
    env_file:
      - .env
    volumes:
      - postgres:/var/lib/postgresql/data
    networks:
      - graphql-express

volumes:
  postgres:
    name: graphql-express-docker-db

networks:
  graphql-express:

Then go on to you terminal and run docker compose up -d or sudo docker-compose up -d (for linux). This spins up the postgres service and makes it available for your application. You also need to install sequelize, an ORM for connecting with and quering your database. To do the, install the following

% npm install sequelize pg pg-hstore

Sequelize also provides a cli which makes it easier to user the ORM by providing cli commands. In this example, you'll make use of sequelize-cli to set up database connection and schema. Enter the following commands in your terminal

% npm install --save-dev sequelize-cli
...
% npx sequelize-cli init

This will create a number of folders

config, which contains config file, which tells CLI how to connect with database
models, contains all models for your project
migrations, contains all migration files

After these has been created, you need to create your user and posts models. To do this, you can use the model:generate command which takes the model name and attributes

% npx sequelize-cli model:generate --name User --attributes name:string

% npx sequelize-cli model:generate --name Post --attributes title:string

This generates the user and posts models which you can edit to add relationships. In the user model, you can add the following lines to the static associate function in the user.js file


static associate({ Post }) {
    this.hasMany(Post, { foreignKey: "userId", onDelete: "CASCADE" })
}

and in the post.js file, you add the belongsTo association in the Post model


static associate({ Post }) {
    this.hasMany(Post, { foreignKey: "userId", onDelete: "CASCADE" })
}

You can then run migration to persist the schema on the database using the db:migrate command


npx sequelize-cli db:migrate

After this, you can create a seed file to insert some raw data by default. This will help you test the server later. You can create a seed file to create demo-users.

% npx sequelize-cli seed:generate --name demo-user
...

You can then proceed to add demo users to the seed files. After adding these users you then use the db:seed:all command to create them.

xxxxxxxxxxxxx-demo-user.js

'use strict';

/** @type {import('sequelize-cli').Migration} */
module.exports = {
  async up (queryInterface, Sequelize) {
    return queryInterface.bulkInsert('Users', [{
        name: 'Naruto Uzumaki',
        createdAt: new Date(),
        updatedAt: new Date()
    }]);
  },
  async down (queryInterface, Sequelize) {
    return queryInterface.bulkDelete('Users', null, {});
  }
};

then


% npx sequelize-cli db:seed:all

Express Server

You can then set up a simple server by adding the following to the index.js file. This spins up the server and add GraphQL to it. It uses the graphqlHTTP function which takes two arguments, schema, which will be defined later and the graphiql which provides a GUI for interacting with our server.


const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { sequelize, User, Post} = require('./models');


const app = express();
app.use('/graphql', graphqlHTTP({
    schema: schema,
    graphiql: true
}))
app.listen(5000, () => (
    await sequelize.authenticate();
    console.log("Running")
))

For this to work though, you need to define a schema which tells GraphQL how your data interacts with each other. This schema takes two arguments; the query argument which is a way for you to fetch data from the server and the mutation argument which gives your server other CRUD functionalities.


const schema = new GraphQLSchema({
    query: rootQuery,
    mutation: rootMutation
})

To define your rootQuery, add the following lines to your server file. The rootQuery is a GraphQLObjectType which defines the name and description for the object. It servers as a data access layer (DAL) which defines the object fields which itself contains definitions of various query fields you can use to fetch data from your server. It also resolves those fields and returns the appropriate data by making queries to the the database.

// root query scope
const rootQuery = new GraphQLObjectType({
    name: "Query",
    description: "Root Query",
    fields: () => ({
        posts: {
            type: new GraphQLList(PostType),
            description: 'List of posts',
            resolve: () => Post.findAll()
        },
        users: {
            type: new GraphQLList(UserType),
            description: 'List of users',
            resolve: () => User.findAll()
        },
        post: {
            type: PostType,
            description: 'A single post',
            args: {
                id: { type: GraphQLInt }
            },
            resolve: (parent, args) => Post.findOne({
                where: {
                    id: args.id
                }
            })
        },
        user: {
            type: UserType,
            description: 'A single user',
            args: {
                id: { type: GraphQLInt }
            },
            resolve: (parent, args) => User.findOne({
                where: {
                    id: args.id
                }
            })
        }
    })
})

You can also define your rootMutation which is very similar to the the rootQuery object. However it differs because it is used to mutate or change data on your server.



const rootMutation = new GraphQLObjectType({
    name: "Mutation",
    description: "Root Mutation",
    fields: () => ({
        addUser: {
            type: UserType,
            description: 'Add a user',
            args: {
                name: { type: GraphQLNonNull(GraphQLString) }
            },
            resolve: (parent, args) => {
                const user = User.create({
                    name: args.name
                })
                return user
            } 
        },
        addPost: {
            type: PostType,
            description: 'Add a post',
            args: {
                title: { type: GraphQLNonNull(GraphQLString) },
                userId: { type: GraphQLNonNull(GraphQLInt) }
            },
            resolve: (parent, args) => {
                const post = Post.create({
                    title: args.title,
                    userId: args.userId
                })
                return post
            }
        }
    })
})

Both the rootQuery and the rootMutation defines some types like the PostType and UserType which represents the definitions for your posts and users respectively. To define these types, which are a bit similar with the rootQuery and rootMutation, you should input the following and edit as required

const UserType = new GraphQLObjectType({
    name: "User",
    description: "A User in our application",
    fields: () => ({
        id: { type: GraphQLNonNull(GraphQLInt) },
        name: { type: GraphQLNonNull(GraphQLString) },
        posts: {
            type: new GraphQLList(PostType),
            resolve: (user) => Post.findAll({
                where: {
                    userId: user.id
                }
            })
        }
    })
})

const PostType = new GraphQLObjectType({
    name: "Post",
    description: "A Post created by a user",
    fields: () => ({
        id: { type: GraphQLNonNull(GraphQLInt) },
        title: { type: GraphQLNonNull(GraphQLString) },
        userId: { type: GraphQLNonNull(GraphQLInt) },
        user: {
            type: UserType,
            resolve: (post) => User.findOne({
                where: {
                    id: post.userId
                }
            })
        }
    })
})

Testing the server

With your database running and everything above put in place as you require, you can proceed to run npm run dev in your terminal session to spin up the server. Your expres server should be available on localhost:5000 and you can interact with the GraphQL server on localhost:5000/graphql which provides a nice user interface.

With this, you have successfully created a GraphQL server using express and connected to a PostgreSQL database instance that was created using docker compose.

The full code for this article is available here on github.

Cheers.

Initiating a NestJs app with PostgreSQL using Docker

Damilare Agba — Tue, 24 Jan 2023 23:57:21 +0000

Introduction

I sometimes find myself trying to remember exactly how to initiate a project after a very long time away. At this point, I've probably spent the last couple months working on a project off an entirely different stack, so much that I haven't initiated a new project in a while.

I decided to create this go-to article for initiating a new project using nestjs with typescript. I also thought it'll be a handy tool for other developers to leverage when getting their backend projects started. I'll simply give a step by step process to get a project started, create it's basic structure, connect to a database using docker and implement a authentication service.

Creating a NestJs App

First, I'll be going through creating a nestjs application, connecting to a postgresql database that will be spun up using docker, creating a User model and configuring an ORM - in this case prisma - to connect with our database. I'll also try to implement a simple authentication system to add some functionality to the app.

To get started with nestJs "a framework for building efficient, scalable Node.js server-side applications", I'll go to my terminal and install nest cli globally using the command below. This provides a way to create a new nest project which bundles with it the core files required to get the project started.

% npm i -g @nestjs/cli

I'll start the new project with this command -nest new <project-name>- which creates a directory where all our files will reside. It also creates a basic structure for the whole application.

% nest new nest-init
... # select a preferred package manager
% code nest-init # or open in your favorite IDE

Now, the working directory looks something like

|-- node_modules/
|-- src
|    |-- main.ts
|    |-- app.module.ts
|-- test/
|-- package.json
|-- README.md
|-- tsconfig.json

NOTE: The src directory initially contained more files but I removed them because I won't be needing them.

The Database

Starting the database

The next thing to do is to set up the database for the app to connect to. I'll do this using docker-compose which is a tool for "running multi-container applications on docker". I start by creating a docker-compose.yml file which will contain the code for running a postgreSQL instance. The file should contain something similar to the code below

version: '3.8'
services:
  postgres:
    image: postgres:13-alpine
    ports:
      - 5432:5432
    env_file:
      - .env
    volumes:
      - postgres:/var/lib/postgresql/data
    networks:
      - nest-init

volumes:
   postgres:
      name: nest-init-docker-db

networks:
   nest-init:

To make use of this, a .env file is required which contains the credentials to be used when spinning up the postgreSQL instance. It should contain the following constants

POSTGRES_DB=<db_name>
POSTGRES_USER=<username>
POSTGRES_PASSWORD=<password>

I then proceed to run the command below which spins up the database with docker; the -d flag allows this to run in detached mode which in-turn makes the terminal session still available for use.

% docker-compose up -d

Connecting to the database

Now that the database is running, I'll proceed to install and initiate prisma which creates a prisma directory and schema file. It also creates a .env file or in this case, adds a required line; DATABASE_URL to the file.

The database url in this case will look something like postgresql://dami:root@localhost:5432/nest-init?schema=public.

To install prisma

% npm install prisma --save-dev
...
% npx prisma init

Now I have a schema.prisma file that contains the database connection variable. It will also contain all the yet to be created models that will be used in the application. It also defines the client to be used which in this case is prisma client. To make use of it though, it needs to be installed by running the command below

% npm install @prisma/client

I also need to install nest config to easily access our configuration variables in the .env file.

% npm i --save @nestjs/config

The ConfigModule needs to be added to the app.module.ts file to be able to make use of the config service with the aid of dependency injection. Now my file looks like this

import { Module } from '@nestjs/common';
import { PrismaModule } from './prisma/prisma.module';
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true
    }),
    PrismaModule
  ],
})
export class AppModule {}

I'll also create a simple User model to be used for the authentication system.

model User {
  id         Int      @id @default(autoincrement())
  email      String   @unique
  name       String
  password   String

  @@map("users")
}

After creating the model, a migration needs to be made so the model will be mapped to the database. This is done by running a simple prisma command

% npx prisma migrate dev

This creates a SQL migrations file and runs the migrations on the database.

Creating required services

Now, I can start creating the required services. Nest CLI provides handy tools for creation of modules, services and controllers. It also automatically bundles related files in a directory and adds the individual service module to the app.module.ts file. At the end or a project, the src folder should look something like;

src
 |-- auth
 |     |-- auth.controller.ts
 |     |-- auth.module.ts
 |     |-- auth.service.ts
 |-- prisma
 |     |-- prisma.module.ts
 |     |-- prisma.service.ts
 |-- app.module.ts
 |-- main.ts

Prisma Service

I'll start by creating the prisma service while would be used to access the database from any part of the application.I'll generate to files, the prisma.module.ts and prisma.service.ts files using the command below.

% nest g module prisma
% nest g service prisma --no-spec

The --no-spec flag ensures that prisma doesn't generate test files alongside the required files. Next, I'll add the following code to the prisma.service.ts file

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient{
    constructor(config: ConfigService) {
        super({
            datasources: {
                db: {
                    url: config.get('DATABASE_URL')
                }
            }
        })
    }

}

and the prisma.module.ts file looks like

import { Global, Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Global()
@Module({
    providers: [PrismaService],
    exports: [PrismaService]
})
export class PrismaModule {}

With this, I can also inject the PrismaService wherever the application needs to access the database.

Auth Service

Going forward, I'll be implementing a simple register endpoint in the authentication system to to test the apps functionality. To do this, the auth service, module and controller files need to be generated using the commands below

% nest g module auth
...
% nest g service auth --no-spec
...
% nest g controller auth --no-spec

The generated module file already contains imports and bundles the service and controller files. I'll go ahead to add the route to the controller file and the register logic in the service file.

I'll create a simple DTO to serve as a schema for the expected payload and use class-validator to validate the incoming data. Note that this needs to be installed running

% npm i class-validator
% npm i class-transformer

The validation pipe also needs to be added to the main.ts file to allow validation in the whole application.

main.ts

import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe({
    whitelist: true
  }))
  await app.listen(3000);
}
bootstrap();

Now I'll write the auth controller

auth.controller.ts

import { Body, Controller, Post } from '@nestjs/common';
import { AuthService } from './auth.service';
import { IsEmail, IsNotEmpty, IsString } from "class-validator"

class RegisterDTO {
    @IsNotEmpty()
    @IsEmail()
    email: string

    @IsNotEmpty()
    @IsString()
    name: string

    @IsNotEmpty()
    @IsString()
    password: string

    @IsNotEmpty()
    @IsString()
    repeatPassword: string
}

@Controller('auth')
export class AuthController {
    constructor(private authService: AuthService) {}

    @Post('register')
    register(@Body() dto: RegisterDTO) {
        return this.authService.register(dto)
    }
}

And in the auth.service.ts file

import { BadRequestException, ForbiddenException, Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
import { PrismaService } from 'src/prisma/prisma.service';
import { RegisterDTO } from './auth.controller';
import * as CryptoJS from 'crypto-js';

@Injectable()
export class AuthService {
    constructor(private prisma: PrismaService, private config: ConfigService) {}

    async register(dto: RegisterDTO) {
        try {
            if (dto.password !== dto.repeatPassword) throw new BadRequestException("Passwords must be equal!")
            const key = CryptoJS.enc.Utf8.parse(this.config.get('SECRET_PASS'));
            const passwordHash = CryptoJS.AES.encrypt(dto.password, key, {iv: key}).toString()
            const user = await this.prisma.user.create({
                data: {
                    name: dto.name,
                    email: dto.email,
                    password: passwordHash
                }
            })
            const {password, ...result} = user
            return {
                statusCode: 201,
                message: "User created successfully.",
                data: result
            }
        } catch (error) {
            console.log(error)
            if (error instanceof PrismaClientKnownRequestError) {
                if (error.code === 'P2002') {
                    throw new ForbiddenException("Email or name has already been used!")
                }
            } throw error;
        }
    }
}

Now I can start the server by running npm run start:dev and make a request to the register endpoint.

The complete code can be found here on Github.
Cheers!

Building a CMS API with Fauna and FastAPI

Damilare Agba — Sun, 19 Dec 2021 14:31:33 +0000

During my recent journey on working with databases, I found a really interesting database to work with. In the past, I have done major work with MongoDB(a NoSQL database) and many other relational databases and I was looking to work with something relatively different.

Today we will build a simple content management system API leveraging fauna and FastAPI, a python framework for building relatively fast APIs.

What is Fauna

Before we get started, let us take a look at a major tool in our arsenal today; Fauna.

Fauna is an interface for interacting with your data that has been stored in a serverless database. The engine on which it runs provides a "...fast, consistent, and reliable..." system, "... with a modern security infrastructure."

Fauna can be seen as a hybrid database system "NoSQL system's flexibility and with the relational querying and transactional capabilities of SQL databases."

Now lets talk about serverless databases. A serverless database is one which gives room for developers to host their data without the need to worry about the low-level specifics of the system hosting it. This allows the developer to spend more time on the development of the application itself.

Setting up our fauna database

To get started, we need to install the fauna driver to be able to make use of it in our project.

$ pip install faunadb

After installing the we want to start out our project so we'll be creating our main.py file which would contain all the logic and resources we'll be exposing on our API.

To create our file we can run this in the terminal

$ touch main.py

Before we get started with writing our code, we need to first create our database on the fauna dashboard.

![Image description]

After creating our database, we need to create our server key. We do this by going to the security tab on our dashboard and creating a new key. admin
Make sure the role is server*

![Image description]

We would get a key which we need to store somewhere safe as fauna would only give us the key once.

Now we can proceed to writing our code. Let us go to our main.py file.

Connecting to our fauna database

We would get started by connecting to our fauna database so we can interact with it.

To do that, first we import the modules need to connect to our db

from faunadb import query as q
from faunadb.objects import Ref
from faunadb.client import FaunaClient

Then we can create our server client by doing

serverClient = FaunaClient(secret="YOUR_FAUNADB_ADMIN_SECRET")

The server client is what is needed to interact with the Fauna data-API (our database).

Our secret here is the server key we generated earlier.

After we create our server client, we proceed by creating our collection. In lay-man terms, a collection is a group of documents* with almost specific similarities, e.g a collection of users, a group of students, and the like. From the perspective of relational databases, it can be seen as a table

*^{We'll get to that later}

We'll be creating two collections, one for our users and the other for our posts. A collection can be created with our client.

serverClient.query(q.create_collection({"name": "users"}))

serverClient.query(q.create_collection({"name": "posts"}))

Next we get ahead by creating indexes for each collection. An index is a way of retrieving documents from our collection. Indexes are needed to be able to make queries to the collections.

Let us create our index for the users and posts

serverClient.query(q.create_index(
    {
        "name": "users_by_email",
        "source": q.collection("users"),
        "permissions": {"read": "public"},
        "terms": [{"field": ["data", "email"]}],
        "unique": True
    }
))

serverClient.query(q.create_index(
    {
        "name": "posts_by_author",
        "s_[](url)_ource": q.collection("posts"),
        "terms": [{"field": ["data", "author"]}],
    }
))

Now before moving forward, let us address what a document is. Writing data to a collection creates a document which can be seen as an individual row of data. From the point of view of relational db a document is a row in a table.

Now that we have all these ready, let us proceed to writing our code.

We would be leveraging FastAPI, a python web framework to create our content management system.

To get started, we would create our app which we would be building our endpoints on.
First, let us import all the libraries we would be using

from datetime import datetime, timedelta
from fastapi import FastAPI, Path, Query, Header


# this creates our app
app = FastAPI()

It is upon this app that we would build our endpoints and logic.

We would be looking at the basic CRUD functionalities of fauna in this article. You can find the code for the project on github.

To get started, let us create a register route for our app. Here we would look at creating and reading a document here. Before we do that, we need to create a model for the information we want our endpoint to receive. This servers as a guide for the data each endpoint receiving information wants.

In FastAPI, pydantic abstracts all the complexities and gives us a simple way to do this.

from pydantic import BaseModel

class User(BaseModel):
    name: str
    email: str
    password: str

This serves as a base model for our user class. We would see how this is used soon.

Let us proceed by creating a way for our users to register. Before that we also need to import some additional libraries. We would import all the libraries we need here and now then we start hacking.

import uuid
from faunadb import query as q
from faunadb.objects import Ref
from datetime import datetime, timedelta
from fastapi import FastAPI


# we create our register route
@app.post('/register')
def register(user: User):  
    pass

Here, we defined that our route would be a post request. Recall the base model we created earlier, we are making use of it here note the data we are expecting with the post request (for the user, we want the name(a string), password (a string) and email (also a string). Recall that FastAPI generates a documentation for us and this would also be included in the documentation automatically.

Then let's proceed to write our logic. What we do is

First check if the email provided has been used by another user (here we'll read from our db using the index we created)
If it hasn't, we create a new user (write to our db)

@app.post('/register')
def register(user: User):
    try:
        # here we read from our db using our index
        sc.query(q.get(q.match(q.index("users_by_email"), user.email)))
        return {
            "msg": "error",
            "detail": "Email has been used."
        }
    except:
        # write the user info to our db
        sc.query(q.create(q.collection('users'), {
            'data': {
                "email": user.email,
                "name": user.name,
                "password": hash_password(user.password),
                "pid": str(uuid.uuid4())
            }
        }))
        return {
            "msg": "success",
            "detail": "Created Successfully"
        }

With this simple resource, we've seen the create and read feature of fauna.

No let us proceed to updating our user information. Earlier, we noticed that we used a base model to receive our user information. However, we can't use the same model now because all fields in the model are compulsory and for our update resource, we might only want to update one field.

To fix this, let us simply create a new base model and make the fields optional.

class UpdateUser(BaseModel):
    name: Optional[str] = None
    email: Optional[str] = None
    password: Optional[str] = None

Now we can proceed to creating our update user resource

@app.post("/update-user")
def update_user(user: UpdateUser, x_access_token: str = Header(None)):
    try:
        data = jwt.decode(x_access_token, secret_key,
                          algorithms=['HS256'])
    except Exception:
        return {
            'msg': 'error',
            'details': 'Token is invalid'
        }
    try:
        resp = sc.query(q.get(q.match(q.index("users_by_email"), data['email'])))
    except:
        return {
            'msg': 'error',
            'details': 'User not found'
        }
    uid = resp['ref'].id()
    data = {}
    if user.email is not None:
        data["email"] = user.email
    if user.name is not None:
        data["name"] = user.name
    if user.password is not None:
        data["password"] = hash_password(user.password)

    sc.query(q.update(q.ref(q.collection("users"), uid), {"data": data}))
    return {
        "msg": "success",
        "details": "User updated successfully"
    }

Here, we see how to update our document in the user collection with the update query.
We have seen ways of interacting with our fauna collection. The syntax used about is a generic syntax for python so it can be used outside FastAPI.

I hope we have learn a few things from this short article.
Cheers

Working with PostgreSQL and flask_sqlalchemy

Damilare Agba — Mon, 03 May 2021 15:15:32 +0000

In this article, we'll be looking at creating and connecting a simple web app built with flask; a python based microframework, to a PostgreSQL database. Here we'll be making use of sqlalchemy which is an object-relational mapper for python. Without further ado, let us get right into it.

PS: I assume you already have python and flask installed so I won't be going into details about that. If you don't, you can visit the python website to download it then run the following command in your terminal to install flask.

$ pip install flask

What is PostgreSQL?

According to its Wikipedia page, "PostgreSQL, also known as Postgres, is a free and open-source relational database management system (RDBMS) emphasizing extensibility and SQL compliance" -Wikipedia

What distinguishes Postgres from other relational databases like MySQL is the fact that it is object-oriented and ships with more use cases and features which is important to run some applications.

I am currently working on a Linux operating system (Parrot to be specific). So we'll be going through these processes the Linux way. Cheers.

Installing Postgres

If like me, you are using the latest version of your Linux distro, then it is very likely that you already have Postgres installed on your machine. Then you can skip to this. If you don't have it installed, however, you can go through the process below to install it.

First, create the file repository configuration

$ sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

Then import the repository signing key

$ wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -

Then go ahead to update the package list

$ sudo apt-get update

With all these done, you can then install Postgresql by doing

$ sudo apt-get install postgresql

Starting The Server

With the installation done, we can then proceed to start the Postgres server by running the following in our terminal

$ sudo service postgresql start
[sudo] password for user:
$

Once this runs without any issue, we know our server is running. With this, let us proceed to create our user and then our database. We are creating a new user here because it is bad practice to use the postgres user (personal opinion though). To do this, we enter the following to get into the postgres cli.

$ sudo -i -u postgres

from the above command, we get a prompt similar to this

postgres@parrot:~$

then we proceed by typing in psql

postgres@parrot:~$psql
...
...
postgres=#

this takes us to an interactive postgres environment where we can run general SQL queries and also postgres specific commands.

Creating a user

We proceed to create a user by typing the SQL command for that.

postgres=# CREATE ROLE user WITH CREATEDB LOGIN PASSWORD 'password';

Here, we created a user with the ability to create databases and also gave the user a login password (password).

We can then create a database for this particular user by doing

postgres=# CREATE DATABASE ourdb WITH OWNER user;

with this done, we have created a database named ourdb for user. Exit the environment by typing \q and exit one after the other.

To read more on PostgreSQL, visit the page here

Creating our web app

Next, we'll be creating our simple web app with flask, a microframework for the python programming language. Read more about it here.

We will set up a simple app by doing

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello, World!'

if __name__ == "__main__":
    app.run()

We would be using flask_sqlalchemy to connect to our Postgres database we created earlier. But first,

What is Flask_sqlalchemy?

"Flask-SQLAlchemy is an extension for Flask that adds support for SQLAlchemy to your application. It aims to simplify using SQLAlchemy with Flask by providing useful defaults and extra helpers that make it easier to accomplish common tasks." - PyPi

SQLAlchemy?

"SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives application developers the full power and flexibility of SQL.

It provides a full suite of well-known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language." SQLAlchemy

With that, we can proceed to writing our configurations, creating our database tables (also known as models), and connecting to the database.

We make our flask app more workable by adding the following lines

from flask import Flask
from flask_sqlalchemy import SQLAlchemy  # 1

app = Flask(__name__)
app.config['SECRET_KEY'] = "xxxxxxxx"    # 2

db = SQLAlchemy(app)

# our database uri
username = "user"
password = "password"
dbname = "ourdb"

app.config["SQLALCHEMY_DATABASE_URI"] = "postgresql://{username}:{password}@localhost:5432/{dbname}"

if __name__ == "__main__":
    app.run()

We also create our model by adding the class right after the database configuration

# basic model
class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(64), unique=True, index=True)
    password = db.Column(db.String(128))

if __name__ == "__main__":
    app.run()

With this done, we can then create our tables for the database by proceeding to the terminal. However, before we do that, we have to install a library to help python connect to the PostgreSQL database. The library is known as psycopg2.

We can install this by running the code below in the terminal

$ pip install psycopg2

If for dependency reasons, we get an error, we can do

$ pip install psycopg2-binary

With that installed, we can proceed to create our table. The connection to the database takes place here. We open a python shell session in the terminal and run the following commands

$ python
...
>>>from ourapp import app, db, User
>>>app.app_context().push()
>>>db.create_all()
>>>

As long as this runs without any errors, we have successfully connected to our database and created the User table. We can then populate the DB either by going to our database and running the SQL commands for that

i.e

$ sudo -i -u postgres

Then we enter the database ourdb owned by user with the following command. (The password would be required here. For us, the password is password)

psql -h <hostname> -d <dbname> -U <username> -p <port>
i.e

postgres@parrot:~$ psql -h localhost -d ourdb -U user -p 5432

This would ask for our password then take us to an interactive command-line environment where we can run SQL commands to populate our database.

We can also do that from our python shell as flask_sqlalchemy allows us to do that.

>>> from ourapp import app, db, User
>>>app.app_context().push()
>>>db.create_all()
>>>
>>>user = User(email="example@email.com", password="password_hash")
>>>db.session.add(user)
>>>db.session.commit()
>>>

With this, we have successfully created a user and added the details to our database.

Conclusion

In this article, we learned about PostgreSQL, how to install and work with it. We also created a simple flask app and saw how to create tables, connect our flask app to the database and populate the database.

I trust with this you are capable of setting up your flask projects for use with the PostgreSQL database. If you have any questions, you can contact me on Twitter @agba_dr3.

Cheers!

Build a Flask Application with Blueprints

Damilare Agba — Thu, 10 Dec 2020 00:25:34 +0000

I'll start by introducing us to Flask, a python based web application microframework as it allows us to determine a major part of the developmental process for our web application. Flask is a lightweight framework that is easy to get started with and can be used to build small projects. That being said, flask can also be used to build very large projects. To do this, we have to learn to organize our projects well. This here brought about the idea of blueprints.

We will be learning what blueprints are, why to use them, how they work, and how to use them. But first, let us start by setting up a basic flask app without a blueprint and then go on to talk more about blueprints.

We start by installing flask

$ pip3 install flask

we then move to create our first flask app with a simple view function

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello World"

if __name__ == "__main__":
    app.run(debug=True)

This is our basic flask app named app.py in our myapp directory.

user:~/Desktop/myapp$ ls
app.py

Now let's talk about blueprints. I am assuming we are already familiar with flask.

A blueprint (generally) can be seen as a model or a plan for representing an idea. With flask, a blueprint is a representation of a flask application i.e it performs its actions in a similar manner to that of the flask application. However, it is not a flask application. This is because a blueprint has to be registered in a flask application for its features or functions to be made available or useful in the entire project.

Blueprints are majorly used to organize our project and group related functions into separate python packages. For instance, if we were building an e-commerce web app, we can create two different blueprints i.e one for the authentication and the other for the logic. This helps to maintain a clean directory layout.

For a blueprint to work, it must be registered on the application to make available its functionalities. A blueprint uses resources from the main application in carrying out its tasks. These resources include static files, templates, application configurations, e.t.c. This shows that blueprints can't work on their own. However, they serve as a library of functions for the application to make use of.

We will proceed by creating an authentication and the main blueprint to demonstrate how they are used. So far, our working directory looks like

myapp
|
|--app.py

Now we create our main blueprint named main.py

from flask import Blueprint

main = Blueprint('main', __name__)

@main.route('/')
def index():
    return "Hello from the main blueprint"

and our app.py file becomes

from flask import Flask
from main import main

app = Flask(__name__)
app.register_blueprint(main)

if __name__ == "__main__":
    app.run(debug=True)

Here we can see that our main.py file now has the view function and our app.py file holds a registration of the blueprint. With this, we can define more view functions related to the running of our application in the main blueprint without tampering with our app.py file. This helps to group together related view functions and foster good layouts.

We can also create our authentication blueprint then register it

from flask import Blueprint

auth = Blueprint('auth', __name__)

@auth.route('/login')
def login():
    pass

and our app.py file becomes

from flask import Flask
from main import main
from auth import auth

app = Flask(__name__)
app.register_blueprint(main)
app.register_blueprint(auth)

if __name__ == "__main__":
    app.run(debug=True)

With this done, our working direction looks more like

myapp
|
|--app.py
|--main.py
|--auth.py

This brings together different view functions into packages to make sure our application is well arranged. For a full project, however, we would be creating our blueprints as python packages instead of files. This is to further create a better architecture for our application, make our application more pythonic and make the working directory look better.

We are not limited to a certian number of blueprints so we can create as much as possible. After creating a blueprint package, I have a directory like the one below.

myapp
|
|--app
|    |--main
|    |    |--__init__.py
|    |    |--main.py
|    |
|    |--auth
|    |    |--__init__.py
|    |    |--auth.py
|    |
|    |--__init__.py
|    |--errors.py
|    |--models.py
|    |-- templates/
|    |--static/
|
|--tests/
|--config.py
|--myapp.py
|--requirements.txt

With this, our view functions are grouped into related packages know here as blueprints, our working directory looks better and a major advantage is that we can edit a part of the application without tampering with other parts.

This here will be my breakpoint for today.
I hope we've learnt a thing or two from this.

Cheers.

Connecting to a MySQL database with SQLAlchemy

Damilare Agba — Sat, 05 Dec 2020 15:47:47 +0000

Setting up my web app with flask, I was trying to connect to a MySQL database and I encountered a few errors. I'll be listing them here and writing about how I solved them.
We'll go through the steps of installing our required tools then we move on to pointing out the errors encountered and how I solved them.

It will be good the state that SQLAlchemy is an ORM for the python programming language

But first, what is an ORM?

ORM or Object Relational Mapper is a software or tool that maps your code to a database without you making use of a database connector directly as it abstracts the whole process of the database connection. This in turn makes it possible for us to connect to any relational database without changing too much code.

(Abstraction is the process of making available the features of a tool or program for direct use without having us bother about how it works).

For this process, we'll be using flask_sqlalchemy, a flask extension to leverage the sqlalchemy features. (abstraction😄)

I am also assuming we already have MySQL installed in our working environment. Read more here on installing MySQL on ubuntu.

We will also be installing flask as this would be a flask app.

$ pip3 install flask
...
$ pip3 install flask_sqlalchemy
...

Next, we move on to creating our database by starting our MySQL session and then create our database

$ mysql -h hostname -u test_user -p
...

mysql > CREATE DATABASE testdb;

After this, we proceed to create our flask app where we will be adding all the configurations and creating a basic database model.

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SECRET_KEY'] = "xxxxxxxx"

db = SQLAlchemy(app)

# configuring our database uri
# note an error here
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql://{username}:{password}@{server}/testdb".format(username, password, server)

# basic model
class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(64), unique=True, index=True)
    password = db.Column(db.String(128))

if __name__ == "__main__":
    app.run(debug=True)

To create our tables in the database, we open a python shell session and do the following

>>>from ourflaskapp import app, db
>>>app.app_context().push()
>>>db.create_all()

db.create_all returns an error

ModuleNotFoundError: No module named 'MySQLdb'

This is because, even if we don't see the database connection process as sqlalchemy abstracts it, it still happens and here, we don't have the right module 'MySQLdb' to make this happen.

I read that python doesn't support mysqldb so we then have to install a mysql python connector

$ pip3 install mysql-connector-python

This solves the issue of the module error, however, we still have an error in connection because we want sqlalchemy to connect using the MySQL connector instead of trying to connect directly. This means we have to change the SQLALCHEMY_DATABASE_URI in our python script

# we change 

app.config["SQLALCHEMY_DATABASE_URI"] = "mysql://{username}:{password}@{server}/testdb".format(username, password, server)

# to 

app.config["SQLALCHEMY_DATABASE_URI"] = "mysql+mysqlconnector://{username}:{password}@{server}/testdb".format(username, password, server)

With this we can go back to the python shell session and create our database with no issues at all

>>>from ourflaskapp import app, db
>>>app.app_context().push()
>>>db.create_all()
>>>

I hope you have learned a thing or two here on the use of sqlalchemy.

Cheers.