WisarWisar
Dasturlash kitobi/7-QISM — TypeScript18 daqiqa

7.7-bob: TS bilan Node/Express loyihasi — declaration files, modullar

7-QISM — TypeScript · 7-mavzu (yakuniy)

1. Kirish va motivatsiya

7-QISMning yakuniy bobiga keldik. TypeScript bilimini — sozlash 7.1-bob, turlar 7.2-bob, generics 7.3-bob, ilg'or turlar 7.4-bob, narrowing 7.5-bob, decorators 7.6-bob — to'liq o'rgandik. Endi hammasini amalda birlashtiramiz: to'liq, professional TypeScript Node/Express backend loyihasi. Bu bob — nazariyani amaliyotga aylantiradi: loyiha tuzilmasi, tsconfig (production), build oqimi, declaration files (.d.ts), va modullar (ESM). Va bu — 8-QISM (NestJS) ga to'liq tayyorlaydi.

5-QISMda Express'ni JavaScript'da yozdik 5.6-bob. Endi uni TypeScript bilan qayta quramiz — va farqni ko'ramiz: tipli req/res, tipli middleware, tipli service'lar, xatolarni kompilyatsiyada ushlash. Bu — real, zamonaviy backend (ko'p kompaniya endi TS'da). NestJS (8) bundan ham yuqori daraja, lekin asos — TS Express.

Ikki yangi tushuncha: declaration files (.d.ts) — turlarni alohida faylda saqlash (kutubxona yaratish, yoki Express tipini kengaytirish — req.user qo'shish). Va modullar — TS'da ESM/CommonJS, import/export, path mapping. Bu bob: to'liq loyiha tuzilmasi, production build, .d.ts, modullar, va TS Express namunasi — chuqur. 7-QISM yakuni va 8-QISM (NestJS) ko'prigi.

O'xshatish: bu bob — mashina yig'ish ustaxonasi. Avval qismlarni o'rgandik (dvigatel — turlar, g'ildirak — generics, elektronika — decorators). Endi hammasini butun mashinaga yig'amiz (ishlaydigan TS backend). tsconfig — yig'ish chizmasi; build — yig'ish jarayoni; .d.ts — qism spetsifikatsiyalari; modullar — qismlar orasidagi ulanish. Natija — yo'lga chiqishga tayyor (production) mashina.

Nega muhim?

  • Amaliy birlashma — TS bilimini real loyihada qo'llash.
  • Zamonaviy backend — ko'p kompaniya TS Express/Node.
  • declaration files — kutubxona, tip kengaytirish (req.user).
  • NestJS tayyorgarligi — 8-QISM uchun to'liq asos.

2. Nazariya — chuqur tushuntirish

2.1. Loyiha tuzilmasi (struktura)

Professional TS backend tuzilmasi (dev.to/reintech):

text
  loyiha/
  ├── src/                    — TS manba kod
  │   ├── index.ts            — entry (server start)
  │   ├── app.ts              — Express app
  │   ├── config/             — sozlamalar (env — 5.8)
  │   ├── controllers/        — route handlerlar 5.6-bob
  │   ├── services/           — biznes logika (9)
  │   ├── models/             — DB modellar (6)
  │   ├── middleware/         — middleware (5.6, 5.10)
  │   ├── routes/             — route ta'riflari
  │   ├── types/              — umumiy turlar, .d.ts
  │   └── utils/              — yordamchilar
  ├── dist/                   — build natija (JS — git'da emas)
  ├── tsconfig.json           — TS sozlama 7.1-bob
  ├── package.json            — scripts (7.1: 2.11)
  └── .env                    — maxfiy (4.5, 5.8)

Qatlamli tuzilma (9: Clean Architecture ruhida): controller (HTTP) service (biznes) model (DB). types/ — umumiy turlar. dist/ — build natija (gitignore — 4.5). Bu — kengaytiriladigan, toza tuzilma (NestJS — 8 — shu g'oyani majburlaydi).

2.2. tsconfig (production backend)

json
{
  "compilerOptions": {
    "target": "ES2022",                 // zamonaviy JS (7.1: 2.7)
    "module": "NodeNext",               // Node modul tizimi (2.6)
    "moduleResolution": "NodeNext",
    "outDir": "./dist",                 // build natija
    "rootDir": "./src",
    "strict": true,                     // QAT'IY (7.1: 2.8)
    "esModuleInterop": true,
    "skipLibCheck": true,               // tez build (kutubxona turlarini tekshirmaslik)
    "forceConsistentCasingInFileNames": true,
    "noUnusedLocals": true,             // ishlatilmagan o'zgaruvchi (toza kod)
    "noUnusedParameters": true,
    "resolveJsonModule": true,          // JSON import
    "sourceMap": true,                  // debug (TS  JS xarita)
    "experimentalDecorators": true,     // dekorator (TypeORM/NestJS — 7.6: 2.3)
    "emitDecoratorMetadata": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

Backend tsconfig (7.1: 2.7 ni kengaytiradi): strict, NodeNext (modul), skipLibCheck (tez), noUnusedLocals/Parameters (toza kod), dekorator (TypeORM/NestJS). Test fayllarni exclude. Bu — production-tayyor sozlama.

2.3. Modullar — ESM vs CommonJS (TS'da)

text
  CommonJS (eski Node):           ESM (zamonaviy):
  const x = require("x")          import x from "x"
  module.exports = y              export default y

  TS'da:
  module: "NodeNext" — ikkalasini ham qo'llaydi (fayl/package.json'ga qarab)
  package.json: "type": "module"  ESM (.js fayllar ESM)

ESM (2.16-JS) — zamonaviy standart (import/export). "type": "module" (package.json) + module: "NodeNext" (tsconfig). ESM'da import yo'lida .js kengaytma kerak (import { x } from "./util.js" — TS faylda ham .js!). Bu — chalkash, lekin Node ESM talabi.

2.4. Import/export (TS'da)

ts
// Named export/import
export const PORT = 3000;
export function salom() {}
import { PORT, salom } from "./config.js";   // .js (ESM — 2.3)

// Default export/import
export default class UserService {}
import UserService from "./UserService.js";

// Type import (faqat tur — runtime'da olib tashlanadi)
import type { User } from "./types.js";      // type-only (tezroq, aniq)
export type { User };

import type — faqat tur import qilish (qiymat emas). Runtime'da olib tashlanadi (faqat tur tekshiruvi). Tezroq, aniq (tur ekanini bildiradi). Aralash: import { type User, funktsiya }. ESM'da .js kengaytma 2.3-bob.

2.5. Declaration files (.d.ts) nima

Declaration file (.d.ts) — faqat tur ma'lumotini saqlaydigan fayl (kod emas — oneuptime):

ts
// types.d.ts — faqat turlar (implementatsiya yo'q)
export interface User {
  id: number;
  ism: string;
}
export declare function salom(ism: string): string;   // declare — faqat e'lon

.d.ts — "tur sarlavhasi" (C'dagi header kabi): faqat turlar/e'lonlar (kod yo'q). Ikki ishlatish: (1) kutubxona yaratganda (foydalanuvchilarga turlar — @types/* — 7.1: 2.13); (2) mavjud JS/global ga tur berish 2.6-bob. tsc declaration: true bilan avtomatik yaratadi.

2.6. Global tip kengaytirish (Express req.user)

.d.ts ning eng amaliy ishi — mavjud tipni kengaytirish (Express reqga user qo'shish — auth — 5.15):

ts
// types/express.d.ts — Express Request'ni kengaytirish
import { User } from "../models/User.js";

declare global {
  namespace Express {
    interface Request {
      user?: User;                  // req.user qo'shamiz (auth middleware — 5.15)
    }
  }
}
export {};                          // modul qilish (global augmentation)

Module augmentation — mavjud tip (Express Request) ni kengaytirish (declare global + interface merging — 7.2: 2.10). Auth middleware (5.15) req.user qo'yadi bu tip orqali TS uni biladi (req.user.id — tipli). Bu — TS backend'da juda ko'p ishlatiladi.

2.7. @types (kutubxona turlari — 7.1 takrori)

bash
npm install express
npm install -D @types/express @types/node      # turlar (7.1: 2.13)

Ko'p JS kutubxona turni o'zida bermaydi @types/X (DefinitelyTyped). @types/node (Node API), @types/express (Express). Zamonaviy kutubxona (Prisma, Zod) — turni o'zida. .d.ts — @types ham shu (jamoa yozgan declaration).

2.8. Build oqimi (dev va production)

text
  Development:
  tsx watch src/index.ts          — to'g'ridan, o'zgarishni kuzatadi (7.1: 2.11)

  Production:
  1. tsc                          — TS  JS (dist/)
  2. node dist/index.js           — JS ishga tushirish

  package.json scripts:
  "dev": "tsx watch src/index.ts",
  "build": "tsc",
  "start": "node dist/index.js",
  "typecheck": "tsc --noEmit"      — faqat tur tekshirish (CI — 10)

Dev — tsx (tez, to'g'ridan — 7.1: 2.11). Production — tsc build (JS) node. typecheck (tsc --noEmit) — CI'da (10) tur tekshiruvi (build'siz). Zamonaviy: tsx/esbuild/swc (tez), yoki tsc (standart). Eski loyihalarda ts-node (klassik TS runner) ham uchraydi — lekin tsx uni almashtirdi (tezroq, ESM'ni oson qo'llaydi, sozlashsiz ishlaydi).

2.9. Path mapping (toza import)

json
// tsconfig.json — qisqa import yo'llari
{
  "compilerOptions": {
    "baseUrl": "./src",
    "paths": {
      "@/*": ["*"],                 // @/config  src/config
      "@services/*": ["services/*"]
    }
  }
}
ts
import { UserService } from "@services/user.js";   // ../../../services o'rniga

Path mapping — uzun nisbiy yo'llar (../../../) o'rniga qisqa alias (@/, @services/). Toza import. Runtime'da ishlashi uchun tsx/tsc-alias/bundler kerak (Node o'zi @/ tushunmaydi). NestJS/Vite buni qo'llaydi.

2.10. Tipli Express (req, res, middleware)

ts
import express, { Request, Response, NextFunction } from "express";

const app = express();

// Tipli route handler (5.6)
app.get("/users/:id", (req: Request, res: Response) => {
  const id = Number(req.params.id);    // params — tipli
  res.json({ id });
});

// Tipli middleware (5.6)
const auth = (req: Request, res: Response, next: NextFunction): void => {
  if (!req.headers.authorization) {
    res.status(401).json({ error: "Token kerak" });
    return;                            // void (qaytarmaydi)
  }
  next();
};

Tipli Express: Request, Response, NextFunction (@types/express). req.params, req.body — tipli (lekin body — any default; generic yoki validatsiya bilan tiplanadi — 2.11). Middleware turi aniq. JS'dan farqi: autocompletion, xato kompilyatsiyada.

2.11. Tipli request body (generic + validatsiya)

ts
// Express Request generic (body/params/query tiplash)
import { Request } from "express";

interface CreateUserBody { ism: string; email: string; }

app.post("/users", (req: Request<{}, {}, CreateUserBody>, res) => {
  req.body.ism;                        // string (tipli!)
});

//  Lekin bu — KOMPILYATSIYA tipi (runtime tekshiruv emas!)
// Haqiqiy himoya — Zod 5.9-bob:
import { z } from "zod";
const schema = z.object({ ism: z.string(), email: z.string().email() });
app.post("/users", (req, res) => {
  const data = schema.parse(req.body);  // runtime validatsiya + tur (5.9)
});

TS tipi runtime'da yo'q (7.1: 2.4): Request<{}, {}, Body> — faqat kompilyatsiya tipi (foydalanuvchi noto'g'ri yuborsa, TS ushlamaydi — runtime'da). Haqiqiy himoya — Zod (5.9 — runtime validatsiya + tur infer). TS + Zod birga: kompilyatsiya + runtime xavfsizlik.

2.12. Tipli error handling (5.10)

ts
import { Request, Response, NextFunction } from "express";

// Custom error class 5.10-bob — tipli
class AppError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
  }
}

// Tipli error handler (5.10 — 4 argument)
const errorHandler = (err: Error, req: Request, res: Response, next: NextFunction): void => {
  if (err instanceof AppError) {        // narrowing (7.5)
    res.status(err.statusCode).json({ error: err.message });
    return;
  }
  res.status(500).json({ error: "Server xatosi" });
};

TS error handling 5.10-bob — err: Error (yoki unknown — xavfsizroq), instanceof narrowing 7.5-bob, custom error class tipli. Bu — 5.10'ni TS bilan (kompilyatsiya xavfsizligi qo'shilgan).

2.13. To'liq TS backend (qatlamlar)

text
  So'rov oqimi (TS — tipli):
  Route (tipli)  Middleware (auth — req.user tipli — 2.6)
        Controller (req/res tipli)  Service (biznes — tipli)
        Model/Repository (DB — tipli — 6)  javob (tipli)

  Har qatlam tipli — xato kompilyatsiyada (oqim bo'ylab xavfsiz)

To'liq TS backend — har qatlam tipli (route controller service model). Ma'lumot turi oqim bo'ylab saqlanadi (User — DB'dan controller'gacha). Xato — kompilyatsiyada (oqimning istalgan joyida). Bu — JS backend 5.6-bob ustidagi katta yutuq.

2.14. NestJS ko'prigi (8 ga)

text
  TS Express (bu bob)             NestJS (8)
  - Qo'lda tuzilma                 majburiy tuzilma (modul/controller/service)
  - Qo'lda DI (import)             avtomatik DI (dekorator + reflect-metadata — 7.6)
  - Express req/res                @Get/@Body/@Param (dekorator — 7.6)
  - Qo'lda sozlash                 konvensiya + dekorator

  NestJS — TS Express'ning "tashkillangan, dekorator" versiyasi

NestJS (8) — bu bobdagi TS Express tushunchalarini (qatlam, tipli, DI) dekorator + konvensiya bilan rasmiylashtiradi. TS Express'ni tushunsangiz — NestJS oson (u xuddi shu, lekin tuzilgan). Bu bob — to'g'ridan NestJS'ga ko'prik (dekorator — 7.6, qatlam — 2.1).

2.15. Best practices (TS backend)

text
   Qatlamli tuzilma (controller/service/model — 2.1, 9)
   strict tsconfig (production sozlama — 2.2)
   ESM + .js kengaytma import 2.3-bob
   import type (faqat tur — 2.4)
   Global tip kengaytirish (req.user — .d.ts — 2.6)
   TS tip + Zod (kompilyatsiya + runtime — 2.11, 5.9)
   Dev: tsx; production: tsc build 2.8-bob
   Path mapping (toza import — 2.9); typecheck CI'da
   Umumiy turlar bir joyda (types/ — 2.1)

3. Sintaksis / tuzilma — tez ma'lumotnoma

text
  Tuzilma 2.1-bob: src/{config,controllers,services,models,middleware,routes,types,utils}
  tsconfig 2.2-bob: strict, NodeNext, outDir, experimentalDecorators
  Modullar (2.3, 2.4): import/export (.js), import type
  .d.ts (2.5, 2.6): declare, declare global (Express Request kengaytirish)
  Build 2.8-bob: dev tsx; prod tsc  node
ts
import express, { Request, Response, NextFunction } from "express";   // tipli (2.10)
import type { User } from "./types.js";                                // type-only (2.4)

4. Batafsil kod namunalari

Misol 1 — package.json va tsconfig (2.2, 2.8)

json
// package.json
{
  "name": "ts-express-backend",
  "type": "module",                            // ESM (2.3)
  "scripts": {
    "dev": "tsx watch src/index.ts",           // dev (2.8)
    "build": "tsc",
    "start": "node dist/index.js",
    "typecheck": "tsc --noEmit"                // CI (2.8)
  },
  "dependencies": { "express": "^4.21.0", "zod": "^3.24.0" },
  "devDependencies": {
    "typescript": "^5.7.0", "tsx": "^4.19.0",
    "@types/express": "^5.0.0", "@types/node": "^22.0.0"
  }
}

Misol 2 — Global tip kengaytirish (req.user — 2.6)

ts
// src/types/express.d.ts — Express Request'ga user qo'shish (2.6)
import { User } from "../models/User.js";

declare global {
  namespace Express {
    interface Request {
      user?: User;                             // req.user (auth — 5.15)
    }
  }
}
export {};                                     // modul (global augmentation)

Misol 3 — Tipli config (env — 5.8, 2.4)

ts
// src/config/index.ts
import "dotenv/config";                        // (5.8)
import { z } from "zod";                       // (5.9 — env validatsiya — 5.8)

const envSchema = z.object({
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
});

const env = envSchema.parse(process.env);      // runtime validatsiya + tur (5.8)

export const config = {
  port: env.PORT,
  databaseUrl: env.DATABASE_URL,
  jwtSecret: env.JWT_SECRET,
  isProd: env.NODE_ENV === "production",
} as const;                                    // as const (7.2: 2.11)

Misol 4 — Tipli middleware (auth — 2.6, 2.10)

ts
// src/middleware/auth.ts
import { Request, Response, NextFunction } from "express";
import jwt from "jsonwebtoken";
import { config } from "../config/index.js";   // (5.8)

interface JwtPayload { sub: number; rol: string; }

export const auth = (req: Request, res: Response, next: NextFunction): void => {
  const token = req.headers.authorization?.split(" ")[1];   // "Bearer X" (5.15)
  if (!token) {
    res.status(401).json({ error: "Avtorizatsiya kerak" });
    return;
  }
  try {
    const payload = jwt.verify(token, config.jwtSecret) as JwtPayload;
    req.user = { id: payload.sub, rol: payload.rol } as any;   // req.user (2.6)
    next();
  } catch {
    res.status(401).json({ error: "Token noto'g'ri" });
  }
};

Misol 5 — Tipli service va controller (2.13)

ts
// src/services/userService.ts — biznes logika (tipli — 9)
import type { User } from "../types/index.js";

export const UserService = {
  async topId(id: number): Promise<User | null> {
    // DB (6) — soddalashtirilgan
    return { id, ism: "Ali", email: "ali@a.uz" } as User;
  },
  async yarat(data: Omit<User, "id">): Promise<User> {   // Omit (7.4)
    return { id: 1, ...data };
  },
};
ts
// src/controllers/userController.ts — HTTP (tipli)
import { Request, Response, NextFunction } from "express";
import { UserService } from "../services/userService.js";

export const userTop = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
  try {
    const user = await UserService.topId(Number(req.params.id));
    if (!user) {
      res.status(404).json({ error: "Topilmadi" });
      return;
    }
    res.json({ success: true, data: user });   // (5.7)
  } catch (err) {
    next(err);                                  // (5.10)
  }
};

Misol 6 — Tipli + Zod validatsiya (2.11)

ts
// src/controllers/authController.ts — Zod bilan (kompilyatsiya + runtime — 2.11)
import { Request, Response, NextFunction } from "express";
import { z } from "zod";                        // (5.9)

const signupSchema = z.object({
  ism: z.string().min(2),
  email: z.string().email(),
  parol: z.string().min(8),
});
type SignupDto = z.infer<typeof signupSchema>;  // schema'dan tur (7.4: infer)

export const signup = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
  try {
    const data: SignupDto = signupSchema.parse(req.body);   // runtime + tur (2.11)
    // data — tipli (ism, email, parol) va runtime tekshirilgan
    res.status(201).json({ success: true });
  } catch (err) {
    if (err instanceof z.ZodError) {            // narrowing (7.5)
      res.status(400).json({ error: err.flatten().fieldErrors });   // (5.9)
      return;
    }
    next(err);
  }
};

Misol 7 — To'liq app.ts va index.ts (2.13)

ts
// src/app.ts — Express app (tipli)
import express, { Application } from "express";
import { errorHandler } from "./middleware/errorHandler.js";   // (5.10)
import userRoutes from "./routes/users.js";

export function createApp(): Application {
  const app = express();
  app.use(express.json());
  app.use("/api/users", userRoutes);
  app.use(errorHandler);                        // oxirda (5.10)
  return app;
}
ts
// src/index.ts — entry (server start)
import { createApp } from "./app.js";
import { config } from "./config/index.js";
import { logger } from "./utils/logger.js";     // (5.12)

const app = createApp();
app.listen(config.port, () => {
  logger.info(`Server ${config.port}-portda (${config.isProd ? "prod" : "dev"})`);
});

// Process xatolari (5.10)
process.on("uncaughtException", (err: Error) => {
  logger.error("Uncaught:", err);
  process.exit(1);
});

Misol 8 — Declaration file (kutubxona — 2.5)

ts
// src/utils/math.ts — implementatsiya
export function summa(a: number, b: number): number { return a + b; }
export interface Hisob { natija: number; }

// tsc declaration: true  avtomatik yaratadi:
// dist/utils/math.d.ts
//   export declare function summa(a: number, b: number): number;
//   export interface Hisob { natija: number; }
//  kutubxona foydalanuvchilari turlarni oladi (@types kerak emas — 2.5, 7.1: 2.13)

5. To'g'ri va noto'g'ri holatlar

1) ESM'da .js kengaytmasiz import

ts
//  ESM'da xato (2.3)
import { x } from "./util";

//  .js kengaytma (TS faylda ham)
import { x } from "./util.js";

2) TS tipga ishonib runtime tekshirmaslik

ts
//  Request<Body> — runtime tekshirmaydi (2.11)
app.post("/x", (req: Request<{}, {}, Body>, res) => { req.body.ism; });

//  Zod (runtime + tur)
const data = schema.parse(req.body);

3) any bilan req.user

ts
//  req.user any (tur yo'q)
(req as any).user.id;

//  global tip kengaytirish (.d.ts — 2.6)
req.user?.id;   // tipli

4) dist'ni git'ga qo'shish

text
 dist/ commit (build natija — keraksiz)
 .gitignore: dist/ (4.5)

5) Production'da tsx

text
 production'da tsx (sekin — 2.8)
 tsc build  node dist

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — Cannot find module './x' or its type declarations

Sababi: ESM'da .js kengaytma yo'q 2.3-bob, yoki @types yo'q 2.7-bob. Yechimi: .js qo'shing; @types/X o'rnating.

Xato 2 — Property 'user' does not exist on type 'Request'

Sababi: global tip kengaytirilmagan 2.6-bob. Yechimi: express.d.ts (declare global — Misol 2).

Xato 3 — exports is not defined / ESM xatosi

Sababi: "type": "module" va module sozlamasi mos emas 2.3-bob. Yechimi: package.json "type": "module" + tsconfig NodeNext.

Xato 4 — Path alias runtime'da ishlamaydi

Sababi: Node @/ tushunmaydi 2.9-bob. Yechimi: tsx/tsc-alias/bundler; yoki nisbiy yo'l.

Xato 5 — Build'dan keyin xato (dev'da ishlaydi)

Sababi: tsx kechiradi, tsc qattiqroq. Yechimi: typecheck (tsc --noEmit) dev'da ham; xatolarni to'g'irlang.

Xato 6 — req.body validatsiyasiz xato

Sababi: TS tipga ishonib, runtime tekshirilmagan 2.11-bob. Yechimi: Zod parse 5.9-bob.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

  • TS (7.1-7.6): hammasi bu yerda amalda.
  • Express 5.6-bob: TS bilan tipli.
  • Env/Zod (5.8, 5.9): tipli config, validatsiya.
  • Auth 5.15-bob: req.user (global tip).
  • Error handling 5.10-bob: tipli handler.
  • DB/ORM (6): tipli model/repository.
  • NestJS (8): to'g'ridan tayyorgarlik (qatlam, dekorator).
  • CI/CD (10): typecheck.
  • Decorators 7.6-bob: TypeORM/NestJS.

8. Eng yaxshi amaliyotlar (best practices)

  • Qatlamli tuzilma (controller/service/model — 2.1, 9).
  • strict production tsconfig (NodeNext, skipLibCheck, noUnused — 2.2).
  • ESM + .js kengaytma import 2.3-bob; import type 2.4-bob.
  • Global tip kengaytirish (req.user — .d.ts — 2.6).
  • TS tip + Zod (kompilyatsiya + runtime — 2.11, 5.9).
  • Dev: tsx; production: tsc build 2.8-bob; typecheck CI'da.
  • Path mapping (toza import — 2.9); umumiy turlar types/.
  • dist/ gitignore 4.5-bob; .env 5.8-bob.
  • Tipli har qatlam (oqim bo'ylab xavfsiz — 2.13).
  • @types kutubxona turlari 2.7-bob.

9. Amaliy loyiha: "To'liq TypeScript Backend"

7-QISMni yakunlovchi loyiha — TS bilimini real backend'da birlashtirish.

Maqsad

To'liq, tipli, qatlamli TypeScript Express backend qurish: tuzilma, tipli qatlamlar, global tip, Zod validatsiya, build oqimi.

Talablar (requirements)

  1. Tuzilma: src/ qatlamlar (config/controllers/services/models/middleware/types — 2.1).
  2. tsconfig + package.json: strict, NodeNext, scripts (dev/build/start/typecheck — Misol 1, 2.2, 2.8).
  3. Tipli config: env + Zod (Misol 3, 5.8).
  4. Global tip: req.user (.d.ts — Misol 2, 2.6).
  5. Tipli middleware: auth (req.user — Misol 4, 2.10).
  6. Tipli service/controller: biznes/HTTP qatlam (Misol 5, 2.13).
  7. Zod validatsiya: request body (tur + runtime — Misol 6, 2.11).
  8. Tipli error handling: custom error, handler (Misol 7, 5.10).
  9. ESM modullar: .js import, import type (2.3, 2.4).
  10. Build: dev (tsx) va production (tsc node) ishlaydi 2.8-bob.

Maslahatlar (hint)

  • ESM: .js kengaytma (2.3, 1-xato).
  • req.user: declare global (2.6, 2-xato, Misol 2).
  • TS tip + Zod (runtime — 2.11, 6-xato).
  • Dev tsx, prod tsc (2.8, 5-xato).
  • import type (faqat tur — 2.4).
  • Qatlam: controller service model 2.1-bob.

"Tayyor" mezonlari (acceptance criteria)

  • Qatlamli tuzilma.
  • tsconfig (strict) + scripts.
  • Tipli config (env + Zod).
  • Global tip (req.user).
  • Tipli middleware (auth).
  • Tipli service/controller.
  • Zod validatsiya (tur + runtime).
  • Tipli error handling.
  • ESM (.js, import type).
  • Dev va production build ishlaydi.

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi QISMga ko'prik

Bu bobda TS bilimini real backend'da birlashtirdik:

  • Loyiha tuzilmasi (qatlamli — controller/service/model — 2.1); production tsconfig 2.2-bob.
  • Modullar (ESM + .js — 2.3; import/export, import type — 2.4); declaration files (.d.ts — 2.5; global tip kengaytirish — req.user — 2.6); @types 2.7-bob.
  • Build (dev tsx / prod tsc — 2.8); path mapping 2.9-bob; tipli Express (req/res/middleware — 2.10); tip + Zod (kompilyatsiya + runtime — 2.11); tipli error 2.12-bob.
  • To'liq tipli backend (oqim bo'ylab xavfsiz — 2.13); NestJS ko'prigi 2.14-bob.

7-QISM (TypeScript) TUGADI! Kirish (nega TS, tsconfig) turlar/interface/enum generics ilg'or turlar (utility/conditional/mapped) narrowing/type guards decorators TS backend loyihasi — to'liq, professional TypeScript bilimi.

Keyingi — 8-QISM: NestJS (chuqur). TypeScript (7), backend (5), DB (6) ni bildik. Endi ularni birlashtiruvchi, zamonaviy, korporativ darajadagi framework — NestJS ni chuqur o'rganamiz: arxitektura (module/controller/provider), dependency injection, DB, DTO/validation, guards/interceptors, auth, testing, va h.k. NestJS — TS Express'ning 7.7-bob "tashkillangan, dekorator" 7.6-bob versiyasi — sizning stack'ingizning eng muhim qismi.

Foydalanilgan rasmiy/ishonchli manbalar

  • typescriptlang.org — TSConfig Reference, Declaration Files, Modules (ESM)
  • DEV/LogRocket — TypeScript Node/Express setup 2026 (struktura, build, .d.ts)
  • OneUptime — TypeScript declaration files; Express + TypeScript best practices

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
7.7-bob: TS bilan Node/Express loyihasi — declaration files, modullar — Wisar