create-enterprise-backend 0.1.0

package/bin/cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { run } from "../core/run.js";
+
+run().catch((err) => {
+  console.error("❌ Error:", err);
+  process.exit(1);
+});

package/core/install.js

@@ -0,0 +1,5 @@
+import { execSync } from "child_process";
+
+export async function installDeps({ targetDir }) {
+  execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+}

package/core/run.js

@@ -0,0 +1,95 @@
+import path from "path";
+import fs from "fs";
+import prompts from "prompts";
+import chalk from "chalk";
+import { generateProject } from "./scaffold.js";
+import { installDeps } from "./install.js";
+
+export async function run() {
+  console.log(chalk.cyan.bold("\n🚀 Create Backend (Enterprise Scaffolder)\n"));
+
+  const projectNameArg = process.argv[2];
+
+  const answers = await prompts(
+    [
+      {
+        type: projectNameArg ? null : "text",
+        name: "projectName",
+        message: "Project name?",
+        validate: (v) =>
+          v?.trim()?.length ? true : "Project name is required"
+      },
+      {
+        type: "select",
+        name: "framework",
+        message: "Select framework",
+        choices: [
+          { title: "Express", value: "express" },
+          { title: "Fastify", value: "fastify" }
+        ]
+      },
+      {
+        type: "select",
+        name: "database",
+        message: "Select database",
+        choices: [
+          { title: "MongoDB", value: "mongo" },
+          { title: "Supabase", value: "supabase" },
+        ]
+      },
+      {
+        type: "toggle",
+        name: "install",
+        message: "Install dependencies now?",
+        initial: true,
+        active: "yes",
+        inactive: "no"
+      }
+    ],
+    {
+      onCancel: () => {
+        console.log(chalk.yellow("\n⛔ Cancelled.\n"));
+        process.exit(0);
+      }
+    }
+  );
+
+  const projectName = (projectNameArg || answers.projectName).trim();
+  const { framework, database } = answers;
+
+  const templatePath = path.resolve(
+    "templates",
+    framework,
+    database
+  );
+
+  // ✅ Validate template exists
+  if (!fs.existsSync(templatePath)) {
+    console.log(
+      chalk.red(
+        `\n❌ Template not found for: ${framework} + ${database}\n`
+      )
+    );
+    process.exit(1);
+  }
+
+  const targetDir = path.join(process.cwd(), projectName);
+
+  console.log(chalk.gray("\n📦 Generating project..."));
+  await generateProject({
+    framework,
+    database,
+    targetDir,
+    projectName
+  });
+
+  if (answers.install) {
+    console.log(chalk.gray("\n📥 Installing dependencies..."));
+    await installDeps({ targetDir });
+  }
+
+  console.log(chalk.green.bold("\n✅ Done!\n"));
+  console.log(
+    `Next steps:\n  cd ${projectName}\n  npm run dev\n`
+  );
+}

package/core/scaffold.js

@@ -0,0 +1,37 @@
+import path from "path";
+import fs from "fs-extra";
+import { fileURLToPath } from "url";
+
+function getPackageRoot() {
+  const __filename = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(__filename), "..");
+}
+
+export async function generateProject({ framework, database, targetDir, projectName }) {
+  const root = getPackageRoot();
+
+  const templateDir = path.join(root, "templates", framework, database);
+
+  const exists = await fs.pathExists(templateDir);
+  if (!exists) {
+    throw new Error(`Template not found: ${framework}/${database}`);
+  }
+
+  if (await fs.pathExists(targetDir)) {
+    throw new Error(`Target folder already exists: ${projectName}`);
+  }
+
+  await fs.ensureDir(targetDir);
+  await fs.copy(templateDir, targetDir, {
+    overwrite: false,
+    errorOnExist: true
+  });
+
+  // Rename package name inside generated package.json (if template has one)
+  const pkgPath = path.join(targetDir, "package.json");
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+    pkg.name = projectName;
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "create-enterprise-backend",
+  "version": "0.1.0",
+  "description": "Enterprise backend scaffolder (Express/Fastify + Mongo/Supabase)",
+  "type": "module",
+  "bin": {
+    "create-enterprise-backend": "./bin/cli.js"
+  },
+  "files": ["bin", "core", "templates", "README.md"],
+  "keywords": [
+    "cli",
+    "scaffold",
+    "backend",
+    "express",
+    "fastify",
+    "mongodb",
+    "supabase"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "prompts": "^2.4.2"
+  }
+}

