starter-structure-cli 0.2.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "starter-structure-cli",
+  "version": "0.2.0",
+  "description": "Scaffold starter projects from your own stack-based template folders",
+  "type": "module",
+  "files": [
+    "bin",
+    "scripts",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "check:templates": "node ./scripts/check-templates.js",
+    "prepack": "node ./scripts/check-templates.js"
+  },
+  "bin": {
+    "starter-structure-cli": "bin/starter-structure-cli.js"
+  },
+  "keywords": [
+    "cli",
+    "scaffold",
+    "starter",
+    "template",
+    "boilerplate"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "picocolors": "^1.1.1"
+  },
+  "license": "MIT"
+}

package/scripts/check-templates.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const templatesRoot = path.resolve(__dirname, "..", "templates");
+
+function hasAnyFile(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isFile()) {
+      return true;
+    }
+
+    if (entry.isDirectory() && hasAnyFile(entryPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function getTemplateDirs(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
+  }
+
+  const templateDirs = [];
+  const categories = fs
+    .readdirSync(rootDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+  for (const category of categories) {
+    const categoryDir = path.join(rootDir, category);
+    const starters = fs
+      .readdirSync(categoryDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => path.join(categoryDir, entry.name));
+
+    templateDirs.push(...starters);
+  }
+
+  return templateDirs;
+}
+
+const emptyTemplates = getTemplateDirs(templatesRoot)
+  .filter((templateDir) => !hasAnyFile(templateDir))
+  .map((templateDir) => path.relative(templatesRoot, templateDir));
+
+if (emptyTemplates.length > 0) {
+  console.error("Template validation failed.");
+  console.error("These template directories do not contain any files:");
+  for (const templateDir of emptyTemplates) {
+    console.error(`- ${templateDir}`);
+  }
+  console.error("");
+  console.error("Add the real starter files before publishing.");
+  console.error("If a template intentionally contains only empty folders, add a .gitkeep file.");
+  process.exit(1);
+}
+
+console.log(`Template validation passed for ${getTemplateDirs(templatesRoot).length} templates.`);

package/templates/backend-only/express-mongoose-jwt/.env.example

@@ -0,0 +1,6 @@
+PORT=5000
+NODE_ENV=development
+MONGODB_URI=mongodb://127.0.0.1:27017/__APP_NAME__
+JWT_SECRET=change-this-secret
+JWT_EXPIRES_IN=7d
+CLIENT_URL=http://localhost:5173

package/templates/backend-only/express-mongoose-jwt/README.md

@@ -0,0 +1,43 @@
+# __APP_NAME__
+
+Express + Mongoose + JWT starter API.
+
+## Features
+
+- User registration and login
+- Password hashing with `bcryptjs`
+- JWT authentication middleware
+- MongoDB connection with Mongoose
+- Structured route/controller/model layout
+- Standard API response helpers
+
+## Project structure
+
+```text
+.
+├── config/
+├── controllers/
+├── middleware/
+├── models/
+├── routes/
+├── utils/
+├── .env.example
+├── .gitignore
+├── index.js
+└── package.json
+```
+
+## Getting started
+
+```bash
+npm install
+cp .env.example .env
+npm run dev
+```
+
+## API endpoints
+
+- `GET /api/health`
+- `POST /api/auth/register`
+- `POST /api/auth/login`
+- `GET /api/auth/me`

package/templates/backend-only/express-mongoose-jwt/config/db.js

@@ -0,0 +1,19 @@
+const mongoose = require("mongoose");
+
+async function connectDB() {
+  const mongoURI = process.env.MONGODB_URI;
+
+  if (!mongoURI) {
+    throw new Error("MONGODB_URI is not defined in environment variables.");
+  }
+
+  try {
+    await mongoose.connect(mongoURI);
+    console.log("MongoDB connected");
+  } catch (error) {
+    console.error("MongoDB connection failed:", error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = connectDB;

package/templates/backend-only/express-mongoose-jwt/controllers/auth/index.js

@@ -0,0 +1,91 @@
+const User = require("../../models/user");
+const { successResponse, errorResponse } = require("../../utils/api-response");
+const generateToken = require("../../utils/generate-token");
+
+async function register(req, res, next) {
+  try {
+    const { name, email, password } = req.body;
+
+    if (!name || !email || !password) {
+      return errorResponse(res, "Name, email, and password are required.", 400);
+    }
+
+    const existingUser = await User.findOne({ email: email.toLowerCase() });
+    if (existingUser) {
+      return errorResponse(res, "User already exists with this email.", 409);
+    }
+
+    const user = await User.create({
+      name,
+      email: email.toLowerCase(),
+      password
+    });
+
+    const token = generateToken(user._id);
+
+    return successResponse(
+      res,
+      {
+        user,
+        token
+      },
+      "Registration successful.",
+      201
+    );
+  } catch (error) {
+    next(error);
+  }
+}
+
+async function login(req, res, next) {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return errorResponse(res, "Email and password are required.", 400);
+    }
+
+    const user = await User.findOne({ email: email.toLowerCase() });
+    if (!user) {
+      return errorResponse(res, "Invalid email or password.", 401);
+    }
+
+    const isPasswordValid = await user.comparePassword(password);
+    if (!isPasswordValid) {
+      return errorResponse(res, "Invalid email or password.", 401);
+    }
+
+    const token = generateToken(user._id);
+
+    return successResponse(
+      res,
+      {
+        user,
+        token
+      },
+      "Login successful."
+    );
+  } catch (error) {
+    next(error);
+  }
+}
+
+async function me(req, res, next) {
+  try {
+    const user = await User.findById(req.user.id);
+
+    if (!user) {
+      return errorResponse(res, "User not found.", 404);
+    }
+
+    return successResponse(res, { user }, "Authenticated user fetched.");
+  } catch (error) {
+    next(error);
+  }
+}
+
+module.exports = {
+  register,
+  login,
+  me
+};

package/templates/backend-only/express-mongoose-jwt/index.js

@@ -0,0 +1,44 @@
+const express = require("express");
+const cors = require("cors");
+const dotenv = require("dotenv");
+const helmet = require("helmet");
+const morgan = require("morgan");
+
+const connectDB = require("./config/db");
+const routes = require("./routes");
+const notFound = require("./middleware/not-found");
+const errorHandler = require("./middleware/error-handler");
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+connectDB();
+
+app.use(
+  cors({
+    origin: process.env.CLIENT_URL || "*",
+    credentials: true
+  })
+);
+app.use(helmet());
+app.use(morgan("dev"));
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.get("/", (_req, res) => {
+  res.json({
+    success: true,
+    message: "__APP_NAME__ API is running"
+  });
+});
+
+app.use("/api", routes);
+
+app.use(notFound);
+app.use(errorHandler);
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});

package/templates/backend-only/express-mongoose-jwt/middleware/authenticate.js

@@ -0,0 +1,35 @@
+const jwt = require("jsonwebtoken");
+
+const User = require("../models/user");
+const { errorResponse } = require("../utils/api-response");
+
+async function authenticate(req, res, next) {
+  try {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      return errorResponse(res, "Unauthorized access.", 401);
+    }
+
+    const token = authHeader.split(" ")[1];
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+    const user = await User.findById(decoded.id).select("_id name email role");
+    if (!user) {
+      return errorResponse(res, "User not found.", 401);
+    }
+
+    req.user = {
+      id: user._id.toString(),
+      name: user.name,
+      email: user.email,
+      role: user.role
+    };
+
+    next();
+  } catch (_error) {
+    return errorResponse(res, "Invalid or expired token.", 401);
+  }
+}
+
+module.exports = authenticate;

