@imksh/create 1.0.26 → 1.0.28

package/templates/node-ts/src/middleware/rateLimiter.ts

@@ -1,53 +0,0 @@
-import rateLimit from "express-rate-limit";
-import { Request, Response } from "express";
-
-interface LimiterConfig {
-  windowMs: number;
-  max: number;
-  message: string;
-  skipSuccessfulRequests?: boolean;
-}
-
-const createLimiter = ({
-  windowMs,
-  max,
-  message,
-  skipSuccessfulRequests = false,
-}: LimiterConfig) =>
-  rateLimit({
-    windowMs,
-    max,
-    standardHeaders: true,
-    legacyHeaders: false,
-    skipSuccessfulRequests,
-
-    keyGenerator: (req: any) => {
-      return req.user?.id || req.ip || req.headers["x-forwarded-for"] || req.socket.remoteAddress;
-    },
-
-    handler: (req: Request, res: Response) => {
-      res.status(429).json({
-        success: false,
-        message,
-      });
-    },
-  });
-
-export const apiLimiter = createLimiter({
-  windowMs: 15 * 60 * 1000,
-  max: 100,
-  message: "Too many requests. Please try again later.",
-});
-
-export const authLimiter = createLimiter({
-  windowMs: 15 * 60 * 1000,
-  max: 10,
-  skipSuccessfulRequests: true,
-  message: "Too many login attempts. Please try again later.",
-});
-
-export const uploadLimiter = createLimiter({
-  windowMs: 60 * 60 * 1000,
-  max: 20,
-  message: "Upload limit reached. Please try again in an hour.",
-});

package/templates/node-ts/src/models/otp.model.ts

@@ -1,27 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IOtp extends Document {
-  email: string;
-  otp: string;
-  createdAt: Date;
-}
-
-const otpSchema = new mongoose.Schema<IOtp>({
-  email: {
-    type: String,
-    required: true,
-  },
-  otp: {
-    type: String,
-    required: true,
-  },
-  createdAt: {
-    type: Date,
-    default: Date.now(),
-    expires: 300,
-  },
-});
-
-const Otp = mongoose.model<IOtp>("Otp", otpSchema);
-
-export default Otp;

package/templates/node-ts/src/models/pushSubscription.model.ts

@@ -1,45 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IPushSubscription extends Document {
-  endpoint: string;
-  keys: {
-    p256dh: string;
-    auth: string;
-  };
-  user?: mongoose.Types.ObjectId;
-  role: "admin" | "user";
-  expiresAt: Date;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-const pushSubscriptionSchema = new mongoose.Schema<IPushSubscription>(
-  {
-    endpoint: {
-      type: String,
-      required: true,
-      unique: true,
-    },
-    keys: {
-      p256dh: { type: String, required: true },
-      auth: { type: String, required: true },
-    },
-    user: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-    },
-    role: {
-      type: String,
-      enum: ["admin", "user"],
-      default: "user",
-    },
-    expiresAt: {
-      type: Date,
-      default: () => new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
-      index: { expires: 0 },
-    },
-  },
-  { timestamps: true },
-);
-
-export default mongoose.model<IPushSubscription>("PushSubscription", pushSubscriptionSchema);

package/templates/node-ts/src/models/user.model.ts