package/templates/express/mongo/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": "js,json",
+  "ignore": ["node_modules"],
+  "exec": "clear && node src/server.js"
+}

package/templates/express/mongo/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "backend-app",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "nodemon src/server.js",
+    "start": "node src/server.js"
+  },
+  "dependencies": {
+    "express": "^4.19.2",
+    "mongoose": "^8.3.0",
+    "dotenv": "^16.4.5",
+    "bcryptjs": "^2.4.3",
+    "jsonwebtoken": "^9.0.2",
+    "cors": "^2.8.5"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.3"
+  }
+}

package/templates/express/mongo/src/app.js

@@ -0,0 +1,41 @@
+import express from "express";
+import cors from "cors";
+import { registerRoutes } from "./routes.js";
+import { globalErrorHandler } from "./utils/error-handler.js";
+
+export function buildApp() {
+  const app = express();
+
+  app.use(cors());
+  app.use(express.json());
+
+  // Root
+  app.get("/", (req, res) => {
+    res.json({
+      status: "ok",
+      message: "Express API is running"
+    });
+  });
+
+  // Health
+  app.get("/health", (req, res) => {
+    res.json({ status: "ok" });
+  });
+
+  // Register ALL routes
+  registerRoutes(app);
+
+  // ❌ 404 Not Found Handler (Express way)
+  app.use((req, res, next) => {
+    res.status(404).json({
+      statusCode: 404,
+      message: "Route not found",
+      path: req.originalUrl
+    });
+  });
+
+  // ✅ Global Error Handler (MUST be last)
+  app.use(globalErrorHandler);
+
+  return app;
+}

package/templates/express/mongo/src/config/db.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+
+export async function connectDB(uri) {
+  if (!uri) {
+    console.warn("⚠️ MongoDB disabled (MONGO_URI not set)");
+    return;
+  }
+
+  try {
+    await mongoose.connect(uri);
+    console.log("✅ MongoDB connected");
+  } catch (err) {
+    console.error("❌ MongoDB connection failed:", err.message);
+    console.warn("⚠️ App running without database");
+  }
+}

package/templates/express/mongo/src/config/env.js

@@ -0,0 +1,9 @@
+import dotenv from "dotenv";
+
+dotenv.config();
+
+export const env = {
+  PORT: process.env.PORT || 5000,
+  MONGO_URI: process.env.MONGO_URI || "",
+  JWT_SECRET: process.env.JWT_SECRET || "changeme"
+};

package/templates/express/mongo/src/middlewares/db-guard.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+export function requireDB(req, res, next) {
+  if (mongoose.connection.readyState !== 1) {
+    return res.status(503).json({
+      statusCode: 503,
+      message: "Database not connected. Please configure MongoDB."
+    });
+  }
+  next();
+}

package/templates/express/mongo/src/middlewares/jwt.guard.js

@@ -0,0 +1,18 @@
+import jwt from "jsonwebtoken";
+import { env } from "../config/env.js";
+
+export function requireAuth(req, res, next) {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+
+  try {
+    const token = authHeader.split(" ")[1];
+    req.user = jwt.verify(token, env.JWT_SECRET);
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid token" });
+  }
+}

package/templates/express/mongo/src/modules/auth/auth.controller.js

