src/
├── domains/                 # Bounded contexts by business domain
│   ├── user/               # User domain example
│   │   ├── domain/         # Core domain logic (framework-agnostic)
│   │   │   ├── entities/
│   │   │   │   └── User.ts
│   │   │   ├── value-objects/
│   │   │   │   └── Email.ts
│   │   │   ├── aggregates/
│   │   │   │   └── UserAggregate.ts
│   │   │   ├── services/
│   │   │   │   └── UserDomainService.ts
│   │   │   └── types.ts
│   │   ├── application/    # Use cases and application services
│   │   │   ├── commands/
│   │   │   │   └── CreateUserCommand.ts
│   │   │   ├── queries/
│   │   │   │   └── GetUserQuery.ts
│   │   │   └── services/
│   │   │       └── UserApplicationService.ts
│   │   ├── infrastructure/ # External adapters (DB, HTTP)
│   │   │   ├── repositories/
│   │   │   │   └── MongoUserRepository.ts
│   │   │   ├── schemas/
│   │   │   │   └── userSchema.ts
│   │   │   └── controllers/
│   │   │       └── userController.ts
│   │   └── index.ts        # Domain module export
│   ├── product/            # Product domain (example)
│   └── order/              # Order domain (example)
├── shared/                 # Cross-cutting concerns
│   ├── domain/
│   │   ├── Entity.ts       # Base entity class
│   │   ├── ValueObject.ts  # Base value object class
│   │   ├── AggregateRoot.ts
│   │   └── DomainEvent.ts
│   ├── infrastructure/
│   │   ├── mongodb.ts      # MongoDB connection
│   │   ├── auth.ts         # Better Auth setup
│   │   └── logger.ts
│   └── kernel/             # Repository interfaces, base types
│       └── repositories/
│           └── Repository.ts
├── modules/                # Elysia entry points (thin controllers)
│   ├── userModule.ts
│   └── index.ts
└── index.ts                # App entry point

MongoDB + Mongoose Setup

Connection Configuration

// shared/infrastructure/mongodb.ts
import mongoose from 'mongoose';

const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/myapp';

declare global {
  var mongooseConnection: typeof mongoose | undefined;
}

export async function connectDB(): Promise<typeof mongoose> {
  if (globalThis.mongooseConnection) {
    return globalThis.mongooseConnection;
  }

  try {
    const connection = await mongoose.connect(MONGODB_URI, {
      bufferCommands: false,
    });

    if (process.env.NODE_ENV !== 'production') {
      globalThis.mongooseConnection = connection;
    }

    console.log('MongoDB connected successfully');
    return connection;
  } catch (error) {
    console.error('MongoDB connection error:', error);
    throw error;
  }
}

export async function disconnectDB(): Promise<void> {
  await mongoose.disconnect();
  globalThis.mongooseConnection = undefined;
}

export { mongoose };

Mongoose Schema Definition

// domains/user/infrastructure/schemas/userSchema.ts
import { Schema, model, Document, Types } from 'mongoose';

export interface IUserDocument extends Document {
  _id: Types.ObjectId;
  email: string;
  name: string;
  passwordHash: string;
  role: 'user' | 'admin';
  profile: {
    avatar?: string;
    bio?: string;
  };
  preferences: {
    notifications: boolean;
    theme: 'light' | 'dark';
  };
  createdAt: Date;
  updatedAt: Date;
}

const userSchema = new Schema<IUserDocument>(
  {
    email: {
      type: String,
      required: true,
      unique: true,
      lowercase: true,
      trim: true,
      index: true,
    },
    name: {
      type: String,
      required: true,
      trim: true,
      minlength: 2,
      maxlength: 100,
    },
    passwordHash: {
      type: String,
      required: true,
      select: false, // Don't include by default in queries
    },
    role: {
      type: String,
      enum: ['user', 'admin'],
      default: 'user',
    },
    profile: {
      avatar: String,
      bio: { type: String, maxlength: 500 },
    },
    preferences: {
      notifications: { type: Boolean, default: true },
      theme: { type: String, enum: ['light', 'dark'], default: 'light' },
    },
  },
  {
    timestamps: true,
    toJSON: {
      virtuals: true,
      transform: (_, ret) => {
        ret.id = ret._id.toString();
        delete ret._id;
        delete ret.__v;
        delete ret.passwordHash;
        return ret;
      },
    },
  }
);

