Pattern 05/22 · Creational

Singleton Đơn bản

Bảo đảm cả tiến trình chỉ có đúng một instance và mở ra một cửa duy nhất để lấy nó. Trong JS, phần "một instance" thì ES module đã làm sẵn, nên giá trị thật của pattern nằm ở chỗ khác: kiểm soát instance ra đời *lúc nào*, *bằng tham số nào*, và *ai được phép thay nó khi test*.

Sáng tạo●○○12 phút đọc8 bướccòn gọi: Global Instance, Module Instance
singletonglobal statemodulelazy initdependency injectiontestingcomposition root

01 — Mở đầu bằng code đang hỏng

Vấn đề

Bạn có utils/db.ts: export const prisma = new PrismaClient(). Ai cần thì import { prisma }. Chạy tốt nửa năm. Rồi bạn viết test unit đầu tiên cho OrderService.cancel() — và test của bạn kết nối thật vào dev DB, vì chỉ cần import là module body chạy, không ai xin phép. Để nó ngừng chạy, bạn thêm vi.mock("~/utils/db"), và từ đó hành vi của test phụ thuộc vào đường dẫn module dạng chuỗi: ai đổi tên file là test im lặng test một thứ không tồn tại.

Có người "cải tiến" cho chuyên nghiệp: class DB { private static inst; static get(cfg) { return this.inst ??= new DB(cfg) } }. Tinh vi. Và bug mới xuất hiện: getInstance(config) nhận tham số, nhưng chỉ tham số của lần gọi đầu tiên được dùng. File A import trước với DSN staging, file B import sau với DSN prod — B im lặng nhận staging. Không exception, không warning, không log. Thứ duy nhất bị phớt lờ là đối số bạn tưởng là có hiệu lực.

Trên server thì nặng hơn. Bạn đặt let currentUser ở module scope của một Nuxt server route, gán trong middleware, đọc ở handler. Một request: đúng. Hai request đồng thời: handler của user A đọc đúng cái currentUser mà request của user B vừa ghi đè. Đây không phải bug hiệu năng, đây là bug bảo mật, và nó tồn tại vì module scope của Node sống suốt tiến trình, còn request thì chỉ sống vài chục ms.

Vòng đời dev và prod cũng không giống nhau. Bật HMR/nodemon, module bị eval lại, client cũ vẫn giữ connection pool trong khi client mới mở thêm pool nữa → hết connection (Prisma phải khuyến cáo cất client vào globalThis trong dev). Serverless thì ngược lại: tiến trình ấm và module state sống dai qua nhiều lần gọi, nên cái Map bạn đặt ở module scope "để cache tạm" hoá ra thành cache vĩnh viễn — và nếu key của nó thiếu tenant id, nó phục vụ dữ liệu của khách này cho khách khác.

Pattern không phải thủ phạm. Thủ phạm là dependency ẩn: chỗ dùng không khai báo trong chữ ký hàm, nên bạn không nhìn thấy nó khi đọc code, không grep ra được ai dùng gì, không đổi được nó khi test, và không di chuyển được nó khi refactor. Chốt lại: "một instance" là yêu cầu chính đáng; "mọi người đều tự đi lấy được từ global" mới là thứ khiến nó đắt.

02 — Ý tưởng, chưa động vào code

Giải pháp

Dáng GoF: constructor private để không ai new được, một static field giữ instance, và một static method getInstance() tạo nó nếu chưa có. Trong TypeScript đúng ba chi tiết đó là đủ, và nó làm đúng hai việc: cấm tạo bản thứ hai, và hoãn việc tạo tới lúc thật sự cần.

Nhưng ở JS ta phải nói thẳng một điều: ES module đã là singleton. Lần import đầu tiên chạy module body, kết quả được lưu trong module registry, mọi importer khác dùng chung đúng object đó. export const prisma = new PrismaClient() là Singleton, ngắn hơn, có type, và không cần ai nhớ gọi getInstance(). Viết thêm class + getInstance lên trên nó chỉ mua thêm một cửa global để truy cập, thứ mà ta sắp bỏ đi.

