@imksh/create 1.0.26 → 1.0.28

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@imksh/create",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "A production-ready create for scaffolding modern applications.",
   "type": "module",
   "bin": {
     "imksh": "./bin/index.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node scripts/test-presets.js",
+    "test:snapshot": "node scripts/snapshot-presets.js",
+    "test:regression": "node scripts/test-presets.js"
   },
   "files": [
     "bin",
     "src",
-    "templates"
+    "templates/layers",
+    "templates/presets"
   ],
   "keywords": [
     "create",

package/src/commands/create.js

@@ -39,7 +39,8 @@ export default async function createCommand(projectName, options) {
     'next-ts',
     'react-native',
     'mern-react-native',
-    'production-fullstack'
+    'production-fullstack',
+    'fullstack-prisma'
   ];
   if (!validTemplates.includes(template)) {
     throw new Error(`Invalid template "${template}". Valid templates are: ${validTemplates.join(', ')}`);

package/src/index.js

@@ -24,7 +24,7 @@ program
   .argument("<project-name>", "Name of the project")
   .option(
     "-t, --template <template>",
-    "Template to use (react, react-ts, node, node-ts, node-prisma, node-prisma-ts, mern, mern-ts, next, next-ts, react-native, mern-react-native, production-fullstack)",
+    "Template to use (react, react-ts, node, node-ts, node-prisma, node-prisma-ts, mern, mern-ts, next, next-ts, react-native, mern-react-native, production-fullstack, fullstack-prisma)",
   )
   .option("--skip-install", "Skip installing dependencies")
   .option("--no-git", "Skip initializing a git repository")

package/src/utils/askTemplate.js

@@ -14,6 +14,7 @@ export async function askTemplate() {
         { name: 'MERN + React Native', value: 'mern-react-native' },
         { name: 'Next.js', value: 'next' },
         { name: 'Production Fullstack', value: 'production-fullstack' },
+        { name: 'Fullstack Prisma', value: 'fullstack-prisma' },
       ],
     },
   ]);

package/src/utils/composeTemplate.js