package/templates/backend-only/express-mongoose-jwt/middleware/error-handler.js

@@ -0,0 +1,16 @@
+const { errorResponse } = require("../utils/api-response");
+
+function errorHandler(error, _req, res, _next) {
+  const statusCode = error.statusCode || 500;
+  const message = error.message || "Internal server error.";
+
+  if (process.env.NODE_ENV !== "test") {
+    console.error(error);
+  }
+
+  return errorResponse(res, message, statusCode, {
+    stack: process.env.NODE_ENV === "development" ? error.stack : undefined
+  });
+}
+
+module.exports = errorHandler;

package/templates/backend-only/express-mongoose-jwt/middleware/not-found.js

@@ -0,0 +1,7 @@
+const { errorResponse } = require("../utils/api-response");
+
+function notFound(req, res) {
+  return errorResponse(res, `Route not found: ${req.originalUrl}`, 404);
+}
+
+module.exports = notFound;

package/templates/backend-only/express-mongoose-jwt/models/user.js

@@ -0,0 +1,54 @@
+const bcrypt = require("bcryptjs");
+const mongoose = require("mongoose");
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true
+    },
+    password: {
+      type: String,
+      required: true,
+      minlength: 6
+    },
+    role: {
+      type: String,
+      enum: ["admin", "user"],
+      default: "user"
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+
+userSchema.pre("save", async function preSave(next) {
+  if (!this.isModified("password")) {
+    return next();
+  }
+
+  const salt = await bcrypt.genSalt(10);
+  this.password = await bcrypt.hash(this.password, salt);
+  next();
+});
+
+userSchema.methods.comparePassword = function comparePassword(candidatePassword) {
+  return bcrypt.compare(candidatePassword, this.password);
+};
+
+userSchema.methods.toJSON = function toJSON() {
+  const userObject = this.toObject();
+  delete userObject.password;
+  return userObject;
+};
+
+module.exports = mongoose.model("User", userSchema);

package/templates/backend-only/express-mongoose-jwt/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "__APP_NAME__",
+  "version": "1.0.0",
+  "description": "Express + Mongoose + JWT starter API",
+  "main": "index.js",
+  "scripts": {
+    "dev": "nodemon index.js",
+    "start": "node index.js"
+  },
+  "keywords": [
+    "express",
+    "mongoose",
+    "jwt",
+    "api"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "helmet": "^8.0.0",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.9.5",
+    "morgan": "^1.10.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.9"
+  }
+}