Nên cách dùng đáng tiền là tách đôi pattern: giữ phần lifecycle (một instance, tạo lười, tạo ở một chỗ duy nhất), bỏ phần global access (không ai import để dùng lén). Instance nằm trong một module, được khởi tạo tại composition root — entrypoint của app, Nuxt plugin, server entry — rồi chảy vào code nghiệp vụ dưới dạng tham số. Server vẫn có một pool; test thì truyền fake vào; và OrderService khai báo đúng thứ nó cần ngay trong chữ ký hàm.

03 — Làm thật, mỗi bước một fragment code

Từng bước một

1

Viết bản GoF trước, để biết nó thật ra mua gì

private constructor chặn new từ bên ngoài. Static field giữ instance. getInstance() tạo nếu chưa có. Tám dòng, và đó là toàn bộ những gì Singleton cho bạn.

Hãy viết nó một lần cho đủ hình, rồi ta sẽ chỉ ra ngay chỗ nào trong tám dòng này là thừa ở JS.

tsdb-goF.ts
export class DB {
  private static inst: DB | undefined

  private constructor(private readonly dsn: string) {}

  static getInstance(dsn: string): DB {
    this.inst ??= new DB(dsn)
    return this.inst
  }

  query(sql: string) { return this.dsn + ' :: ' + sql }
}

DB.getInstance('dsn://staging')
DB.getInstance('dsn://prod') // <-- dsn này bị BỎ QUA, không lỗi
Dòng cuối là chỗ nguy hiểm nhất: API nhận tham số nhưng chỉ tin tham số đầu tiên.
ChốtSingleton = "không cho tạo bản thứ hai" + "tạo lười". Nếu hai thứ đó không phải vấn đề của bạn, bạn không cần pattern này.
2

Nói thẳng: ES module vốn đã là singleton

Module registry của JS map (specifier, realm) → module record. Module body chỉ chạy một lần; các import sau đọc từ cache. Nghĩa là export const x = new Thing() đã bảo đảm "một instance duy nhất" mạnh hơn cả getInstance(): không ai có thể tạo cái thứ hai vì không ai gọi constructor.

Nó còn có type tĩnh. DB.getInstance() trả DB vì bạn tự hứa vậy; import { db } trả DB vì compiler biết.

tslogger.ts
// logger.ts
class Logger {
  private lines: string[] = []
  log(msg: string) { this.lines.push(msg); return this }
  dump() { return this.lines.length }
}
export const logger = new Logger()   // module body chạy ĐÚNG MỘT LẦN

// a.ts:  import { logger } from './logger'   <- lần đầu: chạy body, lưu registry
// b.ts:  import { logger } from './logger'   <- các lần sau: đọc registry
// nên  l1 === l2  luôn đúng, trong cùng một module record + cùng một realm.

// Cái bạn KHÔNG tạo ra được bằng cách này: bản thứ hai. Không ai gọi constructor.
Không class getInstance, không registry thủ công. Module system đã làm phần "exactly one", và nó làm bằng static type chứ không bằng lời hứa.
ChốtViết Singleton class đè lên export const không tăng độ an toàn — nó chỉ thêm một đường để truy cập toàn cục.
3

Lười hoá: đừng chạy khởi tạo lúc import

Cái export const prisma = new ... có một giá phải trả: import là chạy. Trong SSR, bundle bị load để render một trang /about cũng mở luôn connection pool. Serverless trả thêm tiền và thêm cold-start time cho thứ request đó không dùng. Và nếu module khác import ngược lại (circular), nó thấy module chưa khởi tạo xong: undefined hoặc TDZ error lúc 3 giờ sáng.

Chỗ này Singleton thật sự có lãi: getInstance() tạo instance tại lần dùng đầu, tức là sau khi env đã được đọc, config đã validate, và request đầu tiên đã chứng minh là code này cần chạy.

tsdb-lazy.ts
class DB {
  private constructor(readonly dsn: string) {}
  private static inst: DB | undefined

  static get(): DB {
    // env chỉ chắc chắn đọc được sau khi app boot, không phải lúc import
    if (!this.inst) {
      const dsn = process.env.DSN
      if (!dsn) throw new Error('DSN chưa được cấu hình')
      this.inst = new DB(dsn)
    }
    return this.inst
  }
}

