KesiCollection

A full-stack expense splitting application built with Kotlin Multiplatform

📋 Overview

KesiCollection is an expense management and bill-splitting application with support for Android, iOS, Desktop, and a backend server. The project uses Clean Architecture, modular design, and Kotlin Multiplatform to maximize code sharing across all platforms.

Key Features

💰 Expense Splitting - Create groups, track payments, and automatically calculate who owes what
👥 Group Management - Create and manage expense groups with multiple members
📊 Settlement Tracking - View detailed payment history and outstanding balances
🔐 Authentication - Secure JWT-based authentication system
👫 Friend Management - Connect with friends to simplify group creation
📱 Multi-Platform - Runs on Android, iOS, and Desktop with shared business logic

🏗️ Architecture & Design

Clean Architecture

The application follows Clean Architecture principles with clear separation of concerns:

├── domain/          # Business logic and use cases (platform-agnostic)
├── data/           # Data sources, repositories, and API clients
├── feature/        # Feature-specific UI and ViewModels
├── core/           # Shared utilities and design system
└── server/         # Backend REST API

Modular Design

The codebase is organized into 55+ focused modules, each with a single responsibility. The architecture uses umbrella modules to enable multiple applications to share common infrastructure:

Core Modules: Shared across all applications (design system, infrastructure, models, Redux state management)
Feature Modules: Self-contained features that can be composed into different applications
Data Modules: API clients, local database, repositories
Domain Modules: Business logic and use cases
Application Modules: Umbrella modules that compose features and core modules into complete applications

Umbrella Module Architecture

The project is designed to support multiple applications sharing the same core infrastructure:

kesiSplit/              # Expense splitting application (Android/iOS/Desktop)
kesiSplitUmbrella/      # Umbrella module for KesiSplit
feature/                # Generic reusable features
featurekesisplit/       # Expense splitting specific features
core/                   # Shared across ALL applications
    ├── designsystem/   # UI components, theme, typography
    ├── infrastructure/ # Network, storage, utilities
    ├── model/          # Shared data models
    └── redux/          # State management framework

This umbrella approach allows:

✅ Multiple apps with shared UI/UX - Different apps can use the same design system
✅ Code reuse at scale - Core modules are shared across all applications
✅ Independent feature development - Features can be developed and tested in isolation
✅ Flexible composition - Applications cherry-pick which features to include
✅ Consistent architecture - All apps follow the same patterns and structures

Technology Stack

Frontend (Mobile & Desktop)

Kotlin Multiplatform Mobile (KMM) - Share 80%+ code between Android, iOS, and Desktop
Compose Multiplatform - Modern declarative UI framework
Redux Pattern - Predictable unidirectional state management
Voyager - Type-safe navigation
Room Database - Local persistence with SQLite
Koin - Dependency injection
Coroutines & Flow - Asynchronous programming
Ktor Client - HTTP networking

Backend (Server)

Ktor - Asynchronous web framework
Exposed ORM - Type-safe SQL with Kotlin DSL
PostgreSQL - Production database
JWT Authentication - Secure token-based auth
Koin - Dependency injection

Build & DevOps

Gradle Convention Plugins - Standardized build configuration across 55+ modules
Kotlin DSL - Type-safe build scripts
Module Graph Plugin - Visualize module dependencies
Docker Compose - Local development environment

📱 Platforms Supported

✅ Android (API 24+)
✅ iOS (iOS 14+)
✅ Desktop (JVM - macOS, Windows, Linux)
✅ Server (JVM)

🚀 Getting Started

Prerequisites

JDK 17 or higher
Android Studio Hedgehog (2023.1.1) or newer
Xcode 15+ (for iOS development)
Docker & Docker Compose (for backend)

Running the Android App

./gradlew :kesiSplit:assembleDebug
# Or open in Android Studio and run

Running the iOS App

# Build the Kotlin framework
./gradlew :kesiSplit:linkDebugFrameworkIosSimulatorArm64

# Open iosApp/iosApp.xcodeproj in Xcode and run

Running the Desktop App

./gradlew :kesiSplit:run

Running the Backend Server

With Docker Compose (Recommended)

docker-compose up db  # Start PostgreSQL database
./gradlew :server:run # Run the server

Manual Setup

Start a PostgreSQL database
Configure connection in server/src/main/resources/application.conf
Run: ./gradlew :server:run

The server will start at http://localhost:8080

Running Tests

# Run all tests
./gradlew test

# Run specific module tests
./gradlew :featurekesisplit:home:testDebugUnitTest
./gradlew :server:test

🏛️ Project Structure