// Indexes for performance
userSchema.index({ createdAt: -1 });
userSchema.index({ name: 'text', email: 'text' }); // Text search

// Virtual for full display name
userSchema.virtual('displayName').get(function () {
  return this.name;
});

// Instance methods
userSchema.methods.isAdmin = function (): boolean {
  return this.role === 'admin';
};

// Static methods
userSchema.statics.findByEmail = function (email: string) {
  return this.findOne({ email: email.toLowerCase() });
};

export const UserModel = model<IUserDocument>('User', userSchema);

Domain Layer (Pure Business Logic)

Entity Base Class

// shared/domain/Entity.ts
import { Types } from 'mongoose';

export abstract class Entity<T> {
  protected readonly _id: string;
  protected props: T;

  constructor(props: T, id?: string) {
    this._id = id ?? new Types.ObjectId().toString();
    this.props = props;
  }

  get id(): string {
    return this._id;
  }

  equals(entity: Entity<T>): boolean {
    return this._id === entity._id;
  }
}

Value Object Base Class

// shared/domain/ValueObject.ts
export abstract class ValueObject<T> {
  protected readonly props: T;

  constructor(props: T) {
    this.props = Object.freeze(props);
  }

  equals(vo: ValueObject<T>): boolean {
    return JSON.stringify(this.props) === JSON.stringify(vo.props);
  }
}

User Entity

// domains/user/domain/entities/User.ts
import { Entity } from '@/shared/domain/Entity';
import { Email } from '../value-objects/Email';

export interface UserProps {
  email: Email;
  name: string;
  passwordHash: string;
  role: 'user' | 'admin';
  profile: {
    avatar?: string;
    bio?: string;
  };
  preferences: {
    notifications: boolean;
    theme: 'light' | 'dark';
  };
  createdAt: Date;
  updatedAt: Date;
}

export class User extends Entity<UserProps> {
  get email(): Email {
    return this.props.email;
  }

  get name(): string {
    return this.props.name;
  }

  get role(): 'user' | 'admin' {
    return this.props.role;
  }

  get profile() {
    return this.props.profile;
  }

  get preferences() {
    return this.props.preferences;
  }

  isAdmin(): boolean {
    return this.props.role === 'admin';
  }

  updateEmail(newEmail: Email): void {
    this.props.email = newEmail;
    this.props.updatedAt = new Date();
  }

  updateName(newName: string): void {
    if (newName.length < 2) {
      throw new Error('Name must be at least 2 characters');
    }
    this.props.name = newName;
    this.props.updatedAt = new Date();
  }

  updateProfile(profile: Partial<UserProps['profile']>): void {
    this.props.profile = { ...this.props.profile, ...profile };
    this.props.updatedAt = new Date();
  }

  updatePreferences(preferences: Partial<UserProps['preferences']>): void {
    this.props.preferences = { ...this.props.preferences, ...preferences };
    this.props.updatedAt = new Date();
  }

  promoteToAdmin(): void {
    this.props.role = 'admin';
    this.props.updatedAt = new Date();
  }

  static create(
    props: Omit<UserProps, 'createdAt' | 'updatedAt' | 'role' | 'profile' | 'preferences'> &
           Partial<Pick<UserProps, 'role' | 'profile' | 'preferences'>>,
    id?: string
  ): User {
    return new User({
      ...props,
      role: props.role ?? 'user',
      profile: props.profile ?? {},
      preferences: props.preferences ?? { notifications: true, theme: 'light' },
      createdAt: new Date(),
      updatedAt: new Date(),
    }, id);
  }
}

Email Value Object

// domains/user/domain/value-objects/Email.ts
import { ValueObject } from '@/shared/domain/ValueObject';

interface EmailProps {
  value: string;
}

export class Email extends ValueObject<EmailProps> {
  get value(): string {
    return this.props.value;
  }