@@ -1,57 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IUser extends Document {
-  name: string;
-  email: string;
-  phone?: string;
-  avatar?: {
-    publicId?: string;
-    url?: string;
-  };
-  password?: string;
-  role: "user" | "admin" | "other";
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-const userSchema = new mongoose.Schema<IUser>(
-  {
-    name: {
-      type: String,
-      required: [true, "Name is required"],
-      trim: true,
-    },
-
-    email: {
-      type: String,
-      required: [true, "Email is required"],
-      unique: true,
-      lowercase: true,
-      trim: true,
-    },
-    phone: {
-      type: String,
-    },
-    avatar: {
-      publicId: {
-        type: String,
-      },
-      url: {
-        type: String,
-      },
-    },
-    password: {
-      type: String,
-      required: [true, "Password is required"],
-    },
-    role: {
-      type: String,
-      enum: ["user", "admin", "other"],
-      default: "user",
-    },
-  },
-  { timestamps: true },
-);
-
-const User = mongoose.model<IUser>("User", userSchema);
-export default User;

package/templates/node-ts/src/routes/auth.route.ts

@@ -1,22 +0,0 @@
-import express from "express";
-import {
-  signup,
-  login,
-  getMe,
-  logout,
-  updateMe,
-} from "../controllers/auth.controller.js";
-import { protect } from "../middleware/auth.middleware.js";
-import { apiLimiter } from "../middleware/rateLimiter.js";
-
-const router = express.Router();
-
-router.use(apiLimiter);
-
-router.post("/signup", signup);
-router.post("/login", login);
-router.post("/logout", logout);
-router.get("/me", protect, getMe);
-router.put("/me", protect, updateMe);
-
-export default router;

package/templates/node-ts/src/routes/index.ts

@@ -1,12 +0,0 @@
-import express from "express";
-import authRoutes from "./auth.route.js";
-import uploadRoutes from "./upload.route.js";
-import pushRoutes from "./push.route.js";
-
-const router = express.Router();
-
-router.use("/auth", authRoutes);
-router.use("/upload", uploadRoutes);
-router.use("/push", pushRoutes);
-
-export default router;

package/templates/node-ts/src/routes/upload.route.ts

@@ -1,11 +0,0 @@
-import express from "express";
-import { upload } from "../middleware/multer.js";
-import { uploadFile } from "../controllers/upload.controller.js";
-import { protect } from "../middleware/auth.middleware.js";
-import { uploadLimiter } from "../middleware/rateLimiter.js";
-
-const router = express.Router();
-
-router.post("/", protect, uploadLimiter, upload.single("file"), uploadFile);
-
-export default router;

package/templates/node-ts/src/services/auth.service.ts

@@ -1,107 +0,0 @@
-import User from "../models/user.model.js";
-import Otp from "../models/otp.model.js";
-import bcrypt from "bcrypt";
-import { generateToken } from "../utils/jwt.js";
-import { sendOtpEmail } from "../utils/emailOtp.js";
-import { uploadSingleToCloudinary, deleteFromCloudinary } from "../utils/cloudinaryUpload.js";
-import logger from "../utils/logger.js";
-export const signup = async ({ name, email, phone, password }: any) => {
-    const existingUser = await User.findOne({ email });
-    if (existingUser) {
-      const err: any = new Error("User already exists");
-      err.status = 409;
-      throw err;
-    }
-    const salt = await bcrypt.genSalt(10);
-    const hashedPassword = await bcrypt.hash(password, salt);
-    const photoURL = `https://placehold.co/600x400?text=${name.charAt(0).toUpperCase()}`;
-    const newUser = await User.create({
-      name,
-      email: email.toLowerCase(),
-      phone,
-      role: "user",
-      password: hashedPassword,
-      avatar: { url: photoURL, publicId: "" },
-    });
-    return newUser;
-  }
-export const login = async ({ email, password }: any) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err: any = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-    const isValid = await bcrypt.compare(password, user.password);
-    if (!isValid) {
-      const err: any = new Error("Invalid Credentials");
-      err.status = 401;
-      throw err;
-    }
-    return user;
-  }
-export const generateOtp = async (email: string) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err: any = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-    const existingOtp = await Otp.findOne({ email });
-    if (existingOtp) {
-      await existingOtp.deleteOne();
-    }
-    const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    const hashedOtp = await bcrypt.hash(otp, 10);
-    await Otp.create({ email, otp: hashedOtp });
-    await sendOtpEmail(email, otp);
-    return true;
-  }
-export const verifyOtp = async ({ email, otp }: any) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err: any = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-    const existingOtp = await Otp.findOne({ email });
-    if (!existingOtp) {
-      const err: any = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
-    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
-    if (!isMatched) {
-      const err: any = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
-    return user;
-  }
-export const resetPassword = async (user: any, newPassword: any) => {
-    const hashedPassword = await bcrypt.hash(newPassword, 10);
-    user.password = hashedPassword;
-    await user.save();
-    return true;
-  }
-export const updateProfile = async (userId: any, { name, phone, file }: any) => {
-    const user = await User.findById(userId);
-    if (!user) {
-      const err: any = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-    if (name) user.name = name;
-    if (phone) user.phone = phone;
-    if (file) {
-      const uploadResult = await uploadSingleToCloudinary(file, { folder: "codelab/avatars" });
-      if (user.avatar && user.avatar.publicId) {
-        await deleteFromCloudinary(user.avatar.publicId).catch((err) =>
-          logger.error("Old avatar delete error", err)
-        );
-      }
-      user.avatar = { url: uploadResult.url, publicId: uploadResult.publicId };
-    }
-    await user.save();
-    return user;
-  }

package/templates/node-ts/src/types/express.d.ts

@@ -1,10 +0,0 @@
-import { Express } from "express";
-
-declare global {
-  namespace Express {
-    interface Request {
-      user?: any;
-      file?: any;
-    }
-  }
-}

package/templates/node-ts/src/utils/cloudinaryUpload.ts

@@ -1,44 +0,0 @@
-import cloudinary from "../config/cloudinary.js";
-import logger from "./logger.js";
-
-const uploadToCloudinary = async (file: any, options: any = {}) => {
-  if (!file?.buffer) {
-    throw new Error("Invalid file.");
-  }
-  const dataURI = `data:${file.mimetype};base64,${file.buffer.toString("base64")}`;
-  const result = await cloudinary.uploader.upload(dataURI, {
-    folder: options.folder || "uploads",
-    ...options,
-  });
-  return {
-    url: result.secure_url,
-    publicId: result.public_id,
-  };
-};
-
-export const uploadSingleToCloudinary = async (file: any, options: any = {}) => {
-  try {
-    return await uploadToCloudinary(file, options);
-  } catch (error) {
-    logger.error("Cloudinary Upload Error", error);
-    throw new Error("Failed to upload image.");
-  }
-};
-
-export const uploadMultipleToCloudinary = async (files: any[] = [], options: any = {}) => {
-  try {
-    return await Promise.all(files.map((file) => uploadToCloudinary(file, options)));
-  } catch (error) {
-    logger.error("Cloudinary Upload Error", error);
-    throw new Error("Failed to upload images.");
-  }
-};
-
-export const deleteFromCloudinary = async (publicId: string) => {
-  try {
-    return await cloudinary.uploader.destroy(publicId);
-  } catch (error) {
-    logger.error("Cloudinary Delete Error", error);
-    throw new Error("Failed to delete image.");
-  }
-};

package/templates/node-ts/src/utils/emailOtp.ts

@@ -1,30 +0,0 @@
-import sendEmail from "../config/email.js";
-
-const APP_NAME = process.env.APP_NAME || "My App";
-const APP_URL = process.env.APP_URL || "";
-const APP_PRIMARY_COLOR = process.env.APP_PRIMARY_COLOR || "#2563eb";
-
-export const emailOtp = (otp: string, expiry = 10) => ({
-  subject: `${APP_NAME} - Verification Code`,
-  html: `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <title>${APP_NAME}</title>
-</head>
-<body style="margin:0;padding:40px;background:#f3f4f6;font-family:Arial,sans-serif;">
-  <div style="background:#fff;border-radius:12px;padding:30px;max-width:500px;margin:auto;">
-    <h2>Verification Code</h2>
-    <p>Your code is valid for ${expiry} minutes:</p>
-    <div style="font-size:32px;font-weight:bold;color:${APP_PRIMARY_COLOR};text-align:center;margin:20px 0;">${otp}</div>
-  </div>
-</body>
-</html>
-`,
-});
-
-export const sendOtpEmail = async (to: string, otp: string, expiry = 10) => {
-  const template = emailOtp(otp, expiry);
-  await sendEmail(to, template.subject, template.html);
-};

package/templates/node-ts/src/utils/genOtpToken.ts

@@ -1,22 +0,0 @@
-import jwt from "jsonwebtoken";
-import { Response } from "express";
-
-const genOtpToken = (user: any, res?: Response) => {
-  const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
-  const token = jwt.sign({ id: user._id || user.id }, JWT_SECRET, {
-    expiresIn: "10m",
-  });
-
-  if (res) {
-    res.cookie("token", token, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "strict",
-      maxAge: 10 * 60 * 1000, // 10 minutes
-    });
-  }
-
-  return token;
-};
-
-export default genOtpToken;

package/templates/node-ts/src/utils/generateVapidKeys.ts

@@ -1,12 +0,0 @@
-import webpush from "web-push";
-import logger from "./logger.js";
-
-const generateVapidKeys = () => {
-  const vapidKeys = webpush.generateVAPIDKeys();
-  logger.info("Generated VAPID Keys:");
-  logger.info(`Public Key: ${vapidKeys.publicKey}`);
-  logger.info(`Private Key: ${vapidKeys.privateKey}`);
-  return vapidKeys;
-};
-
-export default generateVapidKeys;

package/templates/node-ts/src/utils/jwt.ts

@@ -1,27 +0,0 @@
-import jwt from "jsonwebtoken";
-import { Response } from "express";
-
-export const generateToken = (user: any, res?: Response) => {
-  const payload = { id: user._id || user.id };
-  const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
-  const token = jwt.sign(payload, JWT_SECRET, { expiresIn: "30d" });
-  
-  if (res) {
-    res.cookie("token", token, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === "production",
-      sameSite: "strict",
-      maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
-    });
-  }
-  return token;
-};
-
-export const verifyToken = (token: string) => {
-  try {
-    const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
-    return jwt.verify(token, JWT_SECRET);
-  } catch (error) {
-    return null;
-  }
-};