// so với: export const db = new DB(process.env.DSN!)  <- chạy ngay lúc import
export const useDb = () => DB.get()
Lười hoá biến "import là có side effect" thành "dùng mới có side effect", và lỗi cấu hình thành exception có tên thay vì undefined khó hiểu.
ChốtLười hoá không phải để "tối ưu": nó là cách trì hoãn quyết định khởi tạo tới lúc đã đủ thông tin (env, config, request đầu tiên).
4

Composition root: một file duy nhất biết tham số khởi tạo

Singleton có tham số khởi tạo thì phải có người trả lời câu hỏi "ai truyền, truyền lúc nào". Câu trả lời đúng là: một file — entrypoint của app. Nuxt plugin, server/utils/* init, main.ts, hoặc bin/cli.ts. Ngoài file đó, không ai được biết DSN, API key, hay tên bảng.

Quy tắc hệ quả: code nghiệp vụ không được init. Nó chỉ lấy, và nếu chưa init thì thất bại sớm với thông điệp rõ ràng.

tscomposition-root.ts
let db: DB | undefined

/** Chỉ được gọi từ entrypoint / plugin, đúng một lần. */
export function initDb(config: { dsn: string, pool: number }): void {
  if (db) throw new Error('initDb gọi 2 lần')
  db = new DB(config.dsn)
}

/** Code nghiệp vụ chỉ "lấy", không "tạo". */
export function getDb(): DB {
  if (!db) throw new Error('initDb chưa được gọi — kiểm tra plugin bootstrap')
  return db
}

// nuxt plugin bootstrap.ts: initDb({ dsn: useRuntimeConfig().dbDSN, pool: 5 })
Error message nói thẳng ai sai và sai ở đâu — khác hẳn undefined từ một module chưa kịp init.
ChốtToàn bộ wiring của ứng dụng nên dồn về một chỗ. Nếu ba file cùng new tài nguyên dùng chung, bạn không có Singleton — bạn có race.
5

Cắt phần độc hại: biến nó thành tham số

Đây là bước duy nhất biến "Singleton khó test" thành "Singleton an toàn". Thay vì OrderService tự import { db }, nó nhận db từ bên ngoài, qua constructor hoặc qua tham số của factory. Chữ ký hàm bây giờ khai báo đầy đủ những gì nó cần — nhìn signature là biết dependency, không cần đọc thân hàm.

Type của tham số nên là giao diện nhỏ (DbClient với đúng 2-3 method service dùng), không phải class driver 60 method. Giao diện nhỏ nghĩa là fake dễ viết và driver đổi được.

tsorder-service.ts
export interface DbClient {
  findOne(sql: string, id: string): Promise<any>
  exec(sql: string, ...args: unknown[]): Promise<void>
}

export function createOrderService(db: DbClient) {
  return {
    async cancel(id: string) {
      await db.exec('update orders set status = $1 where id = $2', 'cancel', id)
    },
  }
}

// Wiring duy nhất, ở composition root:
// const orders = createOrderService(getDb())
createOrderService(db) không biết Prisma, không biết Postgres, không import gì để dùng lén.
ChốtDI không phải framework. Nó là "dependency nằm trong chữ ký hàm, không nằm trong import của file nghiệp vụ".
6

Test fake, bỏ vi.mock

Khi dependency là tham số, test chỉ cần một object cùng shape. Không mock theo tên module, không resetModules(), không lo thứ tự test, không cần DB, không cần Docker. Test chạy nhanh tới mức bạn còn muốn viết thêm test.

Đây là điểm mà Singleton "nguyên bản" (mọi người tự đi getInstance()) thua rõ nhất: để test nó, bạn phải dọn global state, và dọn global state thì hai test chạy song song không còn độc lập nữa.

tsorder-service.test.ts
interface DbClient {
  exec(sql: string, ...args: unknown[]): Promise<void>
}
const createOrderService = (db: DbClient) => ({
  cancel: (id: string) => db.exec('update orders set status = $1 where id = $2', 'cancel', id),
})

