@imksh/create 1.0.27 → 1.0.30

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@imksh/create",
-  "version": "1.0.27",
+  "version": "1.0.30",
   "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/{node → layers/node/javascript}/package.json

@@ -24,7 +24,8 @@
     "cloudinary": "^2.0.0",
     "nodemailer": "^6.9.7",
     "socket.io": "^4.7.2",
-    "web-push": "^3.6.6"
+    "web-push": "^3.6.6",
+    "expo-server-sdk": "^3.10.0"
   },
   "devDependencies": {
     "nodemon": "^3.0.1"

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/layers/node/javascript/src/controllers/push.controller.js

@@ -0,0 +1,72 @@
+import PushSubscription from "../models/pushSubscription.model.js";
+import logger from "../utils/logger.js";
+
+export const subscribe = async (req, res, next) => {
+  try {
+    const subscription = req.body;
+    const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
+    
+    if (!subscription) {
+      return next({ status: 400, message: "Invalid subscription payload" });
+    }
+
+    const isExpo = !!subscription.token;
+    const isWeb = !!(subscription.endpoint && subscription.keys);
+
+    if (!isExpo && !isWeb) {
+      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
+    }
+
+    if (isExpo) {
+      const existingSub = await PushSubscription.findOne({ expoPushToken: subscription.token });
+      if (existingSub) {
+        if (userId && String(existingSub.user) !== String(userId)) {
+          existingSub.user = userId; await existingSub.save();
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await PushSubscription.create({
+        type: "EXPO",
+        expoPushToken: subscription.token,
+        user: userId || undefined
+      });
+    } else {
+      const existingSub = await PushSubscription.findOne({ endpoint: subscription.endpoint });
+      if (existingSub) {
+        if (userId && String(existingSub.user) !== String(userId)) {
+          existingSub.user = userId; await existingSub.save();
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await PushSubscription.create({
+        type: "WEB",
+        endpoint: subscription.endpoint,
+        keys: subscription.keys,
+        user: userId || undefined
+      });
+    }
+
+    res.status(201).json({ success: true, message: "Subscription created." });
+  } catch (error) {
+    logger.error("Error in push subscribe controller", error);
+    next(error);
+  }
+};
+
+export const unsubscribe = async (req, res, next) => {
+  try {
+    const { endpoint } = req.body;
+    if (!endpoint) {
+      return next({ status: 400, message: "Endpoint required" });
+    }
+
+    await PushSubscription.deleteOne({ endpoint });
+
+    res.status(200).json({ success: true, message: "Unsubscribed." });
+  } catch (error) {
+    logger.error("Error in push unsubscribe controller", error);
+    next(error);
+  }
+};

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

@@ -1,16 +1,29 @@
 import mongoose from "mongoose";
 
+// Handles both Web Push (endpoint + keys) and Expo Push (expoPushToken)
 const pushSubscriptionSchema = new mongoose.Schema(
   {
+    type: {
+      type: String,
+      enum: ["WEB", "EXPO"],
+      default: "WEB",
+    },
+    // 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/layers/node/javascript/src/utils/pushHelper.js

@@ -0,0 +1,68 @@
+import webpush from "../config/webPush.js";
+import { Expo } from "expo-server-sdk";
+import logger from "./logger.js";
+import PushSubscription from "../models/pushSubscription.model.js";
+
+const expo = new Expo();
+
+export const sendPushToUser = async (
+  userId,
+  title,
+  body,
+  url = "/",
+) => {
+  try {
+    const subscriptions = await PushSubscription.find({ user: userId });
+
+    if (subscriptions.length === 0) return;
+
+    const webSubs = subscriptions.filter(s => s.type === "WEB");
+    const expoSubs = subscriptions.filter(s => s.type === "EXPO");
+
+    // Web Push
+    if (webSubs.length > 0) {
+      const payload = JSON.stringify({ title, body, url });
+      await Promise.allSettled(
+        webSubs.map(async (sub) => {
+          if (!sub.endpoint || !sub.keys) return;
+          const pushSub = { endpoint: sub.endpoint, keys: sub.keys };
+          try {
+            await webpush.sendNotification(pushSub, payload);
+          } catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 410) {
+              await sub.deleteOne();
+            } else {
+              logger.error("Web Push Error", err);
+            }
+          }
+        })
+      );
+    }
+
+    // Expo Push
+    if (expoSubs.length > 0) {
+      const messages = [];
+      for (const sub of expoSubs) {
+        if (!sub.expoPushToken || !Expo.isExpoPushToken(sub.expoPushToken)) continue;
+        messages.push({
+          to: sub.expoPushToken,
+          sound: "default",
+          title,
+          body,
+          data: { url },
+        });
+      }
+
+      const chunks = expo.chunkPushNotifications(messages);
+      for (const chunk of chunks) {
+        try {
+          await expo.sendPushNotificationsAsync(chunk);
+        } catch (error) {
+          logger.error("Error sending push notification chunk", error);
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("Error sending push notification to user", error);
+  }
+};