DEV Community: Arjun Tripathi

How to Choose the Right Authentication Method for Your Backend

Arjun Tripathi — Wed, 06 Aug 2025 03:35:40 +0000

Introduction

In today’s digital landscape, security is no longer optional—it’s essential. At the heart of security lies authentication, the first gatekeeper to your app or service.

Choosing the right authentication method isn’t just about security—it’s about user experience, scalability, and future-proofing your system. Whether you’re building a mobile app, a web dashboard, or a B2B SaaS platform, picking the wrong auth flow can cost you users—or worse, leave you vulnerable to attacks.

In this guide, we’ll explore popular backend authentication methods—OAuth, OTP, and Magic Links—and help you decide which one (or combination) fits your app best.

What Is Authentication?

Before diving in, let’s clarify a common confusion:

Authentication: Proving who you are.
Authorization: Deciding what you're allowed to do.

They go hand in hand—but in this blog, we focus on authentication.

There are two major schools of thought:

Password-based authentication: The classic “email + password” combo.
Passwordless authentication: Logging in without a password—via a code, link, or third-party identity provider.

With data breaches on the rise and users overwhelmed by passwords, passwordless is gaining traction fast.

OAuth (Open Authorization)

What is OAuth?

OAuth is a protocol that lets users log in using another service (like Google, Facebook, GitHub), without giving your app their password. It also allows apps to access user data (like profile info or contacts) from other platforms securely.

How OAuth Works (Simplified Flow)

User clicks “Login with Google”
Redirects to Google login page
User logs in and consents to data sharing
Google sends your app a secure token
Your backend verifies the token and grants access

There are two common OAuth flows:

Authorization Code Flow – for web apps
PKCE (Proof Key for Code Exchange) – for mobile apps and SPAs

Pros:

High security (tokens, scopes, expirations)
No password handling needed
Users trust familiar platforms

Cons:

Complex to implement and debug
Relies on third-party services (if Google is down, login fails)

When to Use:

Apps that support social login
Microservices or API systems
Third-party integrations (e.g., pulling data from Google APIs)

OTP (One-Time Password)

What is OTP?

OTP is a time-sensitive, single-use code sent to the user—usually via SMS, email, or an authenticator app—used to verify identity.

Types of OTP:

SMS OTP
Email OTP
Call OTP
Authenticator apps (e.g., Google Authenticator, Authy)

Pros:

Familiar to users
Works well for MFA (multi-factor authentication)
Doesn’t require remembering passwords

Cons:

Susceptible to SIM-swapping, phishing, and email interception
Can cause friction (users waiting for the code)
Relies on third-party delivery systems

When to Use:

2FA (in addition to passwords or OAuth)
Passwordless login
Time-limited verifications, like during sign-up or sensitive actions

Magic Links (Verification Links)

What is a Magic Link?

A magic link is a one-time-use, time-sensitive URL sent to the user’s email. Clicking it logs them in—no password, no code.

How It Works:

User enters email
App sends a login link with a token
User clicks the link → Authenticated!

Pros:

Extremely simple for users
Great for onboarding and re-engagement
Secure if implemented properly (short lifespan, single-use tokens)

Cons:

Email delivery delays can hurt UX
Risky if links are reused or not time-bound
Phishing risks if users aren’t trained

When to Use:

Low-risk applications
One-click login flows
Onboarding or email verification

Security Comparison

Method	Security Level ⭐	Ease of Use 😊	Best Use Case
OAuth	⭐⭐⭐⭐☆	Medium	Social login, third-party APIs
OTP	⭐⭐⭐☆☆	High	2FA, passwordless, sensitive actions
Magic Link	⭐⭐☆☆☆	Very High	Onboarding, quick sign-ins

Other security considerations:

Token expiration (short-lived = safer)
Replay attacks (OTP/Magic Links should be single-use)
MITM risks (use HTTPS, validate tokens)
Rate-limiting to avoid brute-force attempts

Choosing the Right One

Ask yourself:

Is this a web, mobile, or API-based app?
Are you B2C (mass users) or B2B (fewer, high-value users)?
How sensitive is the data involved?
What is your user’s tolerance for login friction?
Do you need third-party integrations?

App Type	Suggested Auth
Consumer Mobile	OAuth (social) + OTP (MFA)
Admin Dashboard	Magic Link + OTP
SaaS B2B	Email/password + OAuth (Google Workspace)
Public API	OAuth (client credentials or token flow)

Combining Methods

No rule says you must choose just one.

Real-world examples:

Google uses OAuth for login, but asks for OTP on suspicious activity
Slack allows login via magic link, but also supports Google OAuth
Banking apps often use passwords + OTP + device binding

Combining methods lets you balance security with user convenience.

Conclusion

There’s no universal “best” authentication method. The right one depends on:

Your application’s risk profile
User expectations
Technical constraints
Regulatory requirements

Authentication is the front door to your app—make sure it's not a revolving door or a brick wall.

When in doubt, start simple, follow best practices (like OWASP’s guidelines), and iterate based on real user behavior and security audits.

Bonus: Developer Resources

OWASP Authentication Cheat Sheet
OAuth 2.0 Flows Explained
Example Code:
- Magic Link Auth in Node.js
- OTP Auth with Django + Twilio

Tips:

Use diagrams to illustrate auth flows (OAuth steps, OTP loop, Magic Link lifecycle).
Add code snippets for real implementation.
Include links to libraries or tools (e.g., Firebase Auth, Auth0, Passport.js).

Segment Tree

Arjun Tripathi — Wed, 18 Jun 2025 10:41:07 +0000

