Boilerplate / starter template kutubxonasi

// src/server.ts
import express from "express";
import cors from "cors";
import helmet from "helmet";

const app = express();
app.use(helmet());                 // xavfsizlik sarlavhalari (14.7)
app.use(cors());                   // CORS
app.use(express.json());           // JSON body parse

// Health check
app.get("/health", (_, res) => res.json({ status: "ok" }));

// Routerlar
// app.use("/api/users", usersRouter);

// 404
app.use((_, res) => res.status(404).json({ error: "Not found" }));

// Markaziy xato boshqaruvi
app.use((err, _req, res, _next) => {
  console.error(err);
  res.status(err.status || 500).json({ error: err.message || "Server error" });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server: http://localhost:${PORT}`));

// src/routes/users.ts
import { Router } from "express";
const router = Router();

router.get("/", async (req, res, next) => {
  try { /* ro'yxat */ res.json({ data: [] }); }
  catch (e) { next(e); }
});

router.get("/:id", async (req, res, next) => { /* bitta */ });
router.post("/", async (req, res, next) => { /* yaratish  201 */ });
router.put("/:id", async (req, res, next) => { /* yangilash */ });
router.delete("/:id", async (req, res, next) => { /* o'chirish  204 */ });

export default router;

# .env (HECH QACHON git'ga qo'yma — .gitignore'ga)
NODE_ENV=development
PORT=3000
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
JWT_SECRET=change-me-in-production
REDIS_URL=redis://localhost:6379

# .env.example (git'ga qo'yiladi — namuna)
NODE_ENV=
PORT=
DATABASE_URL=
JWT_SECRET=

// src/config.ts — markazlashgan, validatsiyalangan config
export const config = {
  port: Number(process.env.PORT) || 3000,
  dbUrl: process.env.DATABASE_URL!,
  jwtSecret: process.env.JWT_SECRET!,
};
if (!config.dbUrl) throw new Error("DATABASE_URL kerak");

node_modules/
.env
.env.local
dist/
build/
*.log
.DS_Store
coverage/
.next/

// src/middleware/auth.ts
import jwt from "jsonwebtoken";
import { config } from "../config";

export function auth(req, res, next) {
  const header = req.headers.authorization;       // "Bearer <token>"
  const token = header?.split(" ")[1];
  if (!token) return res.status(401).json({ error: "Token kerak" });
  try {
    req.user = jwt.verify(token, config.jwtSecret); // payloadni req'ga
    next();
  } catch {
    res.status(401).json({ error: "Yaroqsiz token" });
  }
}
// Ishlatish: router.get("/me", auth, handler)

# 1-bosqich: build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# 2-bosqich: ishga tushirish (kichik image)
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/server.js"]

services:
  app:
    build: .
    ports: ["3000:3000"]
    env_file: .env
    depends_on: [db, redis]
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    ports: ["5432:5432"]
    volumes: [pgdata:/var/lib/postgresql/data]
  redis:
    image: redis:7-alpine
    ports: ["6379:6379"]
volumes:
  pgdata:

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20, cache: npm }
      - run: npm ci
      - run: npm run lint
      - run: npm test
      - run: npm run build

// package.json (qism)
{
  "scripts": {
    "lint": "eslint .",
    "format": "prettier --write .",
    "prepare": "husky"
  }
}

# .husky/pre-commit
npx lint-staged

// lint-staged (package.json)
"lint-staged": { "*.{ts,js}": ["eslint --fix", "prettier --write"] }

// prisma/schema.prisma
generator client { provider = "prisma-client-js" }
datasource db { provider = "postgresql"; url = env("DATABASE_URL") }

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  authorId  Int
  author    User     @relation(fields: [authorId], references: [id])
  createdAt DateTime @default(now())
}

app/
  layout.tsx          # ildiz layout
  page.tsx            # bosh sahifa
  (auth)/login/page.tsx
  dashboard/page.tsx
  api/users/route.ts  # Route Handler
lib/
  db.ts               # Prisma client (singleton)
  auth.ts             # auth config
components/
  ui/                 # qayta ishlatiladigan komponentlar

// lib/db.ts — Prisma singleton (dev'da ko'p ulanishni oldini oladi)
import { PrismaClient } from "@prisma/client";
const g = globalThis as any;
export const db = g.prisma || new PrismaClient();
if (process.env.NODE_ENV !== "production") g.prisma = db;

# Loyiha nomi
Qisqa tavsif. [Jonli demo](havola)

## Texnologiyalar
Next.js, NestJS, PostgreSQL, ...

## Ishga tushirish
\`\`\`bash
npm install
cp .env.example .env   # to'ldir
npm run dev
\`\`\`

## Xususiyatlar
- ...

## Skrinshot
![demo](havola)