Skip to main content
Node Blueprint CLI supports three popular databases with optimized configurations and Docker support.

​
Available Databases

PostgreSQL

Advanced open-source relational database with JSON support

MySQL

Popular relational database with excellent performance

MongoDB

NoSQL document database for flexible schemas

​
Database Comparison

FeaturePostgreSQLMySQLMongoDB
TypeRelationalRelationalDocument
SchemaStrictStrictFlexible
JSON SupportNativeLimitedNative
TransactionsFull ACIDFull ACIDMulti-document
Best ForComplex queriesHigh read performanceFlexible data models

​
PostgreSQL

PostgreSQL is configured with the pg driver and supports both Prisma and Drizzle ORMs.

​
Configuration

Environment Variables (.env): 
DB_HOST=localhost
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=postgres
DB_NAME=myapp
DATABASE_URL=postgresql://postgres:postgres@localhost:5432/myapp

​
Docker Setup

When Docker is enabled, the CLI generates a PostgreSQL 16 service: docker-compose.yml: 
postgres:
  image: postgres:16-alpine
  container_name: myapp-postgres
  restart: unless-stopped
  ports:
    - "5432:5432"
  env_file:
    - .env
  volumes:
    - postgres-data:/var/lib/postgresql/data
  networks:
    - myapp-network
  healthcheck:
    test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
    interval: 10s
    timeout: 5s
    retries: 5

​
Dependencies

{
  "dependencies": {
    "pg": "^8.16.0"
  },
  "devDependencies": {
    "@types/pg": "^8.15.4"
  }
}
Drizzle Configuration (drizzle.config.ts):
import { defineConfig } from "drizzle-kit";

if (!process.env.DATABASE_URL) {
    throw new Error("DATABASE_URL is not set");
}

export default defineConfig({
    dialect: "postgresql",
    schema: "./dist/src/db/schema/*",
    out: "./migrations",
    dbCredentials: {
        url: process.env.DATABASE_URL
    },
    migrations: {
        prefix: "timestamp",
        table: "drizzle_migrations",
        schema: "public"
    }
});
User Schema (src/db/schema/user-schema.ts):
import { type InferSelectModel, type InferInsertModel, relations } from "drizzle-orm";
import { pgTable, text, timestamp, uuid, varchar, pgEnum } from "drizzle-orm/pg-core";
import { RoleEnum } from "../../enums/role-enum.js";

// create role enum type
const roleEnum = pgEnum("role", Object.values(RoleEnum) as [string, ...string[]]);

// schema definition
export const userSchema = pgTable("user", {
    id: uuid("id").primaryKey().unique().notNull().defaultRandom(),
    name: varchar("name", { length: 50 }),
    email: varchar("email", { length: 255 }).notNull().unique(),
    password: text("password").notNull(),
    role: roleEnum().notNull().default(RoleEnum.USER),
    createdAt: timestamp("created_at").notNull().defaultNow(),
    updatedAt: timestamp("updated_at").notNull().defaultNow()
});

// types
export type SelectableUser = InferSelectModel<typeof userSchema>;
export type InsertableUser = InferInsertModel<typeof userSchema>;
Prisma Schema (prisma/schema.prisma):
generator client {
    provider = "prisma-client-js"
}
  
datasource db {
    provider = "postgresql"
    url      = env("DATABASE_URL")
}

enum RoleEnum {
    admin
    user
}
    
model User {
    id       String  @id @unique @default(uuid())
    name     String? @db.VarChar(50)
    email    String  @unique @db.VarChar(255)
    password String
    role     RoleEnum    @default(user)

    createdAt DateTime @default(now())
    updatedAt DateTime @updatedAt
}

​
MySQL

MySQL is configured with the mysql2 driver for better performance.

​
Configuration

Environment Variables (.env): 
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=root
DB_NAME=myapp
DATABASE_URL=mysql://root:root@localhost:3306/myapp

​
Docker Setup