package/templates/backend-only/express-mongoose-jwt/routes/auth/index.js

@@ -0,0 +1,12 @@
+const express = require("express");
+
+const { login, me, register } = require("../../controllers/auth");
+const authenticate = require("../../middleware/authenticate");
+
+const router = express.Router();
+
+router.post("/register", register);
+router.post("/login", login);
+router.get("/me", authenticate, me);
+
+module.exports = router;

package/templates/backend-only/express-mongoose-jwt/routes/index.js

@@ -0,0 +1,16 @@
+const express = require("express");
+
+const authRoutes = require("./auth");
+
+const router = express.Router();
+
+router.get("/health", (_req, res) => {
+  res.json({
+    success: true,
+    message: "Server is healthy"
+  });
+});
+
+router.use("/auth", authRoutes);
+
+module.exports = router;

package/templates/backend-only/express-mongoose-jwt/utils/api-response.js

@@ -0,0 +1,20 @@
+function successResponse(res, data = null, message = "Success", statusCode = 200) {
+  return res.status(statusCode).json({
+    success: true,
+    message,
+    data
+  });
+}
+
+function errorResponse(res, message = "Something went wrong", statusCode = 500, errors = null) {
+  return res.status(statusCode).json({
+    success: false,
+    message,
+    errors
+  });
+}
+
+module.exports = {
+  successResponse,
+  errorResponse
+};

package/templates/backend-only/express-mongoose-jwt/utils/generate-token.js

@@ -0,0 +1,9 @@
+const jwt = require("jsonwebtoken");
+
+function generateToken(userId) {
+  return jwt.sign({ id: userId }, process.env.JWT_SECRET, {
+    expiresIn: process.env.JWT_EXPIRES_IN || "7d"
+  });
+}
+
+module.exports = generateToken;