package/templates/node-ts/src/utils/logger.ts

@@ -1,27 +0,0 @@
-const colors = {
-  reset: "\x1b[0m",
-  info: "\x1b[36m", // Cyan
-  success: "\x1b[32m", // Green
-  warn: "\x1b[33m", // Yellow
-  error: "\x1b[31m", // Red
-  timestamp: "\x1b[90m", // Gray
-};
-
-type LogLevel = "info" | "success" | "warn" | "error";
-
-const formatMessage = (level: LogLevel, message: string) => {
-  const timestamp = new Date().toISOString();
-  return `${colors.timestamp}[${timestamp}]${colors.reset} ${colors[level] || colors.reset}[${level.toUpperCase()}]${colors.reset} ${message}`;
-};
-
-export const logger = {
-  info: (msg: string) => console.log(formatMessage("info", msg)),
-  success: (msg: string) => console.log(formatMessage("success", msg)),
-  warn: (msg: string) => console.warn(formatMessage("warn", msg)),
-  error: (msg: string, err?: any) => {
-    console.error(formatMessage("error", msg));
-    if (err) console.error(err);
-  },
-};
-
-export default logger;

package/templates/node-ts/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "ts-node": {
-    "esm": true,
-    "experimentalSpecifierResolution": "node"
-  }
-}

package/templates/production-fullstack/client/index.html

@@ -1,14 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="manifest" href="/manifest.json" />
-    <title>React App</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

package/templates/production-fullstack/client/public/_redirects

@@ -1 +0,0 @@
-/*    /index.html   200