docker-compose.yml: 
mysql:
  image: mysql:8
  container_name: myapp-mysql
  restart: unless-stopped
  ports:
    - "3306:3306"
  env_file:
    - .env
  volumes:
    - mysql-data:/var/lib/mysql
  healthcheck:
    test: ["CMD", "mysqladmin", "ping", "-h", "${DB_HOST}", "-u", "${DB_USER}", "-p", "${DB_PASSWORD}"]
    interval: 10s
    timeout: 5s
    retries: 5

​
Dependencies

{
  "dependencies": {
    "mysql2": "^3.14.1"
  }
}
Drizzle Configuration (drizzle.config.ts):
import { defineConfig } from "drizzle-kit";

if (!process.env.DATABASE_URL) {
    throw new Error("DATABASE_URL is not set");
}

export default defineConfig({
    dialect: "mysql",
    schema: "./dist/src/db/schema/*",
    out: "./migrations",
    dbCredentials: {
        url: process.env.DATABASE_URL
    },
    migrations: {
        prefix: "timestamp",
        table: "drizzle_migrations",
        schema: "public"
    }
});
User Schema (src/db/schema/user-schema.ts):
import { type InferSelectModel, type InferInsertModel, relations } from "drizzle-orm";
import { mysqlTable, text, timestamp, varchar, mysqlEnum, int } from "drizzle-orm/mysql-core";
import { RoleEnum } from "../../enums/role-enum";

// create role enum type
const roleEnum = mysqlEnum("role", Object.values(RoleEnum) as [string, ...string[]]);

// schema definition
export const userSchema = mysqlTable("user", {
    id: int("id").primaryKey().autoincrement(),
    name: varchar("name", { length: 50 }),
    email: varchar("email", { length: 255 }).notNull().unique(),
    password: text("password").notNull(),
    role: roleEnum.notNull().default(RoleEnum.USER),
    createdAt: timestamp("created_at").notNull().defaultNow(),
    updatedAt: timestamp("updated_at").notNull().defaultNow()
});

// types
export type SelectableUser = InferSelectModel<typeof userSchema>;
export type InsertableUser = InferInsertModel<typeof userSchema>;

​
MongoDB

MongoDB requires the Mongoose ORM and provides a flexible document-based data model.

​
Configuration

Environment Variables (.env): 
DB_HOST=localhost
DB_PORT=27017
DB_NAME=myapp
DATABASE_URL=mongodb://localhost:27017/myapp

​
Docker Setup

docker-compose.yml: 
mongodb:
  image: mongo:latest
  container_name: myapp-mongodb
  restart: unless-stopped
  ports:
    - "27017:27017"
  env_file:
    - .env
  volumes:
    - mongodb-data:/data/db
  healthcheck:
    test: ["CMD", "mongosh", "--eval", "db.runCommand('ping')"]
    interval: 10s
    timeout: 5s
    retries: 5

​
Dependencies

{
  "dependencies": {
    "mongoose": "^8.15.2"
  },
  "devDependencies": {
    "@types/mongoose": "^5.11.97"
  }
}

​
Database Connection

Connection Handler (src/config/db.ts): 
import mongoose from "mongoose";

const connectDb = async () => {
    try {
        const dbUrl = process.env.DATABASE_URL;
        if (!dbUrl) {
            throw new Error("DATABASE_URL is not defined");
        }
        
        await mongoose.connect(dbUrl);
        console.log("✅ MongoDB connected successfully");
    } catch (error) {
        console.error("❌ MongoDB connection failed:", error);
        process.exit(1);
    }
};

export default connectDb;
MongoDB can only be used with Mongoose ORM. When selecting MongoDB, Mongoose will be automatically configured.

​
Quick Start

1

Run the CLI

npx create-node-blueprint my-app
2

Select your database

Choose PostgreSQL, MySQL, or MongoDB when prompted
3

Configure environment

Update .env file with your database credentials
4

Start with Docker (optional)

docker-compose up -d

Build docs developers (and LLMs) love

Get started for freeTalk to us