@@ -0,0 +1,32 @@
+import { registerUser, loginUser } from "./auth.service.js";
+import { env } from "../../config/env.js";
+import { User } from "./user.model.js";
+
+
+export async function register(req, reply) {
+  try {
+    const result = await registerUser(req.body, env.JWT_SECRET);
+    reply.code(201).send(result);
+  } catch (err) {
+    reply.code(400).send({ message: err.message });
+  }
+}
+
+export async function login(req, reply) {
+  try {
+    const result = await loginUser(req.body, env.JWT_SECRET);
+    reply.send(result);
+  } catch (err) {
+    reply.code(400).send({ message: err.message });
+  }
+}
+
+
+export async function me(req, reply) {
+  const userId = req.user.id;
+
+  const user = await User.findById(userId).select("-password");
+
+  reply.send(user);
+}
+

package/templates/express/mongo/src/modules/auth/auth.routes.js

@@ -0,0 +1,12 @@
+import express from "express";
+import { register, login, me } from "./auth.controller.js";
+import { requireDB } from "../../middlewares/db-guard.js";
+import { requireAuth } from "../../middlewares/jwt.guard.js";
+
+const router = express.Router();
+
+router.post("/register", requireDB, register);
+router.post("/login", requireDB, login);
+router.get("/me", requireDB, requireAuth, me);
+
+export default router;

package/templates/express/mongo/src/modules/auth/auth.service.js

@@ -0,0 +1,68 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import { User } from "./user.model.js";
+
+export async function registerUser({ name, email, password }, jwtSecret) {
+  if (!jwtSecret) {
+    throw new Error("JWT_SECRET not configured");
+  }
+
+  const exists = await User.findOne({ email });
+  if (exists) {
+    throw new Error("Email already exists");
+  }
+
+  const hashedPassword = await bcrypt.hash(password, 10);
+
+  const user = await User.create({
+    name,
+    email,
+    password: hashedPassword
+  });
+
+  const token = jwt.sign(
+    { id: user._id, email: user.email },
+    jwtSecret,
+    { expiresIn: "7d" }
+  );
+
+  return {
+    token,
+    user: {
+      id: user._id,
+      name: user.name,
+      email: user.email
+    }
+  };
+}
+
+export async function loginUser({ email, password }, jwtSecret) {
+  if (!jwtSecret) {
+    throw new Error("JWT_SECRET not configured");
+  }
+
+  const user = await User.findOne({ email });
+  if (!user) {
+    throw new Error("Invalid credentials");
+  }
+
+  const match = await bcrypt.compare(password, user.password);
+  if (!match) {
+    throw new Error("Invalid credentials");
+  }
+
+  const token = jwt.sign(
+    { id: user._id, email: user.email },
+    jwtSecret,
+    { expiresIn: "7d" }
+  );
+
+  return {
+    token,
+    user: {
+      id: user._id,
+      name: user.name,
+      email: user.email
+    }
+  };
+}

package/templates/express/mongo/src/modules/auth/user.model.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    email: { type: String, required: true, unique: true, lowercase: true },
+    password: { type: String, required: true }
+  },
+  { timestamps: true }
+);
+
+// ⚠️ Prevent model overwrite in dev / watch mode
+export const User =
+  mongoose.models.User || mongoose.model("User", userSchema);

package/templates/express/mongo/src/routes.js

@@ -0,0 +1,5 @@
+import authRoutes from "./modules/auth/auth.routes.js";
+
+export function registerRoutes(app) {
+  app.use("/api/auth", authRoutes);
+}

package/templates/express/mongo/src/server.js

@@ -0,0 +1,11 @@
+import { buildApp } from "./app.js";
+import { connectDB } from "./config/db.js";
+import { env } from "./config/env.js";
+
+const app = buildApp();
+
+await connectDB(env.MONGO_URI);
+
+app.listen(env.PORT, () => {
+  console.log(`🚀 Express server running on http://localhost:${env.PORT}`);
+});

package/templates/express/mongo/src/utils/error-handler.js

@@ -0,0 +1,10 @@
+export function globalErrorHandler(err, req, res, next) {
+  console.error(err);
+
+  res.status(err.statusCode || 500).json({
+    statusCode: err.statusCode || 500,
+    message: err.message || "Internal Server Error",
+    path: req.originalUrl,
+    timestamp: new Date().toISOString()
+  });
+}

