build-node-app-personal 1.0.0

package/bin/build-node-app.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import fs from "fs";
+import path from "path";
+import url from "url";
+
+const program = new Command();
+
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function copyTemplate(targetDir, appName, dbType) {
+  let templateFolder;
+  switch (dbType) {
+    case "mongo":
+      templateFolder = "template";
+      break;
+    case "postgres":
+      templateFolder = "template-postgres";
+      break;
+    case "mysql":
+      templateFolder = "template-mysql";
+      break;
+    case "none":
+      templateFolder = "template-none";
+      break;
+    default:
+      console.error(
+        "Unsupported database type. Use 'mongo', 'postgres', 'mysql', or 'none'."
+      );
+      process.exit(1);
+  }
+  const templateDir = path.join(__dirname, "..", templateFolder);
+
+  if (!fs.existsSync(templateDir)) {
+    console.error("Template directory not found:", templateDir);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  const entries = fs.readdirSync(templateDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(templateDir, entry.name);
+    const destPath = path.join(
+      targetDir,
+      entry.name.replace("APP_NAME", appName)
+    );
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, appName);
+    } else {
+      let content = fs.readFileSync(srcPath, "utf8");
+      content = content.replace(/APP_NAME/g, appName);
+      fs.writeFileSync(destPath, content, "utf8");
+    }
+  }
+}
+
+function copyDirRecursive(srcDir, destDir, appName) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(
+      destDir,
+      entry.name.replace("APP_NAME", appName)
+    );
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath, appName);
+    } else {
+      let content = fs.readFileSync(srcPath, "utf8");
+      content = content.replace(/APP_NAME/g, appName);
+      fs.writeFileSync(destPath, content, "utf8");
+    }
+  }
+}
+
+program
+  .name("create-node-app")
+  .argument("<app-name>", "name of the new Node.js app")
+  .option(
+    "-d, --db <type>",
+    "database type (mongo, postgres, mysql, none)",
+    "mongo"
+  )
+  .action((appName, options) => {
+    const targetDir = path.resolve(process.cwd(), appName);
+
+    if (fs.existsSync(targetDir)) {
+      console.error(`Directory ${appName} already exists. Aborting.`);
+      process.exit(1);
+    }
+
+    const dbType = String(options.db || "mongo").toLowerCase();
+
+    console.log(`Creating Node.js app '${appName}'...`);
+    console.log(`Database selected: ${dbType}`);
+
+    copyTemplate(targetDir, appName, dbType);
+
+    console.log("Project created successfully!");
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${appName}`);
+    console.log(`  npm install`);
+    console.log(`  npm run dev`);
+  });
+
+program.parse(process.argv);
+

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "build-node-app-personal",
+  "version": "1.0.0",
+  "description": "CLI to scaffold a Node.js app with basic setup and DB configuration",
+  "bin": {
+    "build-node-app": "bin/build-node-app.js"
+  },
+  "scripts": {
+    "start": "node bin/build-node-app.js",
+    "dev": "node bin/build-node-app.js"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "node",
+    "generator"
+  ],
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "commander": "^12.0.0"
+  }
+}

package/template/.env

@@ -0,0 +1,3 @@
+PORT=4000
+MONGO_URI=mongodb://localhost:27017/APP_NAME
+

package/template/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "APP_NAME",
+  "version": "1.0.0",
+  "description": "Generated Node.js app",
+  "main": "server.js",
+  "scripts": {
+    "dev": "node server.js",
+    "start": "node server.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "express": "^4.19.0",
+    "mongoose": "^8.0.0"
+  }
+}

package/template/server.js

@@ -0,0 +1,21 @@
+import "dotenv/config";
+import { createServer } from "./src/app.js";
+import { connectDB } from "./src/config/db.js";
+
+const port = process.env.PORT || 4000;
+
+async function start() {
+  await connectDB();
+
+  const app = createServer();
+
+  app.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+  });
+}
+
+start().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+

package/template/src/app.js

@@ -0,0 +1,30 @@
+import express from "express";
+import { userRouter } from "./routes/userRoutes.js";
+import { requestLogger } from "./middleware/logger.js";
+import { notFound } from "./middleware/notFound.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+export function createServer() {
+  const app = express();
+
+  // Core middlewares
+  app.use(express.json());
+  app.use(requestLogger);
+
+  // Health check / root route
+  app.get("/", (req, res) => {
+    res.json({ message: "Welcome to APP_NAME API" });
+  });
+
+  // User CRUD routes
+  app.use("/api/users", userRouter);
+
+  // Not found + error handlers
+  app.use(notFound);
+  app.use(errorHandler);
+
+  return app;
+}
+
+
+

package/template/src/config/db.js

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+
+export async function connectDB() {
+  const uri = process.env.MONGO_URI;
+
+  if (!uri) {
+    console.warn("MONGO_URI not set. Skipping DB connection.");
+    return;
+  }
+
+  try {
+    await mongoose.connect(uri);
+    console.log("Connected to MongoDB");
+  } catch (err) {
+    console.error("MongoDB connection error:", err.message);
+    throw err;
+  }
+}
+

package/template/src/controllers/userController.js

@@ -0,0 +1,61 @@
+import { User } from "../models/userModel.js";
+
+export async function createUser(req, res, next) {
+  try {
+    const user = await User.create(req.body);
+    res.status(201).json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUsers(req, res, next) {
+  try {
+    const users = await User.find().lean();
+    res.json(users);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUserById(req, res, next) {
+  try {
+    const user = await User.findById(req.params.id).lean();
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function updateUser(req, res, next) {
+  try {
+    const user = await User.findByIdAndUpdate(req.params.id, req.body, {
+      new: true,
+      runValidators: true,
+    }).lean();
+
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function deleteUser(req, res, next) {
+  try {
+    const user = await User.findByIdAndDelete(req.params.id).lean();
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+

package/template/src/middleware/errorHandler.js

@@ -0,0 +1,12 @@
+// Generic error-handling middleware
+export function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+
+  const status = err.status || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(status).json({
+    message,
+  });
+}
+

package/template/src/middleware/logger.js

@@ -0,0 +1,14 @@
+// Basic request logger middleware
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(
+      `${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`
+    );
+  });
+
+  next();
+}
+

package/template/src/middleware/notFound.js

@@ -0,0 +1,8 @@
+// 404 handler for unknown routes
+export function notFound(req, res, next) {
+  res.status(404).json({
+    message: "Route not found",
+    path: req.originalUrl,
+  });
+}
+

package/template/src/middleware/userMiddleware.js

@@ -0,0 +1,13 @@
+// Basic validation middleware for user payloads
+export function validateUserBody(req, res, next) {
+  const { name, email } = req.body || {};
+
+  if (!name || !email) {
+    return res.status(400).json({
+      message: "Both 'name' and 'email' are required.",
+    });
+  }
+
+  next();
+}
+

package/template/src/models/userModel.js

@@ -0,0 +1,24 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true,
+      lowercase: true,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+export const User = mongoose.models.User || mongoose.model("User", userSchema);
+

package/template/src/routes/userRoutes.js

@@ -0,0 +1,27 @@
+import express from "express";
+import {
+  createUser,
+  getUsers,
+  getUserById,
+  updateUser,
+  deleteUser,
+} from "../controllers/userController.js";
+import { validateUserBody } from "../middleware/userMiddleware.js";
+
+export const userRouter = express.Router();
+
+// Create
+userRouter.post("/", validateUserBody, createUser);
+
+// Read all
+userRouter.get("/", getUsers);
+
+// Read one
+userRouter.get("/:id", getUserById);
+
+// Update
+userRouter.put("/:id", validateUserBody, updateUser);
+
+// Delete
+userRouter.delete("/:id", deleteUser);
+

package/template-mysql/.env

@@ -0,0 +1,7 @@
+PORT=4000
+MYSQL_HOST=localhost
+MYSQL_PORT=3306
+MYSQL_DATABASE=APP_NAME
+MYSQL_USER=root
+MYSQL_PASSWORD=password
+

package/template-mysql/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "APP_NAME",
+  "version": "1.0.0",
+  "description": "Generated Node.js app (MySQL user CRUD)",
+  "main": "server.js",
+  "scripts": {
+    "dev": "node server.js",
+    "start": "node server.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "express": "^4.19.0",
+    "mysql2": "^3.9.0"
+  }
+}

package/template-mysql/server.js

@@ -0,0 +1,21 @@
+import "dotenv/config";
+import { createServer } from "./src/app.js";
+import { connectDB } from "./src/config/db.js";
+
+const port = process.env.PORT || 4000;
+
+async function start() {
+  await connectDB();
+
+  const app = createServer();
+
+  app.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+  });
+}
+
+start().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+

package/template-mysql/src/app.js

@@ -0,0 +1,28 @@
+import express from "express";
+import { userRouter } from "./routes/userRoutes.js";
+import { requestLogger } from "./middleware/logger.js";
+import { notFound } from "./middleware/notFound.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+export function createServer() {
+  const app = express();
+
+  // Core middlewares
+  app.use(express.json());
+  app.use(requestLogger);
+
+  // Health check / root route
+  app.get("/", (req, res) => {
+    res.json({ message: "Welcome to APP_NAME API (MySQL)" });
+  });
+
+  // User CRUD routes
+  app.use("/api/users", userRouter);
+
+  // Not found + error handlers
+  app.use(notFound);
+  app.use(errorHandler);
+
+  return app;
+}
+

package/template-mysql/src/config/db.js

@@ -0,0 +1,32 @@
+import mysql from "mysql2/promise";
+
+export let pool;
+
+export async function connectDB() {
+  try {
+    pool = await mysql.createPool({
+      host: process.env.MYSQL_HOST || "localhost",
+      port: Number(process.env.MYSQL_PORT) || 3306,
+      database: process.env.MYSQL_DATABASE || "APP_NAME",
+      user: process.env.MYSQL_USER || "root",
+      password: process.env.MYSQL_PASSWORD || "password",
+      waitForConnections: true,
+      connectionLimit: 10,
+    });
+
+    await pool.query("SELECT 1");
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        email VARCHAR(255) NOT NULL UNIQUE
+      );
+    `);
+
+    console.log("Connected to MySQL");
+  } catch (err) {
+    console.error("MySQL connection error:", err.message);
+    throw err;
+  }
+}
+

