nurjs-cli 0.1.0

package/templates/app/src/middlewares/errorHandler.middleware.ts.tpl

@@ -0,0 +1,23 @@
+import type { NextFunction, Request, Response } from "express";
+import { AppError, apiErrorResponse } from "nurjs-core";
+import { z } from "zod";
+import { logger } from "../shared/logger/logger.js";
+
+export function errorHandlerMiddleware(
+  error: unknown,
+  _req: Request,
+  res: Response,
+  _next: NextFunction,
+): Response {
+  if (error instanceof z.ZodError) {
+    return res.status(400).json(apiErrorResponse("Validation failed", "VALIDATION_FAILED", z.flattenError(error)));
+  }
+
+  if (error instanceof AppError) {
+    return res.status(error.statusCode).json(apiErrorResponse(error.message, error.code, error.details));
+  }
+
+  logger.error("Unhandled error", error);
+
+  return res.status(500).json(apiErrorResponse("Internal server error", "INTERNAL_SERVER_ERROR"));
+}

package/templates/app/src/middlewares/notFound.middleware.ts.tpl

@@ -0,0 +1,6 @@
+import type { NextFunction, Request, Response } from "express";
+import { notFound } from "nurjs-core";
+
+export function notFoundMiddleware(req: Request, _res: Response, next: NextFunction): void {
+  next(notFound(`Route not found: ${req.method} ${req.originalUrl}`));
+}

package/templates/app/src/middlewares/requestLogger.middleware.ts.tpl

@@ -0,0 +1,17 @@
+import type { NextFunction, Request, Response } from "express";
+import { logger } from "../shared/logger/logger.js";
+
+export function requestLoggerMiddleware(req: Request, res: Response, next: NextFunction): void {
+  const startedAt = Date.now();
+
+  res.on("finish", () => {
+    logger.info("HTTP request", {
+      method: req.method,
+      path: req.originalUrl,
+      statusCode: res.statusCode,
+      durationMs: Date.now() - startedAt,
+    });
+  });
+
+  next();
+}

package/templates/app/src/modules/health/health.controller.ts.tpl

@@ -0,0 +1,12 @@
+import type { Request, Response } from "express";
+import { apiResponse } from "nurjs-core";
+
+export function getHealth(_req: Request, res: Response): Response {
+  return res.status(200).json(
+    apiResponse({
+      status: "ok",
+      engine: "NurJS",
+      timestamp: new Date().toISOString(),
+    }),
+  );
+}

package/templates/app/src/modules/health/health.module.ts.tpl

@@ -0,0 +1,12 @@
+import type { NurModule } from "nurjs-core";
+import { createHealthRouter } from "./health.routes.js";
+
+export const healthModule: NurModule = {
+  name: "health",
+  basePath: "/health",
+  register: () => {
+    return {
+      router: createHealthRouter(),
+    };
+  },
+};

package/templates/app/src/modules/health/health.routes.ts.tpl

@@ -0,0 +1,10 @@
+import { Router } from "express";
+import { getHealth } from "./health.controller.js";
+
+export function createHealthRouter(): Router {
+  const router = Router();
+
+  router.get("/", getHealth);
+
+  return router;
+}

package/templates/app/src/modules/index.ts.tpl

@@ -0,0 +1,12 @@
+import type { NurModule } from "nurjs-core";
+import { healthModule } from "./health/health.module.js";
+
+// nur:imports:start
+// nur:imports:end
+
+export const modules: NurModule[] = [
+  healthModule,
+
+  // nur:modules:start
+  // nur:modules:end
+];

package/templates/app/src/shared/logger/logger.ts.tpl