  private static isValidEmail(email: string): boolean {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  static create(email: string): Email {
    if (!this.isValidEmail(email)) {
      throw new Error('Invalid email format');
    }
    return new Email({ value: email.toLowerCase().trim() });
  }
}

Domain Service

// domains/user/domain/services/UserDomainService.ts
export class UserDomainService {
  static async hashPassword(password: string): Promise<string> {
    return await Bun.password.hash(password, {
      algorithm: 'argon2id',
      memoryCost: 65536,
      timeCost: 3,
    });
  }

  static async verifyPassword(password: string, hash: string): Promise<boolean> {
    return await Bun.password.verify(password, hash);
  }

  static validatePasswordStrength(password: string): { valid: boolean; errors: string[] } {
    const errors: string[] = [];

    if (password.length < 8) {
      errors.push('Password must be at least 8 characters');
    }
    if (!/[A-Z]/.test(password)) {
      errors.push('Password must contain at least one uppercase letter');
    }
    if (!/[a-z]/.test(password)) {
      errors.push('Password must contain at least one lowercase letter');
    }
    if (!/[0-9]/.test(password)) {
      errors.push('Password must contain at least one number');
    }

    return { valid: errors.length === 0, errors };
  }
}

Application Layer (Use Cases)

Create User Command

// domains/user/application/commands/CreateUserCommand.ts
import { User } from '../../domain/entities/User';
import { Email } from '../../domain/value-objects/Email';
import { UserDomainService } from '../../domain/services/UserDomainService';
import type { UserRepository } from '@/shared/kernel/repositories/UserRepository';

export interface CreateUserInput {
  email: string;
  name: string;
  password: string;
}

export interface CreateUserOutput {
  id: string;
  email: string;
  name: string;
  role: string;
}

export class CreateUserCommand {
  constructor(private readonly userRepository: UserRepository) {}

  async execute(input: CreateUserInput): Promise<CreateUserOutput> {
    // Validate password strength
    const passwordValidation = UserDomainService.validatePasswordStrength(input.password);
    if (!passwordValidation.valid) {
      throw new Error(passwordValidation.errors.join(', '));
    }

    // Check if email already exists
    const existingUser = await this.userRepository.findByEmail(input.email);
    if (existingUser) {
      throw new Error('User with this email already exists');
    }

    // Create domain objects
    const email = Email.create(input.email);
    const passwordHash = await UserDomainService.hashPassword(input.password);

    // Create user entity
    const user = User.create({
      email,
      name: input.name,
      passwordHash,
    });

    // Persist
    await this.userRepository.save(user);

    return {
      id: user.id,
      email: user.email.value,
      name: user.name,
      role: user.role,
    };
  }
}

Update User Command

// domains/user/application/commands/UpdateUserCommand.ts
import { Email } from '../../domain/value-objects/Email';
import type { UserRepository } from '@/shared/kernel/repositories/UserRepository';

export interface UpdateUserInput {
  userId: string;
  name?: string;
  email?: string;
  profile?: {
    avatar?: string;
    bio?: string;
  };
  preferences?: {
    notifications?: boolean;
    theme?: 'light' | 'dark';
  };
}

export class UpdateUserCommand {
  constructor(private readonly userRepository: UserRepository) {}

  async execute(input: UpdateUserInput): Promise<void> {
    const user = await this.userRepository.findById(input.userId);
    if (!user) {
      throw new Error('User not found');
    }

    if (input.name) {
      user.updateName(input.name);
    }

    if (input.email) {
      const newEmail = Email.create(input.email);
      // Check if new email is already taken by another user
      const existingUser = await this.userRepository.findByEmail(input.email);
      if (existingUser && existingUser.id !== user.id) {
        throw new Error('Email is already in use');
      }
      user.updateEmail(newEmail);
    }

    if (input.profile) {
      user.updateProfile(input.profile);
    }

    if (input.preferences) {
      user.updatePreferences(input.preferences);
    }

    await this.userRepository.save(user);
  }
}

Get User Query

// domains/user/application/queries/GetUserQuery.ts
import type { User } from '../../domain/entities/User';
import type { UserRepository } from '@/shared/kernel/repositories/UserRepository';

export interface UserDTO {
  id: string;
  email: string;
  name: string;
  role: string;
  profile: {
    avatar?: string;
    bio?: string;
  };
  preferences: {
    notifications: boolean;
    theme: 'light' | 'dark';
  };
  createdAt: Date;
}

export class GetUserQuery {
  constructor(private readonly userRepository: UserRepository) {}