A Segment Tree is a data structure that stores information about array intervals as a tree. This allows answering range queries over an array efficiently, while still being flexible enough to allow quick modification of the array. This includes finding the sum of consecutive array elements a[l... r], or finding the minimum element in a such a range in O(log n) time. Between answering such queries, the Segment Tree allows modifying the array by replacing one element, or even changing the elements of a whole subsegment (e.g. assigning all elements a[l...r] to any value, or adding a value to all element in the subsegment).

Use-case:

You are given an array A[], and you want to perform:

Range queries: e.g., find the sum, minimum, or maximum in a subrange A[l...r].
Point updates: change a value at a specific index.

Why Segment Tree is Needed?

Let's say:

You have an array of size n.
You need to perform multiple range queries (O(n) each) and updates.

Brute Force:
- Query time: O(n)
- Update time: O(1)
Segment Tree:
- Query time: O(log n)
- Update time: O(log n)
- Build time: O(n)

This is why Segment Trees are preferred when both range queries and updates are involved.

Structure of Segment Tree

It's a binary tree.
Each node represents a range (segment).
The root represents the entire range.
Leaves represent individual elements.,

Let’s say the array is:
A = [2, 4, 5, 7, 8, 9]

The segment tree for sum might look like this:

                [0,5]
              /       \
          [0,2]       [3,5]
         /    \       /   \
     [0,1]  [2,2]  [3,4] [5,5]
     /   \
  [0,0] [1,1]

Each node stores the sum of the range it represents.

How to Implement a Segment Tree?

Here's a complete Segment Tree implementation in C++ for:

Building the segment tree
Querying the sum in a range
Updating a single element

Problem:
Given an array arr[], build a segment tree that supports:

update(idx, val) → Update the element at index idx to val
query(l, r) → Return the sum in the range [l, r]

Creation of Segment Tree

Segment tree implemented with nodes and pointers (like your original code), and
Segment tree implemented using arrays (like the one I just showed you).

Here’s a clear breakdown of the key differences:

1. Segment Tree with Nodes and Pointers

Data structure: Uses a tree made up of Node objects, each having pointers to its left and right children.
Memory: Uses dynamic memory allocation (new), creating many small objects (nodes).
Code complexity: More verbose and complex to write because you manage nodes and pointers.
Flexibility: Easier to extend to more complex trees, e.g., when nodes need to store additional info or structure (like persistent segment trees).
Navigation: Navigates using pointers (e.g., node->left), which may be less cache-friendly.
Usage: Often used when you want a conceptual tree structure or advanced versions (like persistent segment trees or when intervals are not contiguous).

2. Segment Tree Using Arrays

Data structure: Uses a single large array (often of size 4*n), where the segment tree nodes are stored in array indices.
Memory: All nodes are stored contiguously in one array, better cache locality, no dynamic allocation per node.
Code complexity: Simpler and shorter code, usually faster to implement.
Navigation: Uses index arithmetic: for node at index i, left child is at 2*i, right child at 2*i+1.
Efficiency: Faster due to better cache performance and less overhead from pointer chasing.
Usage: Common in competitive programming and when the tree size is fixed and known upfront.

Summary Table

Aspect	Node-based Implementation	Array-based Implementation
Data Structure	Nodes with pointers	Single array
Memory Allocation	Dynamic (per node)	Static (one big array)
Code Complexity	More complex, verbose	Simpler, shorter
Performance	Slightly slower due to pointers	Faster due to cache locality
Flexibility	Easier for persistent/complex trees	Limited to fixed-size, simpler trees
Use Cases	Advanced segment trees, non-contiguous intervals	Most segment tree problems, competitive programming

When to use which?

Use array-based if:
- You have a fixed size array and want a clean, fast segment tree for sums, min, max, etc.
- You want simple and efficient code for competitive programming.
Use node-based if:
- You need complex or persistent segment trees.
- You want to handle dynamic intervals or advanced operations that benefit from explicit tree structure.

1. Node-Pointer Based Segment Tree

Structure: Uses explicit Node objects with pointers to left and right children.
Memory: Dynamic allocation; each node stores interval and data.
Pros: Easy to extend for complex trees (persistent segment trees, dynamic intervals).
Cons: Pointer overhead, less cache-friendly, more verbose code.

#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    int start_interval, end_interval;
    Node* lchild;
    Node* rchild;

    Node(int start, int end, int val = 0) {
        start_interval = start;
        end_interval = end;
        data = val;
        lchild = rchild = nullptr;
    }
};

class Segment_Tree {
private:
    Node* construct_tree(vector<int>& arr, int left, int right) {
        if (left == right)
            return new Node(left, right, arr[left]);

        Node* node = new Node(left, right);
        int mid = (left + right) / 2;
        node->lchild = construct_tree(arr, left, mid);
        node->rchild = construct_tree(arr, mid + 1, right);
        node->data = node->lchild->data + node->rchild->data;
        return node;
    }

    int query_range(Node* node, int l, int r) {
        if (!node || l > node->end_interval || r < node->start_interval)
            return 0;  // no overlap

        if (l <= node->start_interval && r >= node->end_interval)
            return node->data;  // total overlap

        // partial overlap
        return query_range(node->lchild, l, r) + query_range(node->rchild, l, r);
    }

    void update_point(Node* node, int idx, int new_val) {
        if (!node || idx < node->start_interval || idx > node->end_interval)
            return;

        if (node->start_interval == node->end_interval) {
            node->data = new_val;
            return;
        }

        update_point(node->lchild, idx, new_val);
        update_point(node->rchild, idx, new_val);

        node->data = node->lchild->data + node->rchild->data;
    }

public:
    Node* root;

