express-modular-monolith 1.1.4 → 1.2.0

package/README.md

@@ -2,6 +2,8 @@
 
 Generate an Express modular monolith boilerplate with JavaScript or TypeScript.
 
+> **Note:** This architecture is not opinionated or prescriptive. You can modify, extend, or completely rewrite it to fit your project's requirements.
+
 ## Usage
 
 ```bash
@@ -14,14 +16,17 @@ npx express-modular-monolith
 * TypeScript template
 * Modular monolith structure
 * Express
+* MongoDB with Mongoose
+* PostgreSQL with Drizzle ORM
 * Automatic Git repository initialization
 * Automatic initial Git commit
 
-## What's New in v1.1.4
+## What's New in v1.2.0
 
-* Added automatic `git init` after generating the project
-* Added automatic initial commit for the generated boilerplate
-* The generated project is ready to start tracking with Git immediately
+* Added MongoDB + Mongoose support
+* Added PostgreSQL + Drizzle ORM support
+* Added database and ORM/ODM selection during project generation
+* Both JavaScript and TypeScript templates support the available database configurations
 
 ## How It Works
 
@@ -31,15 +36,25 @@ Run:
 npx express-modular-monolith
 ```
 
-Choose your preferred language and project location. The CLI will:
+Choose your preferred language, database, and ORM/ODM. The CLI will:
 
 1. Generate the selected boilerplate
-2. Install the required dependencies
-3. Initialize a Git repository
-4. Add the generated files to Git
-5. Create an initial commit
-
-Your generated project will be ready for development with Git already configured.
+2. Configure the selected database and ORM/ODM
+3. Install the required dependencies
+4. Initialize a Git repository
+5. Add the generated files to Git
+6. Create an initial commit
+
+Currently supported configurations:
+
+| Language   | Database   | ORM/ODM  |
+| ---------- | ---------- | -------- |
+| JavaScript | MongoDB    | Mongoose |
+| JavaScript | PostgreSQL | Drizzle  |
+| TypeScript | MongoDB    | Mongoose |
+| TypeScript | PostgreSQL | Drizzle  |
+
+Your generated project will be ready for development with the selected database configuration and Git already initialized.
 
 ## Requirements
 

package/bin/boilerPlateCodes.js

@@ -0,0 +1,19 @@
+export const mongodbConBoilerplateCode = `import mongoose from "mongoose"
+
+const MONGODB_URI = process.env.MONGODB_URI;
+
+export const connectionDB = async () => {
+    try{
+        await mongoose.connect(MONGODB_URI)
+    }catch (error) { 
+        console.error("MongoDB connection failed", error) 
+        process.exit(1)
+    }
+}`
+
+
+export const drizzlePostgresBoilerPlate = `import "dotenv/config";
+import { drizzle } from "drizzle-orm/node-postgres";
+
+
+export const db = drizzle(process.env.POSTGRES_URL);`

package/bin/cli.js

@@ -5,28 +5,52 @@ import { fileURLToPath } from "node:url";
 import { exec as execCallback } from "node:child_process";
 import { promisify } from "node:util";
 import fs from "node:fs/promises";
-import { input, select } from "@inquirer/prompts";
+import process from "node:process";
+import { select } from "@inquirer/prompts";
+import { projectName, language, DB } from "./cliQuestions.js";
+import { dbPackages } from "./packages.js";
+import ora from "ora";
+import { addEnvBasedOnDBs, JSboilerPlateCodeSetUp, DBboilerCodeSetUp, TSboilerPlateCodeSetUp } from "./config.js";
+
 
 const exec = promisify(execCallback);
 