@@ -0,0 +1,158 @@
+/**
+ * composeTemplate.js
+ *
+ * Core engine for the composable template system.
+ *
+ * Architecture:
+ *   templates/
+ *   ├── layers/       # Reusable building blocks (react, node, next, react-native, prisma)
+ *   └── presets/      # Preset definitions (preset.json) + optional overrides/
+ *
+ * Each preset.json defines an ordered list of layers to merge.
+ * File precedence: layer[0] < layer[1] < ... < layer[N] < preset overrides/
+ * Later layers win — always explicit, never accidental.
+ *
+ * Supported preset.json schema:
+ * {
+ *   "layers": [
+ *     "react/base",                         // simple: layer path relative to templates/layers/
+ *     { "layer": "node/javascript", "dest": "server" }  // monorepo: place into a subdir
+ *   ],
+ *   "overrides": "overrides/"               // optional: dir relative to preset dir
+ * }
+ */
+
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_ROOT = path.resolve(__dirname, "../../templates");
+
+/**
+ * Main entry point — compose a preset into targetDir.
+ *
+ * @param {string} presetName  - Name of the preset (e.g. 'react', 'mern-ts')
+ * @param {string} targetDir   - Absolute path to the project destination directory
+ * @param {string} projectName - Name to inject into package.json
+ */
+export async function composeTemplate(presetName, targetDir, projectName) {
+  const presetDir = path.join(TEMPLATES_ROOT, "presets", presetName);
+  const presetJsonPath = path.join(presetDir, "preset.json");
+
+  if (!fs.existsSync(presetJsonPath)) {
+    throw new Error(
+      `Preset not found: ${presetName} (expected ${presetJsonPath})`,
+    );
+  }
+
+  const preset = await fs.readJson(presetJsonPath);
+  const layersRoot = path.join(TEMPLATES_ROOT, "layers");
+
+  await fs.ensureDir(targetDir);
+
+  // --- Step 1: Merge layers in order (low → high priority) ---
+  for (const entry of preset.layers) {
+    const { layer, dest } = normalizeLayerEntry(entry);
+    const layerDir = path.join(layersRoot, layer);
+
+    if (!fs.existsSync(layerDir)) {
+      throw new Error(
+        `Layer directory not found: ${layer} (expected ${layerDir})`,
+      );
+    }
+
+    const destDir = dest ? path.join(targetDir, dest) : targetDir;
+    await fs.ensureDir(destDir);
+
+    await fs.copy(layerDir, destDir, {
+      overwrite: true, // later layers intentionally overwrite earlier ones
+      filter: (src) => {
+        const basename = path.basename(src);
+        return basename !== ".DS_Store";
+      },
+    });
+  }
+
+  // --- Step 2: Apply preset-level overrides (highest priority) ---
+  if (preset.overrides) {
+    const overridesDir = path.join(presetDir, preset.overrides);
+    if (fs.existsSync(overridesDir)) {
+      await fs.copy(overridesDir, targetDir, {
+        overwrite: true,
+        filter: (src) => path.basename(src) !== ".DS_Store",
+      });
+    }
+  }
+
+  // --- Step 3: Post-processing ---
+  await postProcess(targetDir, projectName);
+}
+
+/**
+ * Normalize a layer entry to { layer, dest } shape.
+ * Accepts both string shorthand and object form.
+ */
+function normalizeLayerEntry(entry) {
+  if (typeof entry === "string") {
+    return { layer: entry, dest: null };
+  }
+  return { layer: entry.layer, dest: entry.dest || null };
+}
+
+/**
+ * Post-process the generated project:
+ * 1. Rename _gitignore → .gitignore (npm strips .gitignore from packages)
+ * 2. Copy .env.example → .env if it exists
+ * 3. Patch all package.json files with the project name
+ */
+async function postProcess(targetDir, projectName) {
+  // Rename _gitignore → .gitignore (recursively handle monorepo subdirs)
+  await renameGitignores(targetDir);
+
+  // Copy .env.example → .env (top-level only for single packages;
+  // for monorepos the server subdir has it)
+  await copyEnvExamples(targetDir);
+
+  // Patch all package.json files found in the generated project
+  await patchPackageNames(targetDir, projectName);
+}
+
+async function renameGitignores(dir) {
+  // Only rename top-level _gitignore → .gitignore.
+  // Sub-package _gitignore files (client/_gitignore, server/_gitignore)
+  // are intentionally kept as _gitignore so npm doesn't strip them,
+  // matching the original template behavior.
+  const gitignoreSrc = path.join(dir, "_gitignore");
+  if (fs.existsSync(gitignoreSrc)) {
+    await fs.rename(gitignoreSrc, path.join(dir, ".gitignore"));
+  }
+}
+
+async function copyEnvExamples(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await copyEnvExamples(full);
+    } else if (entry.name === ".env.example") {
+      const envDest = path.join(dir, ".env");
+      if (!fs.existsSync(envDest)) {
+        await fs.copy(full, envDest);
+      }
+    }
+  }
+}
+
+async function patchPackageNames(dir, projectName) {
+  // Only patch the root-level package.json with the project name.
+  // Sub-package package.json files (client/, server/, mobile/) retain
+  // their template names, matching the original copyTemplate behavior.
+  const pkgPath = path.join(dir, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+    pkg.name = projectName;
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+}

package/src/utils/copyTemplate.js

@@ -1,42 +1,20 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+/**
+ * copyTemplate.js
+ *
+ * Public API entry point for template copying.
+ * Delegates to the composable template engine (composeTemplate.js).
+ *
+ * Signature is preserved for backward compatibility.
+ */
+import { composeTemplate } from './composeTemplate.js';
 
+/**
+ * Copy/compose a template into the target directory.
+ *
+ * @param {string} templateName - Preset name (e.g. 'react', 'mern-ts')
+ * @param {string} targetDir    - Absolute path to the destination directory
+ * @param {string} projectName  - Name to inject into package.json(s)
+ */
 export async function copyTemplate(templateName, targetDir, projectName) {
-  const templateDir = path.resolve(__dirname, '../../templates', templateName);
-
-  if (!fs.existsSync(templateDir)) {
-    throw new Error(`Template directory not found: ${templateDir}`);
-  }
-
-  // Copy template files
-  await fs.copy(templateDir, targetDir, {
-    filter: (src) => {
-      const relativePath = path.relative(templateDir, src);
-      return !relativePath.split(path.sep).includes('node_modules');
-    }
-  });
-
-  // Rename package.json project name
-  const packageJsonPath = path.join(targetDir, 'package.json');
-  if (fs.existsSync(packageJsonPath)) {
-    const pkg = await fs.readJson(packageJsonPath);
-    pkg.name = projectName;
-    await fs.writeJson(packageJsonPath, pkg, { spaces: 2 });
-  }
-
-  // Rename _gitignore to .gitignore
-  const gitignorePath = path.join(targetDir, '_gitignore');
-  if (fs.existsSync(gitignorePath)) {
-    await fs.rename(gitignorePath, path.join(targetDir, '.gitignore'));
-  }
-
-  // Copy .env.example to .env if it exists
-  const envExamplePath = path.join(targetDir, '.env.example');
-  if (fs.existsSync(envExamplePath)) {
-    await fs.copy(envExamplePath, path.join(targetDir, '.env'));
-  }
+  await composeTemplate(templateName, targetDir, projectName);
 }

package/templates/{mern/server → layers/node/javascript}/src/controllers/auth.controller.js

@@ -165,3 +165,17 @@ export const updateMe = async (req, res, next) => {
     next(error);
   }
 };
