Dependency Management Without the Container

import { db } from '../infra/db'        // connects at import time
import { stripe } from '../infra/stripe'

export async function expireTrials() {
  const cutoff = new Date()                // untestable boundary condition
  const orgs = await db.org.findMany({ where: { trialEndsAt: { lt: cutoff } } })
  for (const o of orgs) await stripe.subscriptions.cancel(o.subId)
}

type Deps = {
  orgs: { findExpiredTrials(at: Date): Promise<Org[]> }
  billing: { cancel(subId: string): Promise<void> }   // narrow: one method, not the SDK
  now: () => Date
}

export async function expireTrials(deps: Deps) {
  const orgs = await deps.orgs.findExpiredTrials(deps.now())
  for (const o of orgs) await deps.billing.cancel(o.subId)
}

The first version connects to a database as a side effect of being imported, which means a test that imports it connects too, and a malformed connection string is discovered on the first request rather than at boot. The second can be run against a replica by passing a different orgs, tested with a two-line fake because billing has one method rather than an SDK's surface, and tested at a month boundary because now is a value. None of that required a framework — only a parameter.

1async function main() {
2  const cfg = loadConfig(process.env)      // throws on a missing or malformed value
3 
4  // construct eagerly: a bad credential fails the boot, not the first request
5  const pool    = new Pool({ connectionString: cfg.databaseUrl, max: cfg.poolSize })
6  await pool.query('select 1')             // prove it before accepting traffic
7  const payments = makeStripeBilling(cfg.stripeKey, { timeoutMs: 3000 })
8  const clock    = () => new Date()
9 
10  const deps = {
11    db: pool,
12    orgs: makeOrgRepository(pool),
13    billing: payments,                     // narrowed to { charge, cancel } by the factory
14    now: clock,
15  }
16 
17  const app = buildApp(deps)               // handlers close over deps; nothing imports them
18  const server = app.listen(cfg.port)
19 
20  onShutdown(async () => {                 // the root also owns teardown
21    server.close()
22    await pool.end()
23  })
24}
25 
26main().catch((err) => { logger.fatal({ err }, 'startup failed'); process.exit(1) })

Three properties come from this shape and not from any framework: configuration is validated before anything connects, the process exits rather than serving traffic in a broken state, and shutdown has an owner that knows what was opened (Graceful Shutdown).