DEV Community: Nditah

Generative AI in the Movie Industry

Nditah — Thu, 21 Mar 2024 14:13:02 +0000

A Symphony of Human and Machine Creativity

Introduction

In the hallowed halls of Hollywood, where dreams are spun into celluloid magic, a new player has emerged—a silent collaborator that wields algorithms instead of scripts. Generative Artificial Intelligence (AI), once confined to research labs, now dances across soundstages, reshaping the very fabric of cinema. But what exactly is generative AI?

Defining Generative AI

Imagine an invisible screenwriter with an insatiable appetite for data. This digital scribe devours cinematic history, analyzes audience preferences, and whispers fresh narratives into the ears of filmmakers. Generative AI isn't about replacing human creativity; it's about augmenting it. It's a powerful tool that can streamline workflows, spark new ideas, and push the boundaries of storytelling.

The Rise of the Digital Auteur

The term "auteur" traditionally referred to the visionary directors who wielded complete creative control over their films. Today, however, a new kind of auteur is emerging—the digital auteur. Hidden within the complex algorithms, AI co-authors the creative process.

AI-Generated Plot Twists: A Case Study

Consider the 2018 science fiction film "Searching," a thriller that kept audiences guessing until the very last frame. The filmmakers utilized an AI program called "Ringer" to analyze classic suspense films. By identifying patterns and audience reactions, Ringer was able to generate unexpected plot twists that defied convention. This highlights the potential of AI to not just replicate existing formulas, but to create surprising and engaging narratives.

Melodies from the Machine: A New Era of Film Scoring

John Williams. Hans Zimmer. These legendary composers have scored the soundtracks to our lives. But a new generation of musical collaborators is emerging – AI composers. These AI models can analyze emotional arcs, cultural cues, and genre tropes to create original music that perfectly complements a scene. Need a heart-wrenching violin solo to capture a character's grief? An AI can compose it, drawing on centuries of musical evolution to craft a piece that resonates with audiences.

Casting Call: The Algorithmic Talent Scout

Imagine a casting director who can scan vast databases of actors, analyze on-screen chemistry, and predict box office success. This is the power of AI in casting. While star power will always be a factor, AI can help filmmakers discover hidden gems – talented actors who might not have otherwise been considered.

VFX: From Pixels to Dreamscapes

Visual effects (VFX) have always been the driving force behind movie magic. Now, AI algorithms are taking VFX to a whole new level. These algorithms can morph pixels into photorealistic dragons, resurrect long-lost actors with uncanny realism, and conjure entire fantastical worlds. Generative Adversarial Networks (GANs) are pushing the boundaries of what's possible, blurring the lines between reality and simulation.

The Uncertain Future: Balancing Innovation with Humanity

As AI infiltrates every aspect of filmmaking, a crucial question arises: will it homogenize creativity? Can AI replicate the raw emotion and serendipity that defines a truly groundbreaking film? Furthermore, copyright issues come into play – when an AI creates a piece of music or a narrative element, who owns the rights?

Mitigating the Risks: A Collaborative Future

Tyler Perry's recent pause on his Atlanta studio expansion highlights the concerns some industry leaders have about job displacement due to AI. The key lies in striking a balance between innovation and human talent. AI should be seen as a collaborator, not a competitor.

CreateEnsemble: Where AI Meets Artistry

This is where platforms like CreateEnsemble.com come into play. CreateEnsemble.com is a vibrant online community where creators of all disciplines converge. Here, artists can experiment with AI-generated tools, share their creations, and collaborate with other artists. Mentorship programs connect aspiring filmmakers with experienced professionals, and crowdfunding campaigns help bring independent visions to life. The marketplace buzzes with a unique blend of digital artistry and human ingenuity.

Conclusion

The movie industry, once a world guarded by celluloid gatekeepers, now embraces AI with open arms. As we navigate this exciting new era, let's remember: the heart of cinema still beats in human dreams. The script might be penned by an algorithm, but the soul of the film comes from the human storytellers who wield those algorithms. So, get ready, movie lovers. The credits are rolling on the old Hollywood, and the AI orchestra is tuning up for a blockbuster future. But this future won't be defined by machines alone; it will be a symphony of human and machine creativity, working in harmony to tell stories that move, inspire, and amaze.

About the Author: Nditah Samweld

Want to explore the intersection of art and technology further? Join me on CreateEnsemble.com

How to Setup Nodejs Mongodb in Production server on Ubuntu 18.04 in AWS, GCP, Azure, Digital Ocean Cloud Instance or Locally

Nditah — Mon, 27 Jun 2022 10:09:29 +0000

Talking of DevOps practices like infrastructure automation,there are lots of great tools out there for large enterprise applications. However, for small applications, it would be an overkill like using a sledge hammer for a fly. So why would I use Infrastructure as Code System such as Terraform, or Configuration Management System Chef, Ansible, Puppet; when I can simply fly with this 5mins installation guide 😜 (just kidding, I am learning them 📚)

I regularly update the installation steps so get the Github gist for the most recent.

📝 still drafting the article

#!/usr/bin/env bash

# Steps to write and execute a script
# Open the terminal. Go to the directory where you want to create your script.
# Create a file with . sh extension.
# Write the script in the file using an editor.
# Make the script executable with command chmod +x <fileName>.
# Run the script using ./<fileName>.

echo "
----------------------
  Adding a New User to the System 'Sammy'
----------------------
"
adduser sammy

# enter all the prompted info

# Step 3 — Adding the User to the sudo Group

usermod -aG sudo sammy

# Testing sudo Access
su - sammy
sudo ls -la /root


echo "
----------------------
  GIT
----------------------
"
# install curl
sudo apt install curl -y

# install git
sudo apt-get install -y git


echo "
----------------------
  NODE & NPM
----------------------
"
## You may also need development tools to build native addons:
sudo apt-get install gcc g++ make -y

wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash

nvm ls-remote

nvm install 14

nvm alias default  14.15.0

# add nodejs 14 ppa (personal package archive) from nodesource
# curl -sL https://deb.nodesource.com/setup_14.x | sudo -E bash -

# install nodejs and npm
# sudo apt-get install -y nodejs


echo "
----------------------
  MONGODB
----------------------
"

# import mongodb 4.0 public gpg key
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 9DA31620334BD75D9DCB49F368818C72E52529D4

# create the /etc/apt/sources.list.d/mongodb-org-4.0.list file for mongodb
echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.0.list

# reload local package database
sudo apt-get update

# install the latest version of mongodb
sudo apt-get install -y mongodb-org

# start mongodb
sudo systemctl start mongod

# stop mongodb
sudo systemctl stop mongod

# Make a directory as root user
sudo mkdir -p /data/db

# Provide access to the directory
sudo chown -R $USER /data/db


# set mongodb to start automatically on system startup
sudo systemctl enable mongod

# stop mongodb to start automatically on system startup
sudo systemctl disable mongod

# install local replication-set driver for nodejs
sudo npm install --unsafe-perm --verbose -g run-rs -f

# start mongodb replica set
# run-rs --mongod --keep --shell --dbpath /home/user/data"

# start mongod as a background process
 mongod  --fork  --syslog

echo "
----------------------
  PM2
----------------------
"

# install pm2 with npm
npm install -g pm2

# set pm2 to start automatically on system startup
pm2 startup systemd

# make current user the owner of the pm2 log home dir
sudo chown -R $(whoami):$(whoami) /home/ubuntu/.pm2

# create a shell script replica.sh
$ nano replica.sh
    #!/bin/bash
    run-rs --mongod --keep --shell --dbpath /data/db

$ pm2 run replica.sh


echo "
----------------------
  NGINX
----------------------
"

# install nginx
sudo apt-get install -y nginx

# You can make the currrent $USER the owner of that directory
sudo chown -R $(whoami):$(whoami) /var/www

# set the appropriate permissions
chmod 755 -R /var/www


echo "
----------------------
  UFW (FIREWALL)
----------------------
"

# allow ssh connections through firewall
# sudo ufw allow OpenSSH

# allow http & https through firewall
# sudo ufw allow 'Nginx Full'

# enable firewall
# sudo ufw --force enable

echo "
----------------------
  NETWORK TESTING TOOL
----------------------
"

# curl tool
sudo apt  install httpie -y
sudo apt update
sudo apt install redis-server -y


# # comment out `supervised no` and set `supervised systemd`
sudo nano /etc/redis/redis.conf
# > supervised systemd


# restart redis server
sudo systemctl restart redis.service


echo "
----------------------
  SET UP LETS-ENCRYPT
----------------------
"
# Instal CertBot
curl -o- https://raw.githubusercontent.com/vinyll/certbot-install/master/install.sh | bash

# Open the server block file for your domain using nano or your favorite text editor:
sudo nano /etc/nginx/sites-available/example.com
#server_name example.com www.example.com;

# test and restart nginx
sudo nginx -t
sudo systemctl reload nginx

# create the nginx default configuration

nano  default 
# paste the content below

## start 📥 

# website server
server {
    server_name example.com www.example.com;
    root /var/www/html/web/build;
    index index.html;
    location / {
        try_files $uri$args $uri$args/ /index.html;
    }
}
# admin console server
server {
    server_name admin.example.com;
    root /var/www/html/admin/dist;
    index index.html;
    location / {
        try_files $uri$args $uri$args/ /index.html;
    }
}
# demo or documentation server
server {
    server_name developers.example.com;
    root /var/www/html/backend/doc;
    index index.html;
    location / {
        try_files $uri$args $uri$args/ /index.html;
    }
}
# backend api server
server {
    server_name api.example.com;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $remote_addr;
    location / {
        proxy_pass http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_connect_timeout       600;
        proxy_send_timeout          600;
        proxy_read_timeout          600;
        send_timeout                600;
    }
}

## end 📤

sudo rm  /etc/nginx/sites-available/default
sudo mv default  /etc/nginx/sites-available/default


# Set up Certbot to obtain SSL certificates
sudo certbot --nginx -d example.com -d www.example.com  -d api.example.com  -d dev.example.com   -d developers.example.com -d admin.example.com

# To test the renewal process, you can do a dry run with certbot:
sudo certbot renew --dry-run

Send SMS Messages with Node.js using the Vonage API

Nditah — Thu, 23 Jun 2022 11:38:24 +0000

Send SMS Messages with Node.js using the Vonage API

Clone the Source Code on Github

Vonage is an American telecommunications company headquartered in New Jersey.

The company is a publicly held business cloud based communications provider.

Vonage offers SMS, MMS, Voice, and Video Streaming services via their API gateway.

Vonage's SMS API enables you to send and receive text messages to and from users worldwide, with these features:

Programmatically send and receive high volumes of SMS globally.
Send SMS with low latency and high delivery rates.
Receive SMS using local numbers.
Scale your applications with familiar web technologies.
Pay only for what you use, nothing more.
Auto-redact feature to protect privacy.

The Aim of this project is to create a simple Nodejs RESE API that uses Vonage SMS API

Step 1: Initialize Your Project

Start by initializing a Nodejs project in your project folder, and install the Vonage Server SDK for Node.js in your working directory:
Also install the ExpressJs framework and DotEnv for enviromental virables

$ npm init -y
$ npm install @vonage/server-sdk --save
$ npm i dotenv express