+
+export const savePushToken = async (req, res, next) => {
+  try {
+    const { token } = req.body;
+    if (!token) {
+      return next({ status: 400, message: "Token is required." });
+    }
+    await authService.savePushToken(req.user._id, token);
+    res.status(200).json({ success: true, message: "Push token saved successfully" });
+  } catch (error) {
+    logger.error("Error saving push token", error);
+    next(error);
+  }
+};

package/templates/{node → layers/node/javascript}/src/models/pushSubscription.model.js

@@ -1,16 +1,24 @@
 import mongoose from "mongoose";
 
+// Handles both Web Push (endpoint + keys) and Expo Push (expoPushToken)
 const pushSubscriptionSchema = new mongoose.Schema(
   {
+    // Web Push fields
     endpoint: {
       type: String,
-      required: true,
-      unique: true,
+      sparse: true,
     },
     keys: {
-      p256dh: { type: String, required: true },
-      auth: { type: String, required: true },
+      p256dh: { type: String },
+      auth: { type: String },
     },
+
+    // Expo Push field
+    expoPushToken: {
+      type: String,
+      sparse: true,
+    },
+
     user: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",

package/templates/{node → layers/node/javascript}/src/models/user.model.js

@@ -35,6 +35,12 @@ const userSchema = new mongoose.Schema(
       enum: ["user", "admin", "other"],
       default: "user",
     },
+
+    expoPushTokens: [
+      {
+        type: String,
+      },
+    ],
   },
   { timestamps: true },
 );

package/templates/{mern/server → layers/node/javascript}/src/services/auth.service.js

@@ -184,3 +184,20 @@ export const updateProfile = async (userId, { name, phone, file }) => {
     await user.save();
     return user;
   }
+
+/**
+ * Save Expo Push Token
+ */
+export const savePushToken = async (userId, token) => {
+  const user = await User.findById(userId);
+  if (!user) {
+    const err = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+  if (!user.expoPushTokens.includes(token)) {
+    user.expoPushTokens.push(token);
+    await user.save();
+  }
+  return user;
+};

package/templates/{mern-ts/server → layers/node/typescript}/src/controllers/auth.controller.ts

@@ -138,3 +138,17 @@ export const updateMe = async (req: Request, res: Response, next: NextFunction)
     next(error);
   }
 };
+
+export const savePushToken = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { token } = req.body;
+    if (!token) {
+      return next({ status: 400, message: "Token is required." });
+    }
+    await authService.savePushToken(req.user._id, token);
+    res.status(200).json({ success: true, message: "Push token saved successfully" });
+  } catch (error) {
+    logger.error("Error saving push token", error);
+    next(error);
+  }
+};