  async execute(userId: string): Promise<UserDTO | null> {
    const user = await this.userRepository.findById(userId);
    return user ? this.toDTO(user) : null;
  }

  async executeByEmail(email: string): Promise<UserDTO | null> {
    const user = await this.userRepository.findByEmail(email);
    return user ? this.toDTO(user) : null;
  }

  private toDTO(user: User): UserDTO {
    return {
      id: user.id,
      email: user.email.value,
      name: user.name,
      role: user.role,
      profile: user.profile,
      preferences: user.preferences,
      createdAt: user.props.createdAt,
    };
  }
}

Search Users Query

// domains/user/application/queries/SearchUsersQuery.ts
import type { UserRepository, SearchOptions } from '@/shared/kernel/repositories/UserRepository';
import type { UserDTO } from './GetUserQuery';

export interface SearchUsersInput {
  query?: string;
  role?: 'user' | 'admin';
  page?: number;
  limit?: number;
  sortBy?: 'name' | 'email' | 'createdAt';
  sortOrder?: 'asc' | 'desc';
}

export interface SearchUsersOutput {
  users: UserDTO[];
  total: number;
  page: number;
  totalPages: number;
}

export class SearchUsersQuery {
  constructor(private readonly userRepository: UserRepository) {}

  async execute(input: SearchUsersInput): Promise<SearchUsersOutput> {
    const page = input.page ?? 1;
    const limit = input.limit ?? 20;

    const options: SearchOptions = {
      query: input.query,
      role: input.role,
      skip: (page - 1) * limit,
      limit,
      sortBy: input.sortBy ?? 'createdAt',
      sortOrder: input.sortOrder ?? 'desc',
    };

    const { users, total } = await this.userRepository.search(options);

    return {
      users: users.map(user => ({
        id: user.id,
        email: user.email.value,
        name: user.name,
        role: user.role,
        profile: user.profile,
        preferences: user.preferences,
        createdAt: user.props.createdAt,
      })),
      total,
      page,
      totalPages: Math.ceil(total / limit),
    };
  }
}

Infrastructure Layer (MongoDB Repository)

Repository Interface

// shared/kernel/repositories/UserRepository.ts
import type { User } from '@/domains/user/domain/entities/User';
import type { Repository } from './Repository';

export interface SearchOptions {
  query?: string;
  role?: 'user' | 'admin';
  skip?: number;
  limit?: number;
  sortBy?: string;
  sortOrder?: 'asc' | 'desc';
}

export interface SearchResult<T> {
  users: T[];
  total: number;
}

export interface UserRepository extends Repository<User> {
  findByEmail(email: string): Promise<User | null>;
  search(options: SearchOptions): Promise<SearchResult<User>>;
  countByRole(role: 'user' | 'admin'): Promise<number>;
}

MongoDB Repository Implementation

// domains/user/infrastructure/repositories/MongoUserRepository.ts
import { User } from '../../domain/entities/User';
import { Email } from '../../domain/value-objects/Email';
import { UserModel, type IUserDocument } from '../schemas/userSchema';
import type { UserRepository, SearchOptions, SearchResult } from '@/shared/kernel/repositories/UserRepository';
import type { FilterQuery } from 'mongoose';

export class MongoUserRepository implements UserRepository {
  async save(user: User): Promise<void> {
    const data = this.toPersistence(user);

    await UserModel.findByIdAndUpdate(
      user.id,
      { $set: data },
      { upsert: true, new: true }
    );
  }

  async findById(id: string): Promise<User | null> {
    const doc = await UserModel.findById(id).select('+passwordHash');
    return doc ? this.toDomain(doc) : null;
  }

  async findByEmail(email: string): Promise<User | null> {
    const doc = await UserModel.findOne({
      email: email.toLowerCase()
    }).select('+passwordHash');
    return doc ? this.toDomain(doc) : null;
  }

  async delete(id: string): Promise<void> {
    await UserModel.findByIdAndDelete(id);
  }

