Design patterns in 2026 vs Nuxt

export default defineNitroPlugin((nitro) => {
  nitro.hooks.hook('request', (event) => {
    // Observes every incoming request
    console.log(`[${new Date().toISOString()}] ${event.method} ${event.path}`)
  })
})

import { drizzle } from 'drizzle-orm/better-sqlite3'
import Database from 'better-sqlite3'

// One connection, created once, reused for the lifetime of the server
const sqlite = new Database('sqlite.db')
const db = drizzle(sqlite)

// Expose via a function so callers don't hold a reference to the module
export default defineNitroPlugin(() => {
  // db is effectively a singleton - initialized once, shared everywhere
})

import { drizzle } from 'drizzle-orm/better-sqlite3'
import Database from 'better-sqlite3'

// In Nitro, top-level module state IS a singleton
// This runs once per server process
const sqlite = new Database(process.env.DB_PATH!)
export const db = drizzle(sqlite)

import { db } from '../utils/db'

export default defineEventHandler(async () => {
  return db.select().from(users).all()
})

interface PaymentProvider {
  charge(amount: number, currency: string, token: string): Promise<{ id: string }>
  refund(chargeId: string): Promise<void>
}

class StripeProvider implements PaymentProvider {
  async charge(amount: number, currency: string, token: string) {
    const stripe = new Stripe(process.env.STRIPE_KEY!)
    const charge = await stripe.paymentIntents.create({ amount, currency, payment_method: token, confirm: true })
    return { id: charge.id }
  }
  async refund(chargeId: string) {
    const stripe = new Stripe(process.env.STRIPE_KEY!)
    await stripe.refunds.create({ payment_intent: chargeId })
  }
}

class MollieProvider implements PaymentProvider {
  async charge(amount: number, currency: string, token: string) {
    // mollie implementation
    return { id: 'mollie_123' }
  }
  async refund(chargeId: string) { /* ... */ }
}

// Factory - decides which provider based on config
export function createPaymentProvider(): PaymentProvider {
  const provider = process.env.PAYMENT_PROVIDER ?? 'stripe'
  if (provider === 'stripe') return new StripeProvider()
  if (provider === 'mollie') return new MollieProvider()
  throw new Error(`Unknown payment provider: ${provider}`)
}

import { createPaymentProvider } from '../lib/payment'

export default defineEventHandler(async (event) => {
  const { amount, token } = await readBody(event)
  const payment = createPaymentProvider() // doesn't know or care which one
  return await payment.charge(amount, 'eur', token)
})

export default defineEventHandler(async (event) => {
  const { tag, author, limit = 20, page = 0 } = getQuery(event)

  let query = queryCollection('blog').order('date', 'DESC')

  // Conditionally add filters - much cleaner than building SQL strings
  if (tag) query = query.where('tags', 'LIKE', `%${tag}%`)
  if (author) query = query.where('author', '==', author)

  return query.limit(Number(limit)).skip(Number(page) * Number(limit)).find()
})

// Instead of a Strategy class hierarchy, just type the function
type AuthStrategy = (event: H3Event) => Promise<User | null>

const jwtStrategy: AuthStrategy = async (event) => {
  const token = getHeader(event, 'authorization')?.replace('Bearer ', '')
  if (!token) return null
  return verifyJwt(token)
}

const sessionStrategy: AuthStrategy = async (event) => {
  const sessionId = getCookie(event, 'session_id')
  if (!sessionId) return null
  return sessionStore.get(sessionId)
}

const apiKeyStrategy: AuthStrategy = async (event) => {
  const key = getHeader(event, 'x-api-key')
  if (!key) return null
  return db.select().from(apiKeys).where(eq(apiKeys.key, key)).get()?.user ?? null
}

import { jwtStrategy, sessionStrategy, apiKeyStrategy } from '../lib/auth'

// Strategies tried in order - first one that returns a user wins
const strategies = [jwtStrategy, sessionStrategy, apiKeyStrategy]

export default defineEventHandler(async (event) => {
  for (const strategy of strategies) {
    const user = await strategy(event)
    if (user) {
      event.context.user = user
      return
    }
  }
  // No strategy matched - user is unauthenticated
})

// Adds timing to any handler
export function withTiming(handler: EventHandler): EventHandler {
  return defineEventHandler(async (event) => {
    const start = performance.now()
    const result = await handler(event)
    const duration = performance.now() - start
    setResponseHeader(event, 'X-Response-Time', `${duration.toFixed(2)}ms`)
    return result
  })
}

// Requires authentication
export function withAuth(handler: EventHandler): EventHandler {
  return defineEventHandler(async (event) => {
    if (!event.context.user) {
      throw createError({ statusCode: 401, message: 'Unauthorized' })
    }
    return handler(event)
  })
}

// Combine multiple decorators
export function pipe(...decorators: Array<(h: EventHandler) => EventHandler>) {
  return (handler: EventHandler) => decorators.reduceRight((h, d) => d(h), handler)
}

import { withAuth, withTiming, pipe } from '../utils/decorators'

const handler = defineEventHandler(async () => {
  return db.select().from(users).all()
})

// Apply both decorators - clean, composable, no modification to handler
export default pipe(withAuth, withTiming)(handler)

// Your interface - stable, controlled by you
export interface EmailService {
  send(opts: { to: string; subject: string; html: string }): Promise<void>
}

// Adapter for Resend
export class ResendAdapter implements EmailService {
  private client: Resend

  constructor() {
    this.client = new Resend(process.env.RESEND_API_KEY!)
  }

  async send({ to, subject, html }: { to: string; subject: string; html: string }) {
    await this.client.emails.send({
      from: '[email protected]',
      to,
      subject,
      html,
      // Resend has different field names, extra options - adapter handles that
    })
  }
}

// Adapter for Nodemailer (SMTP - legacy systems)
export class SmtpAdapter implements EmailService {
  private transporter: nodemailer.Transporter

  constructor() {
    this.transporter = nodemailer.createTransport({
      host: process.env.SMTP_HOST,
      port: Number(process.env.SMTP_PORT),
      auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS },
    })
  }

  async send({ to, subject, html }: { to: string; subject: string; html: string }) {
    await this.transporter.sendMail({ from: process.env.SMTP_FROM, to, subject, html })
  }
}

import { ResendAdapter, SmtpAdapter } from './adapters/email'

// Swap providers with one config change
export const email = process.env.EMAIL_PROVIDER === 'smtp'
  ? new SmtpAdapter()
  : new ResendAdapter()

import { email } from '../../lib/email' // doesn't know or care which provider

export default defineEventHandler(async (event) => {
  const user = await createUser(await readBody(event))
  // Works with any EmailService implementation
  await email.send({
    to: user.email,
    subject: 'Welcome',
    html: `<p>Hi ${user.name}</p>`,
  })
  return { success: true }
})

// The CRM API returns objects like { ContactData: { first_name_field: '...' } }
// Your code wants { name: string, email: string }

export class HubSpotAdapter {
  async getContact(id: string): Promise<{ name: string; email: string }> {
    const raw = await $fetch(`https://api.hubapi.com/contacts/v1/contact/vid/${id}/profile`, {
      headers: { Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}` },
    })
    // Translate their weird shape to yours
    return {
      name: `${raw.properties.firstname.value} ${raw.properties.lastname.value}`,
      email: raw.properties.email.value,
    }
  }
}