    Segment_Tree(vector<int>& arr) {
        root = construct_tree(arr, 0, arr.size() - 1);
    }

    int query(int l, int r) {
        return query_range(root, l, r);
    }

    void update(int idx, int val) {
        update_point(root, idx, val);
    }
};


int main(){
    int n,q;
    cin >> n >> q;

    vector<int> arr(n);

    for(int i=0;i<n;i++)
        cin >> arr[i];

    Segment_Tree s(arr);

    for(int i = 0 ; i < q ; i++){
        int c,l,r;

        cin >> c >> l >> r;

        if(c == 1){
            s.update(l-1, r);
        }else{
            cout << s.query(l-1, r-1) << endl;
        }
    }
    return 0;
}

2. Array-Based Segment Tree

Structure: Uses a single array tree of size roughly 4*n.
Memory: Contiguous memory, better cache locality.
Pros: Simple, fast, common in competitive programming.
Cons: Less flexible for dynamic/persistent trees.

#include <bits/stdc++.h>
using namespace std;

class SegmentTree {
private:
    vector<int> tree;
    int n;

    void build(vector<int>& arr, int idx, int left, int right) {
        if (left == right) {
            tree[idx] = arr[left];
            return;
        }
        int mid = (left + right) / 2;
        build(arr, 2*idx, left, mid);
        build(arr, 2*idx+1, mid+1, right);
        tree[idx] = tree[2*idx] + tree[2*idx+1];
    }

    int query(int idx, int left, int right, int ql, int qr) {
        if (ql > right || qr < left)  // no overlap
            return 0;
        if (ql <= left && right <= qr)  // total overlap
            return tree[idx];
        int mid = (left + right) / 2;
        return query(2*idx, left, mid, ql, qr) + query(2*idx+1, mid+1, right, ql, qr);
    }

    void update(int idx, int left, int right, int pos, int val) {
        if (left == right) {
            tree[idx] = val;
            return;
        }
        int mid = (left + right) / 2;
        if (pos <= mid)
            update(2*idx, left, mid, pos, val);
        else
            update(2*idx+1, mid+1, right, pos, val);
        tree[idx] = tree[2*idx] + tree[2*idx+1];
    }

public:
    SegmentTree(vector<int>& arr) {
        n = (int)arr.size();
        tree.resize(4*n, 0);
        build(arr, 1, 0, n-1);
    }

    int query(int l, int r) {
        return query(1, 0, n-1, l, r);
    }

