Personal software development project

Rift

A Fortnite-focused software project connecting Discord, Epic Online Services and Fortnite data through a modular TypeScript architecture.

View source on GitHub Explore architecture
rift / dashboard
Rift Overview
DEVELOPMENT
PROJECT Rift
RUNTIME Node.js
LANGUAGE TypeScript
01 — About Rift

One project.
Several systems.

Rift is a personal software development project focused on connecting Fortnite-related functionality with Discord. The application is built with TypeScript and Node.js and separates external services from its core application logic.

The project contains dedicated service layers for Fortnite API access, authentication-related functionality and application storage. This keeps external APIs and persistent data separate from the rest of the application.

Rift is being developed incrementally. Some systems are already implemented while others are being expanded as the project evolves.

The goal is a clean foundation that can grow without turning the application into one large, tightly coupled codebase.

Project principles
Modular services
Secure session handling
Clear separation of concerns
Type-safe development
Minimal public data exposure
02 — Capabilities

Built around
useful building blocks.

Rift's architecture is organized around individual services rather than putting every integration directly into the application core.

EP

Epic Account Integration

Epic Online Services provides the foundation for Epic account authentication and account-related functionality.

FN

Fortnite API

Rift can retrieve Fortnite cosmetic information through a dedicated Fortnite API service.

DC

Discord

Discord provides the user-facing environment for Fortnite-related functionality within the project.

DB

Local Storage

Application data and saved sessions are separated into a dedicated local storage layer.

API

Service Layer

External requests are isolated behind service functions instead of being scattered throughout the application.

TS

Type Safety

Rift uses TypeScript with strict compiler settings to catch problems during development.

03 — Architecture

Separate the pieces.
Connect the system.

The architecture keeps Discord, external APIs, authentication and local persistence in separate responsibilities.

RIFT / SYSTEM OVERVIEW 
                    ┌─────────────────────────┐
                    │                         │
                    │        DISCORD          │
                    │       APPLICATION       │
                    │                         │
                    └────────────┬────────────┘
                                 │
                                 ▼
                    ┌─────────────────────────┐
                    │                         │
                    │         RIFT          │
                    │     APPLICATION CORE    │
                    │                         │
                    └───────┬─────────┬───────┘
                            │         │
                 ┌──────────┘         └──────────┐
                 │                               │
                 ▼                               ▼
       ┌───────────────────┐          ┌───────────────────┐
       │                   │          │                   │
       │  EPIC ONLINE      │          │   FORTNITE API    │
       │  SERVICES         │          │                   │
       │                   │          │                   │
       └───────────────────┘          └───────────────────┘
                 │                               │
                 └──────────────┬────────────────┘
                                │
                                ▼
                     ┌─────────────────────┐
                     │                     │
                     │   STORAGE / DATA    │
                     │                     │
                     │  Sessions + Custom  │
                     │      Profiles       │
                     │                     │
                     └─────────────────────┘
04 — Integrations

The services behind Rift.

Each external system has its own role inside the project.

E

Epic Online Services

Epic account authentication and account-related authorization.

Account
F

Fortnite API

Fortnite cosmetic information and API-backed Fortnite data.

Data
D

Discord

The application environment where Rift's functionality can be exposed to users.

Interface
FS

Local File Storage

Persistent JSON-based application data and saved session information.

Storage
05 — Development

Type-safe by design.

Rift uses TypeScript with strict compiler settings and dedicated typed service interfaces.

fortniteApi.ts 
export type FortniteCosmetic = {
  id: string;
  name: string;
  description?: string;

  type?: {
    value: string;
    displayValue: string;
    backendValue: string;
  };

  rarity?: {
    value: string;
    displayValue: string;
    backendValue: string;
  };
};

export async function
searchCosmetics(
  query: string
): Promise<FortniteCosmetic[]> {
  const cosmetics =
    await getCosmetics();

  return cosmetics.filter(
    cosmetic =>
      cosmetic.name
        .toLowerCase()
        .includes(query.toLowerCase())
  );
}
06 — Technology

The stack behind Rift.

A focused Node.js environment with TypeScript at the center of the application.

Runtime & language

The project runs on Node.js and is written in TypeScript for strong typing and maintainability.

Node.js TypeScript ESNext

Application services

Dedicated modules handle external APIs, authentication-related logic and storage.

Discord EOS REST

Data

Local application data is persisted using a structured JSON storage layer.

JSON File Storage Sessions

Security

Saved authentication data can be protected using authenticated AES-256-GCM encryption.

AES-256-GCM Environment Variables
07 — Security

Sensitive data
stays sensitive.

Rift's storage layer is designed to avoid treating authentication information like ordinary application data.

AES-256-GCM sessions

The project's encryption service uses AES-256-GCM with randomly generated initialization vectors and authentication tags.

Environment-based secrets

Sensitive configuration such as the session encryption key is read from environment variables rather than hard-coded into the application.

No credentials on this website

This website does not contain Epic client secrets, access tokens, refresh tokens or encryption keys.

Minimal information

Rift is designed to use only the information required for the functionality provided by the application.

08 — Roadmap

Where Rift is going.

Rift is a personal project and its architecture will continue to evolve as new functionality is implemented.

Current

Core service architecture

Maintain separate service modules for external APIs, authentication and application storage.

Building

Epic account workflow

Continue developing the Epic Online Services authentication and account integration.

Planned

Expanded Discord functionality

Continue expanding the Discord-side experience around Fortnite-related functionality.

Future

Additional Fortnite services

Add additional Fortnite-related capabilities as the underlying project develops.

09 — Privacy

Built with privacy
in mind.

Rift only uses account information required to provide its functionality. Information is not sold or shared for advertising purposes.

Public website

This website is a static GitHub Pages site. It does not request Epic credentials, does not collect login information and does not contain application secrets.

Application data

Authentication and session information used by Rift's application is separate from this public website. Sensitive credentials should never be committed to public repositories.

10 — Explore

See Rift for yourself.

Rift is a personal software development project built around Fortnite, Discord and Epic Online Services. Follow the source and development on GitHub.

Open Rift on GitHub Developer profile