  async search(options: SearchOptions): Promise<SearchResult<User>> {
    const filter: FilterQuery<IUserDocument> = {};

    // Text search
    if (options.query) {
      filter.$text = { $search: options.query };
    }

    // Role filter
    if (options.role) {
      filter.role = options.role;
    }

    // Build sort
    const sort: Record<string, 1 | -1> = {};
    if (options.sortBy) {
      sort[options.sortBy] = options.sortOrder === 'asc' ? 1 : -1;
    }

    const [docs, total] = await Promise.all([
      UserModel.find(filter)
        .sort(sort)
        .skip(options.skip ?? 0)
        .limit(options.limit ?? 20)
        .select('+passwordHash'),
      UserModel.countDocuments(filter),
    ]);

    return {
      users: docs.map(doc => this.toDomain(doc)),
      total,
    };
  }

  async countByRole(role: 'user' | 'admin'): Promise<number> {
    return UserModel.countDocuments({ role });
  }

  async exists(id: string): Promise<boolean> {
    const count = await UserModel.countDocuments({ _id: id });
    return count > 0;
  }

  private toDomain(doc: IUserDocument): User {
    return new User(
      {
        email: Email.create(doc.email),
        name: doc.name,
        passwordHash: doc.passwordHash,
        role: doc.role,
        profile: doc.profile ?? {},
        preferences: doc.preferences ?? { notifications: true, theme: 'light' },
        createdAt: doc.createdAt,
        updatedAt: doc.updatedAt,
      },
      doc._id.toString()
    );
  }

  private toPersistence(user: User): Partial<IUserDocument> {
    return {
      _id: user.id as any,
      email: user.email.value,
      name: user.name,
      passwordHash: user.props.passwordHash,
      role: user.role,
      profile: user.profile,
      preferences: user.preferences,
      updatedAt: new Date(),
    };
  }
}

Module Layer (Elysia Controllers)

User Module

// modules/userModule.ts
import { Elysia, t } from 'elysia';
import { CreateUserCommand } from '@/domains/user/application/commands/CreateUserCommand';
import { UpdateUserCommand } from '@/domains/user/application/commands/UpdateUserCommand';
import { GetUserQuery } from '@/domains/user/application/queries/GetUserQuery';
import { SearchUsersQuery } from '@/domains/user/application/queries/SearchUsersQuery';
import { MongoUserRepository } from '@/domains/user/infrastructure/repositories/MongoUserRepository';
import { auth } from '@/shared/infrastructure/auth';

// Create repository instance
const userRepository = new MongoUserRepository();

export const userModule = new Elysia({ prefix: '/users' })
  // Auth derive
  .derive(async ({ headers }) => {
    const session = await auth.api.getSession({ headers });
    return { session };
  })

  // Create user (public)
  .post('/', async ({ body, status }) => {
    try {
      const command = new CreateUserCommand(userRepository);
      return await command.execute(body);
    } catch (error) {
      if (error instanceof Error) {
        return status(400, { error: error.message });
      }
      throw error;
    }
  }, {
    body: t.Object({
      email: t.String({ format: 'email' }),
      name: t.String({ minLength: 2, maxLength: 100 }),
      password: t.String({ minLength: 8 }),
    }),
  })

  // Search users (protected)
  .get('/', async ({ query, session, status }) => {
    if (!session) {
      return status(401, { error: 'Unauthorized' });
    }

    const searchQuery = new SearchUsersQuery(userRepository);
    return await searchQuery.execute({
      query: query.q,
      role: query.role as 'user' | 'admin' | undefined,
      page: query.page ? parseInt(query.page) : undefined,
      limit: query.limit ? parseInt(query.limit) : undefined,
      sortBy: query.sortBy as 'name' | 'email' | 'createdAt' | undefined,
      sortOrder: query.sortOrder as 'asc' | 'desc' | undefined,
    });
  }, {
    query: t.Object({
      q: t.Optional(t.String()),
      role: t.Optional(t.String()),
      page: t.Optional(t.String()),
      limit: t.Optional(t.String()),
      sortBy: t.Optional(t.String()),
      sortOrder: t.Optional(t.String()),
    }),
  })