    void update(int pos, int val) {
        update(1, 0, n-1, pos, val);
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, q;
    cin >> n >> q;

    vector<int> arr(n);
    for (int i = 0; i < n; i++)
        cin >> arr[i];

    SegmentTree s(arr);

    while (q--) {
        int c, l, r;
        cin >> c >> l >> r;
        if (c == 1) {
            // update position l-1 with value r
            s.update(l - 1, r);
        } else {
            // query sum in range [l-1, r-1]
            cout << s.query(l - 1, r - 1) << "\n";
        }
    }
    return 0;
}

Comparison Summary

Feature	Node-Pointer Tree	Array-Based Tree
Data Structure	Tree of Node objects (pointers)	Single large array
Memory Usage	Dynamic, more overhead for pointers	Contiguous memory, cache-friendly
Code Complexity	More verbose and explicit	Simpler, shorter
Flexibility	Supports advanced trees (persistent, dynamic intervals)	Mostly static size
Performance	Slightly slower due to pointer chasing	Faster due to cache locality
Common Usage	Complex problems, persistent segment trees	Competitive programming, simple use cases

Key Notes

Function	Description
build	Build the segment tree from the array
queryUtil	Recursive helper for range sum query
updateUtil	Recursive helper for point update
query(l, r)	Public method to query sum in range `[l,r]`
update(i, v)	Public method to update index `i` to value `v`

Additional Code link of GitHub - https://github.com/mearjuntripathi/Data_Structure_Algorithm/tree/main/Tree/Binary%20Tree/SegmentTree

Differences between Node.js and Golang (Go) from the perspective of an experienced developer.

Arjun Tripathi — Wed, 09 Apr 2025 07:31:51 +0000

Certainly! Let's break down the differences between Node.js and Golang (Go) from the perspective of an experienced developer, covering their origins, design philosophies, performance, use cases, and more—just like a human conversation.

1. Origins & Background

Node.js

Birth: Created by Ryan Dahl in 2009.
Purpose: To enable JavaScript (traditionally a browser language) to run on the server.
Runtime: Built on Chrome’s V8 engine (same JS engine that powers Google Chrome).
Philosophy: "JavaScript everywhere" – unify frontend & backend development under one language.

Golang (Go)

Birth: Created by Google (Rob Pike, Ken Thompson, Robert Griesemer) in 2009 (public release in 2012).
Purpose: To replace slow, complex languages (like C++/Java) with a simple, fast, and reliable language for large-scale systems.
Philosophy: "Less is more" – minimal syntax, no inheritance, built for concurrency and scalability.

2. Language & Syntax

Node.js, being a JavaScript runtime, follows an event-driven, asynchronous, and prototype-based paradigm, making it ideal for I/O-heavy operations. JavaScript (and TypeScript) is dynamically typed, though TypeScript adds optional static typing. Error handling relies on callbacks, Promises, or async/await, which can lead to callback hell if not managed properly. Concurrency in Node.js is single-threaded (due to the Event Loop), though Worker Threads help with CPU-heavy tasks. The learning curve is gentle for JS developers, but managing async flows can be tricky.

Golang, on the other hand, is imperative and procedural, with minimal OOP (no classes, just structs and interfaces). It’s statically typed, enforcing strict type checks at compile time. Error handling is explicit—functions return errors that must be checked (if err != nil). Its biggest strength is goroutines, lightweight threads managed by the Go runtime, making concurrency effortless. The syntax is simple and strict, which reduces ambiguity but can feel restrictive to those used to dynamic languages.

3. Performance & Scalability

Node.js is fast for I/O-bound tasks due to its non-blocking Event Loop, but it struggles with CPU-heavy workloads since JavaScript is single-threaded. While V8 optimizations make it quick, memory usage is higher due to the JS runtime overhead.

Golang, being a compiled language, runs closer to the metal, offering better raw performance. Its goroutines handle thousands of concurrent tasks efficiently, making it ideal for scalable, high-load systems. Unlike Node.js, Go excels at CPU-bound tasks thanks to native multithreading. Memory usage is lower and more predictable, making it a better choice for resource-intensive applications.

4. Ecosystem & Tooling

Node.js has the largest package ecosystem (npm/yarn), but this comes with dependency bloat and node_modules chaos. Its standard library is decent, but most functionality comes from third-party packages. Tooling (Webpack, Babel, ESLint) is powerful but complex, requiring significant configuration.

Golang’s ecosystem is leaner but more robust. It uses go mod for dependency management, avoiding the infamous node_modules problem. The standard library is extensive, covering HTTP, encryption, and testing without needing external packages. Tooling is built-in and opinionated—go fmt enforces consistent formatting, go vet catches errors, and go test simplifies testing. Deployment is a breeze since Go compiles to a single binary with no runtime dependencies.

5. Use Cases – Where Each Shines

Node.js is better for:

Real-time apps (Chat, Gaming, Websockets)
APIs & Microservices (Express, Fastify, NestJS)
Serverless & Lambdas (AWS Lambda, Vercel)
Full-stack JS apps (Next.js, Remix)

Golang is better for:

High-performance backends (Cloud infra, Databases)
CLI tools & DevOps (Docker, Kubernetes, Terraform)
Network-heavy apps (Proxies, Crawlers)
System programming (Low-level control like C, but safer)

6. Developer Experience (DX)

Node.js:
- Pros: Huge community, easy prototyping, rich npm packages.
- Cons: Callback hell (mitigated by async/await), dependency bloat.
Golang:
- Pros: Blazing fast compilation, no hidden behaviors, great for teams.
- Cons: Less flexible (no generics until Go 1.18), fewer web frameworks.

7. The Future

Node.js: Still dominant in web dev, but faces competition from Deno/Bun.
Golang: Growing in cloud-native development (K8s, Docker, Cloudflare).

Final Verdict – Which One Should You Choose?

Choosing between Node.js and Golang depends on your project’s needs, team expertise, and long-term goals. Here’s a clear breakdown to help you decide:

✅ Pick Node.js If...

You’re building a web application, API, or real-time service (e.g., chat apps, streaming, collaborative tools).
You want full-stack JavaScript/TypeScript (same language for frontend & backend).
You need a massive ecosystem (npm has packages for almost everything).
Your workload is I/O-heavy (database calls, network requests).
You prefer rapid prototyping and developer-friendly tooling.

Best for: Startups, SaaS products, serverless functions, and teams already skilled in JavaScript.

✅ Pick Golang If...

You need raw performance, scalability, and efficient concurrency.
You’re working on cloud-native apps, microservices, or distributed systems.
You’re building CLI tools, DevOps utilities, or networking software (e.g., proxies, scrapers).
You want predictable memory usage and low-latency execution.
You prefer a simple, strict, and maintainable codebase (great for large teams).

Best for: High-performance backends, cloud infrastructure (Kubernetes, Docker), fintech, and systems programming.

Bonus: When Might You Use Both?

Some modern architectures combine Node.js for the API gateway/user-facing layer (leveraging its rich ecosystem) and Golang for heavy backend processing (where performance is critical).

Final Thoughts

Node.js = Speed of development + JavaScript everywhere.
Golang = Speed of execution + Scalability for demanding workloads.

Both are fantastic—just different tools for different jobs! 🚀

Want More Tech Insights?

If you'd like deeper comparisons (e.g., Node.js vs. Go in microservices, serverless, or WebAssembly), or want to explore other tech battles (Rust vs. Go? Python vs. Node.js?), drop a comment! Let’s geek out together. 🔥

What’s your next project? Which one are you leaning toward—and why? Let’s discuss! 💬

Upload Files on Drive With Node.js

Arjun Tripathi — Sat, 09 Nov 2024 10:06:41 +0000

In situations where storage limitations become a concern, exploring alternative solutions becomes essential. Suppose you're utilizing platforms like GitHub or Versal for hosting frontend applications, which offer restricted storage space, typically around 2GB. In such scenarios, leveraging Google Drive for storing files can be a viable option.

By integrating Google Drive with your Node.js applications, you can harness the robust storage capabilities of Google Cloud. This documentation aims to provide a concise guide on utilizing Google Drive in conjunction with Node.js to manage files efficiently.

Prerequisites

Before embarking on the integration process, ensure you have the following prerequisites in place:

A Google account with access to the Google Cloud Console.
Node.js installed on your local machine.
NPM (Node Package Manager) installed.

Step 1: Set Up Google Cloud Console and Enable Google Drive API

Go to the Google Cloud Console.
Create a new project.
Navigate to "APIs & Services" > "Library".
Search for "Google Drive API" and enable it.

Step 2: Obtain Service Account Credentials

Navigate to "APIs & Services" > "Credentials".
Create a new Service Account.
Download the JSON file with the credentials.

Step 3: Install Necessary Packages

Install the required packages using NPM. This includes the 'googleapis' package, which facilitates interaction with Google APIs.

npm install googleapis

Step 4: Implement File Management Functions
Utilize the provided code snippets to implement various file management functionalities, including:

Listing available files in Google Drive.
Uploading files to Google Drive.
Updating existing files in Google Drive.
Deleting files from Google Drive.
for that you should use folder_id and make it public and editable

Step 5: Start the project

Execute the Node.js application to perform file management operations on Google Drive. Ensure to replace placeholders such as 'FOLDER_ID_HERE' with relevant IDs and file paths. For geting folder id of drive folder we do this.

Let' Code

first we import all necessary libararies

const fs = require('fs');
const { google } = require('googleapis');

// Load API credentials from JSON file
const apikeys = require('FOLDER_ID_HERE');  // Replace 'FOLDER_ID_HERE' with the downloaded api file path

Function to authorize and get access to Google Drive API

// Define the scope for Google Drive API
const SCOPES = ['https://www.googleapis.com/auth/drive'];

// Function to authorize and get access to Google Drive API
async function authorize() {
    const auth = new google.auth.JWT(
        apikeys.client_email,
        null,
        apikeys.private_key,
        SCOPES
    );

    try {
        await auth.authorize();
        return auth;
    } catch (error) {
        throw new Error(`Error authorizing Google Drive API: ${error.message}`);
    }
}

Write a function for get all available file on that drive folder

// Function to list available files in Google Drive
async function listFiles(auth) {
    const drive = google.drive({ version: 'v3', auth });

    try {
        const response = await drive.files.list({
            pageSize: 10,
            fields: 'nextPageToken, files(id, name)',
        });

        const files = response.data.files;
        if (files.length) {
            console.log('Available files:');
            files.forEach(file => {
                console.log(`${file.name} (${file.id})`);
            });
        } else {
            console.log('No files found.');
        }
    } catch (error) {
        throw new Error(`Error listing files in Google Drive: ${error.message}`);
    }
}

Write a function to upload file on drive folder

// Function to upload a file to Google Drive
async function uploadFile(auth, filePath, folderId) {
    const drive = google.drive({ version: 'v3', auth });

    const fileMetadata = {
        name: filePath.split('/').pop(), // Extract file name from path
        parents: [folderId] // Folder ID to upload the file into
    };

    const media = {
        mimeType: 'application/octet-stream',
        body: fs.createReadStream(filePath) // Readable stream for file upload
    };

    try {
        const response = await drive.files.create({
            resource: fileMetadata,
            media: media,
            fields: 'id'
        });

        console.log('File uploaded successfully. File ID:', response.data.id);
        return response.data;
    } catch (error) {
        throw new Error(`Error uploading file to Google Drive: ${error.message}`);
    }
}

Function to delete file to folder

// Function to delete a file from Google Drive
async function deleteFile(auth, fileId) {
    const drive = google.drive({ version: 'v3', auth });

    try {
        await drive.files.delete({
            fileId: fileId
        });

        console.log('File deleted successfully.');
    } catch (error) {
        throw new Error(`Error deleting file from Google Drive: ${error.message}`);
    }
}

Function to update file of drive folder

// Function to update a file in Google Drive
async function updateFile(auth, fileId, filePath) {
    const drive = google.drive({ version: 'v3', auth });

    const fileMetadata = {
        name: filePath.split('/').pop() // Extract file name from path
    };

    const media = {
        mimeType: 'application/octet-stream',
        body: fs.createReadStream(filePath) // Readable stream for file update
    };

    try {
        const response = await drive.files.update({
            fileId: fileId,
            resource: fileMetadata,
            media: media
        });

        console.log('File updated successfully.');
    } catch (error) {
        throw new Error(`Error updating file in Google Drive: ${error.message}`);
    }
}

How to call all function

// Main function to demonstrate file operations
async function main() {
    try {
        const authClient = await authorize();

        // List available files
        console.log('Available files:');
        await listFiles(authClient);

        // Upload a file
        const uploadedFile = await uploadFile(authClient, 'test.txt', 'FOLDER_ID_HERE'); // Replace 'FOLDER_ID_HERE' with the desired folder ID
        const fileId = uploadedFile.id;

        // Update the uploaded file
        await updateFile(authClient, fileId, 'updated_test.txt');

        // Delete the uploaded file
        await deleteFile(authClient, '1kWgn2c_yfXWDnT4DC6ZlUJEG37w79JxA');
    } catch (error) {
        console.error(error);
    }
}

// Call the main function to start the process
main();

After doing all performance we can easily asses drive to upload folder.

Building a RESTful API with Node.js and MySQL

Arjun Tripathi — Thu, 19 Oct 2023 10:49:31 +0000

In our previous blog post, we explored creating CRUD operations for student data using Node.js, Express.js, and JSON. However, we encountered a major drawback – data was lost when the server closed. Today, we're introducing MySQL, a relational database management system, to store data securely.

Let's dive into the world of databases and create a resilient RESTful API using Node.js, unlocking the full potential of web development.

Prerequisites
Step 1: Initialize the Project
Step 2: Set Up the Database
Step 3: Create API Endpoints
- Get All Students
- Get a Student by ID
- Add a Student
- Update a Student
  - Full Update
  - Partial Update -Delete a Student
Step 4: Start the Server
Step 5: Test Your API
Conclusion

Prerequisites

Before you begin, make sure you have the following installed on your system:

Node.js/Express.js
MySQL Server (e.g., MariaDB)
A code editor (e.g., Visual Studio Code)

Step 1: Initialize the Project

Create a new directory for your project.
Open a terminal and navigate to the project directory.
Run npm init to initialize your Node.js project and follow the prompts to create a package.json file.

Install the necessary packages:

mkdir crud-MySQL
cd crud-MySQL
npm init -y
npm i express mysql

Create a database and table where data which we store

All done in inilization

Step 2: Set Up the Database

Create a MySQL database named test.
Inside your project directory, create a JavaScript file (e.g., app.js) and require the necessary modules:

import express from 'express';
import mysql from 'mysql';

Create an instance of the Express application and configure it to parse JSON and URL-encoded data:

const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());