Your package.json will look similar to this:

{
  "name": "vonage-sms",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@vonage/server-sdk": "^2.11.1",
    "dotenv": "^16.0.1",
    "express": "^4.18.1"
  },
  "type": "module"
}

Add "type": "module" to your package.json file to be able to use import statements.

Step 2: Create two files

lib.js and index.js as shown below:

lib.js: a library file for the sendSms function that initializes a Vonage instance with your API credentials

// lib.js
import Vonage from "@vonage/server-sdk";
import 'dotenv/config'

const vonage = new Vonage({
    apiKey: process.env.VONAGE_API_KEY,
    apiSecret: process.env.VONAGE_API_SECRET,
});

const sender = process.env.VONAGE_VIRTUAL_NUMBER;

export const sendSms = (recipient, message) => {
    return new Promise((resolve, reject) => {
    console.log("Initial");
    vonage.message.sendSms(sender, recipient, message, (err, responseData) => {
            if (err) {
                console.log(err);
                reject(err.message)
            } else {
                if (responseData.messages[0]["status"] === "0") {
                    console.dir(responseData);
                    resolve(responseData);
                } else {
                    console.log(
                        `Message failed with error: ${responseData.messages[0]["error-text"]}`
                    );
                    reject(`${responseData.messages[0]["error-text"]}`);
                }
            }
        }
    )  
  })
};

index.js: the main (entry) point for your application.

// index.js
import express from "express";
import 'dotenv/config'
import { sendSms } from "./lib.js";

const PORT = process.env.PORT;
const { json, urlencoded } = express;

const app = express();

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

app.post('/send', (req, res) => {
    const { phone, message } = req.body;
    sendSms(phone, message)
        .then((data) => res.json({ success: true, data }))
        .catch((err) => res.json({ success: false, message: err }));
});

app.listen(PORT, () => {
    console.log(`Server listening at http://localhost:${PORT}`);
});

Step 3: get and Set your Vonage API Credentials

Next, you will need a Vonage API account. If you don’t have one already, you can sign up and start building with about 2$ free credit.

Find your API key and secret in your Vonage Dashboard and assign them to enviromental variables in .env

PORT=3000
VONAGE_VIRTUAL_NUMBER=GIFTI
VONAGE_API_KEY=abc123
VONAGE_API_SECRET=P1Qxyz000000

Step 4: Configure Sender Virtual Number or Register Recipient Test Number

To get Your Number, click here

Go to the Dashboard
Click Number, then Click Your Numbers

There, you can manage your virtual phone numbers and configure their settings.
However, for newly signup users, you can only use test numbers because you can only buy more numbers after upgrading to a paid account.

To get Test Numbers, click here

Until you upgrade your account by making your first payment, you will only be able to send messages to these numbers.

Add one or more phone numbers at your disposable. Vonage will send you a verification code either via SMS or voice message.

Step 5: Finally, run your nodejs express application

Open Postman, Insomnia, or any other http client and post to your server

http://localhost:3000/send

POST Request:

{
    "phone": "+234 test-phone",
    "message": "Hi Developer, testing for Vonage"
}

POST Response:

{
    "success": true,
    "data": {
        "messages": [
            {
                "to": "234-test-phone",
                "message-id": "866cf22f-c55f-482b-81ba-faa02c69578e",
                "status": "0",
                "remaining-balance": "1.71020000",
                "message-price": "0.09660000",
                "network": "62130"
            }
        ],
        "message-count": "1"
    }
}

If you receive the error message

Non-Whitelisted Destination. Your Vonage account is still in demo mode. While in demo mode you must add target numbers to your whitelisted destination list.

Then know that you need to verify if the recipient phone number is registered as a test-phone number as stated in step-4.

Develop a Simple Python Django ToDo App in 1 minute

Nditah — Wed, 20 Apr 2022 08:48:12 +0000

Hello-Django

Completed App |
Django Official Website |
Getting Started

Make a Directory for the Project and navigate into it

mkdir hello-django && cd hello-django
Create and activate a Python Virtual Environment

python3 -m venv venv
source venv/bin/activate
Create a Django Project

django-admin startproject todoapp
Navigate into the django-project folder just created todoapp and Run the server

cd todoapp
python manage.py runserver
Quit the Server with Ctrl + C and create a application component inside the project todolist

python manage.py startapp todolist
Add the application component to the lists of apps in todoapp/settings.py INSTALLED_APPS

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'todolist', /* added line */
]

To add a view, go to todolist/views.py

# Create your views here.
def index(request):
    return render(request, "base.html", { "todo_list": todos })

For each view, register the route in a file urls.py created in the same todolist directory with the view.

from django.urls import path
from . import views

urlpatterns = [
    path("", views.index, name="index")
]

use the include function to add the todolist urls in the todoapp/urls.py on the main app.

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('todolist.urls')),
]

Create the templates/base.html file in the project root directory sitting at the same level with todoapp and todolist directory. Make a small modification required by Django

                {% csrf_token %}

Go to todoapp/settings.py and add the templates directory to the DIR array entry of the TEMPLATES array.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': ['templates'], /* modified */
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Define the todolist model inside todolist/models.py

from django.db import models

# Create your models here.
class Todo(models.Model):
    title=models.CharField(max_length=350)
    complete=models.BooleanField(default=False)

    def __str__(self):
        return self.title

Run python manage.py makemigrations
- The command creates a migration for the model Todo
Then run python manage.py migrate
Create a Super user for the Admin panel python manage.py createsuperuser
Then follow the instruction to create name, email and password
Go to todolist/admin.py and register the model

from django.contrib import admin
from .models import Todo

# Register your models here.
admin.site.register(Todo)

No go to the todolist/views.py and import the Todo model

from django.shortcuts import render
from .models import Todo

# Create your views here.
def index(request):
    todos = Todo.objects.all()
    return render(request, "base.html", { "todo_list": todos })

Run the server again and test python manage.py runserver

Starting development server at http://127.0.0.1:8000/
If you try to add a record, it throws and error.
However, the TodoApp works find through the Admin Panel http://127.0.0.1:8000/admin

to implement the missing views, go to todolist/views.py

from django.shortcuts import render, redirect
from django.views.decorators.http import require_http_methods

from .models import Todo

# Create your views here.
def index(request):
    todos = Todo.objects.all()
    return render(request, "base.html", { "todo_list": todos })

@require_http_methods(["POST"])
def add(request):
    title = request.POST["title"]
    todo = Todo(title=title)
    todo.save()
    return redirect("index")

def update(request, todo_id):
    todo = Todo.objects.get(id=todo_id)
    todo.complete = not todo.complete
    todo.save()
    return redirect("index")

def delete(request, todo_id):
    todo = Todo.objects.get(id=todo_id)
    todo.delete()
    return redirect("index")

Add the views to the urlpatterns in todolist/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('add', views.add, name='add'),
    path('delete/<int:todo_id>/', views.delete, name='delete'),
    path('update/<int:todo_id>/', views.update, name='update'),
]

templates/base.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Todo App - Django</title>
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.css">
        <script src="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.js"></script>
    </head>
    <body>
        <div style="margin-top: 50px;" class="ui container">
            <h1 class="ui center aligned header">Django ToDo App</h1>

            <form class="ui form" action="/add" method="post">
                <div class="field">
                    <label>Todo Title</label>
                    <input type="text" name="title" placeholder="Enter ToDo task...">
                    <br>
                </div>
                <button class="ui blue button" type="submit">Add</button>
            </form>

            <hr>

            {% for todo in todo_list %} 
            <div class="ui segment">
                <p class="ui big header">{{ todo.id }} | {{ todo.title }}</p>

                {% if todo.complete == False %}
                <span class="ui gray label">Not Complete</span>
                {% else %}
                <span class="ui green label">Complete</span>
                {% endif %}

                <a class="ui blue button" href="/update/{{ todo.id }}">Update</a>
                <a class="ui red button" href="/delete/{{ todo.id }}">Delete</a>

            </div>
            {% endfor %}

        </div>


    </body>

</html>

Finally, restart the App python manage.py runserver or refresh.
Review the App at http://127.0.0.1:8000/ and the out-of-the-box Admin Panel
Commit and push your code to github.com and Deactivate the Virtual Env.

$ deactivate

$ conda deactivate

📚 Sam's other blogs

Dev.to | Hashnode.dev | Medium.com
Github

Develop a Simple Python FastAPI ToDo App in 1 minute

Nditah — Wed, 20 Apr 2022 06:06:46 +0000

FastApi-App

Completed App |
FastApi Official Website |

Make a Directory for the Project and navigate into it

mkdir fastapi-app && cd fastapi-app
Create a Python Virtual Environment and Activate it

python3 -m venv venv
ls
source venv/bin/activate
Install Fastapi

pip install fastapi
Install an ASGI server

pip install "uvicorn[standard]"
Install package for the template

pip install python-multipart jinja2
Install package for database support

pip install sqlalchemy
The Open the Project with VSCode and create three files: app.py, database.py and models.py

Note:
Update Pip python3 -m pip install --upgrade pip

app.py

from fastapi import FastAPI, Depends, Request, Form, status

from starlette.responses import RedirectResponse
from starlette.templating import Jinja2Templates

from sqlalchemy.orm import Session
from database import SessionLocal, engine
import models

models.Base.metadata.create_all(bind=engine)

templates = Jinja2Templates(directory="templates")

app = FastAPI()

# Dependency
def get_db():
    db = SessionLocal()
    try: 
        yield db
    finally:
        db.close()

@app.get("/")
async def home(req: Request, db: Session = Depends(get_db)):
    todos = db.query(models.Todo).all()
    return templates.TemplateResponse("base.html", { "request": req, "todo_list": todos })

@app.post("/add")
def add(req: Request, title: str = Form(...), db: Session = Depends(get_db)):
    new_todo = models.Todo(title=title)
    db.add(new_todo)
    db.commit()
    url = app.url_path_for("home")
    return RedirectResponse(url=url, status_code=status.HTTP_303_SEE_OTHER)

@app.get("/update/{todo_id}")
def add(req: Request, todo_id: int, db: Session = Depends(get_db)):
    todo = db.query(models.Todo).filter(models.Todo.id == todo_id).first()
    todo.complete = not todo.complete
    db.commit()
    url = app.url_path_for("home")
    return RedirectResponse(url=url, status_code=status.HTTP_303_SEE_OTHER)


@app.get("/delete/{todo_id}")
def add(req: Request, todo_id: int, db: Session = Depends(get_db)):
    todo = db.query(models.Todo).filter(models.Todo.id == todo_id).first()
    db.delete(todo)
    db.commit()
    url = app.url_path_for("home")
    return RedirectResponse(url=url, status_code=status.HTTP_303_SEE_OTHER)

models.py

from email.policy import default
from sqlalchemy import Boolean, Column, Integer, String
from database import Base

class Todo(Base):
    __tablename__ = "todos"

    id = Column(Integer, primary_key=True)
    title = Column(String(100))
    complete = Column(Boolean, default=False)

database.py

import imp
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

DB_URL = "sqlite:///./db.sqlite"

engine = create_engine(DB_URL, connect_args = { "check_same_thread": False })

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