package/templates/fastify/mongo/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": "js,json",
+  "ignore": ["node_modules"],
+  "exec": "clear && node src/server.js"
+}

package/templates/fastify/mongo/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "backend-app",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "nodemon src/server.js",
+    "start": "node src/server.js"
+  },
+  "dependencies": {
+    "@fastify/jwt": "^7.0.1",
+    "bcryptjs": "^2.4.3",
+    "dotenv": "^16.4.5",
+    "fastify": "^4.27.0",
+    "fastify-plugin": "^5.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.3.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.3"
+  }
+}
+
+

package/templates/fastify/mongo/src/app.js

@@ -0,0 +1,40 @@
+import Fastify from "fastify";
+import { globalErrorHandler } from "./utils/error-handler.js";
+import { registerRoutes } from "./routes.js";
+import jwtPlugin from "./plugins/jwt.js";
+import { env } from "./config/env.js";
+
+export function buildApp() {
+  const app = Fastify({ logger: true });
+
+   
+
+  // JWT plugin
+  app.register(jwtPlugin, { secret: env.JWT_SECRET });
+
+  // Root
+  app.get("/", async () => ({
+    status: "ok",
+    message: "Fastify API is running"
+  }));
+
+  // Health
+  app.get("/health", async () => ({
+    status: "ok"
+  }));
+
+  // Register ALL routes here
+  registerRoutes(app);
+
+  // Global error handler (must be last)
+app.setNotFoundHandler((request, reply) => {
+  reply.code(404).send({
+    statusCode: 404,
+    message: "Route not found",
+    path: request.url
+  });
+});
+
+
+  return app;
+}

package/templates/fastify/mongo/src/config/db.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+
+export async function connectDB(uri, logger = console) {
+  if (!uri) {
+    logger.warn("⚠️  MongoDB disabled (MONGO_URI not set)");
+    return;
+  }
+
+  try {
+    await mongoose.connect(uri);
+    logger.info("✅ MongoDB connected");
+  } catch (err) {
+    logger.error("❌ MongoDB connection failed:", err.message);
+    logger.warn("⚠️  Continuing without database");
+  }
+}

package/templates/fastify/mongo/src/config/env.js

@@ -0,0 +1,9 @@
+import dotenv from "dotenv";
+
+dotenv.config();
+
+export const env = {
+  PORT: process.env.PORT || 5000,
+  MONGO_URI: process.env.MONGO_URI || "",
+  JWT_SECRET: process.env.JWT_SECRET || "changeme"
+};

package/templates/fastify/mongo/src/middlewares/README.md

@@ -0,0 +1,2 @@
+This folder contains reusable Express/Fastify middlewares
+(e.g. auth guards, role guards, rate limiting, etc.)

package/templates/fastify/mongo/src/modules/auth/auth.controller.js

@@ -0,0 +1,32 @@
+import { registerUser, loginUser } from "./auth.service.js";
+import { env } from "../../config/env.js";
+import { User } from "./user.model.js";
+
+
+export async function register(req, reply) {
+  try {
+    const result = await registerUser(req.body, env.JWT_SECRET);
+    reply.code(201).send(result);
+  } catch (err) {
+    reply.code(400).send({ message: err.message });
+  }
+}
+
+export async function login(req, reply) {
+  try {
+    const result = await loginUser(req.body, env.JWT_SECRET);
+    reply.send(result);
+  } catch (err) {
+    reply.code(400).send({ message: err.message });
+  }
+}
+
+
+export async function me(req, reply) {
+  const userId = req.user.id;
+
+  const user = await User.findById(userId).select("-password");
+
+  reply.send(user);
+}
+

package/templates/fastify/mongo/src/modules/auth/auth.routes.js