package/templates/{mern-ts/server → layers/node/typescript}/src/models/pushSubscription.model.ts

@@ -1,11 +1,13 @@
 import mongoose, { Document } from "mongoose";
 
+// Handles both Web Push (endpoint + keys) and Expo Push (expoPushToken)
 export interface IPushSubscription extends Document {
-  endpoint: string;
-  keys: {
+  endpoint?: string;
+  keys?: {
     p256dh: string;
     auth: string;
   };
+  expoPushToken?: string;
   user?: mongoose.Types.ObjectId;
   role: "admin" | "user";
   expiresAt: Date;
@@ -15,15 +17,22 @@ export interface IPushSubscription extends Document {
 
 const pushSubscriptionSchema = new mongoose.Schema<IPushSubscription>(
   {
+    // Web Push fields
     endpoint: {
       type: String,
-      required: true,
-      unique: true,
+      sparse: true,
     },
     keys: {
-      p256dh: { type: String, required: true },
-      auth: { type: String, required: true },
+      p256dh: { type: String },
+      auth: { type: String },
     },
+
+    // Expo Push field
+    expoPushToken: {
+      type: String,
+      sparse: true,
+    },
+
     user: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",

package/templates/{mern-react-native/server → layers/node/typescript}/src/models/user.model.ts

@@ -10,7 +10,7 @@ export interface IUser extends Document {
   };
   password?: string;
   role: "user" | "admin" | "other";
-  expoPushTokens: [string];
+  expoPushTokens: string[];
   createdAt: Date;
   updatedAt: Date;
 }

package/templates/{mern-ts/server → layers/node/typescript}/src/routes/auth.route.ts

@@ -6,6 +6,7 @@ import {
   logout,
   updateMe,
   genSignupOtp,
+  savePushToken,
 } from "../controllers/auth.controller.js";
 import { protect } from "../middleware/auth.middleware.js";
 import { apiLimiter } from "../middleware/rateLimiter.js";
@@ -20,5 +21,6 @@ router.post("/login", login);
 router.post("/logout", logout);
 router.get("/me", protect, getMe);
 router.put("/me", protect, updateMe);
+router.post("/push-token", protect, savePushToken);
 
 export default router;

package/templates/{mern-ts/server → layers/node/typescript}/src/services/auth.service.ts

@@ -146,3 +146,20 @@ export const updateProfile = async (
   await user.save();
   return user;
 };
+
+/**
+ * Save Expo Push Token
+ */
+export const savePushToken = async (userId: string, token: string) => {
+  const user = await User.findById(userId);
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+  if (!user.expoPushTokens.includes(token)) {
+    user.expoPushTokens.push(token);
+    await user.save();
+  }
+  return user;
+};

package/templates/layers/prisma/javascript/README.md

@@ -0,0 +1,71 @@
+# Node.js Prisma Backend Boilerplate
+
+A production-ready Node.js & Express boilerplate project with best-practice architectures, modular routing, and Prisma ORM integration.
+
+## Features
+
+- ⚙️ **Modular Architecture:** Express application setup decoupled into `app.js` (middleware + router wiring) and `index.js` (server initialization & db connection).
+- 🗄️ **Prisma ORM:** Built-in PostgreSQL datasource configuration and schema mapping for `User`, `Otp`, and `PushSubscription` models.
+- 📝 **Colorized Logging:** Zero-dependency custom logger with timestamped success, warning, info, and error layouts.
+- 🛡️ **Security Out-of-the-Box:** Pre-configured with Helmet headers, CORS policies, and global rate limiters (`apiLimiter`, `authLimiter`, `uploadLimiter`).
+- 🔑 **Authentication & JWT:** Custom middlewares for route protection, sign-ups, and log-ins with HTTP-only cookie-based tokens.
+- 📧 **SMTP Mailer & OTP:** Standard mailer transport using Gmail NodeMailer wrapper, integrated with an OTP generator and email template.
+- 🖼️ **File Uploads:** Cloudinary integration utilizing Multer memory buffers for secure, single or multi-file uploads.
+- 🔌 **Socket.io Setup:** Pre-installed Socket.io hooks mapping connected user sessions to active sockets.
+- ✉️ **Web Push:** Push notifications integration powered by VAPID key generators and web-push subscriptions.
+
+## Getting Started
+
+### 1. Configure Environment Variables
+
+Create a `.env` file in the root directory (based on `.env.example`):
+
+```env
+PORT=5001
+JWT_SECRET=your_super_secret_jwt_key
+DATABASE_URL=postgresql://user:password@localhost:5432/db_name
+
+# Cloudinary
+CLOUDINARY_CLOUD_NAME=your_cloud_name
+CLOUDINARY_API_KEY=your_api_key
+CLOUDINARY_API_SECRET=your_api_secret
+
+# SMTP Settings
+SMTP_USER=your_email@gmail.com
+SMTP_PASS=your_app_password
+
+# Web Push
+VAPID_SUBJECT=mailto:your_email@example.com
+VAPID_PUBLIC_KEY=your_vapid_public_key
+VAPID_PRIVATE_KEY=your_vapid_private_key
+```
+
+### 2. Install & Sync Schema
+
+```bash
+# Install dependencies
+npm install
+
+# Push database schema changes locally
+npm run db:push
+
+# Generate Prisma Client types
+npm run db:generate
+
+# Start development server with reload
+npm run dev
+```
+
+## API Endpoints
+
+### Auth Routes (`/api/auth`)
+
+- `POST /signup` - Registers a new user session
+- `POST /login` - Log in user and write token cookie
+- `POST /logout` - Clear token session cookies
+- `GET /me` - Returns logged-in user profile (requires auth)
+- `PUT /me` - Edit profile info and upload avatars (requires auth)
+
+### Upload Routes (`/api/upload`)
+
+- `POST /` - Securely uploads image/file to Cloudinary (requires auth)

package/templates/{node → layers/prisma/javascript}/package.json

@@ -1,14 +1,17 @@
 {
-  "name": "node-template",
+  "name": "node-prisma-template",
   "version": "1.0.0",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
     "start": "node src/index.js",
     "dev": "nodemon src/index.js",
+    "db:push": "prisma db push",
+    "db:generate": "prisma generate",
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
   },
   "dependencies": {
+    "@prisma/client": "^5.6.0",
     "bcrypt": "^5.1.1",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
@@ -20,13 +23,13 @@
     "jsonwebtoken": "^9.0.2",
     "morgan": "^1.10.0",
     "multer": "^1.4.5-lts.1",
-    "mongoose": "^8.0.0",
     "cloudinary": "^2.0.0",
     "nodemailer": "^6.9.7",
     "socket.io": "^4.7.2",
     "web-push": "^3.6.6"
   },
   "devDependencies": {
-    "nodemon": "^3.0.1"
+    "nodemon": "^3.0.1",
+    "prisma": "^5.6.0"
   }
 }

package/templates/layers/prisma/javascript/prisma/schema.prisma

@@ -0,0 +1,41 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id               String             @id @default(uuid())
+  email            String             @unique
+  name             String
+  phone            String?
+  password         String
+  role             String             @default("user")
+  avatarUrl        String?
+  avatarPublicId   String?
+  createdAt        DateTime           @default(now())
+  updatedAt        DateTime           @updatedAt
+  pushSubscriptions PushSubscription[]
+}
+
+model Otp {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  otp       String
+  createdAt DateTime @default(now())
+}
+
+model PushSubscription {
+  id        String   @id @default(uuid())
+  endpoint  String   @unique
+  p256dh    String
+  auth      String
+  role      String   @default("user")
+  userId    String?
+  user      User?    @relation(fields: [userId], references: [id], onDelete: Cascade)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

package/templates/layers/prisma/javascript/src/config/db.js

@@ -0,0 +1,16 @@
+import { PrismaClient } from "@prisma/client";
+import logger from "../utils/logger.js";
+
+export const prisma = new PrismaClient();
+
+const connectDB = async () => {
+  try {
+    await prisma.$connect();
+    logger.success("Prisma Database connected successfully");
+  } catch (error) {
+    logger.error("Prisma Database connection failed", error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;