@@ -0,0 +1,43 @@
+import pino from "pino";
+
+const pinoLogger = pino({
+  level: process.env.LOG_LEVEL ?? "info",
+});
+
+function normalizeMeta(meta?: unknown): Record<string, unknown> {
+  if (meta === undefined) {
+    return {};
+  }
+
+  if (meta instanceof Error) {
+    return {
+      err: meta,
+    };
+  }
+
+  if (typeof meta === "object" && meta !== null) {
+    return meta as Record<string, unknown>;
+  }
+
+  return {
+    value: meta,
+  };
+}
+
+export const logger = {
+  info(message: string, meta?: unknown): void {
+    pinoLogger.info(normalizeMeta(meta), message);
+  },
+
+  warn(message: string, meta?: unknown): void {
+    pinoLogger.warn(normalizeMeta(meta), message);
+  },
+
+  error(message: string, meta?: unknown): void {
+    pinoLogger.error(normalizeMeta(meta), message);
+  },
+
+  debug(message: string, meta?: unknown): void {
+    pinoLogger.debug(normalizeMeta(meta), message);
+  },
+};

package/templates/app/tsconfig.json.tpl

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": [
+      "ES2024"
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/templates/modules/auth/files/src/modules/auth/auth.controller.ts.tpl

@@ -0,0 +1,60 @@
+import type { NextFunction, Request, Response } from "express";
+import { apiResponse, unauthorized } from "nurjs-core";
+import type { AuthService } from "./auth.service.js";
+
+type CreateAuthControllerOptions = {
+  authService: AuthService;
+};
+
+function getBearerToken(req: Request): string | null {
+  const header = req.headers.authorization;
+
+  if (!header?.startsWith("Bearer ")) {
+    return null;
+  }
+
+  return header.slice("Bearer ".length);
+}
+
+export function createAuthController(options: CreateAuthControllerOptions) {
+  const { authService } = options;
+
+  return {
+    async register(req: Request, res: Response, next: NextFunction) {
+      try {
+        const user = await authService.register(req.body);
+        return res.status(201).json(apiResponse(user));
+      } catch (error) {
+        return next(error);
+      }
+    },
+
+    async login(req: Request, res: Response, next: NextFunction) {
+      try {
+        const result = await authService.login(req.body);
+        return res.status(200).json(apiResponse(result));
+      } catch (error) {
+        return next(error);
+      }
+    },
+
+    async logout(_req: Request, res: Response) {
+      return res.status(200).json(apiResponse({ loggedOut: true }));
+    },
+
+    async me(req: Request, res: Response, next: NextFunction) {
+      try {
+        const token = getBearerToken(req);
+
+        if (!token) {
+          throw unauthorized("Missing bearer token");
+        }
+
+        const user = await authService.getCurrentUserFromToken(token);
+        return res.status(200).json(apiResponse(user));
+      } catch (error) {
+        return next(error);
+      }
+    },
+  };
+}

package/templates/modules/auth/files/src/modules/auth/auth.module.ts.tpl

@@ -0,0 +1,22 @@
+import type { NurModule } from "nurjs-core";
+import { createAuthRepository } from "./auth.repository.js";
+import { createAuthRouter } from "./auth.routes.js";
+import { createAuthService } from "./auth.service.js";
+
+export const authModule: NurModule = {
+  name: "auth",
+  basePath: "/auth",
+  register: (ctx) => {
+    const authRepository = createAuthRepository();
+    const authService = createAuthService({
+      authRepository,
+      logger: ctx.logger,
+    });
+
+    return {
+      router: createAuthRouter({
+        authService,
+      }),
+    };
+  },
+};

package/templates/modules/auth/files/src/modules/auth/auth.repository.ts.tpl

@@ -0,0 +1,22 @@
+import type { AuthUser } from "./auth.types.js";
+
+export type AuthRepository = ReturnType<typeof createAuthRepository>;
+
+const users = new Map<string, AuthUser>();
+
+export function createAuthRepository() {
+  return {
+    async create(user: AuthUser): Promise<AuthUser> {
+      users.set(user.id, user);
+      return user;
+    },
+
+    async findByEmail(email: string): Promise<AuthUser | null> {
+      return Array.from(users.values()).find((user) => user.email === email) ?? null;
+    },
+
+    async findById(id: string): Promise<AuthUser | null> {
+      return users.get(id) ?? null;
+    },
+  };
+}

