NEPBS

Node Express Prisma Backend Server

NEPBS is a beginner-friendly CLI tool for creating a ready-to-use Node.js + Express + Prisma backend server.

It helps developers skip repetitive backend setup and start building APIs faster.

📦 NPM Package:
https://www.npmjs.com/package/create-nepbs

Quick Start

Create a new backend project with one command:

npx create-nepbs my-app

NEPBS will ask you to choose:

1. Programming language
2. Database

Then it automatically creates the project, installs the required packages, configures Prisma, and prepares the backend structure.

Language Selection

NEPBS supports both TypeScript and JavaScript.

Choose your language:

1. TypeScript
2. JavaScript

Enter your choice [1]:

Press Enter to use the default option:

TypeScript

TypeScript

TypeScript is the default and recommended option.

TypeScript projects include:

• Strict TypeScript
• ES Modules
• NodeNext module resolution
• tsx for development
• tsc for production builds
• .js extensions in relative imports where required by Node.js ESM

Example:

import app from "./app.js";

JavaScript

JavaScript projects use modern ES Modules.

Example:

import express from "express";

Your application source remains JavaScript when JavaScript mode is selected.

Database Selection

After selecting a language, NEPBS asks you to choose a database.

Choose your database:

1. PostgreSQL
2. MySQL
3. MariaDB
4. SQLite
5. SQL Server
6. CockroachDB
7. MongoDB

Enter your choice [1]:

Press Enter to use:

PostgreSQL

PostgreSQL is the default database.

Supported Databases

| Database | Prisma Provider | Notes | | --- | --- | --- | | PostgreSQL | postgresql | Default | | MySQL | mysql | MySQL database | | MariaDB | mysql | Uses Prisma MySQL connector | | SQLite | sqlite | Local file database | | SQL Server | sqlserver | Microsoft SQL Server | | CockroachDB | cockroachdb | Distributed SQL database | | MongoDB | mongodb | Uses a compatible Prisma profile |

Cloud database providers can also be used through the appropriate database option.

Examples:

Neon          → PostgreSQL
Supabase      → PostgreSQL
Railway       → PostgreSQL / MySQL
PlanetScale   → MySQL
MongoDB Atlas → MongoDB

You only need to provide the correct DATABASE_URL.

What NEPBS Creates

A generated project includes a clean backend foundation with:

• Node.js
• Express.js
• Prisma ORM
• TypeScript or JavaScript
• ES Modules
• Prisma Client setup
• Environment configuration
• CORS
• Cookie Parser
• JWT utilities
• bcrypt password utilities
• Global error handler
• Async error wrapper
• Not-found middleware
• API response helper
• Starter /api/v1 endpoint
• Database-specific Prisma configuration
• Node.js version detection
• Automatic dependency installation

NEPBS intentionally does not generate authentication routes or CRUD modules by default.

The goal is to give developers a clean and understandable backend foundation instead of generating unnecessary application code.

Node.js Compatibility

NEPBS detects the Node.js version installed on your computer before creating the project.

It is designed to handle these Node.js major versions:

19
20
21
22
23
24

NEPBS uses the detected Node.js version, selected language, and selected database to determine an appropriate Prisma configuration.

When the installed Node.js version supports the current Prisma release, NEPBS uses the latest compatible Prisma setup.

When a specific Node.js version or database requires a compatibility profile, NEPBS automatically uses the compatible Prisma configuration and displays a warning when necessary.

For production projects, a currently supported Node.js LTS release is recommended.

Check your versions:

node --version
npm --version

Latest Compatible Packages

NEPBS installs current compatible versions of generated project dependencies.

Common backend dependencies include:

express
prisma
@prisma/client
dotenv
cors
cookie-parser
jsonwebtoken
bcryptjs
http-status-codes

TypeScript projects additionally include:

typescript
tsx
@types/node
@types/express
@types/cookie-parser
@types/jsonwebtoken
@types/cors
@types/bcryptjs

When required, NEPBS also installs the appropriate Prisma database adapter and database driver.

Packages Not Installed by Default

NEPBS keeps generated projects minimal.

The following packages are not installed automatically:

zod
helmet
morgan
eslint
prettier
husky
swagger
nodemon

You can add them later if your project needs them.

Generated Project Structure

A TypeScript project follows a simple structure similar to:

my-app/
├── src/
│   ├── modules/
│   ├── middleware/
│   ├── utils/
│   ├── config/
│   ├── app.ts
│   ├── server.ts
│   └── index.ts
│
├── prisma/
│   └── schema.prisma
│
├── .env
├── .env.example
├── .gitignore
├── package.json
├── tsconfig.json
└── README.md

Depending on the Prisma profile, NEPBS may also generate:

prisma.config.ts
src/generated/prisma/

JavaScript projects use the same basic structure with .js application files where appropriate.

Environment Configuration

NEPBS prepares environment variables such as:

NODE_ENV=development
PORT=5000
DATABASE_URL=
JWT_SECRET=
JWT_EXPIRES_IN=7d
CORS_ORIGIN=http://localhost:3000

After generating your project, update .env with your real database connection.

Example PostgreSQL URL:

DATABASE_URL="postgresql://username:password@localhost:5432/my_database"

Starting a Project

Create a project:

npx create-nepbs my-app

Enter the generated folder:

cd my-app

Update:

.env

Then generate or migrate the database.

For relational databases:

npm run prisma:migrate -- --name init

Then start development:

npm run dev

MongoDB Setup

MongoDB projects use Prisma schema push instead of Prisma Migrate.

Run:

npm run prisma:push

Then:

npm run dev

Test the API

After starting the server, open:

http://localhost:5000/api/v1

Expected response:

{
  "success": true,
  "message": "API is running"
}

Generated Backend Utilities

Prisma Client

NEPBS creates a reusable Prisma Client configuration based on the selected database and Prisma profile.

JWT Helper

JWT helper functions are included for:

Create token
Verify token

Password Helper

bcrypt helper functions are included for:

Hash password
Compare password

Error Handling

The generated project includes:

Global error handler
Not-found middleware
Async error wrapper

API Response Helper

A reusable response helper keeps API responses consistent.

Example:

{
  "success": true,
  "message": "Request completed successfully",
  "data": {}
}

Available Commands

Development Server

npm run dev

Generate Prisma Client

npm run prisma:generate

Create Prisma Migration

npm run prisma:migrate -- --name init

Push Prisma Schema

npm run prisma:push

Open Prisma Studio

npm run prisma:studio

Build

npm run build

Production

npm run start

Example

Create a backend project:

npx create-nepbs blog-api

Choose:

Language: TypeScript
Database: PostgreSQL

Enter the project:

cd blog-api

Update .env:

DATABASE_URL="postgresql://username:password@localhost:5432/blog_api"
JWT_SECRET="your-secure-secret"

Create the initial migration:

npm run prisma:migrate -- --name init

Start development:

npm run dev

Test:

GET http://localhost:5000/api/v1

Response:

{
  "success": true,
  "message": "API is running"
}

Project Name Safety

NEPBS validates the project name before generating files.

It prevents:

Empty project names
Project names containing spaces
Unsafe characters
Unsafe command input
Overwriting non-empty folders

NEPBS will not delete or overwrite an existing non-empty project directory.

Cross-Platform Support

NEPBS is designed to work across common development environments, including:

Windows
macOS
Linux
PowerShell
Command Prompt
Git Bash

The CLI includes Windows-safe process execution for npm commands where required.

Why NEPBS?

Creating a backend project usually requires repeating the same setup:

Install Express
Configure Prisma
Configure TypeScript
Setup database
Setup environment variables
Configure CORS
Configure cookies
Configure JWT
Configure password hashing
Configure error handling
Create project folders
Configure development scripts

NEPBS automates these repetitive tasks.

Instead of spending time configuring a project, you can start building your API.

Who Is NEPBS For?

NEPBS is designed for:

Beginner backend developers
Node.js developers
Express developers
Prisma developers
Students
API developers
Developers learning backend development
Developers who frequently start new backend projects

Use Without Global Installation

The recommended way to use NEPBS is:

npx create-nepbs my-app

No global installation is required.

Global Installation

You can also install NEPBS globally:

npm install -g create-nepbs

Then run:

create-nepbs my-app

NPM Package

Package Name

create-nepbs

NPM Live Page

https://www.npmjs.com/package/create-nepbs

Run

npx create-nepbs my-app

Development Philosophy

NEPBS focuses on:

Simple code
Readable project structure
Beginner-friendly setup
Modern ES Modules
Minimal abstraction
Useful defaults
Automatic repetitive setup
Easy customization

The generated project is intentionally kept simple so developers can understand and modify it easily.

License

MIT License

npx create-nepbs my-app