Define the MySQL connection parameters and establish a connection:

const con = mysql.createConnection({
    host: "localhost",
    user: "root",
    password: "",
    database: "test"
});

con.connect(err => {
    if (err) {
        console.error("Database Connection Error:", err);
    } else {
        console.log('Successfully connected to the database');
    }
});

Step 3: Create API Endpoints

Now, let's define the API endpoints for your RESTful API.

Here we use query promise which use promise which help to avoide "pyramid of doom"

function queryPromise(query, value) {
    return new Promise((resolve, reject) => {
        con.query(query, value, (err, result) => {
            if (err) reject(err);
            else resolve(result);
        })
    })
}

Get All Students

Endpoint: /students
- Method: GET
- Description: Retrieves a list of all student records from database.

app.get("/students/", async (req, res) => {
    try {
        const query = "SELECT * FROM students";
        const result = await queryPromise(query);
        res.status(200).send(result);
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Get a Student by ID

Endpoint: /students/:id
Method: GET
Description: Retrieves a single student record by providing the id parameter in db table.

app.get('/students/:id', async (req, res) => {
    try {
        const id = req.params.id;
        const query = "SELECT * FROM students WHERE id = ?";
        const result = await queryPromise(query, id);
        res.status(200).send(result);
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Add a Student

Endpoint: /students
Method: POST
Description: Adds a new student record to the db table.

app.post('/students', async (req, res) => {
    try {
        const value = req.body;
        const query = "INSERT INTO students SET ?";
        const result = await queryPromise(query, value);

        res.status(201).json({ message: "Data successfully inserted" });
        console.log(result);
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Update a Student

Full Update

Endpoint: /students/:id
Method: PUT
Description: Updates an existing student from table by providing the id parameter.

app.put('/students/:id', async (req, res) => {
    try {
        let id = req.params.id;
        const value = req.body;
        const query = "UPDATE students SET ? WHERE id = ?";
        const result = await queryPromise(query, [value, id]);
        res.status(202).json({ message: "Data updated successfully" });
        console.log(result);
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Partial Update

Endpoint: /students/:id
Method: PATCH
Description: Partially updates an existing student from table by providing the id parameter. You can update one or more fields individually.

app.patch('/students/:id', async (req, res) => {
    try {
        const id = req.params.id;
        const value = req.body;
        const query = "UPDATE students SET ? WHERE id = ?";
        const result = await queryPromise(query, [value, id]);
        res.status(202).json({ message: "Data updated successfully" });
        console.log(result);
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Delete a Student

Endpoint: /students/:id
Method: DELETE
Description: Deletes an existing student from table by providing the id parameter.

app.delete('/students/:id', async (req, res) => {
    try {
        const id = req.params.id;
        const query = "DELETE FROM students WHERE id = ?";
        const result = await queryPromise(query, id);
        res.status(200).json({ message: "Data deleted successfully" });
    } catch (error) {
        console.error(error);
        res.status(500).json({ message: "Some issue occurred" });
    }
});

Step 4: Start the Server

Finally, start the server and listen on a port (e.g., 3000):

const port = process.env.PORT || 3000;
app.listen(port, () => {
    console.log(`Server started on http://localhost:${port}`);
});

Step 5: Test Your API

It's crucial to thoroughly test your RESTful API to ensure that it functions as expected. You can use tools like Postman or cURL to make HTTP requests to the defined endpoints and verify their behavior. Here's how you can test each HTTP request type:

GET Request

Description: Perform a GET request to retrieve data from your API.
Expected Result: Since there's no data in the initial state, the response should be empty. Ensure that the API responds with the correct HTTP status code (usually 200 OK for a successful GET request).

POST Request

Insert element 1

Insert element 2

Insert element 3

Description: Execute a POST request to add new elements to your database.
Expected Result: The API should accept the POST request, insert the specified data into the database, and respond with a success message or a unique identifier for the newly created resource. Check that the data has been added to your database.

PUT Request

To check the update, use a GET Request with a single user:

Description: Use a PUT request to update existing data in your database.
Expected Result: The API should allow updates to the specified resource, and when you subsequently make a GET request for the updated resource, it should return the modified data. Confirm that the resource was successfully updated.

PATCH Request

For verification, use a GET Request with a single user:

Description: Send a PATCH request to partially modify an existing resource.
Expected Result: The API should apply the specified changes to the resource and respond with a success message. When you subsequently make a GET request for the resource, it should return the modified data. Ensure that the partial update was successful.

DELETE Request

To retrieve all data, send a GET Request:

Description: Issue a DELETE request to remove a resource from the database.
Expected Result: The API should delete the specified resource and return a success message. When you make a subsequent GET request for all data, the deleted resource should no longer be present.

By conducting these tests, you can ensure that your RESTful API functions correctly and meets the requirements of your application. It's essential to verify that your API handles various HTTP methods and responds appropriately to different requests.

That's it! You've successfully created and tested a RESTful API using MySQL and Node.js. You can further enhance your API by implementing features like authentication, data validation, error handling, and more to meet the specific needs of your project.

Conclusion

In conclusion, this documentation has outlined the process of creating a RESTful API using MySQL and Node.js. We've covered setting up the environment, establishing a database connection, defining API endpoints, and using query promises to handle asynchronous database queries. This approach enhances code organization and readability, making it easier to manage asynchronous operations in your API. You can further extend this foundation to build more complex and robust applications.

Building a Student Data Management RESTful API with Express.js without database

Arjun Tripathi — Tue, 17 Oct 2023 05:05:27 +0000

Building a Student Data Management RESTful API with Express.js

In this guide, we will walk you through the process of building a RESTful API for managing student data using Node.js and the Express.js framework. This backend code tutorial assumes you have a working knowledge of JavaScript, Node.js, Express.js, and JSON.

Introduction
HTTP Methods and Their Meanings
Starting the Server and Receiving Data
Steps to Set Up the API
Explanation of the Code
API Endpoints
Testing the API
Conclusion

Introduction

In this tutorial, we'll create a Student Data Management RESTful API that enables various operations on student records. With this API, you can retrieve a list of all student data, access specific student details, insert new student records, update existing student information, and delete student records. It's a comprehensive solution for efficiently managing student data in your application.

HTTP Methods and Their Meanings

HTTP methods, or verbs, define the type of action to perform on a resource identified by a URL. Here are the HTTP methods used in this API:

GET: Retrieve data from a specified resource.
POST: Submit data to be processed to a specified resource.
PUT: Update a resource or create a new one if it doesn't exist at a specified URL.
PATCH: Apply partial modifications to a resource.
DELETE: Request the removal of a resource at a specified URL.

These HTTP methods provide a standardized way for clients to interact with web servers and perform various operations on resources, which is essential in a RESTful architecture.

Steps to Set Up the API

Follow these steps to set up the Student Data Management RESTful API using Express.js:

Create a folder:

   mkdir crud-RestAPI

Initialize npm:

   npm init -y

Create a JavaScript file:

   touch index.js

Install Express.js:

   npm i express

Explanation of the Code

The code in index.js does the following:

Sets up an Express.js server and initializes an in-memory data store for student records.
Configures middleware to handle URL-encoded and JSON data in incoming requests.

Please note that the code uses ESM (EcmaScript Module) syntax for importing the Express.js module. There's also a commented line showing how to use Common JS (CJS) syntax.

Starting the Server and Receiving Data

In your Express.js code, you start the server and receive data using specific code segments. Here's how it's done:

Starting the Server

In your JavaScript file (e.g., index.js), you start the server by listening on a specific port. If the process.env.port environment variable is not defined, the server will default to port 3000. Here's the relevant code:

const port = process.env.port || 3000;

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

This code sets up the server and starts it. You'll see a message in the console indicating that the server is running at a specific URL, typically http://localhost:3000.

Receiving Data with Middleware

In your Express application, you use middleware to handle incoming requests. Two important middleware functions are configured to handle URL-encoded and JSON data in incoming requests. Here's how this is set up:

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

express.urlencoded({ extended: true }) is middleware that parses incoming requests with URL-encoded payloads. This is commonly used to parse data sent by HTML forms.
express.json() is middleware that parses incoming requests with JSON payloads. It allows your application to handle JSON data sent in the request body.

These middleware configurations ensure that your API can properly receive and process data sent in various formats.

Now, with these additions, you have the complete process of starting the server and receiving data in your Express.js application, making it easier for users to understand how your API works.

API Endpoints

The API provides the following endpoints:

Storing and Rendering JSON Data

In your Express.js code, you store and render JSON data using the data variable. Here's how this part of the code works:

let data = [
    { "name": "Arjun Tripathi", "course": "MCA", "roll_no": "14", "id": 1 },
    { "name": "Rahul Durgapal", "course": "MCA", "roll_no": "36", "id": 2 },
    { "name": "Aniket Yadav", "course": "MCA", "roll_no": "08", "id": 3 }
];

In the above code, an array named data is initialized. This array acts as an in-memory database where you can store and manipulate student data without using an external database. You can modify this array to include additional student records.

When you define your API endpoints and handle incoming requests, you often interact with this data variable to read or modify student records. For example, when you retrieve data, you send the contents of this array as a JSON response:

By using the data variable, you can effectively manage student data within your Express.js application without the need for an external database. This in-memory database simplifies the development process and helps you learn and experiment with building APIs.

Get All Student Data (Read)

Endpoint: /
Method: GET
Description: Retrieves a list of all student records.

// Endpoint: /
// Method: GET
// Description: Retrieves a list of all student records
app.get('/', function (req, res) {
    res.status(200).json(data);
});

Get a Single Student Record (Read)

Endpoint: /:id
Method: GET
Description: Retrieves a single student record by providing the id parameter.

// Endpoint: /:id
// Method: GET
// Description: Retrieves a single student record by providing the `id` parameter
app.get("/:id", function (req, res) {
    let found = data.find(function (item) {
        return item.id === parseInt(req.params.id);
    });
    if (found) {
        res.status(200).json(found);
    } else {
        res.sendStatus(404);
    }
});

Insert a New Student Record (Create)

Endpoint: /
Method: POST
Description: Adds a new student record to the collection.

// Endpoint: /
// Method: POST
// Description: Adds a new student record to the collection
app.post('/', function (req, res) {
    let items = data.map(item => item.id);
    let newId = items.length > 0 ? Math.max.apply(Math, items) + 1 : 1;
    let newItem = {
        id: newId,
        name: req.body.name,
        course: req.body.course,
        roll_no: req.body.roll_no
    };
    data.push(newItem);
    res.status(201).json({ 'message': "successfully created" });
});

Update a Student Record (Update)

Endpoint: /:id
Method: PUT
Description: Updates an existing student record by providing the id parameter.

// Endpoint: /:id
// Method: PUT
// Description: Updates an existing student record by providing the `id` parameter
app.put('/:id', function (req, res) {
    let found = data.find(function (item) {
        return item.id === parseInt(req.params.id);
    });
    if (found) {
        let updateData = {
            id: found.id,
            name: req.body.name,
            course: req.body.course,
            roll_no: req.body.roll_no
        };
        let targetIndex = data.indexOf(found);
        data.splice(targetIndex, 1, updateData);
        res.status(201).json({ 'message': "data updated" });
    } else {
        res.status(404).json({
            'message': 'unable to insert data because data inserted not matched'
        });
    }
});

Partially Update a Student Record (Update)

Endpoint: /:id
Method: PATCH
Description: Partially updates an existing student record by providing the id parameter. You can update one or more fields individually.

// Endpoint: /:id
// Method: PATCH
// Description: Partially updates an existing student record by providing the `id` parameter. You can update one or more fields individually.
app.patch("/:id", function (req, res) {
    let found = data.find(function (item) {
        return item.id === parseInt(req.params.id);
    });
    if (found) {
        if (req.body.name) {
            found.name = req.body.name;
        }
        if (req.body.course) {
            found.course = req.body.course;
        }
        if (req.body.roll_no) {
            found.roll_no = req.body.roll_no;
        }
        res.status(201).json({ "message": "data updated" });
    } else {
        res.status(404).json({
            'message': 'unable to insert data because data inserted not matched'
        });
    }
});

Delete a Student Record

Endpoint: /:id
Method: DELETE
Description: Deletes an existing student record by providing the id parameter.

// Endpoint: /:id
// Method: DELETE
// Description: Deletes an existing student record by providing the `id` parameter
app.delete('/:id', function (req, res) {
    let found = data.find(function (item) {
        return item.id === parseInt(req.params.id);
    });
    if (found) {
        let targetIndex = data.indexOf(found);
        data.splice(targetIndex, 1);
        res.sendStatus(204);
    } else {
        res.sendStatus(404);
    }
});

For each endpoint, the documentation provides information about the HTTP method, the endpoint URL, and the expected request and response formats.

Testing the API

To test the API endpoints you've defined in your code, you can use tools like Postman or ThunderClient (an extension for Visual Studio Code).

Testing the API with Postman

To test the API endpoints, we recommend using a tool like Postman. However, you can use any API testing tool of your choice. Here, we'll demonstrate how to use Postman to interact with your API.

GET Request

POST Request

PUT Request

To check the update, use a GET Request with a single user:

PATCH Request

For verification, use a GET Request with a single user:

DELETE Request

To retrieve all data, send a GET Request:

In these screenshots, you can observe the interactions with your API. In the GET request, you see all elements. In the POST request, you insert one element. In the PUT request, you update it, but it overwrites the existing data. To demonstrate an update without overwriting, you use a PATCH request. Finally, you delete the inserted data using a DELETE request.

Feel free to use these examples and adjust them to your specific API testing needs. Postman is a powerful tool for API development and testing, making it easier to validate your API's functionality and behavior.

Check out my github repo - link

Conclusion

This API offers basic functionality for managing student data, allowing you to create, retrieve, update, and delete student records in JSON format. For further enhancements, consider adding authentication and validation for robust security and data integrity.

DEV Community: Arjun Tripathi

How to Choose the Right Authentication Method for Your Backend

Introduction

What Is Authentication?

OAuth (Open Authorization)

What is OAuth?

How OAuth Works (Simplified Flow)

Pros:

Cons:

When to Use:

OTP (One-Time Password)

What is OTP?

Types of OTP:

Pros:

Cons:

When to Use:

Magic Links (Verification Links)

What is a Magic Link?

How It Works:

Pros:

Cons:

When to Use:

Security Comparison

Choosing the Right One

Combining Methods

Conclusion

Bonus: Developer Resources

Tips:

Segment Tree

Use-case:

Why Segment Tree is Needed?

Structure of Segment Tree

How to Implement a Segment Tree?

Creation of Segment Tree

1. Segment Tree with Nodes and Pointers

2. Segment Tree Using Arrays

Summary Table

When to use which?

1. Node-Pointer Based Segment Tree

2. Array-Based Segment Tree

Differences between Node.js and Golang (Go) from the perspective of an experienced developer.

1. Origins & Background

Node.js

Golang (Go)

2. Language & Syntax

3. Performance & Scalability

4. Ecosystem & Tooling

5. Use Cases – Where Each Shines

Node.js is better for:

Golang is better for:

6. Developer Experience (DX)

7. The Future

Final Verdict – Which One Should You Choose?

✅ Pick Node.js If...

✅ Pick Golang If...

Bonus: When Might You Use Both?

Final Thoughts

Want More Tech Insights?

Upload Files on Drive With Node.js

Let' Code

Building a RESTful API with Node.js and MySQL

Table of Contents

Prerequisites

Step 1: Initialize the Project

Step 2: Set Up the Database

Step 3: Create API Endpoints

Get All Students

Get a Student by ID

Add a Student

Update a Student

Full Update

Partial Update

Delete a Student

Step 4: Start the Server

Step 5: Test Your API

Conclusion

Building a Student Data Management RESTful API with Express.js without database

Building a Student Data Management RESTful API with Express.js

Table of Contents

Introduction