const calls: string[] = []
const fakeDb: DbClient = {
  exec: async (sql, ...args) => { calls.push(sql + ' | ' + args.join(',')) },
}

await createOrderService(fakeDb).cancel('o1')
console.log(calls.join('  ->  '))
// so với bản Singleton: phải vi.mock("~/utils/db") + mockReset + lo thứ tự test
console
update orders set status = $1 where id = $2 | cancel,o1
ChốtNếu một test cần vi.mock đường dẫn module để chạy được, đó là dấu hiệu dependency đang đi đường vòng thay vì đi qua chữ ký hàm.
7

Không đặt state per-request ở module scope

Rule dứt khoát: module scope chỉ chứa thứ không đổi theo request (pool, client, clock, logger). Bất cứ thứ gì thuộc về một request/user — user hiện tại, quota, tenant, language, request id — phải nằm trong object của request: event.context (Nitro/Nuxt), req.locals (Express), hoặc AsyncLocalStorage.

Vue cũng vậy và tài liệu chính thức cảnh báo: ref() đặt ở module scope của một composable được mọi component dùng chung — tiện cho global state, nhưng trên SSR nó chia sẻ giữa các request, tức là user A nhận trạng thái của user B. Bản an toàn là tạo ref() bên trong function setup/composable, hoặc khai báo rõ nó là global có chủ đích.

tsper-request.ts
const profile = (user?: string) => 'profile của ' + (user ?? 'KHÔNG RÕ')

// ✗ Sai: module scope sống suốt tiến trình, request thì chồng lấn lên nhau
let currentUser: string | undefined
async function handlerA(user: string) { currentUser = user; return profile(currentUser) }
async function handlerB() { return profile(currentUser) }   // đọc lộn của người khác

;(async () => {
  const p = Promise.all([handlerA('user-A'), handlerB()])
  console.log((await p).join(' | '))
})()

// ✓ Đúng: state đi cùng đối tượng của request
async function handler(event: { context: any, user: string }) {
  event.context.user = event.user           // Nitro: event.context sống 1 request
  return profile(event.context.user)
}
console
profile của user-A | profile của user-A
Dòng output là bằng chứng: handler B trả profile của user A. Bug kiểu này không lộ khi test một request — nó chỉ lộ dưới tải, một lần, trong audit log.
ChốtSingleton hoá tài nguyên (pool, client) là đúng. Singleton hoá ngữ cảnh của một request là lỗ hổng.
8

Kiểm tra vòng đời: HMR, warm lambda, dual package

Ba chuyện thật xảy ra với "single" instance. (1) HMR/nodemon: module bị eval lại, instance mới ra đời, instance cũ chưa đóng → pool phình; thuốc là cất instance vào globalThis có điều kiện trong dev, chính xác là cách Prisma khuyến cáo. (2) Warm lambda: state không bị reset giữa hai lần gọi, nên cache module-scope là cache thật — phải có TTL và key đủ ngữ cảnh (tenant, env). (3) Dual package hazard: package bị cài hai bản (ESM + CJS) nghĩa là có hai module record, hai "singleton", và a instanceof B trả false khó hiểu.

Nghiệp vụ phải phòng vệ bằng assert khi init và bằng cách không dựa vào identity của class để quyết định logic.

tslifecycle.ts
class DB { constructor(readonly dsn: string) {} }

// dev: HMR/nodemon eval lại module, nhưng globalThis thì không bị reset
const isDev = "prerender" !== 'production'
const g = globalThis as unknown as { __db?: DB }
let prodInstance: DB | undefined

function getDb(dsn: string): DB {
  if (isDev) return (g.__db ??= new DB(dsn))     // Prisma khuyến cáo đúng kiểu này
  return (prodInstance ??= new DB(dsn))
}

console.log('HMR-safe, cùng instance:', getDb('dsn://a') === getDb('dsn://a'))