package/template-mysql/src/controllers/userController.js

@@ -0,0 +1,62 @@
+import {
+  createUser as createUserModel,
+  getAllUsers,
+  getUserById as getUserByIdModel,
+  updateUser as updateUserModel,
+  deleteUser as deleteUserModel,
+} from "../models/userModel.js";
+
+export async function createUser(req, res, next) {
+  try {
+    const user = await createUserModel(req.body);
+    res.status(201).json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUsers(req, res, next) {
+  try {
+    const users = await getAllUsers();
+    res.json(users);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUserById(req, res, next) {
+  try {
+    const user = await getUserByIdModel(req.params.id);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function updateUser(req, res, next) {
+  try {
+    const user = await updateUserModel(req.params.id, req.body);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function deleteUser(req, res, next) {
+  try {
+    const success = await deleteUserModel(req.params.id);
+    if (!success) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+

package/template-mysql/src/middleware/errorHandler.js

@@ -0,0 +1,12 @@
+// Generic error-handling middleware
+export function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+
+  const status = err.status || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(status).json({
+    message,
+  });
+}
+

package/template-mysql/src/middleware/logger.js

@@ -0,0 +1,14 @@
+// Basic request logger middleware
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(
+      `${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`
+    );
+  });
+
+  next();
+}
+

package/template-mysql/src/middleware/notFound.js

@@ -0,0 +1,8 @@
+// 404 handler for unknown routes
+export function notFound(req, res, next) {
+  res.status(404).json({
+    message: "Route not found",
+    path: req.originalUrl,
+  });
+}
+

package/template-mysql/src/middleware/userMiddleware.js

@@ -0,0 +1,13 @@
+// Basic validation middleware for user payloads
+export function validateUserBody(req, res, next) {
+  const { name, email } = req.body || {};
+
+  if (!name || !email) {
+    return res.status(400).json({
+      message: "Both 'name' and 'email' are required.",
+    });
+  }
+
+  next();
+}
+

package/template-mysql/src/models/userModel.js

@@ -0,0 +1,39 @@
+import { pool } from "../config/db.js";
+
+export async function createUser(data) {
+  const { name, email } = data;
+  const [result] = await pool.query(
+    "INSERT INTO users (name, email) VALUES (?, ?)",
+    [name, email]
+  );
+  const [rows] = await pool.query("SELECT * FROM users WHERE id = ?", [
+    result.insertId,
+  ]);
+  return rows[0];
+}
+
+export async function getAllUsers() {
+  const [rows] = await pool.query("SELECT * FROM users ORDER BY id");
+  return rows;
+}
+
+export async function getUserById(id) {
+  const [rows] = await pool.query("SELECT * FROM users WHERE id = ?", [id]);
+  return rows[0] || null;
+}
+
+export async function updateUser(id, updates) {
+  const { name, email } = updates;
+  await pool.query(
+    "UPDATE users SET name = ?, email = ? WHERE id = ?",
+    [name, email, id]
+  );
+  const [rows] = await pool.query("SELECT * FROM users WHERE id = ?", [id]);
+  return rows[0] || null;
+}
+
+export async function deleteUser(id) {
+  const [result] = await pool.query("DELETE FROM users WHERE id = ?", [id]);
+  return result.affectedRows > 0;
+}
+

package/template-mysql/src/routes/userRoutes.js

@@ -0,0 +1,27 @@
+import express from "express";
+import {
+  createUser,
+  getUsers,
+  getUserById,
+  updateUser,
+  deleteUser,
+} from "../controllers/userController.js";
+import { validateUserBody } from "../middleware/userMiddleware.js";
+
+export const userRouter = express.Router();
+
+// Create
+userRouter.post("/", validateUserBody, createUser);
+
+// Read all
+userRouter.get("/", getUsers);
+
+// Read one
+userRouter.get("/:id", getUserById);
+
+// Update
+userRouter.put("/:id", validateUserBody, updateUser);
+
+// Delete
+userRouter.delete("/:id", deleteUser);
+

package/template-none/.env

@@ -0,0 +1,2 @@
+PORT=4000
+

package/template-none/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "APP_NAME",
+  "version": "1.0.0",
+  "description": "Generated Node.js app (no database, in-memory user store)",
+  "main": "server.js",
+  "scripts": {
+    "dev": "node server.js",
+    "start": "node server.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "express": "^4.19.0"
+  }
+}

package/template-none/server.js

@@ -0,0 +1,18 @@
+import "dotenv/config";
+import { createServer } from "./src/app.js";
+
+const port = process.env.PORT || 4000;
+
+async function start() {
+  const app = createServer();
+
+  app.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+  });
+}
+
+start().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+

package/template-none/src/app.js

@@ -0,0 +1,24 @@
+import express from "express";
+import { userRouter } from "./routes/userRoutes.js";
+import { requestLogger } from "./middleware/logger.js";
+import { notFound } from "./middleware/notFound.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+export function createServer() {
+  const app = express();
+
+  app.use(express.json());
+  app.use(requestLogger);
+
+  app.get("/", (req, res) => {
+    res.json({ message: "Welcome to APP_NAME API (no database)" });
+  });
+
+  app.use("/api/users", userRouter);
+
+  app.use(notFound);
+  app.use(errorHandler);
+
+  return app;
+}
+

package/template-none/src/config/db.js

@@ -0,0 +1,5 @@
+// No-op DB config for --db none
+export async function connectDB() {
+  console.log("No database selected. Using in-memory storage.");
+}
+

package/template-none/src/controllers/userController.js

@@ -0,0 +1,61 @@
+import {
+  createUser as createUserModel,
+  getAllUsers,
+  getUserById as getUserByIdModel,
+  updateUser as updateUserModel,
+  deleteUser as deleteUserModel,
+} from "../models/userModel.js";
+
+export async function createUser(req, res, next) {
+  try {
+    const user = createUserModel(req.body);
+    res.status(201).json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUsers(req, res, next) {
+  try {
+    res.json(getAllUsers());
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUserById(req, res, next) {
+  try {
+    const user = getUserByIdModel(req.params.id);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function updateUser(req, res, next) {
+  try {
+    const user = updateUserModel(req.params.id, req.body);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function deleteUser(req, res, next) {
+  try {
+    const success = deleteUserModel(req.params.id);
+    if (!success) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+

package/template-none/src/middleware/errorHandler.js

@@ -0,0 +1,12 @@
+// Generic error-handling middleware
+export function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+
+  const status = err.status || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(status).json({
+    message,
+  });
+}
+

package/template-none/src/middleware/logger.js

@@ -0,0 +1,14 @@
+// Basic request logger middleware
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(
+      `${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`
+    );
+  });
+
+  next();
+}
+

package/template-none/src/middleware/notFound.js

@@ -0,0 +1,8 @@
+// 404 handler for unknown routes
+export function notFound(req, res, next) {
+  res.status(404).json({
+    message: "Route not found",
+    path: req.originalUrl,
+  });
+}
+

package/template-none/src/middleware/userMiddleware.js

@@ -0,0 +1,13 @@
+// Basic validation middleware for user payloads
+export function validateUserBody(req, res, next) {
+  const { name, email } = req.body || {};
+
+  if (!name || !email) {
+    return res.status(400).json({
+      message: "Both 'name' and 'email' are required.",
+    });
+  }
+
+  next();
+}
+

package/template-none/src/models/userModel.js

@@ -0,0 +1,34 @@
+// In-memory user "model" for apps generated with --db none
+
+let users = [];
+let nextId = 1;
+
+export function createUser(data) {
+  const user = { id: String(nextId++), ...data };
+  users.push(user);
+  return user;
+}
+
+export function getAllUsers() {
+  return users;
+}
+
+export function getUserById(id) {
+  return users.find((u) => u.id === String(id)) || null;
+}
+
+export function updateUser(id, updates) {
+  const idx = users.findIndex((u) => u.id === String(id));
+  if (idx === -1) return null;
+
+  users[idx] = { ...users[idx], ...updates };
+  return users[idx];
+}
+
+export function deleteUser(id) {
+  const idx = users.findIndex((u) => u.id === String(id));
+  if (idx === -1) return false;
+  users.splice(idx, 1);
+  return true;
+}
+

package/template-none/src/routes/userRoutes.js

@@ -0,0 +1,27 @@
+import express from "express";
+import {
+  createUser,
+  getUsers,
+  getUserById,
+  updateUser,
+  deleteUser,
+} from "../controllers/userController.js";
+import { validateUserBody } from "../middleware/userMiddleware.js";
+
+export const userRouter = express.Router();
+
+// Create
+userRouter.post("/", validateUserBody, createUser);
+
+// Read all
+userRouter.get("/", getUsers);
+
+// Read one
+userRouter.get("/:id", getUserById);
+
+// Update
+userRouter.put("/:id", validateUserBody, updateUser);
+
+// Delete
+userRouter.delete("/:id", deleteUser);
+

package/template-postgres/.env

@@ -0,0 +1,7 @@
+PORT=4000
+PG_HOST=localhost
+PG_PORT=5432
+PG_DATABASE=APP_NAME
+PG_USER=postgres
+PG_PASSWORD=password
+

package/template-postgres/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "APP_NAME",
+  "version": "1.0.0",
+  "description": "Generated Node.js app (PostgreSQL user CRUD)",
+  "main": "server.js",
+  "scripts": {
+    "dev": "node server.js",
+    "start": "node server.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "dotenv": "^16.4.0",
+    "express": "^4.19.0",
+    "pg": "^8.11.0"
+  }
+}

package/template-postgres/server.js

@@ -0,0 +1,21 @@
+import "dotenv/config";
+import { createServer } from "./src/app.js";
+import { connectDB } from "./src/config/db.js";
+
+const port = process.env.PORT || 4000;
+
+async function start() {
+  await connectDB();
+
+  const app = createServer();
+
+  app.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+  });
+}
+
+start().catch((err) => {
+  console.error("Failed to start server:", err);
+  process.exit(1);
+});
+

package/template-postgres/src/app.js

@@ -0,0 +1,28 @@
+import express from "express";
+import { userRouter } from "./routes/userRoutes.js";
+import { requestLogger } from "./middleware/logger.js";
+import { notFound } from "./middleware/notFound.js";
+import { errorHandler } from "./middleware/errorHandler.js";
+
+export function createServer() {
+  const app = express();
+
+  // Core middlewares
+  app.use(express.json());
+  app.use(requestLogger);
+
+  // Health check / root route
+  app.get("/", (req, res) => {
+    res.json({ message: "Welcome to APP_NAME API (PostgreSQL)" });
+  });
+
+  // User CRUD routes
+  app.use("/api/users", userRouter);
+
+  // Not found + error handlers
+  app.use(notFound);
+  app.use(errorHandler);
+
+  return app;
+}
+

package/template-postgres/src/config/db.js

@@ -0,0 +1,29 @@
+import pkg from "pg";
+
+const { Pool } = pkg;
+
+export const pool = new Pool({
+  host: process.env.PG_HOST || "localhost",
+  port: Number(process.env.PG_PORT) || 5432,
+  database: process.env.PG_DATABASE || "APP_NAME",
+  user: process.env.PG_USER || "postgres",
+  password: process.env.PG_PASSWORD || "password",
+});
+
+export async function connectDB() {
+  try {
+    await pool.query("SELECT 1");
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL UNIQUE
+      );
+    `);
+    console.log("Connected to PostgreSQL");
+  } catch (err) {
+    console.error("PostgreSQL connection error:", err.message);
+    throw err;
+  }
+}
+

package/template-postgres/src/controllers/userController.js

@@ -0,0 +1,62 @@
+import {
+  createUser as createUserModel,
+  getAllUsers,
+  getUserById as getUserByIdModel,
+  updateUser as updateUserModel,
+  deleteUser as deleteUserModel,
+} from "../models/userModel.js";
+
+export async function createUser(req, res, next) {
+  try {
+    const user = await createUserModel(req.body);
+    res.status(201).json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUsers(req, res, next) {
+  try {
+    const users = await getAllUsers();
+    res.json(users);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function getUserById(req, res, next) {
+  try {
+    const user = await getUserByIdModel(req.params.id);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function updateUser(req, res, next) {
+  try {
+    const user = await updateUserModel(req.params.id, req.body);
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.json(user);
+  } catch (err) {
+    next(err);
+  }
+}
+
+export async function deleteUser(req, res, next) {
+  try {
+    const success = await deleteUserModel(req.params.id);
+    if (!success) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    res.status(204).send();
+  } catch (err) {
+    next(err);
+  }
+}
+

package/template-postgres/src/middleware/errorHandler.js

@@ -0,0 +1,12 @@
+// Generic error-handling middleware
+export function errorHandler(err, req, res, next) {
+  console.error("Error:", err);
+
+  const status = err.status || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(status).json({
+    message,
+  });
+}
+

package/template-postgres/src/middleware/logger.js

@@ -0,0 +1,14 @@
+// Basic request logger middleware
+export function requestLogger(req, res, next) {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    console.log(
+      `${req.method} ${req.originalUrl} ${res.statusCode} - ${duration}ms`
+    );
+  });
+
+  next();
+}
+

package/template-postgres/src/middleware/notFound.js

@@ -0,0 +1,8 @@
+// 404 handler for unknown routes
+export function notFound(req, res, next) {
+  res.status(404).json({
+    message: "Route not found",
+    path: req.originalUrl,
+  });
+}
+

package/template-postgres/src/middleware/userMiddleware.js

@@ -0,0 +1,13 @@
+// Basic validation middleware for user payloads
+export function validateUserBody(req, res, next) {
+  const { name, email } = req.body || {};
+
+  if (!name || !email) {
+    return res.status(400).json({
+      message: "Both 'name' and 'email' are required.",
+    });
+  }
+
+  next();
+}
+

package/template-postgres/src/models/userModel.js

@@ -0,0 +1,35 @@
+import { pool } from "../config/db.js";
+
+export async function createUser(data) {
+  const { name, email } = data;
+  const result = await pool.query(
+    "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *",
+    [name, email]
+  );
+  return result.rows[0];
+}
+
+export async function getAllUsers() {
+  const result = await pool.query("SELECT * FROM users ORDER BY id");
+  return result.rows;
+}
+
+export async function getUserById(id) {
+  const result = await pool.query("SELECT * FROM users WHERE id = $1", [id]);
+  return result.rows[0] || null;
+}
+
+export async function updateUser(id, updates) {
+  const { name, email } = updates;
+  const result = await pool.query(
+    "UPDATE users SET name = $1, email = $2 WHERE id = $3 RETURNING *",
+    [name, email, id]
+  );
+  return result.rows[0] || null;
+}
+
+export async function deleteUser(id) {
+  const result = await pool.query("DELETE FROM users WHERE id = $1", [id]);
+  return result.rowCount > 0;
+}
+

package/template-postgres/src/routes/userRoutes.js

@@ -0,0 +1,27 @@
+import express from "express";
+import {
+  createUser,
+  getUsers,
+  getUserById,
+  updateUser,
+  deleteUser,
+} from "../controllers/userController.js";
+import { validateUserBody } from "../middleware/userMiddleware.js";
+
+export const userRouter = express.Router();
+
+// Create
+userRouter.post("/", validateUserBody, createUser);
+
+// Read all
+userRouter.get("/", getUsers);
+
+// Read one
+userRouter.get("/:id", getUserById);
+
+// Update
+userRouter.put("/:id", validateUserBody, updateUser);
+
+// Delete
+userRouter.delete("/:id", deleteUser);
+