@@ -0,0 +1,24 @@
+import { register, login, me } from "./auth.controller.js";
+import { registerSchema, loginSchema } from "./auth.schema.js";
+import { requireDB } from "../../utils/db-guard.js";
+import { requireAuth } from "../../utils/jwt-guard.js";
+
+export default async function authRoutes(app) {
+  app.post("/register", {
+    preHandler: requireDB,
+    schema: registerSchema,
+    handler: register
+  });
+
+  app.post("/login", {
+    preHandler: requireDB,
+    schema: loginSchema,
+    handler: login
+  });
+
+  // 🔐 JWT protected route
+  app.get("/me", {
+    preHandler: [requireDB, requireAuth],
+    handler: me
+  });
+}

package/templates/fastify/mongo/src/modules/auth/auth.schema.js

@@ -0,0 +1,22 @@
+export const registerSchema = {
+  body: {
+    type: "object",
+    required: ["name", "email", "password"],
+    properties: {
+      name: { type: "string", minLength: 2 },
+      email: { type: "string", format: "email" },
+      password: { type: "string", minLength: 6 }
+    }
+  }
+};
+
+export const loginSchema = {
+  body: {
+    type: "object",
+    required: ["email", "password"],
+    properties: {
+      email: { type: "string", format: "email" },
+      password: { type: "string", minLength: 6 }
+    }
+  }
+};

package/templates/fastify/mongo/src/modules/auth/auth.service.js

@@ -0,0 +1,68 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import { User } from "./user.model.js";
+
+export async function registerUser({ name, email, password }, jwtSecret) {
+  if (!jwtSecret) {
+    throw new Error("JWT_SECRET not configured");
+  }
+
+  const exists = await User.findOne({ email });
+  if (exists) {
+    throw new Error("Email already exists");
+  }
+
+  const hashedPassword = await bcrypt.hash(password, 10);
+
+  const user = await User.create({
+    name,
+    email,
+    password: hashedPassword
+  });
+
+  const token = jwt.sign(
+    { id: user._id, email: user.email },
+    jwtSecret,
+    { expiresIn: "7d" }
+  );
+
+  return {
+    token,
+    user: {
+      id: user._id,
+      name: user.name,
+      email: user.email
+    }
+  };
+}
+
+export async function loginUser({ email, password }, jwtSecret) {
+  if (!jwtSecret) {
+    throw new Error("JWT_SECRET not configured");
+  }
+
+  const user = await User.findOne({ email });
+  if (!user) {
+    throw new Error("Invalid credentials");
+  }
+
+  const match = await bcrypt.compare(password, user.password);
+  if (!match) {
+    throw new Error("Invalid credentials");
+  }
+
+  const token = jwt.sign(
+    { id: user._id, email: user.email },
+    jwtSecret,
+    { expiresIn: "7d" }
+  );
+
+  return {
+    token,
+    user: {
+      id: user._id,
+      name: user.name,
+      email: user.email
+    }
+  };
+}

package/templates/fastify/mongo/src/modules/auth/user.model.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true },
+    email: { type: String, required: true, unique: true, lowercase: true },
+    password: { type: String, required: true }
+  },
+  { timestamps: true }
+);
+
+// ⚠️ Prevent model overwrite in dev / watch mode
+export const User =
+  mongoose.models.User || mongoose.model("User", userSchema);

package/templates/fastify/mongo/src/plugins/jwt.js

@@ -0,0 +1,8 @@
+import fp from "fastify-plugin";
+import jwt from "@fastify/jwt";
+
+export default fp(async (app, opts) => {
+  app.register(jwt, {
+    secret: opts.secret
+  });
+});

package/templates/fastify/mongo/src/routes.js

@@ -0,0 +1,11 @@
+import authRoutes from "./modules/auth/auth.routes.js";
+// later you can add more:
+// import userRoutes from "./modules/users/user.routes.js";
+
+export async function registerRoutes(app) {
+  // Auth routes
+  app.register(authRoutes, { prefix: "/api/auth" });
+
+  // Future modules
+  // app.register(userRoutes, { prefix: "/api/users" });
+}

package/templates/fastify/mongo/src/server.js