  // Get user by ID (protected)
  .get('/:id', async ({ params, session, status }) => {
    if (!session) {
      return status(401, { error: 'Unauthorized' });
    }

    const query = new GetUserQuery(userRepository);
    const user = await query.execute(params.id);

    if (!user) {
      return status(404, { error: 'User not found' });
    }

    return user;
  }, {
    params: t.Object({
      id: t.String(),
    }),
  })

  // Update user (protected, own profile only)
  .patch('/:id', async ({ params, body, session, status }) => {
    if (!session) {
      return status(401, { error: 'Unauthorized' });
    }

    // Users can only update their own profile (unless admin)
    if (session.user.id !== params.id && session.user.role !== 'admin') {
      return status(403, { error: 'Forbidden' });
    }

    try {
      const command = new UpdateUserCommand(userRepository);
      await command.execute({
        userId: params.id,
        ...body,
      });
      return { success: true };
    } catch (error) {
      if (error instanceof Error) {
        return status(400, { error: error.message });
      }
      throw error;
    }
  }, {
    params: t.Object({
      id: t.String(),
    }),
    body: t.Object({
      name: t.Optional(t.String({ minLength: 2, maxLength: 100 })),
      email: t.Optional(t.String({ format: 'email' })),
      profile: t.Optional(t.Object({
        avatar: t.Optional(t.String()),
        bio: t.Optional(t.String({ maxLength: 500 })),
      })),
      preferences: t.Optional(t.Object({
        notifications: t.Optional(t.Boolean()),
        theme: t.Optional(t.Union([t.Literal('light'), t.Literal('dark')])),
      })),
    }),
  })

  // Delete user (admin only)
  .delete('/:id', async ({ params, session, status }) => {
    if (!session) {
      return status(401, { error: 'Unauthorized' });
    }

    if (session.user.role !== 'admin') {
      return status(403, { error: 'Admin access required' });
    }

    await userRepository.delete(params.id);
    return { success: true };
  }, {
    params: t.Object({
      id: t.String(),
    }),
  })

