@rellcodes16/devkit 1.0.0

package/src/templates/node/index.js

@@ -0,0 +1,666 @@
+export function nodePackageJson(appname, options) {
+  const deps = {
+    express: "^4.19.2",
+    cors: "^2.8.5",
+    dotenv: "^16.4.5",
+    morgan: "^1.10.0",
+    helmet: "^7.1.0",
+    "cookie-parser": "^1.4.6",
+    "express-rate-limit": "^7.3.1",
+    "express-mongo-sanitize": "^2.2.0",
+    "xss-clean": "^0.1.4",
+    "serve-favicon": "^2.5.0",
+    validator: "^13.12.0",
+    uuid: "^10.0.0",
+    "http-errors": "^2.0.0",
+  };
+
+  if (options.mongo)     deps["mongoose"]        = "^8.4.3";
+  if (options.prisma)    deps["@prisma/client"]  = "^5.16.0";
+  if (options.turso)     deps["@libsql/client"]  = "^0.6.0";
+  if (options.pg)        deps["postgres"]        = "^3.4.4";
+  if (options.supabase)  deps["@supabase/supabase-js"] = "^2.44.2";
+  if (options.redis)     deps["ioredis"]         = "^5.4.1";
+
+  if (options.drizzle)   deps["drizzle-orm"]     = "^0.32.0";
+
+  if (options.cloudinary) {
+    deps["cloudinary"]                  = "^2.3.1";
+    deps["multer"]                      = "^1.4.5-lts.1";
+    deps["multer-storage-cloudinary"]   = "^4.0.0";
+  }
+
+  if (options.socket) deps["socket.io"] = "^4.7.5";
+
+  const scripts = {
+    dev: "nodemon src/index.js",
+    start: "node src/index.js",
+  };
+
+  if (options.prisma) {
+    scripts["db:migrate"]  = "npx prisma migrate dev";
+    scripts["db:studio"]   = "npx prisma studio";
+    scripts["db:generate"] = "npx prisma generate";
+  }
+
+  if (options.drizzle) {
+    scripts["db:push"]   = "npx drizzle-kit push";
+    scripts["db:studio"] = "npx drizzle-kit studio";
+  }
+
+  return JSON.stringify(
+    {
+      name: appname,
+      version: "1.0.0",
+      description: "",
+      main: "src/index.js",
+      type: "module",
+      scripts,
+      dependencies: deps,
+      devDependencies: { nodemon: "^3.1.4" },
+    },
+    null,
+    2
+  );
+}
+
+export function nodeIndexJs(options) {
+  const imports = [
+    `import express from "express";`,
+    `import cors from "cors";`,
+    `import morgan from "morgan";`,
+    `import helmet from "helmet";`,
+    `import dotenv from "dotenv";`,
+    `import cookieParser from "cookie-parser";`,
+    `import rateLimit from "express-rate-limit";`,
+    `import mongoSanitize from "express-mongo-sanitize";`,
+    `import xss from "xss-clean";`,
+    `import favicon from "serve-favicon";`,
+    `import { fileURLToPath } from "url";`,
+    `import path from "path";`,
+    `import routes from "./routes/index.js";`,
+    `import { errorHandler } from "./middleware/errorHandler.js";`,
+    `import { notFound } from "./middleware/notFound.js";`,
+  ];
+
+  if (options.mongo)    imports.push(`import connectDB from "./config/db.js";`);
+  if (options.prisma)   imports.push(`import prisma from "./config/db.js";`);
+  if (options.turso)    imports.push(`import { db } from "./config/db.js";`);
+  if (options.pg)       imports.push(`import sql from "./config/db.js";`);
+  if (options.supabase) imports.push(`import supabase from "./config/db.js";`);
+  if (options.redis)    imports.push(`import redis from "./config/redis.js";`);
+
+  if (options.socket) {
+    imports.push(
+      `import { createServer } from "http";`,
+      `import { Server } from "socket.io";`
+    );
+  }
+
+  const socketSetup = options.socket
+    ? `
+const httpServer = createServer(app);
+const io = new Server(httpServer, {
+  cors: { origin: process.env.CLIENT_URL || "*", credentials: true },
+});
+
+io.on("connection", (socket) => {
+  console.log("Client connected:", socket.id);
+  socket.on("disconnect", () => console.log("Client disconnected:", socket.id));
+});
+`
+    : "";
+
+  const listenTarget = options.socket ? "httpServer" : "app";
+
+  const dbConnect = options.mongo
+    ? `\n// Connect to MongoDB\nawait connectDB();\n`
+    : "";
+
+  const rateLimitSetup = `
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 100,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: { error: "Too many requests, please try again later." },
+});`;
+
+  return `${imports.join("\n")}
+
+dotenv.config();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+${socketSetup}${dbConnect}${rateLimitSetup}
+
+// Security middleware
+app.use(helmet());
+app.use(mongoSanitize());
+app.use(xss());
+app.use("/api", limiter);
+
+// Core middleware
+app.use(cors({ origin: process.env.CLIENT_URL || "*", credentials: true }));
+app.use(morgan(process.env.NODE_ENV === "production" ? "combined" : "dev"));
+app.use(express.json({ limit: "10kb" }));
+app.use(express.urlencoded({ extended: true }));
+app.use(cookieParser());
+app.use(favicon(path.join(__dirname, "../public", "favicon.ico")));
+
+// Routes
+app.use("/api", routes);
+
+// 404 + error handler
+app.use(notFound);
+app.use(errorHandler);
+
+${listenTarget}.listen(PORT, () => {
+  console.log(\`Server running on http://localhost:\${PORT}\`);
+});
+`;
+}
+
+export function nodeEnv(options) {
+  const lines = [
+    `PORT=3000`,
+    `NODE_ENV=development`,
+    `CLIENT_URL=http://localhost:5173`,
+    ``,
+  ];
+
+  if (options.mongo) {
+    lines.push(`# MongoDB`);
+    lines.push(`MONGODB_URI=mongodb://localhost:27017/mydb`);
+    lines.push(``);
+  }
+
+  if (options.prisma) {
+    lines.push(`# Database (Prisma)`);
+    lines.push(`DATABASE_URL=postgresql://user:password@localhost:5432/mydb`);
+    lines.push(``);
+  }
+
+  if (options.turso) {
+    lines.push(`# Turso (LibSQL)`);
+    lines.push(`TURSO_DATABASE_URL=libsql://your-db.turso.io`);
+    lines.push(`TURSO_AUTH_TOKEN=your-auth-token`);
+    lines.push(``);
+  }
+
+  if (options.pg) {
+    lines.push(`# PostgreSQL`);
+    lines.push(`DATABASE_URL=postgresql://user:password@localhost:5432/mydb`);
+    lines.push(``);
+  }
+
+  if (options.supabase) {
+    lines.push(`# Supabase`);
+    lines.push(`SUPABASE_URL=https://your-project.supabase.co`);
+    lines.push(`SUPABASE_ANON_KEY=your-anon-key`);
+    lines.push(`SUPABASE_SERVICE_ROLE_KEY=your-service-role-key`);
+    lines.push(``);
+  }
+
+  if (options.redis) {
+    lines.push(`# Redis`);
+    lines.push(`REDIS_URL=redis://localhost:6379`);
+    lines.push(``);
+  }
+
+  if (options.cloudinary) {
+    lines.push(`# Cloudinary`);
+    lines.push(`CLOUDINARY_CLOUD_NAME=your-cloud-name`);
+    lines.push(`CLOUDINARY_API_KEY=your-api-key`);
+    lines.push(`CLOUDINARY_API_SECRET=your-api-secret`);
+    lines.push(``);
+  }
+
+  lines.push(`# Auth`);
+  lines.push(`JWT_SECRET=change-this-to-a-long-random-secret`);
+  lines.push(`JWT_EXPIRES_IN=7d`);
+
+  return lines.join("\n");
+}
+
+export function nodeGitignore() {
+  return `node_modules/
+.env
+.env.local
+dist/
+*.log
+.DS_Store
+`;
+}
+
+export function nodeMongoConfig() {
+  return `import mongoose from "mongoose";
+
+export default async function connectDB() {
+  try {
+    const conn = await mongoose.connect(process.env.MONGODB_URI);
+    console.log(\`MongoDB connected: \${conn.connection.host}\`);
+  } catch (err) {
+    console.error("MongoDB connection failed:", err.message);
+    process.exit(1);
+  }
+}
+`;
+}
+
+export function nodePrismaConfig() {
+  return `import { PrismaClient } from "@prisma/client";
+
+const prisma = new PrismaClient({
+  log: process.env.NODE_ENV === "development" ? ["query", "warn", "error"] : ["error"],
+});
+
+export default prisma;
+`;
+}
+
+// Turso — raw SQL client only (no Drizzle unless --drizzle is also passed)
+export function nodeTursoConfig() {
+  return `import { createClient } from "@libsql/client";
+
+const db = createClient({
+  url: process.env.TURSO_DATABASE_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+
+// Usage: const { rows } = await db.execute("SELECT * FROM users WHERE id = ?", [id]);
+export default db;
+`;
+}
+
+// Turso + Drizzle (only when --drizzle flag is also set)
+export function nodeTursoWithDrizzleConfig() {
+  return `import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import * as schema from "./schema.js";
+
+const client = createClient({
+  url: process.env.TURSO_DATABASE_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+
+export const db = drizzle(client, { schema });
+`;
+}
+
+export function nodeTursoSchema() {
+  return `import { text, integer, sqliteTable } from "drizzle-orm/sqlite-core";
+
+// Example table, replace or extend with your own models
+export const users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  email: text("email").notNull().unique(),
+  name: text("name"),
+  createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => new Date()),
+});
+`;
+}
+
+export function nodeDrizzleConfig(options) {
+  const isPg = options.pg;
+  return `import { defineConfig } from "drizzle-kit";
+import dotenv from "dotenv";
+dotenv.config();
+
+export default defineConfig({
+  schema: "./src/config/schema.js",
+  out: "./drizzle",
+  dialect: "${isPg ? "postgresql" : "turso"}",
+  dbCredentials: {
+${isPg
+  ? `    url: process.env.DATABASE_URL,`
+  : `    url: process.env.TURSO_DATABASE_URL,\n    authToken: process.env.TURSO_AUTH_TOKEN,`}
+  },
+});
+`;
+}
+
+export function nodePgConfig() {
+  return `import postgres from "postgres";
+
+const sql = postgres(process.env.DATABASE_URL, {
+  max: 10,              // connection pool size
+  idle_timeout: 20,     // close idle connections after 20s
+  connect_timeout: 10,  // fail fast if DB unreachable
+});
+
+// Usage: const users = await sql\`SELECT * FROM users WHERE id = \${id}\`;
+export default sql;
+`;
+}
+
+export function nodePgWithDrizzleConfig() {
+  return `import postgres from "postgres";
+import { drizzle } from "drizzle-orm/postgres-js";
+import * as schema from "./schema.js";
+
+const client = postgres(process.env.DATABASE_URL, { max: 10 });
+export const db = drizzle(client, { schema });
+`;
+}
+
+export function nodePgSchema() {
+  return `import { pgTable, serial, text, varchar, timestamp } from "drizzle-orm/pg-core";
+
+// Example table — replace or extend with your own models
+export const users = pgTable("users", {
+  id: serial("id").primaryKey(),
+  email: varchar("email", { length: 255 }).notNull().unique(),
+  name: text("name"),
+  createdAt: timestamp("created_at").defaultNow(),
+});
+`;
+}
+
+// Supabase
+export function nodeSupabaseConfig() {
+  return `import { createClient } from "@supabase/supabase-js";
+
+// Public client — safe for read operations and auth flows
+export const supabase = createClient(
+  process.env.SUPABASE_URL,
+  process.env.SUPABASE_ANON_KEY
+);
+
+// Admin client — full access, never expose to the browser
+export const supabaseAdmin = createClient(
+  process.env.SUPABASE_URL,
+  process.env.SUPABASE_SERVICE_ROLE_KEY
+);
+
+export default supabase;
+`;
+}
+
+// Redis
+export function nodeRedisConfig() {
+  return `import Redis from "ioredis";
+
+const redis = new Redis(process.env.REDIS_URL, {
+  maxRetriesPerRequest: 3,
+  enableReadyCheck: true,
+  lazyConnect: true,
+});
+
+redis.on("connect", () => console.log("Redis connected"));
+redis.on("error", (err) => console.error("Redis error:", err.message));
+
+// Helpers
+export async function getCache(key) {
+  const data = await redis.get(key);
+  return data ? JSON.parse(data) : null;
+}
+
+export async function setCache(key, value, ttlSeconds = 300) {
+  await redis.set(key, JSON.stringify(value), "EX", ttlSeconds);
+}
+
+export async function deleteCache(key) {
+  await redis.del(key);
+}
+
+export default redis;
+`;
+}
+
+export function nodePrismaSchema() {
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+// Add your models below
+// model User {
+//   id        String   @id @default(uuid())
+//   email     String   @unique
+//   name      String?
+//   createdAt DateTime @default(now())
+//   updatedAt DateTime @updatedAt
+// }
+`;
+}
+
+export function nodeCloudinaryConfig() {
+  return `import { v2 as cloudinary } from "cloudinary";
+import { CloudinaryStorage } from "multer-storage-cloudinary";
+import multer from "multer";
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+  api_key:    process.env.CLOUDINARY_API_KEY,
+  api_secret: process.env.CLOUDINARY_API_SECRET,
+});
+
+const storage = new CloudinaryStorage({
+  cloudinary,
+  params: {
+    folder: "uploads",
+    allowed_formats: ["jpg", "jpeg", "png", "webp", "gif"],
+    transformation: [{ width: 1200, crop: "limit" }],
+  },
+});
+
+export const upload = multer({ storage });
+export default cloudinary;
+`;
+}
+
+export function nodeErrorHandler() {
+  return `export function errorHandler(err, req, res, next) {
+  const status = err.status || err.statusCode || 500;
+  const message = err.message || "Internal Server Error";
+
+  if (process.env.NODE_ENV === "development") {
+    console.error(\`[ERROR \${status}]\`, err.stack);
+  }
+
+  res.status(status).json({
+    success: false,
+    error: message,
+    ...(process.env.NODE_ENV === "development" && { stack: err.stack }),
+  });
+}
+`;
+}
+
+export function nodeNotFound() {
+  return `export function notFound(req, res, next) {
+  res.status(404).json({
+    success: false,
+    error: \`Route not found — \${req.method} \${req.originalUrl}\`,
+  });
+}
+`;
+}
+
+export function nodeAsyncHandler() {
+  return `/**
+ * Wraps an async route handler and forwards errors to Express error middleware.
+ * Eliminates try/catch boilerplate in every controller.
+ *
+ * Usage:
+ *   router.get("/", asyncHandler(async (req, res) => { ... }));
+ */
+export const asyncHandler = (fn) => (req, res, next) =>
+  Promise.resolve(fn(req, res, next)).catch(next);
+`;
+}
+
+export function nodeRoutes() {
+  return `import { Router } from "express";
+
+const router = Router();
+
+router.get("/health", (req, res) => {
+  res.json({ success: true, status: "ok", timestamp: new Date().toISOString() });
+});
+
+export default router;
+`;
+}
+
+export function nodeUserModel(withCloudinary = false) {
+  const avatarField = withCloudinary
+    ? `    avatar: {
+      url:      { type: String, default: "" },
+      publicId: { type: String, default: "" },
+    },`
+    : "";
+
+  return `import mongoose from "mongoose";
+import validator from "validator";
+import { v4 as uuidv4 } from "uuid";
+
+const userSchema = new mongoose.Schema(
+  {
+    _id:  { type: String, default: uuidv4 },
+    name: {
+      type:      String,
+      required:  [true, "Name is required"],
+      trim:      true,
+      minlength: [2, "Name must be at least 2 characters"],
+    },
+    email: {
+      type:      String,
+      required:  [true, "Email is required"],
+      unique:    true,
+      lowercase: true,
+      validate:  [validator.isEmail, "Please provide a valid email"],
+    },
+    password: {
+      type:      String,
+      required:  [true, "Password is required"],
+      minlength: [8, "Password must be at least 8 characters"],
+      select:    false,
+    },
+    role: {
+      type:    String,
+      enum:    ["user", "admin"],
+      default: "user",
+    },
+${avatarField}
+    isActive: { type: Boolean, default: true },
+  },
+  { timestamps: true }
+);
+
+// Strip password from JSON responses
+userSchema.set("toJSON", {
+  transform: (doc, ret) => {
+    delete ret.password;
+    return ret;
+  },
+});
+
+const User = mongoose.model("User", userSchema);
+export default User;
+`;
+}
+
+export function nodeReadme(appname, options) {
+  const stackLines = [
+    "- Node.js + Express",
+    "- Helmet (security headers)",
+    "- CORS",
+    "- Morgan (logging)",
+    "- express-rate-limit",
+    "- express-mongo-sanitize",
+    "- xss-clean",
+    "- cookie-parser",
+    "- dotenv",
+    "- validator",
+    "- uuid",
+    "- serve-favicon",
+  ];
+
+  if (options.mongo)    stackLines.push("- Mongoose (MongoDB)");
+  if (options.prisma)   stackLines.push("- Prisma (PostgreSQL)");
+  if (options.turso)    stackLines.push(options.drizzle ? "- Turso (LibSQL) + Drizzle ORM" : "- Turso (LibSQL) — raw SQL client");
+  if (options.pg)       stackLines.push(options.drizzle ? "- postgres.js (PostgreSQL) + Drizzle ORM" : "- postgres.js (PostgreSQL)");
+  if (options.supabase) stackLines.push("- Supabase JS client");
+  if (options.redis)    stackLines.push("- Redis (ioredis)");
+  if (options.cloudinary) stackLines.push("- Cloudinary + Multer");
+  if (options.socket)   stackLines.push("- Socket.io");
+
+  const dbSteps = [];
+  if (options.mongo)    dbSteps.push("# Set MONGODB_URI to your local or Atlas connection string");
+  if (options.prisma)   dbSteps.push("npx prisma migrate dev   # after setting DATABASE_URL");
+  if (options.turso && options.drizzle)  dbSteps.push("npx drizzle-kit push    # after setting TURSO credentials");
+  if (options.pg && options.drizzle)     dbSteps.push("npx drizzle-kit push    # after setting DATABASE_URL");
+  if (options.supabase) dbSteps.push("# Set SUPABASE_URL, SUPABASE_ANON_KEY, SUPABASE_SERVICE_ROLE_KEY");
+  if (options.redis)    dbSteps.push("# Make sure Redis is running: redis-server");
+
+  const modelSection = options.mongo ? "  models/       # Mongoose models\n  " : "";
+
+  const configLines = ["  config/", "    db.js        # Database connection"];
+  if (options.redis)      configLines.push("    redis.js     # Redis client + cache helpers");
+  if (options.cloudinary) configLines.push("    cloudinary.js # Cloudinary config + multer");
+  if (options.drizzle)    configLines.push("    schema.js    # Drizzle table definitions");
+
+  const envRows = [
+    "| `PORT` | Server port (default 3000) |",
+    "| `NODE_ENV` | Environment (development / production) |",
+    "| `CLIENT_URL` | Allowed CORS origin |",
+    options.mongo    && "| `MONGODB_URI` | MongoDB connection string |",
+    (options.prisma || options.pg) && "| `DATABASE_URL` | PostgreSQL connection string |",
+    options.turso    && "| `TURSO_DATABASE_URL` | Turso database URL |",
+    options.turso    && "| `TURSO_AUTH_TOKEN` | Turso auth token |",
+    options.supabase && "| `SUPABASE_URL` | Supabase project URL |",
+    options.supabase && "| `SUPABASE_ANON_KEY` | Supabase anon/public key |",
+    options.supabase && "| `SUPABASE_SERVICE_ROLE_KEY` | Supabase service role key (server only) |",
+    options.redis    && "| `REDIS_URL` | Redis connection URL |",
+    options.cloudinary && "| `CLOUDINARY_CLOUD_NAME` | Cloudinary cloud name |",
+    options.cloudinary && "| `CLOUDINARY_API_KEY` | Cloudinary API key |",
+    options.cloudinary && "| `CLOUDINARY_API_SECRET` | Cloudinary API secret |",
+    "| `JWT_SECRET` | JWT signing secret |",
+    "| `JWT_EXPIRES_IN` | JWT expiry (e.g. 7d) |",
+  ].filter(Boolean).join("\n");
+
+  return `# ${appname}
+
+Scaffolded with [devkit](https://github.com/rellcodes16/devkit).
+
+## Stack
+
+${stackLines.join("\n")}
+
+## Getting started
+
+\`\`\`bash
+cp .env.example .env
+${dbSteps.join("\n")}
+npm run dev
+\`\`\`
+
+## Project structure
+
+\`\`\`
+src/
+  routes/       # Express routers
+  controllers/  # Route handler logic
+  middleware/   # errorHandler, notFound, asyncHandler
+  ${modelSection}${configLines.join("\n")}
+  index.js      # App entry point
+public/
+  favicon.ico
+\`\`\`
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+${envRows}
+`;
+}