-const projectName = await input({
-  message: "Project name:"
+const spinnerDiscardingStdin = ora({
+	text: "Loading Packages",
+	spinner: process.argv[2],
+    color: "cyan"
 });
 
-const language = await select({
-  message: "Choose a language:",
-  choices: [
-    {
-      name: "JavaScript",
-      value: "javascript"
-    },
-    {
-      name: "TypeScript",
-      value: "typescript"
-    }
-  ]
-});
 
+let modelTool;
+
+if (DB === "mongodb") {
+  modelTool = await select({
+    message: "Choose ODM:",
+    choices: [
+      {
+        name: "Mongoose",
+        value: "mongoose"
+      }
+    ]
+  });
+} else {
+  modelTool = await select({
+    message: "Choose ORM:",
+    choices: [
+      {
+        name: "Drizzle",
+        value: "drizzle"
+      },
+      {
+        name: "Prisma",
+        value: "prisma"
+      }
+    ]
+  });
+}
+
+spinnerDiscardingStdin.start("Installing required packages, wait for a while");
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -48,29 +72,84 @@ if (projectName === ".") {
   packageJson.name = projectName;
 }
 
+const selectedPackages = dbPackages[DB][modelTool];
+
+packageJson.dependencies = {
+  ...packageJson.dependencies,
+  ...selectedPackages.dependencies
+};
+
+packageJson.devDependencies = {
+  ...packageJson.devDependencies,
+  ...selectedPackages.devDependencies
+};
+
 await fs.writeFile(
   packageJsonPath,
   JSON.stringify(packageJson, null, 2)
-);
+).catch((err)=>{
+  spinnerDiscardingStdin.fail(err)
+  spinnerDiscardingStdin.start()
+});
+
+let lang;
+
+if (templatePath.includes("javascript")) {
+  await JSboilerPlateCodeSetUp(projectPath)
+  await DBboilerCodeSetUp(projectPath, DB, modelTool, lang = "javascript")
+}
+
+if (templatePath.includes("typescript")) {
+  await TSboilerPlateCodeSetUp(projectPath)
+  await DBboilerCodeSetUp(projectPath, DB, modelTool, lang = "typescript")
+  if(modelTool === "mongoose"){
+    await exec("npm install @types/mongoose -D", {
+      cwd: projectPath
+    })
+  }
+}
 
 await exec("npx gitignore node", {
   cwd: projectPath
-})
+}).catch((err)=>{
+  spinnerDiscardingStdin.fail("Failed to load .gitignore, run 'npx gitignore node in project root directory to load .gitignore")
+  spinnerDiscardingStdin.start()
+});
+
+await fs.writeFile(".env", "PORT=8000\n").catch((err)=>{
+  spinnerDiscardingStdin.fail("Failed to create .env file")
+  spinnerDiscardingStdin.start()
+}).then(async ()=>{
+  await addEnvBasedOnDBs(projectPath, DB)
+});
 
-await fs.writeFile(".env", "PORT=8000\n")
 
 await exec("npm install", {
   cwd: projectPath
-})
+}).catch((err)=>{
+  spinnerDiscardingStdin.fail("Failed to load required packeages, run 'npm install' to load packages")
+  spinnerDiscardingStdin.start()
+});
 
 await exec("git init", {
   cwd: projectPath
-})
+}).catch((err)=>{
+  spinnerDiscardingStdin.fail("Failed to initialize the repo, run 'git init' to initialize the repo")
+  spinnerDiscardingStdin.start()
+});
 
 await exec("git add .", {
   cwd: projectPath
-})
+}).catch((err)=>{
+  spinnerDiscardingStdin.fail("Failed to get staged the files, run 'git add .' to get staged")
+  spinnerDiscardingStdin.start()
+});
 
 await exec(`git commit -m "Initial commit"`, {
   cwd: projectPath
-})
+}).catch((err)=>{
+  spinnerDiscardingStdin.fail(`Failed to commit, run 'git commit -m "Inital commit"`)
+  spinnerDiscardingStdin.start()
+});
+
+spinnerDiscardingStdin.succeed("Packages successfully installed");

package/bin/cliQuestions.js

@@ -0,0 +1,38 @@
+import { input, select } from "@inquirer/prompts";
+
+
+export const projectName = await input({
+  message: "Project name:"
+});
+
+export const language = await select({
+  message: "Choose a language:",
+  choices: [
+    {
+      name: "JavaScript",
+      value: "javascript"
+    },
+    {
+      name: "TypeScript",
+      value: "typescript"
+    }
+  ]
+});
+
+export const DB = await select({
+  message: "Choose a database:",
+  choices: [
+    {
+      name: "PostgreSQL",
+      value: "postgresql"
+    },
+    {
+      name: "MySQL",
+      value: "mysql"
+    },
+    {
+      name: "MongoDB",
+      value: "mongodb"
+    }
+  ]
+});

