starter-structure-cli 0.2.0 → 0.2.2

package/lib/template-builder.js

@@ -0,0 +1,338 @@
+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);
+
+export const repoRoot = path.resolve(__dirname, "..");
+export const templatesRoot = path.join(repoRoot, "templates");
+
+const templateSourcesRoot = path.join(repoRoot, "template-sources");
+const presetsRoot = path.join(templateSourcesRoot, "presets");
+const buildManifestPath = path.join(templatesRoot, ".templates-manifest.json");
+const includePattern = /\{\{\s*include:\s*([^\s}]+)\s*\}\}/g;
+const textFileExtensions = new Set([
+  ".cjs",
+  ".css",
+  ".d.ts",
+  ".example",
+  ".html",
+  ".js",
+  ".json",
+  ".jsx",
+  ".md",
+  ".mjs",
+  ".prisma",
+  ".svg",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".yaml",
+  ".yml"
+]);
+const textFileNames = new Set([".gitignore", ".npmignore", ".env"]);
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function removeDir(dirPath) {
+  fs.rmSync(dirPath, {
+    recursive: true,
+    force: true,
+    maxRetries: 5,
+    retryDelay: 100
+  });
+}
+
+function applyVariables(input, variables) {
+  return Object.entries(variables).reduce(
+    (result, [key, value]) => result.split(`__${key}__`).join(String(value)),
+    input
+  );
+}
+
+function isTextFile(filePath) {
+  return textFileNames.has(path.basename(filePath)) || textFileExtensions.has(path.extname(filePath));
+}
+
+function resolveIncludePath(sourcePath, includePath) {
+  if (includePath.startsWith("./") || includePath.startsWith("../")) {
+    return path.resolve(path.dirname(sourcePath), includePath);
+  }
+
+  return path.join(templateSourcesRoot, includePath);
+}
+
+function renderTextFile(sourcePath, variables, activeStack = []) {
+  const resolvedPath = path.resolve(sourcePath);
+
+  if (activeStack.includes(resolvedPath)) {
+    const cycle = [...activeStack, resolvedPath].map((item) => path.relative(repoRoot, item)).join(" -> ");
+    throw new Error(`Include cycle detected: ${cycle}`);
+  }
+
+  const nextStack = [...activeStack, resolvedPath];
+  const content = fs.readFileSync(resolvedPath, "utf8");
+
+  const withIncludes = content.replace(includePattern, (_match, includePath) => {
+    const includeSource = resolveIncludePath(resolvedPath, includePath);
+
+    if (!fs.existsSync(includeSource)) {
+      throw new Error(
+        `Missing include "${includePath}" referenced from ${path.relative(repoRoot, resolvedPath)}`
+      );
+    }
+
+    if (!isTextFile(includeSource)) {
+      throw new Error(
+        `Include "${includePath}" referenced from ${path.relative(repoRoot, resolvedPath)} must be a text file`
+      );
+    }
+
+    return renderTextFile(includeSource, variables, nextStack);
+  });
+
+  return applyVariables(withIncludes, variables);
+}
+
+function copyFile(sourcePath, targetPath, variables) {
+  ensureDir(path.dirname(targetPath));
+
+  if (!isTextFile(sourcePath)) {
+    fs.copyFileSync(sourcePath, targetPath);
+    return;
+  }
+
+  fs.writeFileSync(targetPath, renderTextFile(sourcePath, variables), "utf8");
+}
+
+function copyDir(sourceDir, targetDir, variables) {
+  ensureDir(targetDir);
+
+  for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetName = applyVariables(entry.name, variables);
+    const targetPath = path.join(targetDir, targetName);
+
+    if (entry.isDirectory()) {
+      copyDir(sourcePath, targetPath, variables);
+      continue;
+    }
+
+    copyFile(sourcePath, targetPath, variables);
+  }
+}
+
+function getPresetFiles(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(rootDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+    .map((entry) => path.join(rootDir, entry.name));
+}
+
+function loadPreset(presetPath) {
+  return JSON.parse(fs.readFileSync(presetPath, "utf8"));
+}
+
+function resolveSource(relativePath) {
+  return path.join(templateSourcesRoot, relativePath);
+}
+
+function buildPreset(preset) {
+  const targetDir = path.join(repoRoot, preset.output);
+  const variables = preset.variables ?? {};
+
+  removeDir(targetDir);
+  ensureDir(targetDir);
+
+  for (const basePath of preset.base ?? []) {
+    copyDir(resolveSource(basePath), targetDir, variables);
+  }
+
+  for (const layerPath of preset.layers ?? []) {
+    copyDir(resolveSource(layerPath), targetDir, variables);
+  }
+
+  return targetDir;
+}
+
+function collectLatestModifiedTime(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return 0;
+  }
+
+  let latest = fs.statSync(rootDir).mtimeMs;
+
+  for (const entry of fs.readdirSync(rootDir, { withFileTypes: true })) {
+    const entryPath = path.join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      latest = Math.max(latest, collectLatestModifiedTime(entryPath));
+      continue;
+    }
+
+    latest = Math.max(latest, fs.statSync(entryPath).mtimeMs);
+  }
+
+  return latest;
+}
+
+function hasAnyFile(dir) {
+  if (!fs.existsSync(dir)) {
+    return false;
+  }
+
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isFile()) {
+      return true;
+    }
+
+    if (entry.isDirectory() && hasAnyFile(entryPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function writeBuildManifest(outputs) {
+  ensureDir(templatesRoot);
+  fs.writeFileSync(
+    buildManifestPath,
+    JSON.stringify(
+      {
+        builtAt: new Date().toISOString(),
+        outputs
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+}
+
+export function canBuildTemplates() {
+  return fs.existsSync(templateSourcesRoot) && fs.existsSync(presetsRoot);
+}
+
+export function getPresetDefinitions() {
+  if (!canBuildTemplates()) {
+    return [];
+  }
+
+  const presetCategories = fs
+    .readdirSync(presetsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(presetsRoot, entry.name));
+
+  return presetCategories.flatMap(getPresetFiles).map((presetPath) => loadPreset(presetPath));
+}
+
+export function getTemplateDirs(rootDir = templatesRoot) {
+  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;
+}
+
+export function validateTemplates(rootDir = templatesRoot) {
+  const templateDirs = getTemplateDirs(rootDir);
+  const emptyTemplates = templateDirs
+    .filter((templateDir) => !hasAnyFile(templateDir))
+    .map((templateDir) => path.relative(rootDir, templateDir));
+
+  return {
+    templateDirs,
+    emptyTemplates
+  };
+}
+
+export function buildTemplates() {
+  const presetDefinitions = getPresetDefinitions();
+
+  if (presetDefinitions.length === 0) {
+    return [];
+  }
+
+  removeDir(templatesRoot);
+  ensureDir(templatesRoot);
+
+  const builtTargets = [];
+
+  for (const preset of presetDefinitions) {
+    const targetDir = buildPreset(preset);
+    builtTargets.push(path.relative(repoRoot, targetDir));
+  }
+
+  writeBuildManifest(builtTargets);
+  return builtTargets;
+}
+
+export function hasCurrentTemplates() {
+  const presetDefinitions = getPresetDefinitions();
+
+  if (presetDefinitions.length === 0) {
+    return getTemplateDirs().length > 0;
+  }
+
+  if (!fs.existsSync(buildManifestPath)) {
+    return false;
+  }
+
+  for (const preset of presetDefinitions) {
+    const outputDir = path.join(repoRoot, preset.output);
+    if (!hasAnyFile(outputDir)) {
+      return false;
+    }
+  }
+
+  const manifestMtime = fs.statSync(buildManifestPath).mtimeMs;
+  const latestSourceMtime = collectLatestModifiedTime(templateSourcesRoot);
+
+  return manifestMtime >= latestSourceMtime;
+}
+
+export function ensureTemplatesReady() {
+  if (hasCurrentTemplates()) {
+    return {
+      built: false,
+      builtTargets: []
+    };
+  }
+
+  if (!canBuildTemplates()) {
+    return {
+      built: false,
+      builtTargets: []
+    };
+  }
+
+  return {
+    built: true,
+    builtTargets: buildTemplates()
+  };
+}

package/package.json

@@ -1,17 +1,30 @@
 {
   "name": "starter-structure-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Scaffold starter projects from your own stack-based template folders",
+  "homepage": "https://github.com/mohosin2126/starter-structure-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mohosin2126/starter-structure-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mohosin2126/starter-structure-cli/issues"
+  },
   "type": "module",
   "files": [
     "bin",
-    "scripts",
+    "lib",
     "templates",
     "README.md"
   ],
   "scripts": {
+    "build:architecture-stubs": "node ./scripts/generate-architecture-stubs.js",
+    "build:templates": "node ./scripts/build-templates.js",
+    "check:publish-version": "node ./scripts/check-publish-version.js",
     "check:templates": "node ./scripts/check-templates.js",
-    "prepack": "node ./scripts/check-templates.js"
+    "stats:downloads": "node ./scripts/check-package-usage.js",
+    "prepack": "node ./scripts/build-templates.js && node ./scripts/check-templates.js",
+    "prepublishOnly": "node ./scripts/check-publish-version.js"
   },
   "bin": {
     "starter-structure-cli": "bin/starter-structure-cli.js"

package/templates/.templates-manifest.json

@@ -0,0 +1,36 @@
+{
+  "builtAt": "2026-03-07T19:21:03.519Z",
+  "outputs": [
+    "templates/backend-only/express-mongoose-jwt",
+    "templates/backend-only/express-prisma-mysql-jwt-ts",
+    "templates/backend-only/express-prisma-mysql-jwt",
+    "templates/frontend-only/react-admin-dashboard",
+    "templates/fullstack/nextjs-tailwind-mongoose-mongodb",
+    "templates/fullstack/nextjs-tailwind-nextauth-prisma",
+    "templates/fullstack/nextjs-tailwind-prisma-mysql",
+    "templates/fullstack/nextjs-tailwind-prisma-postgres",
+    "templates/fullstack/react-vite-ts-tailwind-express-mongoose",
+    "templates/fullstack/react-vite-ts-tailwind-express-prisma-mysql",
+    "templates/fullstack/react-vite-ts-tailwind-express-prisma-postgres",
+    "templates/fullstack/react-vite-ts-tailwind-express-sequelize-mysql",
+    "templates/fullstack/vue-vite-ts-tailwind-express-mongoose",
+    "templates/fullstack/vue-vite-ts-tailwind-express-prisma-mysql",
+    "templates/monorepo-client-server/nextjs-express-prisma",
+    "templates/monorepo-client-server/react-vite-ts-express-mongoose",
+    "templates/monorepo-client-server/react-vite-ts-express-prisma",
+    "templates/monorepo-client-server/vue-vite-ts-express-mongoose",
+    "templates/monorepo-turbo-pnpm/nextjs-api-express-prisma",
+    "templates/monorepo-turbo-pnpm/nextjs-api-nestjs-prisma",
+    "templates/monorepo-turbo-pnpm/react-vite-api-express-mongoose",
+    "templates/single/nextjs-tailwind",
+    "templates/single/nextjs-ts-tailwind",
+    "templates/single/react-vite-shadcn-tailwind",
+    "templates/single/react-vite-tailwind-landing",
+    "templates/single/react-vite-tailwind",
+    "templates/single/react-vite-ts-shadcn-tailwind",
+    "templates/single/react-vite-ts-tailwind-landing",
+    "templates/single/react-vite-ts-tailwind",
+    "templates/single/vue-vite-tailwind",
+    "templates/single/vue-vite-ts-tailwind"
+  ]
+}

package/templates/backend-only/express-prisma-mysql-jwt/.env.example

@@ -0,0 +1,6 @@
+PORT=5000
+NODE_ENV=development
+DATABASE_URL="mysql://root:password@localhost:3306/__APP_NAME__"
+JWT_SECRET=change-this-secret
+JWT_EXPIRES_IN=7d
+CLIENT_URL=http://localhost:5173

package/templates/backend-only/express-prisma-mysql-jwt/README.md

@@ -0,0 +1,47 @@
+# __APP_NAME__
+
+Express + Prisma + MySQL + JWT starter API.
+
+## Features
+
+- User registration and login
+- Password hashing with `bcryptjs`
+- JWT authentication middleware
+- Prisma ORM with MySQL
+- Structured route/controller/middleware/utils layout
+- Ready-to-edit Prisma schema
+
+## Project structure
+
+```text
+.
+├── config/
+├── controllers/
+├── middleware/
+├── prisma/
+├── routes/
+├── utils/
+├── .env.example
+├── .gitignore
+├── index.js
+└── package.json
+```
+
+## Getting started
+
+```bash
+npm install
+cp .env.example .env
+npx prisma generate
+npx prisma migrate dev --name init
+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-prisma-mysql-jwt/config/prisma/index.js

@@ -0,0 +1,5 @@
+const { PrismaClient } = require("@prisma/client");
+
+const prisma = new PrismaClient();
+
+module.exports = prisma;

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

@@ -0,0 +1,115 @@
+const bcrypt = require("bcryptjs");
+
+const prisma = require("../../config/prisma");
+const { successResponse, errorResponse } = require("../../utils/api-response");
+const generateToken = require("../../utils/generate-token");
+const userSelect = require("../../utils/user-select");
+
+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 normalizedEmail = email.toLowerCase();
+    const existingUser = await prisma.user.findUnique({
+      where: { email: normalizedEmail }
+    });
+
+    if (existingUser) {
+      return errorResponse(res, "User already exists with this email.", 409);
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    const user = await prisma.user.create({
+      data: {
+        name,
+        email: normalizedEmail,
+        password: hashedPassword
+      },
+      select: userSelect
+    });
+
+    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 normalizedEmail = email.toLowerCase();
+    const user = await prisma.user.findUnique({
+      where: { email: normalizedEmail }
+    });
+
+    if (!user) {
+      return errorResponse(res, "Invalid email or password.", 401);
+    }
+
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      return errorResponse(res, "Invalid email or password.", 401);
+    }
+
+    const token = generateToken(user.id);
+
+    const safeUser = await prisma.user.findUnique({
+      where: { id: user.id },
+      select: userSelect
+    });
+
+    return successResponse(
+      res,
+      {
+        user: safeUser,
+        token
+      },
+      "Login successful."
+    );
+  } catch (error) {
+    next(error);
+  }
+}
+
+async function me(req, res, next) {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: req.user.id },
+      select: userSelect
+    });
+
+    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-prisma-mysql-jwt/index.js

@@ -0,0 +1,54 @@
+const express = require("express");
+const cors = require("cors");
+const dotenv = require("dotenv");
+const helmet = require("helmet");
+const morgan = require("morgan");
+
+const prisma = require("./config/prisma");
+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;
+
+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);
+
+async function startServer() {
+  try {
+    await prisma.$connect();
+    console.log("Prisma connected");
+
+    app.listen(PORT, () => {
+      console.log(`Server running on port ${PORT}`);
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error.message);
+    process.exit(1);
+  }
+}
+
+startServer();

package/templates/backend-only/express-prisma-mysql-jwt/middleware/authenticate/index.js

@@ -0,0 +1,34 @@
+const jwt = require("jsonwebtoken");
+
+const prisma = require("../config/prisma");
+const { errorResponse } = require("../utils/api-response");
+const userSelect = require("../utils/user-select");
+
+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 prisma.user.findUnique({
+      where: { id: decoded.id },
+      select: userSelect
+    });
+
+    if (!user) {
+      return errorResponse(res, "User not found.", 401);
+    }
+
+    req.user = user;
+    next();
+  } catch (_error) {
+    return errorResponse(res, "Invalid or expired token.", 401);
+  }
+}
+
+module.exports = authenticate;

package/templates/backend-only/express-prisma-mysql-jwt/middleware/error-handler/index.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-prisma-mysql-jwt/middleware/not-found/index.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;