package/templates/modules/auth/files/src/modules/auth/auth.routes.ts.tpl

@@ -0,0 +1,21 @@
+import { Router } from "express";
+import { validateRequest } from "nurjs-core";
+import { createAuthController } from "./auth.controller.js";
+import { loginSchema, registerSchema } from "./auth.schema.js";
+import type { AuthService } from "./auth.service.js";
+
+type CreateAuthRouterOptions = {
+  authService: AuthService;
+};
+
+export function createAuthRouter(options: CreateAuthRouterOptions): Router {
+  const router = Router();
+  const controller = createAuthController(options);
+
+  router.post("/register", validateRequest(registerSchema), controller.register);
+  router.post("/login", validateRequest(loginSchema), controller.login);
+  router.post("/logout", controller.logout);
+  router.get("/me", controller.me);
+
+  return router;
+}

package/templates/modules/auth/files/src/modules/auth/auth.schema.ts.tpl

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+export const registerSchema = z.object({
+  body: z.object({
+    name: z.string().min(2),
+    email: z.email(),
+    password: z.string().min(8),
+  }),
+});
+
+export const loginSchema = z.object({
+  body: z.object({
+    email: z.email(),
+    password: z.string().min(1),
+  }),
+});
+
+export type RegisterInput = z.infer<typeof registerSchema>["body"];
+export type LoginInput = z.infer<typeof loginSchema>["body"];

package/templates/modules/auth/files/src/modules/auth/auth.service.ts.tpl

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import type { NurLogger } from "nurjs-core";
+import { badRequest, unauthorized } from "nurjs-core";
+import { comparePassword, hashPassword } from "../../shared/security/password.js";
+import { signAuthToken, verifyAuthToken } from "../../shared/security/jwt.js";
+import type { AuthRepository } from "./auth.repository.js";
+import type { LoginInput, RegisterInput } from "./auth.schema.js";
+import type { AuthTokenPayload, PublicAuthUser } from "./auth.types.js";
+
+type CreateAuthServiceOptions = {
+  authRepository: AuthRepository;
+  logger: NurLogger;
+};
+
+export type AuthService = ReturnType<typeof createAuthService>;
+
+function toPublicUser(user: { id: string; name: string; email: string; createdAt: string }): PublicAuthUser {
+  return {
+    id: user.id,
+    name: user.name,
+    email: user.email,
+    createdAt: user.createdAt,
+  };
+}
+
+export function createAuthService(options: CreateAuthServiceOptions) {
+  const { authRepository, logger } = options;
+
+  return {
+    async register(input: RegisterInput) {
+      const existingUser = await authRepository.findByEmail(input.email);
+
+      if (existingUser) {
+        throw badRequest("Email is already registered");
+      }
+
+      const user = await authRepository.create({
+        id: randomUUID(),
+        name: input.name,
+        email: input.email,
+        passwordHash: await hashPassword(input.password),
+        createdAt: new Date().toISOString(),
+      });
+
+      logger.info("Auth user registered", { userId: user.id });
+
+      return toPublicUser(user);
+    },
+
+    async login(input: LoginInput) {
+      const user = await authRepository.findByEmail(input.email);
+
+      if (!user) {
+        throw unauthorized("Invalid email or password");
+      }
+
+      const passwordMatches = await comparePassword(input.password, user.passwordHash);
+
+      if (!passwordMatches) {
+        throw unauthorized("Invalid email or password");
+      }
+
+      const token = signAuthToken({
+        sub: user.id,
+        email: user.email,
+      });
+
+      return {
+        user: toPublicUser(user),
+        token,
+      };
+    },
+
+    async getCurrentUserFromToken(token: string) {
+      let payload: AuthTokenPayload;
+
+      try {
+        payload = verifyAuthToken<AuthTokenPayload>(token);
+      } catch {
+        throw unauthorized("Invalid or expired bearer token");
+      }
+
+      const user = await authRepository.findById(payload.sub);
+
+      if (!user) {
+        throw unauthorized("Authenticated user no longer exists");
+      }
+
+      return toPublicUser(user);
+    },
+  };
+}

