Backend Architecture Bun · ElysiaJS · Drizzle · TypeScript

import { sqliteTable, text, real, integer } from 'drizzle-orm/sqlite-core'
import { sql } from 'drizzle-orm'

export const users = sqliteTable('users', {
  id:           text('id').primaryKey().$defaultFn(
                  () => crypto.randomUUID()),
  email:        text('email').notNull().unique(),
  name:         text('name').notNull(),
  passwordHash: text('password_hash').notNull(),
  role:         text('role', {
                  enum: ['admin', 'user', 'moderator']
                }).notNull().default('user'),
  createdAt:    integer('created_at', { mode: 'timestamp' })
                .notNull().default(sql`(unixepoch())`),
})

export const products = sqliteTable('products', {
  id:        text('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
  name:      text('name').notNull(),
  price:     real('price').notNull(),
  sku:       text('sku').notNull().unique(),
  createdBy: text('created_by').references(() => users.id),
  createdAt: integer('created_at', { mode: 'timestamp' })
              .notNull().default(sql`(unixepoch())`),
})

// Type inference — zero manual interface duplication
export type UserRow    = typeof users.$inferSelect
export type NewUser    = typeof users.$inferInsert
export type ProductRow = typeof products.$inferSelect

import { drizzle } from 'drizzle-orm/bun-sqlite'
import { Database } from 'bun:sqlite'
import * as schema from './schema'
import { config } from '../config'

// Bun.sqlite is built-in — zero native deps
const sqlite = new Database(config.DATABASE_URL, {
  create: true,
  readwrite: true,
})

// Enable WAL mode for concurrent reads
sqlite.exec('PRAGMA journal_mode=WAL;')
sqlite.exec('PRAGMA foreign_keys=ON;')

export const db = drizzle(sqlite, { schema, logger: true })
export type DB = typeof db

// For PostgreSQL production — swap the driver:
// import { drizzle } from 'drizzle-orm/postgres-js'
// import postgres from 'postgres'
// export const db = drizzle(postgres(config.DATABASE_URL))

import { eq, ilike, count, sql } from 'drizzle-orm'
import { db } from '../../infrastructure/database/db'
import { users } from '../../infrastructure/database/schema'
import type { IUserRepository, ListOptions } from '../../domain/repositories/IUserRepository'
import { NotFoundError } from '../../domain/errors/AppError'

export class UserRepository implements IUserRepository {

  async findById(id: string) {
    return db.query.users.findFirst({
      where: eq(users.id, id)
    }) ?? null
  }

  async findByEmail(email: string) {
    return db.query.users.findFirst({
      where: eq(users.email, email)
    }) ?? null
  }

  async create(data: NewUser) {
    const [row] = await db.insert(users).values(data).returning()
    return row
  }

  async list({ page = 1, limit = 20, search }: ListOptions) {
    const offset = (page - 1) * limit
    const where = search ? ilike(users.name, `%${search}%`) : undefined
    const [data, [{ total }]] = await Promise.all([
      db.select().from(users).where(where).limit(limit).offset(offset),
      db.select({ total: count() }).from(users).where(where),
    ])
    return { data, total, page, pages: Math.ceil(total / limit) }
  }
}

import { Redis } from 'ioredis'
import { config } from './config'

export const redis = new Redis(config.REDIS_URL, {
  maxRetriesPerRequest: 3,
  lazyConnect: true,
})

// Generic typed cache helper
export async function cached<T>(
  key: string,
  ttlSeconds: number,
  fetcher: () => Promise<T>,
): Promise<T> {
  const hit = await redis.get(key)
  if (hit) return JSON.parse(hit) as T

  const value = await fetcher()
  await redis.setex(key, ttlSeconds, JSON.stringify(value))
  return value
}

// In a service:
// return cached(`user:${id}`, 300, () => this.userRepo.findById(id))

import pino from 'pino'
import { config } from './config'

export const logger = pino({
  level: config.NODE_ENV === 'production' ? 'info' : 'debug',
  transport: config.NODE_ENV !== 'production'
    ? { target: 'pino-pretty', options: { colorize: true } }
    : undefined,
  // Structured fields on every log
  base: {
    env:     config.NODE_ENV,
    service: 'api',
    version: process.env.npm_package_version,
  },
  // Redact sensitive fields
  redact: ['body.password', 'headers.authorization'],
})

// Request logging Elysia plugin
export const loggerPlugin = new Elysia()
  .onRequest(({ request }) => {
    logger.info({ method: request.method, url: request.url }, '→ request')
  })
  .onAfterHandle(({ request, set }) => {
    logger.info({ status: set.status, url: request.url }, '← response')
  })

import { describe, it, expect, beforeAll } from 'bun:test'
import { treaty } from '@elysiajs/eden'
import { app }   from '../index'

// Eden Treaty gives fully typed test client
const api = treaty(app)

describe('Auth', () => {
  it('registers a new user', async () => {
    const { data, error } = await api.auth.register.post({
      email:    'test@example.com',
      name:     'Test User',
      password: 'SecurePass123!',
    })
    expect(error).toBeNull()
    expect(data?.email).toBe('test@example.com')
  })

  it('rejects duplicate email', async () => {
    const { error } = await api.auth.register.post({
      email: 'test@example.com',   // same email
      name: 'Another', password: 'Pass123!',
    })
    expect(error?.status).toBe(409)
  })

  it('logs in and returns access token', async () => {
    const { data } = await api.auth.login.post({
      email:    'test@example.com',
      password: 'SecurePass123!',
    })
    expect(data?.accessToken).toBeDefined()
  })
})