// Cache module-scope trên server: key PHẢI đủ ngữ cảnh, và phải có hạn dùng
const cacheKey = (tenant: string, id: string) => tenant + ':' + id
console.log('key đủ ngữ cảnh:', cacheKey('t1', 'u1') !== cacheKey('t2', 'u1'))
console
HMR-safe, cùng instance: true
key đủ ngữ cảnh: true
??= trên globalThis là một Singleton "cho phép dev restart". Nó cũng là bằng chứng Singleton có thể chỉ để chữa một vấn đề của môi trường, không phải của thiết kế.
Chốt"Một instance" chỉ đúng trong một module record và một realm. Dev, serverless và node_modules duplicate là ba chỗ assumption đó vỡ.

04 — Ai nói chuyện với ai

Cấu trúc

  • SingletonClass giữ static field + `getInstance()`. Constructor private để `new` từ ngoài là lỗi biên dịch.
  • InstanceĐúng một object sống suốt vòng đời module/tiến trình: pool, client, reporter, clock.
  • CompositionRootEntrypoint (plugin Nuxt, server entry, main.ts) khởi tạo instance với config thật và truyền xuống.
  • ClientCode nghiệp vụ. Nhận instance **làm tham số**, không import để tự đi lấy.
  • TestDoubleFake cùng interface, truyền vào đúng chỗ Client nhận — thay cho mock theo tên module.
   ✗ Bản phổ biến (dependency ẩn)
   ┌───────────────────────────────────────────┐
   │ OrderService  ──import──►  utils/db.ts    │  test import là
   │ CartService   ──import──►  (new Client)   │  nối DB thật
   └───────────────────────────────────────────┘

   ✓ Bản giữ lifecycle, bỏ global access

   Composition root (plugin / entry)
        │  initDb(config)         tạo lười, đúng 1 lần
        ▼
   ┌────────────────────┐   private constructor
   │ module "db"        │   ┌──────────────────────┐
   │  let db: DB        │──►│ DB instance (1)      │
   │  initDb()  getDb() │   └──────────────────────┘
   └─────────┬──────────┘
             │ createOrderService(db)   ← dependency nằm trong chữ ký
             ▼
   ┌──────────────────────────────┐
   │ OrderService(db: DbClient)   │  test: createOrderService(fakeDb)
   └──────────────────────────────┘

05 — Sửa tuỳ ý, chạy ngay tại đây

Chạy thử: singleton có kiểm soát, fake cho test, và state per-request

tsdemo.ts
interface KV {
  get(k: string): string
  set(k: string, v: string): void
}
class Store implements KV {
  static created = 0
  private m = new Map<string, string>()
  constructor() { Store.created++ }
  get(k: string) { return this.m.get(k) ?? '<null>' }
  set(k: string, v: string) { this.m.set(k, v) }
}

// getInstance: lần đầu mới tạo, các lần sau trả lại đúng object cũ
class Registry {
  private static self: Store | undefined
  static get(): Store {
    if (!Registry.self) Registry.self = new Store()
    return Registry.self
  }
}

Registry.get().set('a', '1')
console.log('1 same object =', Registry.get() === Registry.get(), '| Store đã tạo =', Store.created)

// Dependency Injection: hàm nhận KV, không tự đi lấy singleton
const dump = (kv: KV, keys: string[]) => keys.map(k => k + '=' + kv.get(k)).join(' ')
const store = Registry.get()
store.set('b', '2')
console.log('2 prod        :', dump(store, ['a', 'b']))

// Test fake: singleton thành đối số -> test không phải dọn global state
const fake: KV = { get: k => 'FAKE:' + k, set: () => {} }
console.log('3 test fake   :', dump(fake, ['a', 'b']))

// Server: module sống suốt tiến trình -> state phải tạo per-request
const perRequest = () => { const s = new Store(); s.set('user', 'u'); return s.get('user') }
console.log('4 per-request :', perRequest(), perRequest(), '| tổng Store đã tạo =', Store.created)
console
1 same object = true | Store đã tạo = 1
2 prod        : a=1 b=2
3 test fake   : a=FAKE:a b=FAKE:b
4 per-request : u u | tổng Store đã tạo = 3

Cùng code này chạy được bằng Bun: bun run demo.ts. Output in ra được kiểm tự động trong quá trình build site.

06 — Thành thật về cái giá

Khi nào dùng, khi nào đừng

Dùng khi

  • Tài nguyên tạo đắt và dùng chung có lợi: DB pool, driver, connection WebSocket, client SDK đã authenticate, thread/worker pool.
  • Tài nguyên chỉ được phép tồn tại một theo semantic: một AudioContext cho một tab, một sequence phát sinh ID, một reporter gom metric theo lô, một console writer để log không xen kẽ dòng.
  • Cần lazy: việc khởi tạo đắt hoặc phụ thuộc config, và app có thể chạy cả ngày mà không chạm tới nó (admin, export, payment).
  • Cần một điểm khởi tạo duy nhất để kiểm soát vòng đời: bật/tắt, đổi config lúc boot, đóng gracefully khi tiến trình nhận SIGTERM.
  • Trình duyệt: bạn thật sự chỉ có một document, một localStorage, một performance — Singleton ở đó là hiện thực khách quan, không phải lựa chọn.

Đừng dùng khi

  • Dependency ẩn là chi phí thật: caller không khai báo trong chữ ký, nên đọc code không thấy, grep không ra, đổi implementation phải sửa mọi nơi import, và refactor module thành package khác là công trình.
  • Test: instance sống dai làm test phụ thuộc thứ tự — test A ghi, test B đọc được dữ liệu của A. Bạn sẽ thêm reset()/clearCache() "chỉ để test", tức là vừa mở thêm một cửa phá vỡ tính đóng gói. Chữa bằng DI + fake, không chữa bằng --isolated.
  • Server: module scope chia sẻ giữa mọi request trong cùng tiến trình. State per-request (user, tenant, quota, language) đặt ở đó là rò rỉ dữ liệu giữa người dùng; cache module-scope không TTL là OOM từ từ. Serverless làm cả hai khó thấy hơn vì tiến trình ấm không đoán được.
  • getInstance(config) bỏ qua config của lần gọi thứ 2 im lặng. Nếu hai caller hợp lệ có thể đòi config khác nhau, đó không phải Singleton — đó là Factory, và bạn đang che một bug bằng một pattern.
  • Over-engineering: export const config = loadConfig() đã là Singleton. Đừng dựng class Config { static getInstance() } cho đủ bộ — bạn chỉ thêm một global accessor. Tương tự, đừng DI hoá một hàm thuần tuý 5 dòng không I/O: DI mua khả năng test/swap, không mua điểm thiết kế.
  • Hai module record là hai "singleton" (dual package ESM/CJS, hai copy trong node_modules, worker cùng realm). instanceof và Map key-based identity bắt đầu sai. Dựa vào interface, đừng dựa vào identity của class để rẽ nhánh.

07 — Bạn đã gặp nó rồi, chỉ là không gọi tên

Trong code thật

Prisma client singleton (khuyến cáo chính thức)

Docs của Prisma khuyên tạo một PrismaClient rồi export, và trong dev thì cất nó trên globalThis vì nodemon/ts-node-dev eval lại module khiến pool connection tăng tới mức hết limit. Đây chính là Singleton, và cũng chính là ví dụ "vòng đời dev khác prod".

axios default export

import axios from "axios" cho bạn một instance dùng chung. axios.defaults.headers.common.Authorization = ... ảnh hưởng tới mọi call trong tiến trình — tiện một cách nguy hiểm. Đó là lý do docs luôn khuyên axios.create(...) khi bạn cần config riêng: thoát Singleton khi Singleton thành global mutable.

Composable Vue: ref() ở module scope

Tài liệu Vue ("Sharing Composables State") chỉ đúng pattern này: ref() đặt ngoài function thì mọi component dùng chung state. Kèm cảnh báo SSR: state đó chia sẻ giữa các request, nên code an toàn là tạo ref() bên trong composable. Singleton là thứ bạn phải chọn có ý thức, không phải mặc định.

Nuxt/Nitro server: event.context và useRuntimeConfig

Nitro giữ đồ nặng (driver, pool) ở module scope để tái dùng giữa các request, nhưng mọi thứ thuộc về một request phải nằm trong event.context; useRuntimeConfig() là singleton của config, đọc lúc boot. Đúng ranh giới này thì HMR không phá, sai thì leak giữa người dùng.

Browser: AudioContext, localStorage, performance

Môi trường chỉ cung cấp một phiên bản, nên các lib audio giữ đúng một AudioContext trong module của họ (trình duyệt giới hạn số context đồng thời và sẽ cảnh báo). navigator.clipboard, window.matchMedia cũng một mình một chợ — Singleton không phải lựa chọn ở đây, nó là hợp đồng của platform.

08 — Tự tay làm

Bài tập

`orderService.ts` đang `import { db } from "~/utils/db"` rồi dùng `db.exec(...)`; test của nó bắt buộc `vi.mock("~/utils/db")` và hay fail khi chạy cả file. Refactor: service nhận dependency qua tham số với interface tối giản, giữ **default** là instance thật ở composition root, rồi viết lại test dùng fake mà không mock module nào.

Gợi ý, mở từng cái một:

  1. Liệt kê đúng những gì service gọi trên db — thường chỉ 2 method. Khai báo interface DbClient với đúng 2 method đó (interface segregation, và fake ngắn hơn nhiều).
  2. Chuyển từ class OrderService + import sang function createOrderService(db: DbClient). Muốn "ai cũng gọi được không cần truyền", cho tham số một default: db = getDb(). Wiring mặc định ở production, còn test thì truyền fake.
  3. Test: dựng const calls: string[] = [], fake exec chỉ push vào calls, rồi assert calls. Nếu bạn vẫn cần vi.mock, nghĩa là còn chỗ nào đó tự import để dùng lén.

Tách interface nhỏ, đưa dependency vào tham số của factory function, giữ default getDb() cho production. Production không đổi một dòng wiring nào; test mất toàn bộ mock và mất luôn sự phụ thuộc vào thứ tự chạy.

tsbai-tap.ts
// db.ts — composition root giữ phần "một instance"
export interface DbClient {
  exec(sql: string, ...args: unknown[]): Promise<void>
}
let real: DbClient | undefined
export function initDb(client: DbClient): void {
  if (real) throw new Error('initDb gọi 2 lần')
  real = client
}
export function getDb(): DbClient {
  if (!real) throw new Error('initDb chưa được gọi')
  return real
}

// order-service.ts — không import gì để dùng lén (đọc DbClient/getDb từ db.ts)
export const createOrderService = (db: DbClient = getDb()) => ({
  async cancel(id: string) {
    await db.exec('update orders set status = $1 where id = $2', 'cancel', id)
  },
})

// test — không vi.mock, không reset, chạy độc lập
const calls: string[] = []
const fake: DbClient = { exec: async (sql, ...a) => { calls.push(sql + ' [' + a.join(',') + ']') } }

await createOrderService(fake).cancel('o1')   // test: tự truyền dependency
initDb(fake)                                  // wiring: đúng MỘT lần, ở entry
await createOrderService().cancel('o2')       // không truyền -> lấy getDb()

console.log('số lệnh đã ghi:', calls.length, '| instance duy nhất:', getDb() === getDb())

09 — Đọc cặp để hiểu bản chất

Pattern liên quan

  • FacadeRất hay đi cặp: module singleton thường đi kèm một số function exported dễ dùng, thành Facade. Facade lo "API dễ gọi", Singleton lo "đúng một instance" — hai vấn đề khác nhau, đừng lẫn.
  • FlyweightCùng là "dùng chung instance", nhưng Flyweight dùng chung **nhiều** object nhỏ chia sẻ state bất biến, còn Singleton dùng chung **một** object cả đời. Flyweight tối ưu bộ nhớ; Singleton quản lifecycle.
  • ProxyProxy là chỗ tự nhiên để gói một singleton lười: `getInstance()` bên trong handler, lần gọi đầu tiên mới tạo instance thật. Virtual Proxy và lazy Singleton khác nhau chủ yếu ở tên gọi.
  • Abstract FactoryAbstract Factory chọn **họ** object theo môi trường (dev/test/prod), Singleton quyết định thứ được chọn tồn tại **một lần**. Cặp này hay gặp: driver thật cho prod, driver fake cho test, mỗi cái một instance.