package/templates/modules/auth/files/src/modules/auth/auth.types.ts.tpl

@@ -0,0 +1,14 @@
+export type AuthUser = {
+  id: string;
+  name: string;
+  email: string;
+  passwordHash: string;
+  createdAt: string;
+};
+
+export type PublicAuthUser = Omit<AuthUser, "passwordHash">;
+
+export type AuthTokenPayload = {
+  sub: string;
+  email: string;
+};

package/templates/modules/auth/files/src/modules/auth/index.ts.tpl

@@ -0,0 +1 @@
+export { authModule } from "./auth.module.js";

package/templates/modules/auth/files/src/shared/security/jwt.ts.tpl

@@ -0,0 +1,49 @@
+import jwt, {
+  type JwtPayload,
+  type Secret,
+  type SignOptions,
+} from "jsonwebtoken";
+
+const DEFAULT_DEV_JWT_SECRET = "nurjs-dev-secret-change-me";
+
+function getJwtSecret(): Secret {
+  const secret = process.env.JWT_SECRET;
+
+  if (!secret && process.env.NODE_ENV === "production") {
+    throw new Error("JWT_SECRET is required in production.");
+  }
+
+  return secret ?? DEFAULT_DEV_JWT_SECRET;
+}
+
+function getJwtExpiresIn(): SignOptions["expiresIn"] {
+  return (process.env.JWT_EXPIRES_IN ?? "1d") as SignOptions["expiresIn"];
+}
+
+export function signJwt(payload: string | object | Buffer): string {
+  return jwt.sign(payload, getJwtSecret(), {
+    expiresIn: getJwtExpiresIn(),
+  });
+}
+
+export function verifyJwt<TPayload extends object = JwtPayload>(
+  token: string,
+): TPayload {
+  const decoded = jwt.verify(token, getJwtSecret());
+
+  if (typeof decoded !== "object" || decoded === null) {
+    throw new Error("Invalid JWT payload.");
+  }
+
+  return decoded as TPayload;
+}
+
+export function signAuthToken(payload: string | object | Buffer): string {
+  return signJwt(payload);
+}
+
+export function verifyAuthToken<TPayload extends object = JwtPayload>(
+  token: string,
+): TPayload {
+  return verifyJwt<TPayload>(token);
+}

package/templates/modules/auth/files/src/shared/security/password.ts.tpl

@@ -0,0 +1,11 @@
+import bcrypt from "bcryptjs";
+
+const SALT_ROUNDS = 12;
+
+export async function hashPassword(password: string): Promise<string> {
+  return bcrypt.hash(password, SALT_ROUNDS);
+}
+
+export async function comparePassword(password: string, passwordHash: string): Promise<boolean> {
+  return bcrypt.compare(password, passwordHash);
+}

package/templates/modules/auth/manifest.json

@@ -0,0 +1,29 @@
+{
+  "name": "auth",
+  "description": "Authentication module skeleton",
+  "moduleImport": "import { authModule } from \"./auth/auth.module.js\";",
+  "moduleExportName": "authModule",
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "jsonwebtoken": "^9.0.3"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10"
+  },
+  "env": [
+    "JWT_SECRET=",
+    "JWT_EXPIRES_IN=1d"
+  ],
+  "creates": [
+    "src/modules/auth/auth.module.ts",
+    "src/modules/auth/auth.routes.ts",
+    "src/modules/auth/auth.controller.ts",
+    "src/modules/auth/auth.service.ts",
+    "src/modules/auth/auth.repository.ts",
+    "src/modules/auth/auth.schema.ts",
+    "src/modules/auth/auth.types.ts",
+    "src/modules/auth/index.ts",
+    "src/shared/security/password.ts",
+    "src/shared/security/jwt.ts"
+  ]
+}