templates/base.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Todo App - Fastapi</title>
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.css">
        <script src="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.js"></script>
    </head>
    <body>
        <div style="margin-top: 50px;" class="ui container">
            <h1 class="ui center aligned header">Fastapi ToDo App</h1>

            <form class="ui form" action="/add" method="post">
                <div class="field">
                    <label>Todo Title</label>
                    <input type="text" name="title" placeholder="Enter ToDo task...">
                    <br>
                </div>
                <button class="ui blue button" type="submit">Add</button>
            </form>

            <hr>

            {% for todo in todo_list %} 
            <div class="ui segment">
                <p class="ui big header">{{ todo.id }} | {{ todo.title }}</p>

                {% if todo.complete == False %}
                <span class="ui gray label">Not Complete</span>
                {% else %}
                <span class="ui green label">Complete</span>
                {% endif %}

                <a class="ui blue button" href="/update/{{ todo.id }}">Update</a>
                <a class="ui red button" href="/delete/{{ todo.id }}">Delete</a>

            </div>
            {% endfor %}

        </div>


    </body>

</html>

To run the app, with uvicorn using the file_name:app_instance

uvicorn app:app --reload

Preview the App at http://127.0.0.1:8000/ and the out-of-the-box API Documentation

Commit and push your code to github.com and Deactivate the Virtual Env.

$ deactivate
$ conda deactivate

📚 Sam's other blogs: Dev.to | Hashnode.dev | Medium.com
Github

Develop a Simple Python Flask ToDo App in 1 minute

Nditah — Wed, 20 Apr 2022 01:45:49 +0000

Flask-App

Completed App
Official Website |
Quick Start

Make a Directory for the Project and navigate into it

mkdir flask-app && cd flask-app
Create a Python Virtual Environment and Activate it

python3 -m venv venv
ls
source venv/bin/activate
Install Flask and SQLAlchemy

pip install Flask Flask-SQLAlchemy
The Open the Project with VSCode.
Create a file app.py and the templates directory with a base.html file

app.py


from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

class Todo(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100))
    complete = db.Column(db.Boolean)

db.create_all()

@app.get("/")
def home():
    todo_list = db.session.query(Todo).all()
    return render_template("base.html", todo_list=todo_list)

@app.post("/add")
def add():
    title = request.form.get("title")
    new_todo = Todo(title=title, complete=False)
    db.session.add(new_todo)
    db.session.commit()
    return redirect(url_for("home"))

@app.get("/update/<int:todo_id>")
def update(todo_id):
    todo = db.session.query(Todo).filter(Todo.id == todo_id).first()
    todo.complete = not todo.complete
    db.session.commit()
    return redirect(url_for("home"))

@app.get("/delete/<int:todo_id>")
def delete(todo_id):
    todo = db.session.query(Todo).filter(Todo.id == todo_id).first()
    db.session.delete(todo)
    db.session.commit()
    return redirect(url_for("home"))

templates/base.html

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Todo App - Flask</title>
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.css">
        <script src="https://cdn.jsdelivr.net/npm/semantic-ui@2.4.2/dist/semantic.min.js"></script>
    </head>
    <body>
        <div style="margin-top: 50px;" class="ui container">
            <h1 class="ui center aligned header">Flask ToDo App</h1>

            <form class="ui form" action="/add" method="post">
                <div class="field">
                    <label>Todo Title</label>
                    <input type="text" name="title" placeholder="Enter ToDo task...">
                    <br>
                </div>
                <button class="ui blue button" type="submit">Add</button>
            </form>

            <hr>

            {% for todo in todo_list %} 
            <div class="ui segment">
                <p class="ui big header">{{ todo.id }} | {{ todo.title }}</p>

                {% if todo.complete == False %}
                <span class="ui gray label">Not Complete</span>
                {% else %}
                <span class="ui green label">Complete</span>
                {% endif %}

                <a class="ui blue button" href="/update/{{ todo.id }}">Update</a>
                <a class="ui red button" href="/delete/{{ todo.id }}">Delete</a>

            </div>
            {% endfor %}

        </div>


    </body>

</html>

To run the app, Export Enviromental variables

export FLASK_APP=app.py

export FLASK_ENV=development

flask run

How To Build a GraphQL API with Apollo-Server and Prisma

Nditah — Mon, 23 Aug 2021 14:38:34 +0000

Introduction

GraphQL is a query language designed to build client applications by providing an intuitive and flexible syntax and system for describing their data requirements and interactions. In the previous lesson, you learnt how use GraphQL and Prisma in combination as their responsibilities complement each other.
In this lesson, you learn how to work with multiple models having complex relationships that truly mirrors a business.

Content

🔷 Step 1 — Creating the Node.js Project

🔷 Step 2 — Setting Up Prisma with PostgreSQL

🔷 Step 3 — Creating and Migrating the Database with Prisma

🔷 Step 4 — Defining the GraphQL Schema

🔷 Step 5 — Defining the GraphQL Resolvers

🔷 Step 6 — Creating the GraphQL Server

🔷 Step 7 — Testing and Deployment

Prerequisites

Complete the previous lesson

🔷 Step 1 — Creating the Node.js Project

First, create a new directory for your project, initialize npm and install dependencies:

$ mkdir node-graphql-lesson-04

$ cd node-graphql-lesson-04

$ npm init --yes

$ npm install apollo-server graphql

apollo-server: Apollo Server is a community-maintained open-source GraphQL server that's compatible with any GraphQL client. It's the best way to build a production-ready, self-documenting GraphQL API that can use data from any source.
graphql: GraphQL.js is the JavaScript reference implementation for GraphQL. It provides two important capabilities: building a type schema and serving queries against that type schema

You have created your project and installed the dependencies. In the next step you define the GraphQL schema which determines the operations that the API can handle.

🔷 Step 2 — Setting Up Prisma with PostgreSQL

The Prisma schema is the main configuration file for your Prisma setup and contains your database schema.

Begin by installing the Prisma CLI with the following command:

$ npm install prisma -D

The Prisma CLI will help with database workflows such as running database migrations and generating Prisma Client.

Next, you’ll set up your PostgreSQL database using Docker. Create a new Docker Compose file with the following command:

$  touch docker-compose.yml

Now add the following code to the newly created file:

# node-graphql-lesson-04/docker-compose.yml

version: '3.8'
services:
  postgres:
    image: postgres:13
    restart: always
    environment:
      - POSTGRES_USER=db_user
      - POSTGRES_PASSWORD=db_password
    volumes:
      - postgres:/var/lib/postgresql/data
    ports:
      - '5432:5432'
volumes:
  postgres:

This Docker Compose configuration file is responsible for starting the official PostgreSQL Docker image on your machine. The POSTGRES_USER and POSTGRES_PASSWORD environment variables set the credentials for the superuser (a user with admin privileges). You will also use these credentials to connect Prisma to the database. Finally, you define a volume where PostgreSQL will store its data, and bind the 5432 port on your machine to the same port in the Docker container.

With this setup in place, go ahead and launch the PostgreSQL database server with the following command:

$ docker-compose up -d

With the PostgreSQL container running, you can now create your Prisma setup. Run the following command from the Prisma CLI:

$ npx prisma init

# node-graphql-lesson-04/prisma/.env

DATABASE_URL="postgresql://db_user:db_password@localhost:5432/college_db?schema=public"

🔷 Step 3 — Creating and Migrating the Database with Prisma

Your GraphQL API for College has a single entity named Student. In this step, you’ll evolve the API by defining a new model in the Prisma schema and adapting the GraphQL schema to make use of the new model. You will introduce a Teacher, a Course and a Department model. Also, there exist a one-to-many relation from Department to the Student model as well as betwwen a Teacher, to a Course. This will allow you to represent the Teacher of Course and associate multiple Courses to each Teacher for instance. Then you will evolve the GraphQL schema to allow creating Teacher and associating Course with teachers through the API.

First, open the Prisma schema and add the following:

The college management system basically should have the following entities:

Students
Teachers
Departments
Courses

Other entities like Lessons, Fees, Marksheet, and Classes are obviously part of the solution, however, but for the sake of this lesson would not be necessary. See the entity diangram below:

Go to node-graphql/prisma/schema.prisma Add the following model definitions to it:

//* node-graphql-lesson-04/prisma/schema.prisma

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Student {
  id        Int        @id @default(autoincrement())
  email     String     @unique @db.VarChar(255)
  fullName  String?    @db.VarChar(255)
  enrolled  Boolean    @default(false)
  dept      Department @relation(fields: [deptId], references: [id])
  deptId    Int
  createdAt DateTime   @default(now())
  updatedAt DateTime   @updatedAt

  @@map(name: "student")
}

model Department {
  id          Int       @id @default(autoincrement())
  name        String    @unique
  description String?   @db.VarChar(500)
  students    Student[]
  courses     Course[]
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt

  @@map(name: "department")
}

model Teacher {
  id        Int         @id @default(autoincrement())
  email     String      @unique @db.VarChar(255)
  fullName  String?     @db.VarChar(255)
  courses   Course[]
  type      TeacherType @default(FULLTIME)
  createdAt DateTime    @default(now())
  updatedAt DateTime    @updatedAt

  @@map(name: "teacher")
}

model Course {
  id          Int         @id @default(autoincrement())
  code        String      @unique
  title       String      @db.VarChar(255)
  description String?     @db.VarChar(500)
  teacher     Teacher?    @relation(fields: [teacherId], references: [id])
  teacherId   Int?
  dept        Department? @relation(fields: [deptId], references: [id])
  deptId      Int?
  createdAt   DateTime    @default(now())
  updatedAt   DateTime    @updatedAt

  @@map(name: "course")
}

enum TeacherType {
  FULLTIME
  PARTTIME
}

You’ve added the following to the Prisma schema:

The Department model to represent course Specialties.
The Teacher model to represent course Instructors/Facilitators.
The Course model to represent subject matters

The Student model has been modifies as follows:

Two relation fields: dept and deptId. Relation fields define connections between models at the Prisma level and do not exist in the database. These fields are used to generate the Prisma Client and to access relations with Prisma Client.
The deptId field, which is referenced by the @relation attribute. Prisma will create a foreign key in the database to connect Student and Department.

Note that the dept field in the Student model is optional, similarly to the teacher field in Course model. That means you’ll be able to create students unassociated with a department as well as a course without and associated Teacher.

The relationship makes sense because course are usually later on assigned to Teachers and also registered students are usually matriculated into a Department.

Next, create and apply the migration locally with the following command:

$  npx prisma migrate dev

If the migration succeeds you will receive the following:

Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "college_db", schema "public" at "localhost:5432"

Database reset successful

The following migration(s) have been applied:

migrations/
  └─ 20210821201819_init/
    └─ migration.sql

✔ Generated Prisma Client (2.29.1) to ./node_modules/@prisma/client in 109ms

The command also generates Prisma Client so that you can make use of the new table and fields.

You will now update the GraphQL schema and resolvers to make use of the updated database schema.

With the model in place, you can now create the corresponding table in the database using Prisma Migrate. This can be done with the migrate dev command that creates the migration files and runs them.

Open up your terminal again and run the following command:

$ npx prisma migrate dev --name "init"

You’ve now created your database schema. Next, you will install Prisma Client.

Prisma Client is an auto-generated and type-safe Object Relational Mapper (ORM) that you can use to programmatically read and write data in a database from a Node.js application. In this step, you’ll install Prisma Client in your project.