@@ -0,0 +1,15 @@
+import { buildApp } from "./app.js";
+import { connectDB } from "./config/db.js";
+import { env } from "./config/env.js";
+
+const app = buildApp();
+
+await connectDB(env.MONGO_URI, app.log);
+
+app.listen({ port: env.PORT }, (err, address) => {
+  if (err) {
+    app.log.error(err);
+    process.exit(1);
+  }
+  app.log.info(`🚀 Server running at ${address}`);
+});

package/templates/fastify/mongo/src/services/README.md

@@ -0,0 +1,2 @@
+This folder contains shared business logic services
+used across multiple modules.

package/templates/fastify/mongo/src/utils/db-guard.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+export function requireDB(req, reply, done) {
+  if (mongoose.connection.readyState !== 1) {
+    return reply.code(503).send({
+      statusCode: 503,
+      message: "Database not connected. Please configure MongoDB."
+    });
+  }
+  done();
+}

package/templates/fastify/mongo/src/utils/error-handler.js

@@ -0,0 +1,18 @@
+export function globalErrorHandler(error, request, reply) {
+  // Log full error (for dev / prod logs)
+  request.log.error(error);
+
+  // Default values
+  const statusCode = error.statusCode || 500;
+  const message =
+    statusCode === 500
+      ? "Internal Server Error"
+      : error.message;
+
+  reply.code(statusCode).send({
+    statusCode,
+    message,
+    path: request.url,
+    timestamp: new Date().toISOString()
+  });
+}

package/templates/fastify/mongo/src/utils/jwt-guard.js

@@ -0,0 +1,10 @@
+export async function requireAuth(request, reply) {
+  try {
+    await request.jwtVerify();
+  } catch (err) {
+    reply.code(401).send({
+      statusCode: 401,
+      message: "Unauthorized: Invalid or missing token"
+    });
+  }
+}

package/templates/fastify/supabase/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "fastify-supabase-app",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "nodemon src/server.js",
+    "start": "node src/server.js"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.45.0",
+    "dotenv": "^16.4.5",
+    "fastify": "^4.27.0",
+    "fastify-plugin": "^5.1.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.3"
+  }
+}

package/templates/fastify/supabase/src/app.js

@@ -0,0 +1,23 @@
+import Fastify from "fastify";
+import requestContext from "./plugins/request-content.js";
+import { registerRoutes } from "./routes.js";
+import { globalErrorHandler } from "./utils/error-handler.js";
+
+export function buildApp() {
+  const app = Fastify({ logger: true });
+
+  app.register(requestContext);
+
+  app.get("/", async () => ({
+    status: "ok",
+    message: "Fastify Supabase Enterprise API"
+  }));
+
+  app.get("/health", async () => ({ status: "ok" }));
+
+  registerRoutes(app);
+
+  app.setErrorHandler(globalErrorHandler);
+
+  return app;
+}

package/templates/fastify/supabase/src/config/env.js