  // Get current user
  .get('/me', async ({ session, status }) => {
    if (!session) {
      return status(401, { error: 'Unauthorized' });
    }

    const query = new GetUserQuery(userRepository);
    return await query.execute(session.user.id);
  });

Better Auth Setup with MongoDB

// shared/infrastructure/auth.ts
import { betterAuth } from 'better-auth';
import { mongodbAdapter } from 'better-auth/adapters/mongodb';
import { mongoose } from './mongodb';

export const auth = betterAuth({
  database: mongodbAdapter(mongoose.connection.getClient()),
  emailAndPassword: {
    enabled: true,
    minPasswordLength: 8,
  },
  session: {
    expiresIn: 60 * 60 * 24 * 7, // 7 days
    updateAge: 60 * 60 * 24, // 1 day
  },
  user: {
    additionalFields: {
      role: {
        type: 'string',
        defaultValue: 'user',
      },
    },
  },
});

Auth Module

// modules/authModule.ts
import { Elysia } from 'elysia';
import { auth } from '@/shared/infrastructure/auth';

export const authModule = new Elysia({ prefix: '/auth' })
  .mount(auth.handler);

App Entry Point

// index.ts
import { Elysia } from 'elysia';
import { openapi } from '@elysiajs/openapi';
import { cors } from '@elysiajs/cors';
import { connectDB } from '@/shared/infrastructure/mongodb';
import { userModule } from './modules/userModule';
import { authModule } from './modules/authModule';

// Connect to MongoDB before starting server
await connectDB();

const app = new Elysia()
  .use(cors())
  .use(openapi())
  .use(authModule)
  .use(userModule)
  .get('/health', async () => {
    const { mongoose } = await import('@/shared/infrastructure/mongodb');
    return {
      status: 'ok',
      mongodb: mongoose.connection.readyState === 1 ? 'connected' : 'disconnected',
    };
  })
  .onError(({ error, set }) => {
    console.error(error);

    if (error.message.includes('not found')) {
      set.status = 404;
      return { error: error.message };
    }
    if (error.message.includes('already exists') || error.message.includes('validation')) {
      set.status = 400;
      return { error: error.message };
    }

    set.status = 500;
    return { error: 'Internal server error' };
  })
  .listen(3000);

console.log(`Server running at http://localhost:${app.server?.port}`);

export type App = typeof app;

MongoDB Aggregation Examples

Complex Query in Repository

// Example: Get user statistics
async getUserStats(): Promise<{ totalUsers: number; byRole: Record<string, number> }> {
  const result = await UserModel.aggregate([
    {
      $group: {
        _id: '$role',
        count: { $sum: 1 },
      },
    },
  ]);

  const byRole: Record<string, number> = {};
  let total = 0;

  for (const item of result) {
    byRole[item._id] = item.count;
    total += item.count;
  }

  return { totalUsers: total, byRole };
}

// Example: Get users with recent activity
async getRecentlyActiveUsers(days: number): Promise<User[]> {
  const since = new Date();
  since.setDate(since.getDate() - days);

  const docs = await UserModel.find({
    updatedAt: { $gte: since },
  })
    .sort({ updatedAt: -1 })
    .limit(50)
    .select('+passwordHash');

  return docs.map(doc => this.toDomain(doc));
}

Testing with Bun

// domains/user/application/commands/__tests__/CreateUserCommand.test.ts
import { describe, it, expect, mock, beforeEach } from 'bun:test';
import { CreateUserCommand } from '../CreateUserCommand';

describe('CreateUserCommand', () => {
  let mockRepo: any;

  beforeEach(() => {
    mockRepo = {
      findByEmail: mock(() => Promise.resolve(null)),
      save: mock(() => Promise.resolve()),
    };
  });

  it('should create a user with valid input', async () => {
    const command = new CreateUserCommand(mockRepo);
    const result = await command.execute({
      email: 'test@example.com',
      name: 'Test User',
      password: 'Password123',
    });

    expect(result.email).toBe('test@example.com');
    expect(result.name).toBe('Test User');
    expect(result.role).toBe('user');
    expect(mockRepo.save).toHaveBeenCalled();
  });

  it('should reject weak passwords', async () => {
    const command = new CreateUserCommand(mockRepo);

    expect(
      command.execute({
        email: 'test@example.com',
        name: 'Test User',
        password: 'weak',
      })
    ).rejects.toThrow();
  });

  it('should reject duplicate emails', async () => {
    mockRepo.findByEmail = mock(() => Promise.resolve({ id: '123' }));

    const command = new CreateUserCommand(mockRepo);

    expect(
      command.execute({
        email: 'existing@example.com',
        name: 'Test User',
        password: 'Password123',
      })
    ).rejects.toThrow('already exists');
  });
});

Common Commands

# Initialize project
bun init
bun add elysia @elysiajs/openapi @elysiajs/cors
bun add mongoose better-auth
bun add -d typescript @types/bun

# Run MongoDB locally (Docker)
docker run -d -p 27017:27017 --name mongodb mongo:7

# Run development
bun run --watch src/index.ts

# Run tests
bun test

# Build for production
bun build src/index.ts --outdir dist --target bun

Key MongoDB Best Practices

Use Indexes - Create indexes for frequently queried fields
Select Fields - Use .select() to limit returned fields
Lean Queries - Use .lean() for read-only operations (faster)
Aggregation - Use aggregation pipeline for complex queries
Transactions - Use sessions for multi-document transactions
Connection Pooling - Mongoose handles this automatically
Schema Validation - Use Mongoose validators for data integrity

Document Design Patterns

Embedded Documents (Denormalization)

// Good for data that's always accessed together
profile: {
  avatar: String,
  bio: String,
}

Referenced Documents

// Good for large related data
const orderSchema = new Schema({
  user: { type: Schema.Types.ObjectId, ref: 'User' },
  // ...
});

// Populate when needed
const order = await OrderModel.findById(id).populate('user');

Hybrid Approach

// Store summary in document, reference for full data
const orderSchema = new Schema({
  user: { type: Schema.Types.ObjectId, ref: 'User' },
  userName: String, // Denormalized for quick access
  userEmail: String,
});

elysiajs-ddd-mongoose

ElysiaJS Domain-Driven Design with MongoDB Expert

Core Architecture

DDD Folder Structure