Open up your terminal again and install the Prisma Client npm package:

$  npm install @prisma/client

With the database and GraphQL schema created, and Prisma Client installed, you will now use Prisma Client in the GraphQL resolvers to read and write data in the database. You’ll do this by replacing the content of the database.js, which you’ve used so far to hold your data.

//* node-graphql-lesson-04/src/database.js

const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient();

module.exports = {
  prisma,
}

Next, create a file database.js in your project src and add the students array to it as shown below:

🔷 Step 4 — Defining the GraphQL Schema

A schema is a collection of type definitions (hence typeDefs) that together define the shape of queries that can be executed against your API. This will convert the GraphQL schema string into the format that Apollo expects. Create a src directory and inside it, create the schema.js file.

$ mkdir src
$ touch src/schema.js

Now add the following code to the file:

//* node-graphql-lesson-04/src/schema.js

const { gql } = require("apollo-server")

const typeDefs = gql `

 type Student {
    id: ID!
    email: String!
    fullName: String!
    dept: Department!
    enrolled: Boolean
    updatedAt: String
    createdAt: String
  }

  type Department {
    id: ID!
    name: String!
    description: String
    students: [Student]
    courses: [Course]
    updatedAt: String
    createdAt: String
  }

  type Teacher {
    id: ID!
    email: String!
    fullName: String!
    courses: [Course]
    type: TeacherType
    updatedAt: String
    createdAt: String
  }

  type Course {
    id: ID!
    code: String!
    title: String!
    description: String
    teacher: Teacher
    dept: Department
    updatedAt: String
    createdAt: String
  }

  input TeacherCreateInput {
    email: String!
    fullName: String!
    courses: [CourseCreateWithoutTeacherInput!]
  }

  input CourseCreateWithoutTeacherInput {
    code: String!
    title: String!
    description: String
  }

  type Query {
    enrollment: [Student!]
    students: [Student!]
    student(id: ID!): Student
    departments: [Department!]!
    department(id: ID!): Department
    courses: [Course!]!
    course(id: ID!): Course
    teachers: [Teacher!]!
    teacher(id: ID!): Teacher
  }

  type Mutation {
    registerStudent(email: String!, fullName: String!, deptId: Int!): Student!
    enroll(id: ID!): Student
    createTeacher(data: TeacherCreateInput!): Teacher!
    createCourse(code: String!, title: String!, teacherEmail: String): Course!
    createDepartment(name: String!, description: String): Department!
  }

enum TeacherType {
  FULLTIME
  PARTTIME
}
`

module.exports = {
    typeDefs,
  }

In this updated code, you’re adding the following changes to the GraphQL schema:

The Teacher type, which returns an array of Course.
The Department type, which returns an array of Student.
The Course type which has a Teacher type
The dept of type Department field to the Student type.
The createTeacher mutation, which expects the TeacherCreateInput as its input type.
The CourseCreateWithoutTeacherInput input type used in the TeacherCreateInput input for creating teachers as part of the createTeacher mutation.
The teacherEmail optional argument to the createCourse mutation.

With the schema created, you will now create the resolvers to match the schema.

🔷 Step 5 — Defining the GraphQL Resolvers

Make a sub-directory called resolvers inside the src directory.
Now, inside the resolvers create three files index.js, query.js, mutation.js as follows:

$ mkdir src/resolvers
$ touch src/resolvers/index.js
$ touch src/resolvers/query.js
$ touch src/resolvers/mutation.js

Inside the mutation.js file, enter the following:

//* node-graphql-lesson-04/src/resolvers/mutation.js

const { prisma } = require("../database.js");

const Mutation = {
    registerStudent: (parent, args) => {
      return prisma.student.create({
        data: {
          email: args.email,
          fullName: args.fullName,
          dept: args.deptId && {
            connect: { id: args.deptId },
          },
        },
      });
    },
    enroll: (parent, args) => {
      return prisma.student.update({
        where: { id: Number(args.id) },
        data: {
          enrolled: true,
        },
      });
    },

    createTeacher: (parent, args) => {
      return prisma.teacher.create({
        data: {
          email: args.data.email,
          fullName: args.data.fullName,
          courses: {
            create: args.data.courses,
          },
        },
      });
    },

    createCourse: (parent, args) => {
      console.log(parent, args)
      return prisma.course.create({
        data: {
          code: args.code,
          title: args.title,
          teacher: args.teacherEmail && {
            connect: { email: args.teacherEmail },
          },
        },
      });
    },

    createDepartment: (parent, args) => {
      return prisma.department.create({
        data: {
          name: args.name,
          description: args.description,
        },
      });
    },
  };

  module.exports = {
    Mutation,
  }

Inside the query.js file, enter the following:

//* node-graphql-lesson-04/src/resolvers/query.js

const { prisma } = require("../database.js");

const Query = {
    enrollment: (parent, args) => {
      return prisma.student.findMany({
        where: { enrolled: true },
      });
    },
    student: (parent, args) => {
      return prisma.student.findFirst({
        where: { id: Number(args.id) },
      });
    },

    students: (parent, args) => {
      return prisma.student.findMany({});
    },

    departments: (parent, args) => {
      return prisma.department.findMany({});
    },

    department: (parent, args) => {
      return prisma.department.findFirst({
        where: { id: Number(args.id) },
      });
    },

    courses: (parent, args) => {
      return prisma.course.findMany({});
    },

    course: (parent, args) => {
      return prisma.course.findFirst({
        where: { id: Number(args.id) },
      });
    },

    teachers: (parent, args) => {
      return prisma.teacher.findMany({});
    },

    teacher: (parent, args) => {
      return prisma.teacher.findFirst({
        where: { id: Number(args.id) },
      });
    },
  };

  module.exports = {
    Query,
  }

And lastly, inside the index.js file, enter the following:

//* node-graphql-lesson-04/src/resolvers/index.js

const { prisma } = require("../database.js");
const { Query } = require("./query.js");
const { Mutation } = require("./mutation.js");

const Student = {
  id: (parent, args, context, info) => parent.id,
  email: (parent) => parent.email,
  fullName: (parent) => parent.fullName,
  enrolled: (parent) => parent.enrolled,
  dept: (parent, args) => {
    return prisma.department.findFirst({
      where: { id: parent.dept },
    });
  },
};

const Department = {
  id: (parent) => parent.id,
  name: (parent) => parent.name,
  description: (parent) => parent.description,
  students: (parent, args) => {
    return prisma.department.findUnique({
        where: { id: parent.id },
      }).students();
  },
  courses: (parent, args) => {
    return prisma.department.findUnique({
        where: { id: parent.id },
      }).courses();
  },
};

const Teacher = {
  id: (parent) => parent.id,
  email: (parent) => parent.email,
  fullName: (parent) => parent.fullName,
  courses: (parent, args) => {
    return prisma.teacher.findUnique({
        where: { id: parent.id },
      }).courses();
  },
};

const Course = {
  id: (parent) => parent.id,
  code: (parent) => parent.code,
  title: (parent) => parent.title,
  description: (parent) => parent.description,
  teacher: (parent, args) => {
    return prisma.course.findUnique({
        where: { id: parent.id },
      }).teacher();
  },
  dept: (parent, args) => {
    return prisma.course.findUnique({
      where: { id: parent.id },
    }).dept();
  },
};

const resolvers = {
  Student,
  Department,
  Teacher,
  Course,
  Query,
  Mutation,
};

module.exports = {
  resolvers,
};

Let’s break down the changes to the resolvers:

The createCourse mutation resolver now uses the teacherEmail argument (if passed) to create a relation between the created course and an existing teacher.
The new createTeacher mutation resolver creates a teacher and related courses using nested writes.
The Teacher.courses and Post.teacher resolvers define how to resolve the courses and teacher fields when the Teacher or Post are queried. These use Prisma’s Fluent API to fetch the relations.

🔷 Step 6 — Creating the GraphQL Server

In this step, you will create the GraphQL server with Apollo Server and bind it to a port so that the server can accept connections.

First, run the following command to create the file for the server:

$ touch src/index.js

Now add the following code to the file:

//* node-graphql-lesson-04/src/index.js

const { ApolloServer } = require('apollo-server')
const { typeDefs } = require('./schema')
const { resolvers } = require('./resolvers')

const port = process.env.PORT || 9090;

const server = new ApolloServer({ resolvers, typeDefs });

server.listen({ port }, () => console.log(`Server runs at: http://localhost:${port}`));

Start the server to test the GraphQL API:

$  npm start
$  npm install nodemon -D

Finally, your package.json file looks like:

{
  "name": "node-graphql-lesson-04",
  "version": "1.0.0",
  "description": "Graphql backend with node, prisma, postgres and docker",
  "main": "index.js",
  "scripts": {
    "start": "nodemon src/"
  },
  "keywords": [
    "Graphql",
    "Backend",
    "Prisma",
    "Postgre",
    "Docker",
    "Node.js"
  ],
  "author": "Nditah Sam <nditah@telixia.com>",
  "license": "ISC",
  "dependencies": {
    "@prisma/client": "^2.29.1",
    "apollo-server": "^3.1.2",
    "graphql": "^15.5.1"
  },
  "devDependencies": {
    "nodemon": "^2.0.12",
    "prisma": "^2.29.1"
  }
}

🔷 Step 7 — Testing and Deployment

Test the node-graphql-prisma backend by executing the following GraphQL queries and mutations:

Create Department

 mutation {
  createDepartment(name: "Backend Engineering", description: "Express, ApolloServer, Prisma, Docker, Postgres") {
    id
    name
    description

  }
}

mutation {
  createDepartment(name: "Frontend Development", description: "React, Angular, Vue, Gatsby, CSS, Bootstrap") {
    id
    name
    description
  }
}

### Create Course


mutation CreateCourseMutation($createCourseCode: String!, $createCourseTitle: String!) {
  createCourse(code: $createCourseCode, title: $createCourseTitle) {
    id
    code
    title
    description
    teacher {
      id
      fullName
    }
  }
}

### Create Teacher

mutation CreateTeacherMutation($createTeacherData: TeacherCreateInput!) {
  createTeacher(data: $createTeacherData) {
    id
    fullName
    createdAt
    courses {
      id
      code
      title
    }
  }
}

Notice that you can fetch the teacher whenever the return value of a query is Course. In this example, the Course.teacher resolver will be called.

Finally, commit your changes and push to deploy the API:

$  git add .
$  git commit -m "Feature: Add Teacher, Couse, Department"
$  git push

You have successfully evolved your database schema with Prisma Migrate and exposed the new model in your GraphQL API.
The Github repository of this project can be found here.

Conclusion

Even though this lesson is not meant to compare REST vs. Graphql, it should be highlighted that:

🔷 While GraphQL simplifies data consumption, REST design standards are strongly favoured by many sectors due to cache-ability features, security, tooling community and ultimate reliability. For this reason and its storied record, many web services favour REST design.

🔷 Regardless of their choice, backend developers must understand exactly how frontend users will interact with their APIs to make the correct design choices. Though some API styles are easier to adopt than others, with the right documentation and walk-throughs in place, backend engineers can construct a high-quality API platform that frontend developers will love, no matter what style is used.

💻 📓 📕 📗 📘 📙 📔 📒 📚 📖 💙 💜 💓 💗 💖 💘 💝 🎁 🎊 🎉

How To Build a CRUD RESTful API with Node.js, Prisma, and PostgreSQL in 5 Steps

Nditah — Mon, 09 Aug 2021 19:18:17 +0000

Introduction

Object Relational Mapper (ORM) is a framework that provides layers of abstraction over database to facilitate interacting with data that come from incompatible data sources, and managing queries. In this basic lesson, we see how to build a backend with Node.js, Prisma and a docker instance of PostgreSQL database.

Prisma is an open-source ORM for Nodejs and TypeScript written in Rust. It stands proud amongst other Javascript ORMs like Sequelize, Bookshelf, Waterline, Objection, and TypeORM. It consists of 3 main tools:

🔷 Prisma Client: Auto-generated and type-safe database client
🔷 Prisma Migrate: Declarative data modeling and customizable migrations
🔷 Prisma Studio: A GUI to view and edit data in your database.

These tools aim to increase an application developer’s productivity in their database workflows.

Prisma currently supports PostgreSQL, MySQL, SQLite, SQL Server (preview) and MongoDB (preview).

Prerequisites

To practice this lesson, you need to have the following:

Node.js v10 to v14 is installed on your computer.
PostgreSQL v13 is running which can easily set up with Docker as demonstrated here.
Optionally, VsCode and a nice cup of tea ☕️

Content

Step 1 — Creating Your TypeScript Project
Step 2 — Setting Up Prisma with PostgreSQL
Step 3 — Defining Your Data Model and Creating Database Tables
Step 4 — Exploring Prisma Client Queries in a Plain Script
Step 5 — Implementing Your First REST API Route

The Github repository of this project can be found here.

🕐 Step 1 — Creating Your TypeScript Project

In this step, you will set up a plain TypeScript project using npm. This project will be the foundation for the REST API you’re going to build throughout the lesson.

First, let's create a new directory for the project:

$    mkdir playlist

Next, navigate into the directory and initialize an empty npm project.

$    cd playlist
$    npm init -y

You will have something similar to this:

Wrote to /home/user/Projects/lesson/playlist/package.json:

{
  "name": "playlist",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Next, setup TypeScript in your project by executing the following command:

$    npm install typescript ts-node @types/node -D

This installs three packages as development dependencies in your project:

🔷 typescript: The TypeScript toolchain.
🔷 ts-node: A package to run TypeScript applications without prior compilation to JavaScript.
🔷 @types/node: The TypeScript type definitions for Node.js.

And lastly, add a tsconfig.json file in the playlist directory to ensure TypeScript is properly configured for the project.

playlist/tsconfig.json

{
  "compilerOptions": {
    "sourceMap": true,
    "outDir": "dist",
    "strict": true,
    "lib": ["esnext"],
    "esModuleInterop": true
  }
}

🕐 Step 2 — Setting Up Prisma with PostgreSQL

In this step, you will install the Prisma CLI, create your initial Prisma schema file, and set up PostgreSQL with Docker and connect Prisma to it. The Prisma schema is the main configuration file for your Prisma setup and contains your database schema.

Start by installing the Prisma CLI with the following command:

$    npm install prisma -D

Next, you’ll set up your PostgreSQL database using Docker. Create a new Docker-Compose file with the following command:

$    nano docker-compose.yml

Now add the following code to the newly created file:
playlist/docker-compose.yml

version: '3.8'
services:
  postgres:
    image: postgres:13
    restart: always
    environment:
      - POSTGRES_USER=africa
      - POSTGRES_PASSWORD=village_people
    volumes:
      - postgres:/var/lib/postgresql/data
    ports:
      - '5432:5432'
volumes:
  postgres:

This Docker Compose file configures a PostgreSQL database that can be accessed via port 5432 of the Docker container. Also note that the database credentials are currently set as africa (user name) and village_people (user password). You are free to adjust these credentials to your preferred user and password. Save and exit the file.

With this setup in place, go ahead and launch the PostgreSQL database server with the following command:

$    docker-compose up -d

Hey, it may take a while because the docker image will be pulled and launched, unless you have ran it before. Sip your tea ☕️ now. When it's done, run:

$    docker ps

The output of this command will be similar to this:


CONTAINER ID   IMAGE         COMMAND                  CREATED        STATUS        PORTS                                       NAMES
7621fce68710   postgres:13   "docker-entrypoint.s…"   13 hours ago   Up 13 hours   0.0.0.0:5432->5432/tcp, :::5432->5432/tcp   playlist_postgres_1

With the database server running, you can now create your Prisma setup. Run the following command from the Prisma CLI:

$    npx prisma init

This will print the following output:

✔ Your Prisma schema was created at prisma/schema.prisma
  You can now open it in your favorite editor.

After you ran the command, the Prisma CLI created a new folder called prisma in your project. It contains the following two files:

🔷 schema.prisma
The main configuration file for your Prisma project (will include your data model).

🔷 .env
A dotenv file to define your database connection URL.

To make sure Prisma knows about the location of your database, open the .env file and adjust the DATABASE_URL environment variable.

First open the .env file:

# Set the appropriate value for the Database
DB_HOST=localhost
DB_PORT=5432
DB_SCHEMA=playlist
POSTGRES_USER=africa
POSTGRES_PASSWORD=village_people
POSTGRES_DB=playlist

DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${DB_HOST}:${DB_PORT}/${POSTGRES_DB}?schema=${DB_SCHEMA}&sslmode=prefer

🕐 Step 3 — Defining Your Data Model and Creating Database Tables

In this step, you will define your data model in the Prisma schema file.
This data model will then be mapped to the database with Prisma Migrate, which will generate and send the SQL statements for creating the tables that correspond to your data model.
Since you’re building a playlist application, the main entities of the application will be artists and songs.

Prisma uses its own data modeling language to define the shape of your application data.

First, open your prisma/schema.prisma file with your favourite editor and make these changes:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}


model Artist {
  id    Int     @default(autoincrement()) @id
  email String  @unique
  name  String?
  songs Song[]
}

model Song {
  id        Int     @default(autoincrement()) @id
  title     String
  content   String?
  released Boolean @default(false)
  singer    Artist?   @relation(fields: [singerId], references: [id])
  singerId  Int?
}

You are defining two models, called Artist and Song. Each of these has a number of fields that represent the properties of the model. The models will be mapped to database tables; the fields represent the individual columns.

Also note that there’s a one-to-many relation between the two models, specified by the songs and singer relation fields on Artist and Song. This means that one artist can be associated with many songs.

With these models in place, you can now create the corresponding tables in the database using Prisma Migrate. In your terminal run the following command:

$    npx prisma migrate dev --name "init"

This command creates a new SQL migration on your filesystem and sends it to the database. The output of this command will be similar to this:

Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "playlist", schema "public" at "localhost:5432"

PostgreSQL database playlist created at localhost:5432

The following migration(s) have been created and applied from new schema changes:

migrations/
  └─ 20210810103751_init/
    └─ migration.sql

Your database is now in sync with your schema.

The SQL migration file in the /home/user/Projects/lesson/playlist/prisma/migrations/20210810103751_init/migration.sql directory has the following statements that were executed against the database:

-- CreateTable
CREATE TABLE "Artist" (
    "id" SERIAL NOT NULL,
    "email" TEXT NOT NULL,
    "name" TEXT,

    PRIMARY KEY ("id")
);

-- CreateTable
CREATE TABLE "Song" (
    "id" SERIAL NOT NULL,
    "title" TEXT NOT NULL,
    "content" TEXT,
    "released" BOOLEAN NOT NULL DEFAULT false,
    "singerId" INTEGER,

    PRIMARY KEY ("id")
);

-- CreateIndex
CREATE UNIQUE INDEX "Artist.email_unique" ON "Artist"("email");

-- AddForeignKey
ALTER TABLE "Song" ADD FOREIGN KEY ("singerId") REFERENCES "Artist"("id") ON DELETE SET NULL ON UPDATE CASCADE;

🕐 Step 4 — Exploring Prisma Client Queries in a Plain Script

Prisma Client is an auto-generated and type-safe query builder that you can use to programmatically read and write data in a database from a Node.js or TypeScript application. You will use it for database access within your REST API routes, replacing traditional ORMs, plain SQL queries, custom data access layers, or any other method of talking to a database.

In this step, you will install Prisma Client and get familiar with the queries you can send with it. Before implementing the routes for your REST API in the next steps, you will first explore some of the Prisma Client queries in a plain, executable script.

First, go ahead and install Prisma Client in your project by opening up your terminal and installing the Prisma Client npm package:

$    npm install @prisma/client

Next, create a new directory called src that will contain your source files and create a TypeScript file inside of the new directory:

$    nano src/main.ts

All of the Prisma Client queries return promises that you can await in your code. This requires you to send the queries inside of an async function.

Add the following boilerplate with an async function that’s executed in your script:

// playlist/src/main.ts

import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

async function main() {
  // ... your Prisma Client queries will go here
}

main()
  .catch((e) => console.error(e))
  .finally(async () => await prisma.disconnect())

Here’s a quick breakdown of the boilerplate:

🔷 You import the PrismaClient constructor from the previously installed @prisma/client npm package.
🔷 You instantiate PrismaClient by calling the constructor and obtain an instance called prisma.
🔷 You define an async function called main where you’ll add your Prisma Client queries next.
🔷 You call the main function, while catching any potential exceptions and ensuring Prisma Client closes any open database connections by calling prisma.disconnect().

With the main function in place, you can start adding Prisma Client queries to the script. Adjust index.ts to look as follows:


// playlist/src/main.ts

import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

async function main() {
  const newArtist = await prisma.artist.create({
    data: {
      name: 'Osinachi Kalu',
      email: 'sinach@sinachmusic.com',
      songs: {
        create: {
          title: 'I Know Who I Am',
        },
      },
    },
  })
  console.log('Created new artist: ', newArtist)

  const allArtists = await prisma.artist.findMany({
    include: { songs: true },
  })
  console.log('All artists: ')
  console.dir(allArtists, { depth: null })
}

main()
  .catch((e) => console.error(e))
  .finally(async () => await prisma.$disconnect())

//!  put a dollar-sign between "." and "disconnect"

In this code, you’re using two Prisma Client queries:

create: Creates a new User record. Notice that you’re actually using a nested write, meaning you’re creating both a Artist and Song record in the same query.
findMany: Reads all existing Artist records from the database. You’re providing the include option that additionally loads the related Song records for each Artist record. Now run the script with the following command:

$ npx ts-node src/main.ts

You will receive the following output in your terminal:

Created new artist:  { id: 1, email: 'sinach@sinachmusic.com', name: 'Osinachi Kalu' }
All artists: 
[
  {
    id: 1,
    email: 'sinach@sinachmusic.com',
    name: 'Osinachi Kalu',
    songs: [
      {
        id: 1,
        title: 'I Know Who I Am',
        content: null,
        released: false,
        singerId: 1
      }
    ]
  }
]

Alternatively, you can manipulate the record in the Postgres Database using Prisma Studio by running:

$    npx prisma studio

The output:

Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Prisma Studio is up on http://localhost:5555