kesicollection/
│
├── build-logic/                    # Custom Gradle convention plugins
│   └── convention/                 # Reusable build configuration
│
├── core/                           # Core shared modules
│   ├── designsystem/              # UI components, theme, typography
│   ├── infrastructure/            # Network, storage, utilities
│   ├── model/                     # Shared data models
│   └── redux/                     # State management framework
│
├── domain/                         # Business logic (platform-agnostic)
│   ├── authentication/            # Auth use cases
│   ├── datetime/                  # Date/time utilities
│   └── misc/                      # Shared domain logic
│
├── data/                          # Data layer
│   ├── api/                       # API models
│   ├── authentication/            # Auth repository
│   ├── exposed/                   # Database ORM
│   ├── friendship/                # Friend management data
│   ├── ktor/                      # HTTP client setup
│   ├── repository/                # Data repositories
│   ├── room/                      # Local database
│   └── server/                    # Server data layer
│
├── feature/                       # Generic features
│   ├── authentication/            # Login/register screens
│   ├── friendlookup/              # Friend search
│   ├── getstarted/                # Onboarding
│   └── nomms/                     # Additional features
│
├── featurekesisplit/              # Expense splitting features
│   ├── home/                      # Main dashboard
│   ├── splits/                    # List of splits
│   ├── split/                     # Split detail view
│   ├── createsplit/               # Create new split
│   ├── creategroup/               # Create expense group
│   ├── addpayment/                # Add payment to split
│   ├── submitpayment/             # Submit payment confirmation
│   ├── paymentdetail/             # Payment details view
│   ├── splitdetail/               # Split details view
│   ├── splitbalance/              # Balance calculations
│   ├── deletesettlement/          # Delete settlement
│   ├── groupmembersselection/     # Select group members
│   └── createanonymousmember/     # Add non-registered members
│
├── kesiSplit/                     # Main mobile application (umbrella for Android/iOS/Desktop)
├── kesiSplitUmbrella/            # Umbrella module composing core + features
├── iosApp/                        # iOS-specific code
├── server/                        # Backend Ktor application
└── docker-server/                 # Docker configuration

🎯 Modularization Strategy

Gradle Convention Plugins

The build system uses custom convention plugins to standardize configuration across all 55+ modules:

KMPLibraryConventionPlugin - Base configuration for Kotlin Multiplatform libraries
KMPLibraryComposeConventionPlugin - Compose Multiplatform UI libraries
FeatureConventionPlugin - Feature module configuration with common dependencies
KMPApplicationConventionPlugin - Application module setup
KtorConventionPlugin - Server and client Ktor configuration

This approach eliminates duplication in build files and ensures consistency across the entire codebase.

Module Dependency Management

Each module explicitly declares its dependencies in build.gradle.kts, creating a directed acyclic graph (DAG) of dependencies. The module graph visualization below shows how core modules are depended upon by all features, while features remain independent of each other.

Key architectural constraints:

Core modules have no dependencies on feature or data modules
Domain modules are pure Kotlin with no platform dependencies
Feature modules depend only on core and domain modules
Data modules bridge domain and platform-specific implementations

📊 Module Dependency Graph

The following diagram shows the dependency relationships between core modules:

Module Graph

%%{
  init: {
    'theme': 'neutral'
  }
}%%

