8.25-bob: Multi-tenancy (SaaS)

  SaaS — dasturni XIZMAT sifatida sotish (oylik obuna — 8.29)
  TENANT — bir mijoz-kompaniya (ijarachi)

  Bitta ilova:
  ├── Tenant A (Mana kompaniya) — o'z mijozlari, mahsulotlari
  ├── Tenant B (Olma kompaniya) — o'z ma'lumoti (A'ni KO'RMAYDI)
  └── Tenant C (...)

   Har tenant IZOLYATSIYALANGAN (bir-birini ko'rmaydi)
   Bitta kodbaza, bitta deploy (yangilanish — hammaga)

  HAR SO'ROVDA — qaysi tenant ekanini aniqlash:

  1. Subdomain: mana.app.uz, olma.app.uz  tenant = subdomain (eng keng)
  2. Custom domain: crm.mana.uz  DB'dan domen  tenant
  3. Header: X-Tenant-ID: mana (API uchun)
  4. JWT: token ichida tenantId (login'da belgilanadi — 8.9)
  5. Path: app.uz/mana/... (kamroq)

   Eng keng: subdomain (UI) + JWT tenantId (auth)

// Tenant aniqlovchi — bir nechta manbani ustuvorlik bilan tekshiradi
@Injectable()
export class TenantResolver {
  constructor(private tenantRepo: TenantRepository, private cache: CacheService) {}

  async resolve(req: Request): Promise<string> {
    // 1) JWT — ENG ishonchli (imzolangan — 8.9). Bo'lsa, shu yakuniy.
    if (req.user?.tenantId) return req.user.tenantId;

    const host = req.hostname;                          // masalan: mana.app.uz | crm.mana.uz

    // 2) Subdomain — asosiy domenning bir qismi bo'lsa (mana.app.uz  "mana")
    if (host.endsWith(".app.uz")) {
      const subdomain = host.split(".")[0];
      const t = await this.tenantBySubdomain(subdomain);
      if (t) return t.id;
    }

    // 3) Custom domen — mijozning o'z domeni (crm.mana.uz)  DB xaritasi (cache bilan)
    const byDomain = await this.cache.wrap(`domain:${host}`, () =>
      this.tenantRepo.findByCustomDomain(host),
    );
    if (byDomain) return byDomain.id;

    // 4) Header — faqat server-server API uchun (mijoz brauzeri emas — soxtalashtiriladi)
    const header = req.header("X-Tenant-ID");
    if (header && (await this.tenantRepo.findOneBy({ id: header }))) return header;

    throw new BadRequestException("Tenant aniqlanmadi");   // hech biri  rad
  }

  private tenantBySubdomain(sub: string) {
    return this.cache.wrap(`sub:${sub}`, () => this.tenantRepo.findBySubdomain(sub));
  }
}

  ┌──────────────────────┬────────────────────────────────────────┐
  │ 1. Shared schema     │ Bitta DB, bitta schema, tenant_id ustun│
  │    (+ tenant_id)     │ Har jadvalda tenant_id. Filtr bilan.   │
  │                      │  Arzon, oddiy, oson masshtab          │
  │                      │  Izolyatsiya app/RLS'ga bog'liq       │
  │                      │  MVP, ko'p kichik tenant (eng keng)    │
  ├──────────────────────┼────────────────────────────────────────┤
  │ 2. Schema-per-tenant │ Bitta DB, har tenant alohida schema    │
  │                      │  Yaxshi izolyatsiya, o'rtacha narx    │
  │                      │  Migration murakkab (har schema)      │
  ├──────────────────────┼────────────────────────────────────────┤
  │ 3. Database-per-     │ Har tenant alohida DB                  │
  │    tenant            │  Maksimal izolyatsiya (compliance)    │
  │                      │  Qimmat, masshtab qiyin               │
  │                      │  enterprise, qattiq talab             │
  └──────────────────────┴────────────────────────────────────────┘

// Har jadvalda tenant_id ustun
@Entity()
export class Customer {
  @PrimaryGeneratedColumn("uuid") id: string;
  @Column() @Index() tenantId: string;                // QAYSI tenant (indeks!)
  @Column() ism: string;
  @Column() telefon: string;
}

//  HAR so'rovda tenant_id filtri (eng muhim — 2.5)
async mijozlar(tenantId: string) {
  return this.repo.find({ where: { tenantId } });     // FAQAT shu tenant
}

// MUAMMO: har so'rovda qo'lda tenant_id — unutiladi (xavf!)
// YECHIM: avtomatik (har so'rovga tenant_id qo'shiladi)

// TypeORM — global scope / repository wrapper
@Injectable()
export class TenantAwareRepository<T> {
  constructor(private repo: Repository<T>, private tenant: TenantContext) {}

  find(options: any = {}) {
    return this.repo.find({
      ...options,
      where: { ...options.where, tenantId: this.tenant.tenantId },   // AVTOMATIK
    });
  }
  // create, update, delete — barchasi tenant_id bilan
}

// Tenant kontekst — joriy so'rovning tenant'i (request-scoped)
@Injectable()
export class TenantMiddleware implements NestMiddleware {
  use(req: any, res: any, next: () => void) {
    // Subdomain'dan 2.2-bob: mana.app.uz  "mana"
    const subdomain = req.hostname.split(".")[0];
    // yoki JWT'dan: req.user.tenantId (8.9)
    req.tenantId = subdomain;
    if (!req.tenantId) throw new BadRequestException("Tenant aniqlanmadi");
    next();
  }
}

// AsyncLocalStorage (har so'rov uchun izolyatsiya — global kontekst)
// yoki REQUEST-scoped provider (8.2 scope)

-- PostgreSQL RLS — izolyatsiya DB'da (app emas — eng ishonchli)
ALTER TABLE customers ENABLE ROW LEVEL SECURITY;

CREATE POLICY tenant_isolation ON customers
  USING (tenant_id = current_setting('app.current_tenant')::uuid);

-- Har so'rovdan oldin tenant o'rnatiladi:
-- SET app.current_tenant = 'mana-tenant-id';
--  endi customers'dan SELECT faqat shu tenant qatorlarini qaytaradi (DB kafolati)

// Schema-per-tenant — dinamik ulanish (tenant'ga qarab schema)
async tenantConnection(tenantId: string): Promise<DataSource> {
  // Har tenant — alohida schema (yoki DB)
  return new DataSource({
    type: "postgres",
    schema: `tenant_${tenantId}`,                     // dinamik schema
    // database-per-tenant: database: `tenant_${tenantId}_db`
  }).initialize();
}
//  Connection pool boshqaruvi (har tenant ulanish — resurs — 6.15)
//  Migration — har schema/DB'ga (murakkab — 6.14)

// Yangi tenant ro'yxatdan o'tkazish (kompaniya qo'shilish)
async tenantYarat(dto: CreateTenantDto): Promise<Tenant> {
  // 1. Tenant yozuvi
  const tenant = await this.tenantRepo.save({
    nom: dto.kompaniya, subdomain: dto.subdomain, reja: "trial",   // (8.29 subscription)
  });
  // 2. Admin user (kompaniya egasi)
  await this.usersService.yarat({ ...dto.admin, tenantId: tenant.id, rol: "owner" });
  // 3. Boshlang'ich ma'lumot (default sozlama, namuna)
  await this.seedDefaults(tenant.id);
  // 4. Schema-per-tenant bo'lsa: schema + migration (2.8)
  // 5. Xush kelibsiz email (8.10)
  return tenant;
}

   HAR so'rovda tenant filtri (avtomatik — qo'lga ishonmaslik — 2.5)
   RLS (DB darajasida himoya — 2.7) — ikkinchi qatlam
   Tenant ID JWT'da (o'zgartirib bo'lmaydigan — imzolangan — 8.9)
   Cross-tenant tekshirish (ID bo'yicha to'g'ridan kirish testi)
   Tenant kontekst har so'rovda majburiy (yo'q  rad)
   Resurs cheklash (bir tenant boshqasini sekinlatmasin — rate limit)
   Test: tenant A tenant B ma'lumotini KO'RA OLMASLIGI (8.11)
   Bir izolyatsiya xatosi = falokat (raqib ma'lumotini ko'rish)

   Strategiya tanlovi (shared schema + RLS — boshlash — 2.3)
   Tenant aniqlash (subdomain + JWT — 2.2)
   AVTOMATIK tenant filtri (qo'lga ishonmaslik — 2.5)
   RLS (DB himoya — ikkinchi qatlam — 2.7)
   Tenant kontekst (har so'rovda — request-scoped — 2.6)
   tenant_id indeks (tez filtr — 2.4); cross-tenant test (8.11, 2.10)
   Onboarding avtomatik (self-service trial — 2.9, 8.29)
   Resurs cheklash (tenant izolyatsiyasi — 2.10)
   Hybrid (katta tenant  alohida DB — 2.3)

  ┌────────────────┬──────────────────┬──────────────────┬──────────────────┐
  │ Mezon          │ Shared schema    │ Schema-per-      │ Database-per-    │
  │                │ (+ tenant_id)    │ tenant           │ tenant           │
  ├────────────────┼──────────────────┼──────────────────┼──────────────────┤
  │ Izolyatsiya    │ Zaif (app/RLS)   │ O'rtacha         │ Maksimal         │
  │ Narx (infra)   │ Eng arzon        │ O'rtacha         │ Eng qimmat       │
  │ Masshtab       │ Oson (10k+)      │ Cheklangan       │ Qiyin            │
  │  (tenant soni) │                  │ (~yuzlab schema) │ (~o'nlab DB)     │
  │ Migration      │ Bir marta        │ Har schema'ga    │ Har DB'ga        │
  │ Connection pool│ Bitta pool       │ Ko'p ulanish     │ Ko'p pool        │
  │ Backup/restore │ Umumiy (tenant   │ Schema bo'yicha  │ Tenant bo'yicha  │
  │                │ ajratish qiyin)  │                  │ (oson, aniq)     │
  │ Xesh so'rov    │ Yaxshi (indeks)  │ Yaxshi           │ Yaxshi           │
  │ Qachon         │ MVP, ko'p kichik │ B2B, o'rta soni, │ Enterprise,      │
  │                │ tenant, tez o'sish│ o'rtacha izolyatsiya│ compliance (bank,│
  │                │                  │                  │ sog'liq), kam    │
  │                │                  │                  │ katta tenant     │
  └────────────────┴──────────────────┴──────────────────┴──────────────────┘

// nestjs-cls — request-scope'siz tenant kontekst (singleton provider'lar bilan)
// app.module.ts
ClsModule.forRoot({
  middleware: { mount: true },           // har so'rovda yangi CLS kontekst
});

// Tenant'ni kontekstga qo'yish (middleware/guard ichida)
@Injectable()
export class TenantMiddleware implements NestMiddleware {
  constructor(private readonly cls: ClsService) {}
  use(req: any, _res: any, next: () => void) {
    const subdomain = req.hostname.split(".")[0];   // yoki JWT'dan (2.2)
    this.cls.set("tenantId", subdomain);            // kontekstga (so'rov izolyatsiyasi)
    next();
  }
}

// Service — SINGLETON, lekin kontekstdan tenant oladi (request-scope shart emas)
@Injectable()
export class CustomersService {
  constructor(private readonly cls: ClsService, private repo: Repository<Customer>) {}
  hammasi() {
    const tenantId = this.cls.get("tenantId");      // joriy so'rov tenant'i
    return this.repo.find({ where: { tenantId } });
  }
}

// Prisma client extension — har so'rovga tenant filtri avtomatik
function tenantExtension(tenantId: string) {
  return Prisma.defineExtension((client) =>
    client.$extends({
      query: {
        $allModels: {
          async $allOperations({ args, query, operation }) {
            // O'qish/o'chirish/yangilash — where'ga tenantId qo'shiladi
            if (["findMany", "findFirst", "updateMany", "deleteMany", "count"].includes(operation)) {
              args.where = { ...args.where, tenantId };
            }
            // Yaratishda — tenantId majburiy o'rnatiladi
            if (operation === "create") {
              args.data = { ...args.data, tenantId };
            }
            return query(args);
          },
        },
      },
    }),
  );
}

// Har so'rovda tenant'ga bog'langan client (kontekstdan — 2.13)
@Injectable()
export class PrismaTenantService {
  constructor(private base: PrismaService, private cls: ClsService) {}
  get client() {
    return this.base.$extends(tenantExtension(this.cls.get("tenantId")) as any);
  }
}

// Schema-per-tenant — barcha tenantga migration (loop bilan)
@Injectable()
export class TenantMigrationService {
  constructor(private tenantRepo: TenantRepository, private config: ConfigService) {}

  async migrateAll() {
    const tenants = await this.tenantRepo.find({ where: { faol: true } });
    for (const tenant of tenants) {
      const ds = new DataSource({
        type: "postgres",
        schema: `tenant_${tenant.id}`,                // shu tenant schema'si
        migrations: ["dist/migrations/*.js"],
        entities: [Customer, Product],
      });
      await ds.initialize();
      try {
        await ds.runMigrations();                     // shu schema'ga qo'llaydi
      } finally {
        await ds.destroy();                           // ulanishni yopish (resurs — 6.15)
      }
    }
  }
}
//  Yangi tenant onboarding'da 2.9-bob darhol migration ishga tushiriladi (schema tayyor bo'lsin)

@Entity()
export class TenantSettings {
  @PrimaryColumn() tenantId: string;
  @Column({ default: "UZS" }) valyuta: string;
  @Column({ default: "uz" }) til: string;
  @Column({ type: "jsonb", default: {} }) branding: {           // logo, rang (UI)
    logoUrl?: string; asosiyRang?: string;
  };
  @Column({ type: "jsonb", default: {} }) features: Record<string, boolean>;   // feature-flag
}

// Feature-flag tekshiruvi (reja bilan bog'liq — 8.29)
@Injectable()
export class FeatureService {
  constructor(private repo: Repository<TenantSettings>, private cls: ClsService) {}
  async yoqilganmi(feature: string): Promise<boolean> {
    const s = await this.repo.findOneBy({ tenantId: this.cls.get("tenantId") });
    return s?.features?.[feature] ?? false;                      // default — o'chiq
  }
}

// Guard: funksiya rejaga kirmasa — rad (masalan "advancedReports" faqat pro rejada)
@Injectable()
export class FeatureGuard implements CanActivate {
  constructor(private reflector: Reflector, private features: FeatureService) {}
  async canActivate(ctx: ExecutionContext): Promise<boolean> {
    const need = this.reflector.get<string>("feature", ctx.getHandler());
    if (need && !(await this.features.yoqilganmi(need))) {
      throw new ForbiddenException("Bu funksiya rejangizga kirmaydi");   // upsell (8.29)
    }
    return true;
  }
}

// Tenant bo'yicha rate-limit — throttler kalitini tenant'dan olish
@Injectable()
export class TenantThrottlerGuard extends ThrottlerGuard {
  // Limitni tenant bo'yicha izolyatsiya qilish (global emas)
  protected async getTracker(req: Record<string, any>): Promise<string> {
    return req.tenantId ?? req.ip;                    // tenant'ga bog'langan hisoblagich
  }
}

// Kvota — oylik so'rov/yozuv soni (rejaga qarab — 8.29)
@Injectable()
export class QuotaService {
  constructor(private redis: Redis, private cls: ClsService) {}
  async iste'molOshir(metric: string, limit: number) {
    const tenantId = this.cls.get("tenantId");
    const oy = new Date().toISOString().slice(0, 7);              // "2026-07"
    const key = `quota:${tenantId}:${metric}:${oy}`;
    const joriy = await this.redis.incr(key);
    if (joriy === 1) await this.redis.expire(key, 32 * 24 * 3600);  // oy oxirida tozalanadi
    if (joriy > limit) {
      throw new ForbiddenException("Oylik kvota tugadi — rejani oshiring");   // 8.29-bob
    }
  }
}

@Injectable()
export class TenantLifecycleService {
  constructor(private dataSource: DataSource, private storage: StorageService) {}

  // 1. Data export — tenant'ning barcha ma'lumotini fayl sifatida (GDPR portability)
  async export(tenantId: string): Promise<string> {
    const data = {
      customers: await this.dataSource.getRepository(Customer).findBy({ tenantId }),
      products: await this.dataSource.getRepository(Product).findBy({ tenantId }),
      // ... barcha tenant jadvallari
    };
    return this.storage.saqla(`export/${tenantId}.json`, JSON.stringify(data));  // yuklab olish havolasi
  }

  // 2. Yumshoq o'chirish — grace period (30 kun, fikridan qaytishi mumkin)
  async deaktivatsiya(tenantId: string) {
    await this.dataSource.getRepository(Tenant).update(tenantId, {
      faol: false,
      ochirishSanasi: new Date(Date.now() + 30 * 24 * 3600 * 1000),   // 30 kun keyin
    });
  }

  // 3. Qattiq o'chirish — grace period tugagach (GDPR right to erasure)
  async butunlayOchir(tenantId: string) {
    await this.dataSource.transaction(async (manager) => {
      // Bog'liqlik tartibida o'chirish (yoki cascade — 8.3)
      await manager.delete(Customer, { tenantId });
      await manager.delete(Product, { tenantId });
      await manager.delete(TenantSettings, { tenantId });
      await manager.delete(User, { tenantId });
      await manager.delete(Tenant, { id: tenantId });
      // Schema/db-per-tenant bo'lsa: DROP SCHEMA tenant_<id> CASCADE (2.8)
    });
    await this.storage.ochir(`export/${tenantId}.json`);   // export faylini ham (grace tugadi)
  }
}

// Reja  limit/feature xaritasi (8.29 subscription bilan)
const REJALAR = {
  trial: { maxUsers: 3, apiLimit: 1000, features: ["basic"] },
  basic: { maxUsers: 10, apiLimit: 50_000, features: ["basic"] },
  pro:   { maxUsers: 100, apiLimit: 500_000, features: ["basic", "advancedReports", "api"] },
};

// Tenant iste'molini billing uchun o'lchash (usage-based — 8.29)
@Injectable()
export class UsageService {
  async yozib(tenantId: string, metric: "apiCall" | "storage", miqdor = 1) {
    // Oylik iste'mol — hisob davri oxirida billing'ga uzatiladi (8.29)
    // (2.17 kvota bilan bir manba — bir marta o'lchang, ikkala maqsadga ishlating)
  }
}

   tenant_id — HAR filtrlanadigan jadvalda indeks 2.4-bob; ko'p ustunli
    so'rovda composite indeks (tenant_id, boshqa_ustun) — 6.10
   "Katta tenant" (data hajmi katta) — shared schema'da boshqa kichiklarni
    sekinlatishi mumkin  hybrid: alohida DB'ga ko'chirish 2.12-bob
   Connection pool — shared schema'da bitta pool (samarali); schema/db-per-
    tenant'da ulanish soni tez oshadi  cache + limit (Misol 9, 6.15)
   Cache kaliti — HAR doim tenant_id bilan (cross-tenant cache leak
    oldini olish — noto'g'ri tenant'ga cache berilmasin) — 6.16
   Fon vazifalari (queue — 8.22) — job payload'ida tenantId; worker
    kontekstni tiklaydi (ALS kontekst HTTP so'rovsiz)
   Monitoring — metrikalarni tenant bo'yicha teglash (qaysi tenant og'ir)

TENANT ANIQLASH 2.2-bob: subdomain | JWT tenantId | X-Tenant-ID header
STRATEGIYA 2.3-bob: shared+tenant_id | schema-per-tenant | db-per-tenant

Shared schema 2.4-bob: har jadval @Column tenantId @Index
Avtomatik filtr 2.5-bob: repository wrapper / TypeORM subscriber / RLS
RLS 2.7-bob: CREATE POLICY ... USING (tenant_id = current_setting('app.current_tenant'))
Kontekst (2.6, 2.13): middleware  cls.set("tenantId"); REQUEST-scoped / AsyncLocalStorage / nestjs-cls
Prisma filtr 2.14-bob: client.$extends({ query: { $allModels: {...} } })
Feature-flag 2.16-bob: FeatureGuard + @SetMetadata("feature", "pro-funksiya")
Kvota 2.17-bob: tenant bo'yicha throttler getTracker()  tenantId; Redis incr

@Entity()
export class Tenant {
  @PrimaryGeneratedColumn("uuid") id: string;
  @Column({ unique: true }) subdomain: string;        // mana.app.uz
  @Column() nom: string;
  @Column({ default: "trial" }) reja: string;         // subscription (8.29)
  @Column({ default: true }) faol: boolean;
}

// Tenant kontekst (AsyncLocalStorage — so'rov izolyatsiyasi)
import { AsyncLocalStorage } from "async_hooks";

@Injectable()
export class TenantContext {
  private als = new AsyncLocalStorage<{ tenantId: string }>();

  run(tenantId: string, callback: () => any) {
    return this.als.run({ tenantId }, callback);
  }
  get tenantId(): string {
    const store = this.als.getStore();
    if (!store) throw new Error("Tenant kontekst yo'q");
    return store.tenantId;
  }
}

@Injectable()
export class TenantMiddleware implements NestMiddleware {
  constructor(private tenantRepo: TenantRepository, private context: TenantContext) {}

  async use(req: Request, res: Response, next: () => void) {
    // 1. Subdomain'dan (2.2)
    const host = req.hostname;                         // mana.app.uz
    const subdomain = host.split(".")[0];

    // 2. Tenant topish
    const tenant = await this.tenantRepo.findBySubdomain(subdomain);
    if (!tenant || !tenant.faol) {
      throw new NotFoundException("Tenant topilmadi yoki faol emas");
    }

    // 3. Kontekstga qo'yish (butun so'rov bo'ylab)
    this.context.run(tenant.id, () => next());
  }
}
// app.module: consumer.apply(TenantMiddleware).forRoutes("*")

// TypeORM subscriber — har save/query'ga tenant_id avtomatik
@EventSubscriber()
export class TenantSubscriber implements EntitySubscriberInterface {
  constructor(dataSource: DataSource, private context: TenantContext) {
    dataSource.subscribers.push(this);
  }

  beforeInsert(event: InsertEvent<any>) {
    if ("tenantId" in event.entity) {
      event.entity.tenantId = this.context.tenantId;  // AVTOMATIK qo'shiladi (2.5)
    }
  }
}

// Query filtri — global (yoki tenant-aware repository)
@Injectable()
export class CustomersService {
  constructor(
    @InjectRepository(Customer) private repo: Repository<Customer>,
    private context: TenantContext,
  ) {}

  hammasi() {
    return this.repo.find({ where: { tenantId: this.context.tenantId } });   // avtomatik (2.5)
  }
  async bitta(id: string) {
    const c = await this.repo.findOne({ where: { id, tenantId: this.context.tenantId } });
    if (!c) throw new NotFoundException();             // boshqa tenant  topilmadi (izolyatsiya)
    return c;
  }
}

// RLS — har so'rovdan oldin tenant o'rnatish (DB himoyasi)
@Injectable()
export class RlsService {
  constructor(@InjectDataSource() private dataSource: DataSource, private context: TenantContext) {}

  // Har so'rovda tenant'ni DB sessiyasiga o'rnatish
  async withTenant<T>(callback: (manager: EntityManager) => Promise<T>): Promise<T> {
    return this.dataSource.transaction(async (manager) => {
      await manager.query(`SET LOCAL app.current_tenant = '${this.context.tenantId}'`);
      return callback(manager);                        // endi barcha so'rov RLS bilan
    });
  }
}

// migration — RLS policy (6.14)
// ALTER TABLE customers ENABLE ROW LEVEL SECURITY;
// CREATE POLICY tenant_iso ON customers USING (tenant_id = current_setting('app.current_tenant')::uuid);

// JWT'da tenantId (login'da belgilanadi — 8.9, imzolangan — o'zgartirib bo'lmaydi)
@Injectable()
export class TenantGuard implements CanActivate {
  constructor(private context: TenantContext) {}

  canActivate(ctx: ExecutionContext): boolean {
    const req = ctx.switchToHttp().getRequest();
    const tenantId = req.user?.tenantId;              // JWT payload (8.9)
    if (!tenantId) throw new ForbiddenException("Tenant aniqlanmadi");
    req.tenantId = tenantId;
    return true;
  }
}

// JWT payload (8.9 — login'da tenantId qo'shiladi)
// { sub: userId, tenantId: "mana-id", rol: "admin" }

@Injectable()
export class OnboardingService {
  async tenantYarat(dto: CreateTenantDto): Promise<Tenant> {
    // Subdomain band emasligini tekshir
    if (await this.tenantRepo.findBySubdomain(dto.subdomain)) {
      throw new ConflictException("Bu subdomain band");
    }
    return this.dataSource.transaction(async (manager) => {   // atomik (8.13)
      // 1. Tenant
      const tenant = await manager.save(Tenant, {
        subdomain: dto.subdomain, nom: dto.kompaniya, reja: "trial",
        trialTugashi: new Date(Date.now() + 14 * 24 * 3600 * 1000),   // 14 kun (8.29)
      });
      // 2. Admin user
      await manager.save(User, {
        tenantId: tenant.id, email: dto.adminEmail,
        parol: await bcrypt.hash(dto.parol, 12), rol: "owner",   // (8.7, 8.9)
      });
      // 3. Default sozlama
      await manager.save(TenantSettings, { tenantId: tenant.id, valyuta: "UZS" });
      return tenant;
    });
    // 4. Xush kelibsiz email 8.10-bob — transaction'dan keyin (fonda — 8.22)
  }
}

@Controller("customers")
@UseGuards(JwtAuthGuard, TenantGuard)                 // auth + tenant (8.9, 2.5)
export class CustomersController {
  constructor(private service: CustomersService) {}

  @Get()
  hammasi() {
    return this.service.hammasi();                    // avtomatik tenant filtri (Misol 3)
  }

  @Get(":id")
  bitta(@Param("id") id: string) {
    return this.service.bitta(id);                    // boshqa tenant  404 (izolyatsiya)
  }

  @Post()
  yarat(@Body() dto: CreateCustomerDto) {
    return this.service.yarat(dto);                   // tenant_id avtomatik (subscriber — Misol 3)
  }
}
// Dasturchi tenant_id'ni o'ylamaydi (avtomatik — xato kamayadi)

// ENG MUHIM test — izolyatsiya buzilmasligini isbotlash
describe("Tenant izolyatsiyasi (e2e)", () => {
  it("tenant A tenant B mijozini KO'RA OLMAYDI", async () => {
    // Tenant A mijoz yaratadi
    const tokenA = await login("admin@tenant-a.uz");
    const mijozA = await request(app.getHttpServer())
      .post("/customers").set("Authorization", `Bearer ${tokenA}`)
      .send({ ism: "Mijoz A" }).expect(201);

    // Tenant B uning ID'si bilan to'g'ridan so'raydi (IDOR urinishi — 8.7)
    const tokenB = await login("admin@tenant-b.uz");
    await request(app.getHttpServer())
      .get(`/customers/${mijozA.body.id}`)            // A'ning mijozi!
      .set("Authorization", `Bearer ${tokenB}`)
      .expect(404);                                   // KO'RA OLMAYDI (izolyatsiya — to'g'ri!)
  });
});
//  Bu test O'TMASA — izolyatsiya buzilgan (falokat)

// Har tenant — alohida schema (dinamik ulanish)
@Injectable()
export class TenantConnectionService {
  private connections = new Map<string, DataSource>();   // cache (connection pool — 6.15)

  async getConnection(tenantId: string): Promise<DataSource> {
    if (this.connections.has(tenantId)) return this.connections.get(tenantId)!;

    const ds = new DataSource({
      type: "postgres",
      host: this.config.get("DB_HOST"),
      schema: `tenant_${tenantId}`,                   // alohida schema (2.8)
      entities: [Customer, Product],
    });
    await ds.initialize();
    this.connections.set(tenantId, ds);
    return ds;
  }
  //  Migration har schema'ga 6.14-bob; connection limit (6.15)
}

  SaaS multi-tenant tuzilma:
  src/
  ├── tenancy/
  │   ├── tenant.context.ts          (AsyncLocalStorage — Misol 1)
  │   ├── tenant.middleware.ts       (aniqlash — Misol 2)
  │   ├── tenant.guard.ts            (JWT — Misol 5)
  │   ├── tenant.subscriber.ts       (avtomatik filtr — Misol 3)
  │   └── onboarding.service.ts      (yangi tenant — Misol 6)
  ├── customers/ (tenant-aware — Misol 7)
  └── ...

  Har so'rov oqimi:
  Request (mana.app.uz)  TenantMiddleware (subdomain  tenant)
   JWT auth (tenantId — 8.9)  TenantContext (kontekst)
   Service (avtomatik tenant filtri — Misol 3) + RLS (DB himoya — Misol 4)
   faqat shu tenant ma'lumoti (izolyatsiya — 2.10)

   Strategiya: shared schema + RLS (boshlash)  katta tenant alohida DB (hybrid)

 where: { tenantId } qo'lda (unutiladi  oqish — 2.5)
 avtomatik (subscriber/RLS)

 ?tenantId=... (soxtalashtiriladi — 2.10)
 JWT'da (imzolangan — o'zgartirib bo'lmaydi)

 bir kod xatosi  oqish (2.7)
 app filtri + RLS (ikki qatlam)

 izolyatsiya tekshirilmagan (2.10)
 AB izolyatsiya testi (Misol 8)

 1000 kichik tenant  1000 DB (qimmat — 2.3)
 shared schema + RLS