Go to the browser at http://localhost:5555 and explore your models. Then hit Ctrl + C to stop Prisma Studio at the terminal or just open a new terminal in the same playlist project directory.

🕐 Step 5 — Implementing Your First REST API Route

In this step, you will install Express in your application. Express is a popular web framework for Node.js that you will use to implement your REST API routes in this project. The first route you will implement will allow you to fetch all artists from the API using a GET request. The artist data will be retrieved from the database using Prisma Client.

Go ahead and install Express with the following command:

$    npm install express

Since you’re using TypeScript, you’ll also want to install the respective types as development dependencies. Run the following command to do so:

$    npm install @types/express -D

Create a new file in the src directory, index.ts and enter the following to start your REST API:


// playlist/src/index.ts

// #1
import { PrismaClient } from '@prisma/client'
import express from 'express'

// #2
const prisma = new PrismaClient()

// #3
const app = express()

// #4
app.use(express.json())

// #5
app.get('/artists', async (req, res) => {
  const artists = await prisma.artist.findMany()
  res.json({
    success: true,
    payload: artists,
    message: "Operation Successful",
  })
})

app.use((req, res, next) => {
    res.status(404);
    return res.json({
      success: false,
      payload: null,
      message: `API SAYS: Endpoint not found for path: ${req.path}`,
    });
  });

// #6
app.listen(3000, () =>
  console.log('REST API server ready at: http://localhost:3000'),
)

Here’s a quick breakdown of the code:

You import PrismaClient and express from the respective npm packages.
You instantiate PrismaClient by calling the constructor and obtain an instance called prisma.
You create your Express app by calling express().
You add the express.json() middleware to ensure JSON data can be processed properly by Express.
You implement your first route by adding the api endpoint between the calls to app.use and app.listen.
You start the server on port 3000.

The output:

REST API server ready at: http://localhost:3000

To test your route, open up a browser to http://localhost:3000.

Alternatively, open new terminal window or tab (so that your local web server can keep running) and execute the following command:

curl http://localhost:3000/artists

You will receive the User data that you created in the previous step:

The output:

{"success":true,"payload":[{"id":1,"email":"sinach@sinachmusic.com","name":"Osinachi Kalu"}],"message":"Operation Successful"}

Step 6 — Implementing the Remaining REST API Routes

In this step, you will implement the remaining REST API routes for your blogging application. At the end, your web server will serve various GET, POST, PUT, and DELETE requests.

Here is an overview of the different routes you will implement:

SN	HTTP Method	Route	Description
1	GET	/playlist	Fetches all released songs.
2	GET	/song/:id	Fetches a specific song by its Id.
3	POST	/artist	Creates a new artist.
4	POST	/song	Creates (or compose) a new song (unreleased)
5	PUT	/song/release/:id	Sets the released field of a song to true.
6	DELETE	/song/:id	Deletes a song by its database record Id.

Next, modify the index.ts file to implement the other API routes:

// playlist/src/index.ts

import { PrismaClient } from '@prisma/client'
import express from 'express'

const prisma = new PrismaClient()
const app = express()
app.use(express.json())

//* 1. Fetches all released songs.
app.get('/playlist', async (req, res) => {
    const songs = await prisma.song.findMany({
        where: { released: true },
        include: { singer: true }
    })
    res.json({
        success: true,
        payload: songs,
    })
})

//* 2. Fetches a specific song by its ID.
app.get(`/song/:id`, async (req, res) => {
    const { id } = req.params
    const song = await prisma.song.findFirst({
        where: { id: Number(id) },
    })
    res.json({
        success: true,
        payload: song,
    })
})

//* 3. Creates a new artist.
app.post(`/artist`, async (req, res) => {
    const result = await prisma.artist.create({
        data: { ...req.body },
    })
    res.json({
        success: true,
        payload: result,
    })
})

//* 4. Creates (or compose) a new song (unreleased)
app.post(`/song`, async (req, res) => {
    const { title, content, singerEmail } = req.body
    const result = await prisma.song.create({
        data: {
            title,
            content,
            released: false,
            singer: { connect: { email: singerEmail } },
        },
    })
    res.json({
        success: true,
        payload: result,
    })
})

//* 5. Sets the released field of a song to true.
app.put('/song/release/:id', async (req, res) => {
    const { id } = req.params
    const song = await prisma.song.update({
        where: { id: Number(id) },
        data: { released: true },
    })
    res.json({
        success: true,
        payload: song,
    })
})

//* 6. Deletes a song by its ID.
app.delete(`/song/:id`, async (req, res) => {
    const { id } = req.params
    const song = await prisma.song.delete({
        where: { id: Number(id) },
    })
    res.json({
        success: true,
        payload: song,
    })
})

//* 7. Fetches all Artist.
app.get('/artists', async (req, res) => {
    const artists = await prisma.artist.findMany()
    res.json({
        success: true,
        payload: artists,
    })
})

app.use((req, res, next) => {
    res.status(404);
    return res.json({
        success: false,
        payload: null,
        message: `API SAYS: Endpoint not found for path: ${req.path}`,
    });
});

// #6
app.listen(3000, () =>
    console.log('REST API server ready at: http://localhost:3000'),
)

You can test the new routes by stopping the server with CTRL + C. Then, restart the server using:

$     npx ts-node src/index.ts

Test the API routes

Fetches all released songs.

$ curl http://localhost:3000/playlist
Fetches a specific song by its ID.

$ curl http://localhost:3000/song/1
Creates a new artist.

curl -X POST -H "Content-Type: application/json" -d '{"name":"Nditah Sam", "email":"contact@telixia.com"}' http://localhost:3000/artist
Creates (or compose) a new song (unreleased)

curl -X POST -H "Content-Type: application/json" -d '{"title":"Take my hand", "singerEmail":"contact@telixia.com"}' http://localhost:3000/song
Sets the released field of a song to true.

curl -X PUT http://localhost:3000/song/release/2
Deletes a song by its database record Id.

curl -X DELETE http://localhost:3000/song/1
Re-query playlist again

curl http://localhost:3000/playlist

Conclusion

In this lesson, you created a REST API server with a number of different routes to create, read, update, and delete Artist and Song data for a sample playlist backend application. Inside of the API routes, you are using the Prisma Client to send the respective queries to your postgres database.

In our next lesson, you will learn How To Build a GraphQL API with Node, Prisma and Postgres.

💻 📓 💝 📕 💓 📗 💖 📘 💗 📙 💜 📔 📒 🎊 📚 📖 💙 🎁 🎉

How To Build a GraphQL API with Node.js, Prisma, Docker and Postgres

Nditah — Mon, 09 Aug 2021 19:15:29 +0000

Introduction

REST (REpresentational State Transfer) is an architectural style for distributed hypermedia systems.
An API is a set of definitions and protocols for building and integrating application software.
Whereas REST is an architectural style, GraphQL is data query and manipulation language for APIs, and a runtime for fulfilling queries with existing data.
GraphQL was developed to solves many of the challeneges of flexibility and efficiency that developers encountered when interacting with RESTful APIs.
GraphQL is not a programming language capable of arbitrary computation, but is instead a language used to make requests to application services that have capabilities defined in this specification.

Prisma is an open-source ORM for Nodejs and TypeScript. In our previous lesson on "How To Build a REST API with Node.js, Prisma ORM, PostgreSQL Database, and Docker" you implemented your first REST API Route. Today, we are going to take a step further to build a Grapghql API with Nodejs, Prisma, and Postgres.

In this lesson, you will use GraphQL and Prisma in combination as their responsibilities complement each other.
You’ll build a GraphQL API for a college management application in JavaScript using Node.js.
You will first use ApolloServer to build the GraphQL API backed by in-memory data structures.

Content

🔷 Step 1 — Creating the Node.js Project

🔷 Step 2 — Defining the GraphQL Schema

🔷 Step 2 — Defining the GraphQL Resolvers

🔷 Step 3 — Creating the GraphQL Server

🔷 Step 4 — Setting Up Prisma with PostgreSQL

🔷 Step 5 — Defining the Data Model with Prisma Migrate

🔷 Step 6 — Using Prisma Client in the GraphQL Resolvers

🔷 Step 7 — Creating and Migrating the PostgreSQL Database in App Platform

🔷 Step 8 — Modifying the Student Model

🔷 Step 9 — Testing

The Github repository of this project can be found here.

Prerequisites

Node.js v10 to v14
Docker installed on your computer (to run the PostgreSQL database locally).
Basic familiarity with Node.js is helpful, but not strictly required for this lesson.

Step 1 — Creating the Node.js Project

In this step, you will set up a Node.js project with npm and install the dependencies apollo-server and graphql.

This project will be the foundation for the GraphQL API that you’ll build and deploy throughout this tutorial.

First, create a new directory for your project:

$ mkdir node-graphql

Next, navigate into the directory and initialize an empty npm project:

cd node-graphql
npm init --yes

This command creates a minimal package.json file that is used as the configuration file for your npm project.

You will receive the following output:

Output
Wrote to /home/Projects/lesson/node-graphql/package.json:
{
  "name": "node-graphql",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

You’re now ready to configure TypeScript in your project.

Execute the following command to install the necessary dependencies:

$ npm install apollo-server graphql

This installs two packages as dependencies in your project:

apollo-server: The HTTP library that you use to define how GraphQL requests are resolved and how to fetch data.
graphql: is the library you’ll use to build the GraphQL schema.

You’ve created your project and installed the dependencies. In the next step you will define the GraphQL schema.

Step 2 — Defining the GraphQL Schema and Resolvers

In this step, you will define the GraphQL schema and corresponding resolvers. The schema will define the operations that the API can handle. The resolvers will define the logic for handling those requests using in-memory data structures, which you will replace with database queries in the next step.

First, create a new directory called src that will contain your source files:

$ mkdir src

Then run the following command to create the file for the schema:

$ touch src/schema.js

Now add the following code to the file:

//* node-graphql/src/schema.js

const { gql } = require('apollo-server')

const typeDefs = gql`

  type Student {
    id: ID!
    email: String!
    fullName: String!
    dept: String
    enrolled: Boolean
  }

  type Query {
    enrollment: [Student!]
    students: [Student!]!
    student(id: ID!): Student
  }

  type Mutation {
    registerStudent(email: String!, fullName: String!, dept: String): Student!
    enroll(id: ID!): Student
  }
`
module.exports = {
  typeDefs,
}

Here you define the GraphQL schema using the gql tagged template. A schema is a collection of type definitions (hence typeDefs) that together define the shape of queries that can be executed against your API. This will convert the GraphQL schema string into the format that Apollo expects. Node the ! sign on id: ID! for example. It means id of type ID cannot be null. Read more from here.

The schema introduces three types:

Student: Defines the type for a student in your college app and contains four fields where each field is followed by its type, for example, String.
Query: Defines the enrollment query which returns multiple students as denoted by the square brackets and the student query which accepts a single argument and returns a single Student.
Mutation: Defines the registerStudent mutation for creating a registering Student and the enroll mutation which accepts an id and returns a Student.

Note that every GraphQL API has a query type and may or may not have a mutation type. These types are the same as a regular object type, but they are special because they define the entry point of every GraphQL query.

Next, create a file database.js in your project src and add the students array to it as shown below:


// node-graphql/src/database.js

const students = [
    {
      id: 1,
      email: 'ada@telixia.com',
      fullName: 'Ada Eze',
      dept: 'Software Engineering',
      enrolled: true,
    },
    {
      id: 2,
      email: 'musa@telixia.com',
      fullName: 'Musa Bashir',
      dept: 'Data Engineering',
      enrolled: true,
    },
    {
      id: 3,
      email: 'ola@telixia.com',
      fullName: 'Omolara Liza',
      dept: 'System Security',
      enrolled: false,
    },
  ]

  module.exports = {
    students,
  }

You define the students array with three pre-defined students. Notice that the structure of each student object matches the Student type you defined in the schema. This array holds the students that will be served by the API. In a subsequent step, you will replace the array once the database and Prisma Client are introduced.

Next, create a file resolver.js in your project src and define the resolvers object. Import the students array to it as shown below:

// node-graphql/src/resolvers.js

const { students } =  require('./database.js');

const resolvers = {

    Student: {
        id: (parent, args, context, info) => parent.id,
        email: (parent) => parent.email,
        fullName: (parent) => parent.fullName,
        dept: (parent) => parent.dept,
        enrolled: (parent) => parent.enrolled,
      },

    Query: {
      enrollment: (parent, args) => {
        return students.filter((student) => student.enrolled)
      },
      student: (parent, args) => {
        return students.find((student) => student.id === Number(args.id))
      },
    },

    Mutation: {
      registerStudent: (parent, args) => {
        students.push({
          id: students.length + 1,
          email: args.email,
          fullName: args.fullName,
          dept: args.dept,
          enrolled: false,
        })
        return students[students.length - 1]
      },
      enroll: (parent, args) => {
        const studentToEnroll = students.find((student) => student.id === Number(args.id))
        studentToEnroll.enrolled = true
        return studentToEnroll
      },
    },

  }


  module.exports = {
    resolvers,
  }

You define the resolvers following the same structure as the GraphQL schema. Every field in the schema’s types has a corresponding resolver function whose responsibility is to return the data for that field in your schema. For example, the Query.enrollment() resolver will return the enrolled students by filtering the students array.

Resolver functions receive four arguments namely: parent, args, context, and info. See a brief explanation below:

parent: The parent is the return value of the previous resolver in the resolver chain. For top-level resolvers, the parent is undefined, because no previous resolver is called. For example, when making a enrollment query, the query.enrollment() resolver will be called with parent’s value undefined and then the resolvers of Student will be called where parent is the object returned from the enrollment resolver.
args: This argument carries the parameters for the query, for example, the student query, will receive the id of the student to be fetched.
context: An object that gets passed through the resolver chain that each resolver can write to and read from, which allows the resolvers to share information.
info: An AST representation of the query or mutation. You can read more about the details in part III of this series: Demystifying the info Argument in GraphQL Resolvers.

Since the context and info are not necessary in these resolvers, only parent and args are defined.

Step 3 — Creating the GraphQL Server

In this step, you will create the GraphQL server with Apollo Server and bind it to a port so that the server can accept connections.

First, run the following command to create the file for the server:

$ touch src/index.js

Now add the following code to the file:

// node-graphql/src/index.js

const { ApolloServer } = require('apollo-server')
const { typeDefs } = require('./schema')
const { resolvers } = require('./resolvers')

const port = process.env.PORT || 9090;

const server = new ApolloServer({ resolvers, typeDefs });

server.listen({ port }, () => console.log(`Server runs at: http://localhost:${port}`));

Here you instantiate the server and pass the imported resolvers and typeDefs from the previous step.

The port the server will bind to is set from the PORT environment variable and if not set, it will default to 9090. The PORT environment variable will be automatically set by App Platform and ensure your server can accept connections once deployed.

Your GraphQL API is ready to run. Start the server with the following command:

$ node src/index.js

You will receive the following output:

Output
Server ready at: http://localhost:9090

It’s considered good practice to add a start script to your package.json so that the entry point to your server is clear. Moreover, this will allow App Platform to start the server once deployed.

To do so, add the following line to the "scripts" object in package.json:

{
  "name": "node-graphql",
  "version": "1.0.0",
  "description": "Grapghql API with Nodejs, Prisma, Postgres and Docker",
  "main": "index.js",
  "scripts": {
    "start":  "node src/"
  },
  "keywords": ["Grapghql", "API", "Node.js", "Prisma", "Postgres", "Docker"],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "apollo-server": "^2.18.2",
    "graphql": "^15.3.0"
  }
}

Now you can start the server with the following command:

$ npm start

To test the GraphQL API, open the URL from the output, which will lead you to the GraphQL Playground.

If you encounter and error like this:

Error: listen EADDRINUSE: address already in use :::9090
    at Server.setupListenHandle [as _listen2] (net.js:1320:16)
    at listenInCluster (net.js:1368:12)
    at Server.listen (net.js:1454:7)
    at /home/peace/Projects/Lesson/node-graphql/node_modules/apollo-server/dist/index.js:74:24
    at new Promise (<anonymous>)
    at ApolloServer.listen (/home/peace/Projects/Lesson/node-graphql/node_modules/apollo-server/dist/index.js:72:15)
Emitted 'error' event on Server instance at:
    at emitErrorNT (net.js:1347:8)
    at processTicksAndRejections (internal/process/task_queues.js:82:21) {
  code: 'EADDRINUSE',
  errno: -98,
  syscall: 'listen',
  address: '::',
  port: 9090
}
npm ERR! code ELIFECYCLE
npm ERR! errno 1
npm ERR! node-graphql@1.0.0 start: `node ./src`
npm ERR! Exit status 1

$ npx kill-port 9090
$ npm start

CLick on Query your server

The GraphQL Playground is an IDE where you can test the API by sending queries and mutations.

For example, to test the enrollment query which only returns enrolled students, enter the following query to the left side of the IDE and send the query by pressing the Run button:

Operation

query ExampleQuery {
  enrollment {
    id
    email
    fullName
    dept
  }
}

Response

{
  "data": {
    "enrollment": [
      {
        "id": "1",
        "email": "ada@telixia.com",
        "fullName": "Ada Eze",
        "dept": "Software Engineering"
      },
      {
        "id": "2",
        "email": "musa@telixia.com",
        "fullName": "Musa Bashir",
        "dept": "Data Engineering"
      }
    ]
  }
}

To test the registerStudent mutation, enter the following mutation:

Operation

mutation {
  registerStudent(
    email: "contact@telixia.com",
    fullName: "Sammy",
    ) {
    id
    email
    fullName
    dept
    enrolled
  }
}

Response

 {
  "data": {
    "registerStudent": {
      "id": "4",
      "email": "contact@telixia.com",
      "fullName": "Sammy",
      "dept": null,
      "enrolled": false
    }
  }
}

Note: You can choose which fields to return from the mutation by adding or removing fields within the curly braces following registerStudent. For example, if you wanted to only return the id and email you could simple omit the fullName, dept and enrolled field.

You have successfully created and tested the GraphQL server. In the next step, you will create a GitHub repository for the project.

Step 4 — Creating the GitHub Repository

In this step, you will create a GitHub repository for your project and push your changes so that the GraphQL API can be automatically deployed from GitHub to any cloud platform of your choice.

Begin by initializing a repository from the prisma-graphql folder:

$ git init

To avoid committing the node_modules folder and the .env file, begin by creating a .gitignore file:

$ touch .gitignore

# .gitignore 
# Specifies intentionally untracked files to ignore when using Git
# http://git-scm.com/docs/gitignore

.vscode/
npm-debug.log*
node_modules/

Next, use the following two commands to commit the code to the repository:

$ git add .
$ git commit -m 'Initial commit'

Now that the changes have been committed to your local repository, you will create a repository in GitHub and push your changes.

Go to GitHub to create a new repository. For consistency, name the repository node-graphql-lesson-03 and then click Create repository.

After the repository was created, push the changes with the following commands, which includes renaming the default local branch to main:

$ git remote add origin git@github.com:<USERNAME>/node-graphql-lesson-03.git
$ git branch -M main
$ git push --set-upstream origin main

You have successfully committed and pushed the changes to GitHub.

Step 6 — Setting Up Prisma with PostgreSQL

So far the GraphQL API you built used the in-memory students array in the database.js file to store data. This means that if your server restarts, all changes to the data will be lost. To ensure that your data is safely persisted, you will replace the database.js with a PostgreSQL database and use Prisma to access the data.

In this step, you will install the Prisma CLI, create your initial Prisma schema, set up PostgreSQL locally with Docker, and connect Prisma to it.

The Prisma schema is the main configuration file for your Prisma setup and contains your database schema.

Begin by installing the Prisma CLI with the following command:

$ npm install prisma -D

The Prisma CLI will help with database workflows such as running database migrations and generating Prisma Client.

Next, you’ll set up your PostgreSQL database using Docker. Create a new Docker Compose file with the following command:

$  touch docker-compose.yml

Now add the following code to the newly created file:


# node-graphql/docker-compose.yml

version: '3.8'
services:
  postgres:
    image: postgres:13
    restart: always
    environment:
      - POSTGRES_USER=db_user
      - POSTGRES_PASSWORD=db_password
    volumes:
      - postgres:/var/lib/postgresql/data
    ports:
      - '5432:5432'
volumes:
  postgres:

With this setup in place, go ahead and launch the PostgreSQL database server with the following command:

$ docker-compose up -d

The Output:

Creating network "node-graphql_default" with the default driver
Creating volume "node-graphql_postgres" with default driver
Creating node-graphql_postgres_1 ... done

You can verify that the database server is running with the following command:

$ docker ps

This will output something similar to:

CONTAINER ID   IMAGE         COMMAND                  CREATED          STATUS          PORTS                                       NAMES
ca2813291692   postgres:13   "docker-entrypoint.s…"   40 seconds ago   Up 35 seconds   0.0.0.0:5432->5432/tcp, :::5432->5432/tcp   node-graphql_postgres_1

With the PostgreSQL container running, you can now create your Prisma setup. Run the following command from the Prisma CLI:

$ npx prisma init

Note that as a best practice, all invocations of the Prisma CLI should be prefixed with npx. This ensures it’s using your local installation.

After running the command, the Prisma CLI created a new folder called prisma in your project. It contains the following two files:

schema.prisma: The main configuration file for your Prisma project (in which you will include your data model).
.env: A dotenv file to define your database connection URL.

To make sure Prisma knows about the location of your database, open the prisma/.env file:

Adjust the DATABASE_URL environment variable to look as follows:

# node-graphql/prisma/.env

DATABASE_URL="postgresql://db_user:db_password@localhost:5432/college_db?schema=public"

Note that you’re using the database credentials db_user and db_password, which are specified in the Docker Compose file. To learn more about the format of the connection URL, visit the Prisma docs.

You have successfully started PostgreSQL and configured Prisma using the Prisma schema. In the next step, you will define your data model for the Student and use Prisma Migrate to create the database schema.

Step 7 — Defining the Data Model with Prisma Migrate

Now you will define your data model in the Prisma schema file you’ve just created. This data model will then be mapped to the database with Prisma Migrate, which will generate and send the SQL statements for creating the tables that correspond to your data model.

Since you’re building a college portal, the main entities of the application will be students, teachers and courses. In this step, you will define a Student model with a similar structure to the Student type in the GraphQL schema. In a later step, you will evolve the app and add a Teacher and Course models.