package/bin/config.js

@@ -0,0 +1,272 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import ora from "ora";
+import { drizzlePostgresBoilerPlate, mongodbConBoilerplateCode } from "./boilerPlateCodes.js";
+
+
+const spinnerDiscardingStdin = ora({
+    text: "Loading Packages",
+    spinner: process.argv[2],
+    color: "cyan"
+});
+
+
+export const JSboilerPlateCodeSetUp = async (projectPath) => {
+    const appJsPath = path.join(projectPath, "/src/app.js")
+
+    const targetLine = 8
+    const insertedData = `app.get("/", (req, res)=> {
+  res.json("Server is up and running")
+})`
+
+    const data = await fs.readFile(appJsPath, "utf-8")
+
+    const lines = data.split(/\r?\n/);
+    lines.splice(targetLine - 1, 0, insertedData);
+    const updatedContent = lines.join("\n");
+
+    fs.writeFile(appJsPath, updatedContent, "utf-8", (err) => {
+        if (err) {
+            spinnerDiscardingStdin.fail(err?.message)
+            spinnerDiscardingStdin.start()
+            return;
+        }
+    });
+
+
+}
+
+export const TSboilerPlateCodeSetUp = async (projectPath) => {
+    const appTsPath = path.join(projectPath, "/src/app.ts")
+      
+    const targetLine = [2, 8]
+
+    const insertedData = [
+    `import type { Express, Request, Response } from "express"`,
+    `app.get("/", (req:Request, res:Response)=> {
+    res.json("Server is up and running")
+})`
+    ]
+
+    const data = await fs.readFile(appTsPath, "utf-8")
+
+    const lines = data.split(/\r?\n/);
+    
+    lines.splice(targetLine[0] , 0, insertedData[0]);
+    lines.splice(1, 1)
+    lines.splice(targetLine[1] , 0, insertedData[1]);
+
+    const updatedContent = lines.join("\n");
+    
+    fs.writeFile(appTsPath, updatedContent, "utf-8", (err) => {
+    if (err) {
+        spinnerDiscardingStdin.fail(err?.message)
+        spinnerDiscardingStdin.start()
+        return;
+    }
+    });
+}
+
+export const addEnvBasedOnDBs = async (projectPath, DB) => {
+    const targetLine = 2
+
+    if (DB === "mongodb") {
+        const envVar = "MONGODB_URI=mongodb+srv://<username>:<password>@<cluster-url>/<database_name>?retryWrites=true&w=majority"
+
+        const dotEnvPath = path.join(projectPath, ".env")
+
+        const envData = await fs.readFile(dotEnvPath, "utf-8")
+
+        const lines = envData.split(/\r?\n/);
+        lines.splice(targetLine - 1, 0, envVar);
+
+        const updatedContent = lines.join("\n");
+
+        fs.writeFile(dotEnvPath, updatedContent, "utf-8", (err) => {
+            if (err) {
+                spinnerDiscardingStdin.fail(err?.message)
+                spinnerDiscardingStdin.start()
+                return;
+            }
+        });
+    }
+
+    if (DB === "postgresql" || DB === "mysql") {
+        const envVar = "DATABASE_URL=postgresql://user:password@localhost:5432/mydatabase?sslmode=prefer"
+
+        const dotEnvPath = path.join(projectPath, ".env")
+
+        const envData = await fs.readFile(dotEnvPath, "utf-8")
+
+        const lines = envData.split(/\r?\n/);
+        lines.splice(targetLine - 1, 0, envVar);
+
+        const updatedContent = lines.join("\n");
+
+        fs.writeFile(dotEnvPath, updatedContent, "utf-8", (err) => {
+            if (err) {
+                spinnerDiscardingStdin.fail(err?.message)
+                spinnerDiscardingStdin.start()
+                return;
+            }
+        });
+    }
+}
+
+export const DBboilerCodeSetUp = async (projectPath, DB, modelTool, language) => {
+    if (language === "javascript") {
+        if (DB === "mongodb") {
+            const dbJsPath = path.join(projectPath, "/src/common/config/db.js")
+
+            fs.writeFile(dbJsPath, mongodbConBoilerplateCode, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+
+            const serverJsPath = path.join(projectPath, "/src/server.js")
+            const serverJsData = await fs.readFile(serverJsPath, "utf-8");
+            
+            const targetLine = [3, 9]
+            const insertedData = [`import { connectionDB } from "./common/config/db.js"`,
+                `        await connectionDB()`];
+            
+            const lines = serverJsData.split(/\r?\n/);
+            lines.splice(targetLine[0] - 1, 0, insertedData[0])
+            lines.splice(targetLine[1], 1)
+            lines.splice(targetLine[1], 0, insertedData[1])
+
+
+
+            const updatedContent = lines.join("\n");
+
+            fs.writeFile(serverJsPath, updatedContent, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+        }
+
+    if (DB === "postgresql" && modelTool === "drizzle") {
+            const dbJsPath = path.join(projectPath, "/src/common/config/db.js")
+
+            fs.writeFile(dbJsPath, drizzlePostgresBoilerPlate, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+
+            const serverJsPath = path.join(projectPath, "/src/server.js");
+            const serverJsData = await fs.readFile(serverJsPath, "utf-8");
+
+            const targetLine = [3, 9]
+            const insertedData = [`import { db } from "./common/config/db.js";
+    import { sql } from "drizzle-orm"`,
+                '        await db.execute(sql`select 1`)'];
+
+            const lines = serverJsData.split(/\r?\n/);
+            lines.splice(targetLine[0] - 1, 0, insertedData[0])
+            lines.splice(targetLine[1], 1)
+            lines.splice(targetLine[1], 0, insertedData[1])
+
+
+
+            const updatedContent = lines.join("\n");
+
+            fs.writeFile(serverJsPath, updatedContent, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+        }
+    }
+
+    if (language === "typescript") {
+        if (DB === "mongodb") {
+            const dbTsPath = path.join(projectPath, "/src/common/config/db.ts")
+
+            const mongodbBoilerlines = mongodbConBoilerplateCode.split(/\r?\n/)
+            mongodbBoilerlines.splice(2, 1)
+            mongodbBoilerlines.splice(2, 0, 'const MONGODB_URI = process.env.MONGODB_URI!;')
+
+            const updatedmongodbBoiler = mongodbBoilerlines.join("\n")
+
+            fs.writeFile(dbTsPath, updatedmongodbBoiler, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+
+            const serverTsPath = path.join(projectPath, "/src/server.ts")
+            const serverTsData = await fs.readFile(serverTsPath, "utf-8");
+            
+            const targetLine = [3, 9]
+            const insertedData = [`import { connectionDB } from "./common/config/db.ts"`,
+                `        await connectionDB()`];
+            
+            const lines = serverTsData.split(/\r?\n/);
+            lines.splice(targetLine[0] - 1, 0, insertedData[0])
+            lines.splice(targetLine[1], 1)
+            lines.splice(targetLine[1], 0, insertedData[1])
+
+
+
+            const updatedContent = lines.join("\n");
+
+            fs.writeFile(serverTsPath, updatedContent, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+        }
+
+        if (DB === "postgresql" && modelTool === "drizzle") {
+            const dbTsPath = path.join(projectPath, "/src/common/config/db.ts")
+
+            fs.writeFile(dbTsPath, drizzlePostgresBoilerPlate, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+
+            const serverTsPath = path.join(projectPath, "/src/server.ts");
+            const serverTsData = await fs.readFile(serverTsPath, "utf-8");
+
+            const targetLine = [3, 9]
+            const insertedData = [`import { db } from "./common/config/db.ts";
+import { sql } from "drizzle-orm"`,
+                '        await db.execute(sql`select 1`)'];
+
+            const lines = serverTsData.split(/\r?\n/);
+            lines.splice(targetLine[0] - 1, 0, insertedData[0])
+            lines.splice(targetLine[1], 1)
+            lines.splice(targetLine[1], 0, insertedData[1])
+
+
+
+            const updatedContent = lines.join("\n");
+
+            fs.writeFile(serverTsPath, updatedContent, "utf-8", (err)=>{
+                if (err) {
+                    spinnerDiscardingStdin.fail(err?.message)
+                    spinnerDiscardingStdin.start()
+                    return;
+                }
+            })
+        }
+    }
+}

package/bin/packages.js

@@ -0,0 +1,51 @@
+export const dbPackages = {
+  mongodb: {
+    mongoose: {
+      dependencies: {
+        "mongoose": "^9.9.4"
+      }
+    }
+  },
+
+  postgresql: {
+    drizzle: {
+      dependencies: {
+        "drizzle-orm": "^0.45.2",
+        "pg": "^8.20.0"
+      },
+      devDependencies: {
+        "drizzle-kit": "^0.31.10"
+      }
+    },
+
+    prisma: {
+      dependencies: {
+        "@prisma/client": "^7.10.0",
+        "pg": "^8.20.0"
+      },
+      devDependencies: {
+        "prisma": "^7.10.0"
+      }
+    }
+  },
+
+  mysql: {
+    drizzle: {
+      dependencies: {
+        "drizzle-orm": "^0.45.2"
+      },
+      devDependencies: {
+        "drizzle-kit": "^0.31.10"
+      }
+    },
+
+    prisma: {
+      dependencies: {
+        "@prisma/client": "^7.10.0"
+      },
+      devDependencies: {
+        "prisma": "^7.10.0"
+      }
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-modular-monolith",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "This is a modular monolith project generator for Express.js",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "license": "MIT",
   "author": "Md Khalid Hossain",
   "dependencies": {
-    "@inquirer/prompts": "^8.6.0"
+    "@inquirer/prompts": "^8.6.0",
+    "ora": "^9.4.1"
   }
 }

package/templates/javascript/src/app.js

@@ -1,8 +1,9 @@
-import express from 'express'
+import express from "express"
 
 const app = express()
 
 app.use(express.json())
 app.use(express.urlencoded({ extended: true }))
 
+
 export default app 

package/templates/javascript/src/server.js

@@ -1,5 +1,5 @@
-import 'dotenv/config'
-import app from './app.js'
+import "dotenv/config"
+import app from "./app.js"
 
 
 const PORT = process.env.PORT || 8000
@@ -11,7 +11,7 @@ const PORT = process.env.PORT || 8000
             console.log(`Server is running at port ${PORT}`)
         })
     } catch (error) {
-        console.error('Failed to start server', error)
+        console.error("Failed to start server", error)
         process.exit(1)
     }
 })()

package/templates/typescript/package.json

@@ -16,7 +16,8 @@
     "@types/express": "^5.0.6",
     "@types/node": "^25.6.0",
     "tsc-watch": "^7.2.0",
-    "tsx": "^4.21.0"
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
   },
   "keywords": [],
   "author": "",

package/templates/typescript/src/app.ts

@@ -1,7 +1,10 @@
-import express from 'express'
-import type { Express } from 'express'
-
+import express from "express"
+import type { Express } from "express"
 
 const app:Express = express()
 
+app.use(express.json())
+app.use(express.urlencoded({ extended: true }))
+
+
 export default app 

package/templates/typescript/src/server.ts

@@ -1,5 +1,5 @@
-import 'dotenv/config'
-import app from './app.js'
+import "dotenv/config"
+import app from "./app.js"
 
 
 const PORT = process.env.PORT || 8000
@@ -11,7 +11,7 @@ const PORT = process.env.PORT || 8000
             console.log(`Server is running at port ${PORT}`)
         })
     } catch (error) {
-        console.error('Failed to start server', error)
+        console.error("Failed to start server", error)
         process.exit(1)
     }
 })()

package/templates/typescript/tsconfig.json

@@ -32,6 +32,9 @@
     // "noFallthroughCasesInSwitch": true,
     // "noPropertyAccessFromIndexSignature": true,
 
+    // it's added to resolve import statements with .ts extension, you can configure your own way to fix the same issue
+    "rewriteRelativeImportExtensions": true,
+
     // Recommended Options
     "strict": true,
     "jsx": "react-jsx",