create-nodets-app-nish 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nodets-app-nish",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Command line tool to create a new Node.js + Express + MongoDB + TypeScript project template",
   "license": "ISC",
   "author": "krish112407",

package/templates/nodejs-typescript/.env.example

@@ -0,0 +1,12 @@
+PORT=3000
+MONGODB_URI=mongodb://localhost:27017/your-app-name
+JWT_SECRET=your-secret-key-here
+CORS_ORIGIN=http://localhost:3000
+
+# Email Configuration
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_SECURE=false
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+SMTP_FROM=noreply@yourapp.com

package/templates/nodejs-typescript/src/admin/model.register.ts

@@ -0,0 +1,5 @@
+import { Admin } from "../models/admin.models.js";
+
+export const models = {
+    "Admin": Admin
+}

package/templates/nodejs-typescript/src/app.ts

@@ -0,0 +1,17 @@
+import express from "express";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+
+const app = express();
+
+app.use(cors({
+    origin: process.env.CORS_ORIGIN,
+    credentials: true
+}))
+
+app.use(express.json({limit:"16kb"}))
+app.use(express.urlencoded({extended:true,limit:"16kb"}))
+app.use(express.static("public"))
+app.use(cookieParser())
+
+export {app}

package/templates/nodejs-typescript/src/db/index.ts

@@ -0,0 +1,13 @@
+import mongosee from "mongoose"
+
+
+async function connectDB(){
+    try {
+        await mongosee.connect(process.env.MONGODB_URI as string)
+        console.log("MongoDB connected")
+    } catch (error) {
+        console.log(error)
+    }
+}
+
+export {connectDB}

package/templates/nodejs-typescript/src/index.ts

@@ -0,0 +1,16 @@
+import { app } from "./app.js";
+import dotenv from "dotenv";
+import { connectDB } from "./db/index.js";
+
+dotenv.config();
+
+const port = process.env.PORT || 3000;
+
+connectDB().then(() => {
+    app.listen(port, () => {
+        console.log(`Server is running on port ${port}`);
+    });
+})
+    .catch((err) => {
+        console.log("Error connecting to database", err);
+    })

package/templates/nodejs-typescript/src/interface/admin.interface.ts

@@ -0,0 +1,12 @@
+import { Document } from "mongoose";
+
+
+interface IAdmin extends Document{
+    username:string;
+    email:string;
+    password:string;
+    generateAccessToken():string;
+    isPasswordCorrect(password:string):Promise<boolean>
+}
+
+export type { IAdmin }

package/templates/nodejs-typescript/src/models/admin.models.ts

@@ -0,0 +1,46 @@
+import type { IAdmin } from "../interface/admin.interface.js";
+import mongoose, { Document } from "mongoose";
+import jwt from "jsonwebtoken";
+import bcrypt from "bcrypt";
+
+type AdminType = IAdmin & Document;
+
+
+const AdminSchema = new mongoose.Schema<AdminType>({
+    username: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    password: {
+        type: String,
+        required: true
+    }
+})
+
+AdminSchema.pre("save", async function () {
+    if (this.isModified("password")) {
+        this.password = await bcrypt.hash(this.password, 10)
+    }
+})
+
+AdminSchema.methods.generateAccessToken = function (): string {
+    return jwt.sign({
+        _id: this._id,
+        username: this.username,
+        email: this.email
+    }, process.env.JWT_SECRET as string, {
+        expiresIn: "1d"
+    })
+}
+
+AdminSchema.methods.isPasswordCorrect = async function (password: string): Promise<boolean> {
+    return await bcrypt.compare(password, this.password)
+}
+
+export const Admin = mongoose.model<AdminType>("Admin", AdminSchema)

package/templates/nodejs-typescript/src/utils/apiResponse.ts

@@ -0,0 +1,22 @@
+import type { Response } from "express";
+
+class ApiResponse{
+    constructor(
+        public statusCode: number,
+        public message: string,
+        public data: any
+    ){
+        this.statusCode = statusCode
+        this.message = message
+        this.data = data
+    }
+}
+
+
+function returnResponse(res:Response,statusCode:number,message:string,data:any){
+    return res.status(statusCode).json(
+        new ApiResponse(statusCode,message,data)
+    )
+}
+
+export {returnResponse}

package/templates/nodejs-typescript/src/utils/asyncHandler.ts

@@ -0,0 +1,9 @@
+import type { Request, Response, NextFunction, RequestHandler } from "express";
+
+function asyncHandler(fn: RequestHandler) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+export { asyncHandler };

package/templates/nodejs-typescript/src/utils/login.ts

@@ -0,0 +1,43 @@
+import type { Model } from "mongoose";
+import * as modeldata from "../admin/model.register.js";
+
+// Accepts either string or object for identifier
+type Identifier = string | Record<string, any>;
+
+async function login(
+    model: keyof typeof modeldata.models, // TS now knows only valid models can be used
+    uniqueIdentifier: Identifier,
+    password: string
+) {
+    const Model: Model<any> = modeldata.models[model]; // cast to Model<any> to avoid TS errors
+    if (!Model) {
+        throw new Error("Model not found");
+    }
+
+    // If uniqueIdentifier is a string, assume it's an 'id' search
+    const query = typeof uniqueIdentifier === "string"
+        ? { id: uniqueIdentifier }
+        : uniqueIdentifier;
+
+    const user = await Model.findOne(query);
+    if (!user) {
+        throw new Error("User not found");
+    }
+
+    // Check password
+    const isPasswordCorrect = await user.isPasswordCorrect(password);
+    if (!isPasswordCorrect) {
+        throw new Error("Password is not correct");
+    }
+
+    // Generate token
+    const token = user.generateAccessToken();
+
+    if (!token) {
+        throw new Error("Token not generated");
+    }
+    return token;
+}
+
+
+export { login }

package/templates/nodejs-typescript/src/utils/sendMail.ts

@@ -0,0 +1,47 @@
+import nodemailer from "nodemailer";
+import type { Transporter } from "nodemailer";
+
+interface MailOptions {
+    to: string;
+    subject: string;
+    text?: string;
+    html?: string;
+    from?: string;
+}
+
+let transporter: Transporter | null = null;
+
+// Initialize transporter (only once)
+function getTransporter(): Transporter {
+    if (!transporter) {
+        transporter = nodemailer.createTransport({
+            host: process.env.SMTP_HOST,
+            port: Number(process.env.SMTP_PORT) || 587,
+            secure: process.env.SMTP_SECURE === "true", // true for 465, false for other ports
+            auth: {
+                user: process.env.SMTP_USER,
+                pass: process.env.SMTP_PASS,
+            },
+        });
+    }
+    return transporter;
+}
+
+export async function sendMail(options: MailOptions): Promise<void> {
+    const mailOptions = {
+        from: options.from || process.env.SMTP_FROM || "no-reply@example.com",
+        to: options.to,
+        subject: options.subject,
+        text: options.text,
+        html: options.html,
+    };
+
+    try {
+        const transporter = getTransporter();
+        const info = await transporter.sendMail(mailOptions);
+        console.log("Email sent:", info.messageId);
+    } catch (error) {
+        console.error("Error sending email:", error);
+        throw new Error("Failed to send email");
+    }
+}

package/templates/nodejs-typescript/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": false,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}