Note: The GraphQL API can be seen as an abstraction layer for your database. When building a GraphQL API, it’s common for the GraphQL schema to closely resemble your database schema. However, as an abstraction, the two schemas won’t necessarily have the same structure, thereby allowing you to control which data you want to expose over the API. This is because some data might be considered sensitive or irrelevant for the API layer.

Prisma uses its own data modeling language to define the shape of your application data.

Go to node-graphql/prisma/schema.prisma Add the following model definitions to it:

//* node-graphql/prisma/schema.prisma

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Student {
  id       Int     @id @default(autoincrement())
  email    String
  fullName String
  dept     String?
  enrolled Boolean @default(false)
}

You are defining a model called Student with a number of fields. The model will be mapped to a database table; the fields represent the individual columns.

The id fields have the following field attributes:

@default(autoincrement()) : This sets an auto-incrementing default value for the column.
@id: This sets the column as the primary key for the table.

With the model in place, you can now create the corresponding table in the database using Prisma Migrate. This can be done with the migrate dev command that creates the migration files and runs them.

Open up your terminal again and run the following command:

$ npx prisma migrate dev --name "init"

This will output something similar to:

Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "college_db", schema "public" at "localhost:5432"

PostgreSQL database college_db created at localhost:5432

The following migration(s) have been created and applied from new schema changes:

migrations/
  └─ 20210815160400_init/
    └─ migration.sql

Your database is now in sync with your schema.

This command creates a new migration on your file system and runs it against the database to create the database schema. Here’s a quick overview of the options that are provided to the command:

--name "init": Specifies the name of the migration (will be used to name the migration folder that’s created on your file system).
--skip-generate: Skips generating Prisma Client (this will be done in the next step).

Your prisma/migrations directory is now populated with the SQL migration file. This approach allows you to track changes to the database schema and create the same database schema in production.

Note: If you’ve already used Prisma Migrate with the college_db database and there is an inconsistency between the migrations in the prisma/migration folder and the database schema you will be prompted to reset the database with the following output:

Output
? We need to reset the PostgreSQL database "college_db" at "localhost:5432". All data will be lost.
Do you want to continue? › (y/N)
You can resolve this by entering y which will reset the database. Beware that this will cause all data in the database to be lost.

You’ve now created your database schema. In the next step, you will install Prisma Client and use it in your GraphQL resolvers.

Step 8 — Using Prisma Client in the GraphQL Resolvers

Open up your terminal again and install the Prisma Client npm package:

$  npm install @prisma/client

Note: Prisma Client gives you rich auto-completion by generating code based on your Prisma schema to the node_modules folder. To generate the code you use the npx prisma generate command. This is typically done after you create and run a new migration. On the first install, however, this is not necessary as it will automatically be generated for you in a postinstall hook.

With the database and GraphQL schema created, and Prisma Client installed, you will now use Prisma Client in the GraphQL resolvers to read and write data in the database. You’ll do this by replacing the content of the database.js, which you’ve used so far to hold your data.

//* node-graphql/src/database.js

const { PrismaClient } = require('@prisma/client')

const prisma = new PrismaClient();

module.exports = {
  prisma,
}

Now you will update the Query resolvers to fetch enrolled students from the database. Update the resolvers.Query object with the following resolvers:

//* node-graphql/src/resolvers.js


const resolvers = {
  Query: {
    enrollment: (parent, args) => {
      return prisma.student.findMany({
        where: { enrolled: true },
      });
    },
    student: (parent, args) => {
      return prisma.student.findFirst({
        where: { id: Number(args.id) },
      });
    },
  },

Here, you’re using two Prisma Client queries:

findMany: Fetches students whose enrolled field is false.
findOne: Fetches a single student whose id field equals the id GraphQL argument.

Note, that as per the GraphQL specification, the ID type is serialized the same way as a String. Therefore you convert to a Number because the id in the Prisma schema is an int.

Next, you will update the Mutation resolver to save and update students in the database. Update the resolvers.Mutation Object with the following resolvers:


//* node-graphql/src/resolvers.js



const resolvers = {
  ...
  Mutation: {
    registerStudent: (parent, args) => {
      return prisma.student.create({
        data: {
          email: args.email,
          fullName: args.fullName,
        },
      });

    },
    enroll: (parent, args) => {
      return prisma.student.update({
        where: {
          id: Number(args.id),
        },
        data: {
          enrolled: true,
        },
      });
    },
  },
}

Final resolvers.js looks like this:

//* node-graphql/src/resolvers.js

const { prisma } = require("./database.js");

const Student = {
  id: (parent, args, context, info) => parent.id,
  email: (parent) => parent.email,
  fullName: (parent) => parent.fullName,
  dept: (parent) => parent.dept,
  enrolled: (parent) => parent.enrolled,
};

const Query = {
  enrollment: (parent, args) => {
    return prisma.student.findMany({
      where: { enrolled: true },
    });
  },
  students: (parent, args) => {
    return prisma.student.findMany({});
  },
  student: (parent, args) => {
    return prisma.student.findFirst({
      where: { id: Number(args.id) },
    });
  },
};

const Mutation = {
  registerStudent: (parent, args) => {
    return prisma.student.create({
      data: {
        email: args.email,
        fullName: args.fullName,
        dept: args.dept,
      },
    });
  },
  enroll: (parent, args) => {
    return prisma.student.update({
      where: { id: Number(args.id) },
      data: {
        enrolled: true,
      },
    });
  },
};

const resolvers = { Student, Query, Mutation };

module.exports = {
  resolvers,
};

You’re using two Prisma Client queries:

create: Create a Student record.
update: Update the enrolled field of the Student record whose id matches the one in the query argument.

Now that you’ve updated the resolvers to use Prisma Client, start the server to test the flow of data between the GraphQL API and the database with the following command:

$ npm start

Open the GraphQL playground at the address from the output and test the GraphQL API using the same queries from Step 3.

Then run the following two commands to commit the changes:

$  git add .
$  git commit -m 'Feature: Add Prisma'
$  git push

Run the migrations against the database with Prisma Migrate.

$ npx prisma migrate dev

Testing

Create Student

mutation {
  registerStudent(email: "Olivia@telixia.com", fullName: "Olivia Catherine", dept: "Backend Engineer") {
    id
    fullName
    dept
    email
    enrolled

  }
}

Result

{
  "data": {
    "registerStudent": {
      "id": "2",
      "fullName": "Olivia Catherine",
      "dept": "Backend Engineer",
      "email": "Olivia@telixia.com",
      "enrolled": false
    }
  }
}

Enroll Student

mutation {
  enroll(id: 2) {
    id
    fullName
    email
    dept
    enrolled
  }
}

Result

{
  "data": {
    "enroll": {
      "id": "2",
      "fullName": "Olivia Catherine",
      "email": "Olivia@telixia.com",
      "dept": "Backend Engineer",
      "enrolled": true
    }
  }
}

Query

query Query {
  enrollment {
    id
    email
    fullName
    dept
    enrolled
  }
}

Result

{
  "data": {
    "enrollment": [
      {
        "id": "1",
        "email": "felix@telixia.com",
        "fullName": "Musah Felix",
        "dept": null,
        "enrolled": true
      },
      {
        "id": "2",
        "email": "Olivia@telixia.com",
        "fullName": "Olivia Catherine",
        "dept": "Backend Engineer",
        "enrolled": true
      }
    ]
  }
}

Conclusion

Congratulations! You have completed the first part of Node Backend with Graphql and Prisma.
You will discover the full advantage in a more advance backend application with more than two models having a relationship.
A good example is having not only student, but also Teacher, Department, Courses Models added to our application.

💻 📓 💝 📕 💓 📗 💖 📘 💗 📙 💜 📔 📒 🎊 📚 📖 💙 🎁 🎉

Happy Reading & Coding

💻 📓 📕 📗 📘 📙 📔 📒 📚 📖 💙 💜 💓 💗 💖 💘 💝 🎁 🎊 🎉

DEV Community: Nditah

Generative AI in the Movie Industry

A Symphony of Human and Machine Creativity

How to Setup Nodejs Mongodb in Production server on Ubuntu 18.04 in AWS, GCP, Azure, Digital Ocean Cloud Instance or Locally

Send SMS Messages with Node.js using the Vonage API

Send SMS Messages with Node.js using the Vonage API

Step 1: Initialize Your Project

Step 2: Create two files

Step 3: get and Set your Vonage API Credentials

Step 4: Configure Sender Virtual Number or Register Recipient Test Number

To get Your Number, click here

To get Test Numbers, click here

Step 5: Finally, run your nodejs express application

POST Request:

POST Response:

Develop a Simple Python Django ToDo App in 1 minute

Hello-Django

templates/base.html

📚 Sam's other blogs

Develop a Simple Python FastAPI ToDo App in 1 minute

FastApi-App

app.py

models.py

database.py

templates/base.html

Develop a Simple Python Flask ToDo App in 1 minute

Flask-App

app.py

templates/base.html

How To Build a GraphQL API with Apollo-Server and Prisma

Introduction

Content

Prerequisites

🔷 Step 1 — Creating the Node.js Project

🔷 Step 2 — Setting Up Prisma with PostgreSQL

🔷 Step 3 — Creating and Migrating the Database with Prisma

🔷 Step 4 — Defining the GraphQL Schema

🔷 Step 5 — Defining the GraphQL Resolvers

🔷 Step 6 — Creating the GraphQL Server

🔷 Step 7 — Testing and Deployment

Create Department

Conclusion

Further Reading

💻 📓 📕 📗 📘 📙 📔 📒 📚 📖 💙 💜 💓 💗 💖 💘 💝 🎁 🎊 🎉

How To Build a CRUD RESTful API with Node.js, Prisma, and PostgreSQL in 5 Steps

Introduction

Prerequisites

Content

🕐 Step 1 — Creating Your TypeScript Project

🕐 Step 2 — Setting Up Prisma with PostgreSQL

🕐 Step 3 — Defining Your Data Model and Creating Database Tables

🕐 Step 4 — Exploring Prisma Client Queries in a Plain Script

🕐 Step 5 — Implementing Your First REST API Route

Test the API routes

Conclusion

Further Reading

💻 📓 💝 📕 💓 📗 💖 📘 💗 📙 💜 📔 📒 🎊 📚 📖 💙 🎁 🎉

How To Build a GraphQL API with Node.js, Prisma, Docker and Postgres

Introduction

Content

Prerequisites

Step 1 — Creating the Node.js Project

Step 2 — Defining the GraphQL Schema and Resolvers

Step 3 — Creating the GraphQL Server

Step 4 — Creating the GitHub Repository

Step 6 — Setting Up Prisma with PostgreSQL

Step 7 — Defining the Data Model with Prisma Migrate

Step 8 — Using Prisma Client in the GraphQL Resolvers

Testing

Create Student

Enroll Student

Query

Conclusion

Further Reading

💻 📓 💝 📕 💓 📗 💖 📘 💗 📙 💜 📔 📒 🎊 📚 📖 💙 🎁 🎉

💻 📓 📕 📗 📘 📙 📔 📒 📚 📖 💙 💜 💓 💗 💖 💘 💝 🎁 🎊 🎉