@@ -0,0 +1,18 @@
+import dotenv from "dotenv";
+
+dotenv.config();
+
+function required(key) {
+  if (!process.env[key]) {
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return process.env[key];
+}
+
+export const env = {
+  PORT: process.env.PORT || 5000,
+
+  SUPABASE_URL: process.env.SUPABASE_URL,
+  SUPABASE_ANON_KEY: process.env.SUPABASE_ANON_KEY,
+  SUPABASE_SERVICE_ROLE_KEY: process.env.SUPABASE_SERVICE_ROLE_KEY
+};

package/templates/fastify/supabase/src/config/supabase.js

@@ -0,0 +1,23 @@
+import { createClient } from "@supabase/supabase-js";
+import { env } from "./env.js";
+
+function createSupabaseClient(name, url, key) {
+  if (!url || !key) {
+    console.warn(`⚠️ Supabase ${name} client disabled (missing env vars)`);
+    return null;
+  }
+
+  return createClient(url, key);
+}
+
+export const supabasePublic = createSupabaseClient(
+  "public",
+  env.SUPABASE_URL,
+  env.SUPABASE_ANON_KEY
+);
+
+export const supabaseAdmin = createSupabaseClient(
+  "admin",
+  env.SUPABASE_URL,
+  env.SUPABASE_SERVICE_ROLE_KEY
+);

package/templates/fastify/supabase/src/modules/auth/auth.controller.js

@@ -0,0 +1,7 @@
+import { getCurrentUser } from "./auth.service.js";
+
+export async function me(req, reply) {
+  reply.send({
+    user: getCurrentUser(req.user)
+  });
+}

package/templates/fastify/supabase/src/modules/auth/auth.routes.js

@@ -0,0 +1,9 @@
+import { me } from "./auth.controller.js";
+import { requireAuth } from "../../utils/auth-guard.js";
+
+export default async function authRoutes(app) {
+  app.get("/me", {
+    preHandler: requireAuth,
+    handler: me
+  });
+}

package/templates/fastify/supabase/src/modules/auth/auth.service.js

@@ -0,0 +1,7 @@
+export function getCurrentUser(user) {
+  return {
+    id: user.id,
+    email: user.email,
+    role: user.role
+  };
+}

package/templates/fastify/supabase/src/plugins/request-content.js

@@ -0,0 +1,16 @@
+import fp from "fastify-plugin";
+import { supabasePublic } from "../config/supabase.js";
+
+export default fp(async (app) => {
+  app.decorateRequest("user", null);
+
+  app.addHook("preHandler", async (req) => {
+    const auth = req.headers.authorization;
+    if (!auth?.startsWith("Bearer ")) return;
+
+    const token = auth.split(" ")[1];
+    const { data } = await supabasePublic.auth.getUser(token);
+
+    req.user = data?.user || null;
+  });
+});

package/templates/fastify/supabase/src/routes.js

@@ -0,0 +1,5 @@
+import authRoutes from "./modules/auth/auth.routes.js";
+
+export async function registerRoutes(app) {
+  app.register(authRoutes, { prefix: "/api/auth" });
+}

package/templates/fastify/supabase/src/server.js

@@ -0,0 +1,27 @@
+import { buildApp } from "./app.js";
+import { env } from "./config/env.js";
+
+const app = buildApp();
+
+const MAX_PORT_TRIES = 20;
+
+async function listenSilently(startPort) {
+  let port = startPort;
+
+  for (let i = 0; i < MAX_PORT_TRIES; i++) {
+    try {
+      await app.listen({ port });
+      app.log.info(`🚀 Server running at http://localhost:${port}`);
+      return;
+    } catch (err) {
+      if (err.code !== "EADDRINUSE") {
+        throw err;
+      }
+      port++;
+    }
+  }
+
+  throw new Error("No available ports found");
+}
+
+listenSilently(env.PORT);

package/templates/fastify/supabase/src/utils/auth-guard.js

@@ -0,0 +1,27 @@
+import { supabasePublic } from "../config/supabase.js";
+
+export async function requireAuth(request, reply) {
+  if (!supabasePublic) {
+    return reply.code(503).send({
+      message: "Auth service not configured (Supabase disabled)"
+    });
+  }
+
+  const auth = request.headers.authorization;
+
+  if (!auth || !auth.startsWith("Bearer ")) {
+    return reply.code(401).send({ message: "Unauthorized" });
+  }
+
+  const token = auth.split(" ")[1];
+
+  const { data, error } = await supabasePublic.auth.getUser(token);
+
+  if (error || !data?.user) {
+    return reply.code(401).send({
+      message: "Invalid or expired token"
+    });
+  }
+
+  request.user = data.user;
+}

package/templates/fastify/supabase/src/utils/error-handler.js

@@ -0,0 +1,10 @@
+export function globalErrorHandler(error, request, reply) {
+  request.log.error(error);
+
+  reply.code(error.statusCode || 500).send({
+    statusCode: error.statusCode || 500,
+    message: error.message || "Internal Server Error",
+    path: request.url,
+    timestamp: new Date().toISOString()
+  });
+}