graph LR
  subgraph :common
    :common:component["component"]
  end
  subgraph :core
    :core:infrastructure["infrastructure"]
    :core:designsystem["designsystem"]
    :core:redux["redux"]
    :core:model["model"]
  end
  subgraph :data
    :data:api["api"]
    :data:server["server"]
  end
  subgraph :data:client
    :data:client:friendship["friendship"]
    :data:client:authentication["authentication"]
    :data:client:ktor["ktor"]
  end
  subgraph :datakesisplit
    :datakesisplit:transaction["transaction"]
    :datakesisplit:split["split"]
    :datakesisplit:splitgroup["splitgroup"]
    :datakesisplit:api["api"]
  end
  subgraph :domain
    :domain:authentication["authentication"]
    :domain:misc["misc"]
  end
  subgraph :feature
    :feature:authentication["authentication"]
    :feature:friendlookup["friendlookup"]
    :feature:getstarted["getstarted"]
    :feature:nomms["nomms"]
  end
  subgraph :featurekesisplit
    :featurekesisplit:deletesettlement["deletesettlement"]
    :featurekesisplit:groupmembersselection["groupmembersselection"]
    :featurekesisplit:addpayment["addpayment"]
    :featurekesisplit:creategroup["creategroup"]
    :featurekesisplit:paymentdetail["paymentdetail"]
    :featurekesisplit:split["split"]
    :featurekesisplit:splits["splits"]
    :featurekesisplit:createanonymousmember["createanonymousmember"]
    :featurekesisplit:createsplit["createsplit"]
    :featurekesisplit:home["home"]
    :featurekesisplit:splitbalance["splitbalance"]
    :featurekesisplit:splitdetail["splitdetail"]
    :featurekesisplit:submitpayment["submitpayment"]
  end
  :domain:authentication --> :core:infrastructure
  :featurekesisplit:deletesettlement --> :core:designsystem
  :featurekesisplit:deletesettlement --> :core:redux
  :featurekesisplit:groupmembersselection --> :core:designsystem
  :featurekesisplit:groupmembersselection --> :core:redux
  :common:component --> :core:model
  :common:component --> :core:designsystem
  :feature:authentication --> :core:designsystem
  :feature:authentication --> :core:redux
  :featurekesisplit:addpayment --> :core:designsystem
  :featurekesisplit:addpayment --> :core:redux
  :data:client:friendship --> :core:infrastructure
  :datakesisplit:transaction --> :core:infrastructure
  :featurekesisplit:creategroup --> :core:designsystem
  :featurekesisplit:creategroup --> :core:redux
  :featurekesisplit:paymentdetail --> :core:designsystem
  :featurekesisplit:paymentdetail --> :core:redux
  :kesiSplitUmbrella --> :core:designsystem
  :datakesisplit:split --> :core:infrastructure
  :featurekesisplit:split --> :core:designsystem
  :featurekesisplit:split --> :core:redux
  :datakesisplit:splitgroup --> :core:infrastructure
  :data:api --> :core:model
  :featurekesisplit:splits --> :core:designsystem
  :featurekesisplit:splits --> :core:redux
  :datakesisplit:api --> :core:model
  :feature:friendlookup --> :core:designsystem
  :feature:friendlookup --> :core:redux
  :data:client:authentication --> :core:infrastructure
  :featurekesisplit:createanonymousmember --> :core:designsystem
  :featurekesisplit:createanonymousmember --> :core:redux
  :feature:getstarted --> :core:designsystem
  :feature:getstarted --> :core:redux
  :featurekesisplit:createsplit --> :core:designsystem
  :featurekesisplit:createsplit --> :core:redux
  :featurekesisplit:home --> :core:designsystem
  :featurekesisplit:home --> :core:redux
  :data:server --> :core:infrastructure
  :core:infrastructure --> :domain:misc
  :feature:nomms --> :core:designsystem
  :feature:nomms --> :core:redux
  :featurekesisplit:splitbalance --> :core:designsystem
  :featurekesisplit:splitbalance --> :core:redux
  :featurekesisplit:splitdetail --> :core:designsystem
  :featurekesisplit:splitdetail --> :core:redux
  :featurekesisplit:submitpayment --> :core:designsystem
  :featurekesisplit:submitpayment --> :core:redux
  :data:client:ktor --> :core:model

classDef focus fill:#769566,stroke:#fff,stroke-width:2px,color:#fff;
class :core:infrastructure focus
class :core:designsystem focus
class :core:redux focus
class :core:model focus

🔧 Development Tools

Module Graph Plugin - Visualizes module dependencies (see graph above)
Gradle Convention Plugins - Standardizes build configuration
Type-Safe Project Accessors - Compile-time safe module references
Gradle Build Cache - Speeds up incremental builds

🤝 Contributing

Suggestions and feedback are welcome! Feel free to:

Open issues for bugs or suggestions
Submit pull requests
Provide architectural feedback

📄 License

This project is open source and available for reference and learning purposes.

Built with ❤️ using Kotlin Multiplatform

Navigation Menu

Repository navigation

About

Repository files navigation

KesiCollection

📋 Overview

Key Features

🏗️ Architecture & Design

Clean Architecture

Modular Design

Umbrella Module Architecture

Technology Stack

📱 Platforms Supported

🚀 Getting Started

Prerequisites

Running the Android App

Running the iOS App

Running the Desktop App

Running the Backend Server

With Docker Compose (Recommended)

Manual Setup

Running Tests

🏛️ Project Structure

🎯 Modularization Strategy

Gradle Convention Plugins

Module Dependency Management

📊 Module Dependency Graph

Module Graph

🔧 Development Tools

🤝 Contributing

📄 License

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
.fleet		.fleet
build-logic		build-logic
common/component		common/component
core		core
data		data
docker-server		docker-server
domain		domain
feature		feature
featurekesisplit		featurekesisplit
gradle		gradle
iosApp		iosApp
kesiSplit		kesiSplit
kesiSplitUmbrella		kesiSplitUmbrella
server		server
.gitignore		.gitignore
Dockerfile		Dockerfile
README.md		README.md
build.gradle.kts		build.gradle.kts
docker-compose.yml		docker-compose.yml
gradle.properties		gradle.properties
gradlew		gradlew
gradlew.bat		gradlew.bat
settings.gradle.kts		settings.gradle.kts

Latest commit

History

Folders and files

Repository files navigation

KesiCollection

📋 Overview

Key Features

🏗️ Architecture & Design

Clean Architecture

Modular Design

Umbrella Module Architecture

Technology Stack

📱 Platforms Supported

🚀 Getting Started

Prerequisites

Running the Android App

Running the iOS App

Running the Desktop App

Running the Backend Server

With Docker Compose (Recommended)

Manual Setup

Running Tests

🏛️ Project Structure

🎯 Modularization Strategy

Gradle Convention Plugins

Module Dependency Management

📊 Module Dependency Graph

Module Graph

🔧 Development Tools

🤝 Contributing

📄 License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages