{"id":50809740,"url":"https://github.com/mustafabinguldev/nexus-cache-orchestrator","last_synced_at":"2026-06-13T03:34:39.710Z","repository":{"id":353649538,"uuid":"1220339858","full_name":"mustafabinguldev/nexus-cache-orchestrator","owner":"mustafabinguldev","description":"Central data orchestration layer using Redis Pub/Sub and MongoDB for distributed server systems.","archived":false,"fork":false,"pushed_at":"2026-06-03T14:41:23.000Z","size":258,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-06-03T16:18:03.550Z","etag":null,"topics":["cache-control","cache-storage","cachemanager","minecraft","minecraft-plugin","mongodb","mongodb-database","redis","redis-cache","redis-client","spigot","spigot-plugin"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/mustafabinguldev.png","metadata":{"files":{"readme":"README.MD","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-04-24T19:51:18.000Z","updated_at":"2026-06-03T14:48:27.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/mustafabinguldev/nexus-cache-orchestrator","commit_stats":null,"previous_names":["mustafabinguldev/nexus-core","mustafabinguldev/nexus-cache-orchestrator"],"tags_count":7,"template":false,"template_full_name":null,"purl":"pkg:github/mustafabinguldev/nexus-cache-orchestrator","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mustafabinguldev%2Fnexus-cache-orchestrator","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mustafabinguldev%2Fnexus-cache-orchestrator/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mustafabinguldev%2Fnexus-cache-orchestrator/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mustafabinguldev%2Fnexus-cache-orchestrator/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/mustafabinguldev","download_url":"https://codeload.github.com/mustafabinguldev/nexus-cache-orchestrator/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mustafabinguldev%2Fnexus-cache-orchestrator/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34271500,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-13T02:00:06.617Z","response_time":62,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["cache-control","cache-storage","cachemanager","minecraft","minecraft-plugin","mongodb","mongodb-database","redis","redis-cache","redis-client","spigot","spigot-plugin"],"created_at":"2026-06-13T03:34:37.912Z","updated_at":"2026-06-13T03:34:39.704Z","avatar_url":"https://github.com/mustafabinguldev.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"### Central Data Orchestrator for Distributed Minecraft Servers (Redis + MongoDB)\n\n\u003e *\"The central brain between your distributed Minecraft infrastructure and your persistent data layer.\"*\n\n[![Java](https://img.shields.io/badge/Java-17+-blue?style=flat-square\u0026logo=java)](https://www.java.com)\n[![Redis](https://img.shields.io/badge/Redis-Message%20Broker-red?style=flat-square\u0026logo=redis)](https://redis.io)\n[![MongoDB](https://img.shields.io/badge/MongoDB-Persistence-green?style=flat-square\u0026logo=mongodb)](https://www.mongodb.com)\n\n---\n\n## 📖 Table of Contents\n\n- [What is Nexus Core?](#-what-is-nexus-core)\n- [System Architecture](#-system-architecture)\n- [Data Flow Diagram](#-data-flow-diagram)\n- [Core Components](#-core-components)\n- [Getting Started](#-getting-started)\n- [Writing an Addon](#️-writing-an-addon)\n- [DataAddon API Reference](#-dataaddon-api-reference)\n- [Annotations Reference](#-annotations-reference)\n- [Request Lifecycle](#-request-lifecycle)\n- [Protocol \u0026 Packet Structure](#-protocol--packet-structure)\n- [Redis Key Strategy](#-redis-key-strategy)\n- [Dashboard \u0026 Monitoring](#-dashboard--monitoring)\n- [Configuration](#️-configuration)\n- [Best Practices](#-best-practices)\n\n---\n\n## 🧠 What is Nexus Core?\n\n**Nexus Core** is a standalone Java application that acts as the **central orchestration layer** for a distributed Minecraft network. Instead of every Spigot server connecting directly to MongoDB and managing its own cache, all data operations are delegated to Nexus Core through a **Redis pub/sub message bus**.\n\nThis design solves three critical problems at scale:\n\n| Problem | Without Nexus Core | With Nexus Core |\n|---|---|---|\n| **DB Connections** | Every server holds its own connection pool | Single optimized connection pool |\n| **Cache Coherency** | Each server has its own stale cache | Centralized Redis cache, always consistent |\n| **Data Logic** | Duplicated across every server's codebase | Defined once in a `DataAddon`, shared everywhere |\n\nThink of it as a **microservice** purpose-built for Minecraft infrastructure — Nexus Core owns all data, and your Spigot servers are just thin clients.\n\n---\n\n## 🏗️ System Architecture\n\n```\n┌─────────────────────────────────────────────────────────────────┐\n│                                                                 │\n│                                                                 │\n│   ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │\n│   │  Spigot #1   │    │  Spigot #2   │    │  Spigot #3   │     │\n│   │  (Lobby)     │    │  (PvP)       │    │  (Survival)  │     │\n│   └──────┬───────┘    └──────┬───────┘    └──────┬───────┘     │\n│          │                   │                   │             │\n│          └───────────────────┼───────────────────┘             │\n│                              │  Redis Pub/Sub                   │\n│                    ┌─────────▼──────────┐                      │\n│                    │    Redis Broker     │                      │\n│                    │  (Message Bus)      │                      │\n│                    └─────────┬──────────┘                      │\n│                              │                                  │\n│                    ┌─────────▼──────────┐                      │\n│                    │   ⬡ NEXUS CORE ⬡   │  ← YOU ARE HERE     │\n│                    │                    │                      │\n│                    │  ┌──────────────┐  │                      │\n│                    │  │ AddonRegistry│  │                      │\n│                    │  │  Addon #100  │  │                      │\n│                    │  │  Addon #200  │  │                      │\n│                    │  │  Addon #500  │  │                      │\n│                    │  └──────┬───────┘  │                      │\n│                    └─────────┼──────────┘                      │\n│                              │  CRUD Operations                 │\n│                    ┌─────────▼──────────┐                      │\n│                    │      MongoDB        │                      │\n│                    │  ┌───────────────┐ │                      │\n│                    │  │ nexus_core_db │ │                      │\n│                    │  │  → players    │ │                      │\n│                    │  │  → guilds     │ │                      │\n│                    │  │  → economy    │ │                      │\n│                    │  └───────────────┘ │                      │\n│                    └────────────────────┘                      │\n└─────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## 🔄 Data Flow Diagram\n\nEvery interaction follows a strict **request → orchestrate → respond** lifecycle:\n\n```\nSpigot Server                Redis                  Nexus Core               MongoDB\n     │                         │                        │                       │\n     │  1. PUBLISH packet       │                        │                       │\n     │  {                       │                        │                       │\n     │    protocol: 500,        │                        │                       │\n     │    source: \"pvp-1\",      │                        │                       │\n     │    type: GET_DATA,       │                        │                       │\n     │    data: {name:\"Steve\"}  │                        │                       │\n     │  }                       │                        │                       │\n     │─────────────────────────►│                        │                       │\n     │                          │  2. Route to listener  │                       │\n     │                          │───────────────────────►│                       │\n     │                          │                        │  3. Lookup AddonRegistry\n     │                          │                        │     protocol 500 → ExampleAddon\n     │                          │                        │                       │\n     │                          │                        │  4. handleRequest()   │\n     │                          │                        │     pre-check / reject│\n     │                          │                        │                       │\n     │                          │                        │  5. Check Redis cache │\n     │                          │                        │     key: \"example_addon_Steve\"\n     │                          │                        │──── CACHE HIT? ──────►│\n     │                          │                        │◄─── return cached ────│\n     │                          │                        │                       │\n     │                          │                        │  (CACHE MISS)         │\n     │                          │                        │  6. MongoDB query     │\n     │                          │                        │  db.players.findOne(  │\n     │                          │                        │    {name: \"Steve\"}    │\n     │                          │                        │  )                    │\n     │                          │                        │──────────────────────►│\n     │                          │                        │◄── Document ──────────│\n     │                          │                        │                       │\n     │                          │                        │  7. Write to cache    │\n     │                          │  8. PUBLISH response   │                       │\n     │                          │◄───────────────────────│                       │\n     │  9. Receive response     │                        │                       │\n     │◄─────────────────────────│                        │                       │\n     │                          │                        │                       │\n```\n\n### Request Types\n| Type | Description | MongoDB Operation | Cache |\n|------|-------------|-------------------|-------|\n| `GET_DATA` | Fetch a document by ID field | `findOne()` | Read-through |\n| `SET_DATA` | Insert or update a document | `replaceOne(upsert)` | Write-through |\n| `REMOVE_DATA` | Remove a document by ID | `deleteOne()` | Invalidate |\n| `INCREMENT_DATA` | Atomically increment a numeric field on an existing document | `findOne()` + in-memory mutate | Write-through |\n| `UPDATE_DATA` | Partially update fields on an existing document | `updateOne()` | Write-through |\n| `BROADCAST` | Push a data payload to a target server over Redis pub/sub | None | Bypass |\n| `LOAD_CACHE` | Pre-load a document into memory cache by ID | `findOne()` | Warm |\n\n---\n\n## 🧩 Core Components\n\n### `NexusApplication`\nThe main entry point and bootstrapper. Initializes the Redis connection, MongoDB client, and loads all registered `DataAddon` instances into the registry. Exposes `getDataSize()` and `getAddonSize()` for the live dashboard.\n\n### `DataAddon`\nThe abstract base class that defines a **data module**. Each addon maps to exactly one MongoDB collection and one Redis key namespace. You extend this class to add new data types to the network.\n\n### `ProtocolHandler`\nA thread-safe `Map\u003cInteger, DataAddon\u003e` keyed on `addonId()`. When a packet arrives with `protocol: 500`, the registry looks up the corresponding addon in O(1) and delegates the operation.\n\n### `NexusJsonDataContainer`\nA thin wrapper around a JSON object that is passed into `handleRequest()`. Provides helper methods for reading typed values from the packet payload without null-pointer noise.\n\n### Dashboard (`Main.java`)\nA Swing-based live monitoring UI built entirely with Java2D — no external UI frameworks. Displays real-time JVM CPU, process RAM, cache object count, and addon count with animated donut charts and scrolling line graphs.\n\n---\n\n## 🚀 Getting Started\n\n### Prerequisites\n\n- Java 17+\n- A running Redis instance (`redis-server`)\n- A running MongoDB instance (`mongod`)\n\n### Build \u0026 Run\n\n```bash\n# Clone the repository\ngit clone https://github.com/mustafabinguldev/nexus-core.git\ncd nexus-core\n\n# Build with Maven\nmvn clean package -DskipTests\n\n# Run the application\njava -jar target/nexus-core-4.0.jar\n```\n\nThe **Nexus Core Dashboard** will launch. Fill in your Redis host, MongoDB URI, and server port, then click **INITIALIZE NEXUS ENGINE**.\n\n### Default Configuration\n\n| Field | Default |\n|---|---|\n| Redis Host | `127.0.0.1` |\n| MongoDB URI | `mongodb://localhost:27017` |\n| Server Port | `8080` |\n\n---\n\n## 🛠️ Writing an Addon\n\nAn addon is the fundamental unit of data in Nexus Core. Each addon represents a single collection of documents, defines the schema via annotations, and optionally intercepts requests before they are processed.\n\n### Step 1 — Extend `DataAddon`\n\n```java\npackage network.darkland.addons;\n\nimport network.darkland.protocol.DataAddon;\nimport network.darkland.protocol.NexusJsonDataContainer;\nimport network.darkland.protocol.backup.annotations.DbDataModels;\n\npublic class PlayerStatsAddon extends DataAddon {\n\n    // -------------------------------------------------------\n    //  IDENTITY\n    // -------------------------------------------------------\n\n    @Override\n    public int addonId() {\n        return 100; // Must be globally unique across all addons\n    }\n\n    @Override\n    public String addonName() {\n        return \"Player Stats\";\n    }\n\n    // -------------------------------------------------------\n    //  DATABASE TARGET\n    // -------------------------------------------------------\n\n    @Override\n    public String getDatabase() {\n        return \"nexus_core_db\";\n    }\n\n    @Override\n    public String getCollection() {\n        return \"player_stats\"; // db.player_stats\n    }\n\n    // -------------------------------------------------------\n    //  CACHE NAMESPACE\n    // -------------------------------------------------------\n\n    @Override\n    public String cacheKeyHeaderTag() {\n        return \"stats\"; // Redis key: \"stats:\u003cvalue of @isId field\u003e\"\n    }\n\n    // -------------------------------------------------------\n    //  DATA MODEL\n    // -------------------------------------------------------\n\n    @DbDataModels(isId = true)\n    private String uuid; // Primary key — used for both DB lookup and cache key\n\n    @DbDataModels(defaultValue = \"0\", isId = false)\n    private int kills;\n\n    @DbDataModels(defaultValue = \"0\", isId = false)\n    private int deaths;\n\n    @DbDataModels(defaultValue = \"0\", isId = false)\n    private double balance;\n\n    @DbDataModels(defaultValue = \"false\", isId = false)\n    private boolean isPremium;\n\n    // -------------------------------------------------------\n    //  REQUEST INTERCEPTOR\n    // -------------------------------------------------------\n\n    @Override\n    public boolean handleRequest(String source, RequestType requestType, NexusJsonDataContainer data) {\n        // 'source' is the server ID that sent the packet, e.g. \"pvp-1\"\n        // Return false to reject this request without processing it.\n\n        if (requestType == RequestType.REMOVE_DATA) {\n            // Example: only allow deletes from the \"admin\" server\n            return source.equals(\"admin\");\n        }\n\n        return true;\n    }\n}\n```\n\n### Step 2 — Register the Addon\n\nIn your `NexusApplication` constructor or initialization block, register the addon:\n\n```java\n// NexusApplication.java\nNexusApplication.getInstance().getProtocolHandler().registerAddon(new PlayerStatsAddon());\n```\n\nThat's it. Nexus Core will now automatically handle all `GET_DATA`, `SET_DATA`, `REMOVE_DATA` requests for protocol ID `100`, routing them to the `player_stats` MongoDB collection.\n\n---\n\n## 📚 DataAddon API Reference\n\n```java\npublic abstract class DataAddon {\n\n    /**\n     * The unique numeric ID for this addon.\n     * Remote clients send this as the `protocol` field in their packets.\n     * Must be unique — duplicate IDs will throw at startup.\n     */\n    public abstract int addonId();\n\n    /**\n     * Human-readable name shown in the dashboard and log output.\n     */\n    public abstract String addonName();\n\n    /**\n     * The MongoDB database name this addon operates on.\n     * Multiple addons can share the same database.\n     */\n    public abstract String getDatabase();\n\n    /**\n     * The MongoDB collection this addon reads and writes.\n     * Each addon should have its own dedicated collection.\n     */\n    public abstract String getCollection();\n\n    /**\n     * The prefix for Redis cache keys managed by this addon.\n     * Full key format: \"{cacheKeyHeaderTag}:{idFieldValue}\"\n     * Example: \"stats:550e8400-e29b-41d4-a716-446655440000\"\n     *\n     * Keep this short and unique to avoid key collisions\n     * between addons that share the same database.\n     */\n    public abstract String cacheKeyHeaderTag();\n\n    /**\n     * Called before every data operation.\n     *\n     * @param source      The server ID that originated the request (e.g. \"pvp-1\")\n     * @param requestType GET_DATA / SET_DATA / REMOVE_DATA / INCREMENT_DATA \n     * @param data        The payload container from the incoming packet\n     * @return true  → process the request normally\n     *         false → reject and send an empty response back to source\n     */\n    public abstract boolean handleRequest(\n        String source,\n        RequestType requestType,\n        NexusJsonDataContainer data\n    );\n}\n```\n\n---\n\n## 🏷️ Annotations Reference\n\nThe `@DbDataModels` annotation is how Nexus Core discovers your schema at runtime via reflection. Every field you want persisted must be annotated.\n\n```java\n@DbDataModels(isId = true)\nprivate String uuid;\n```\n\n| Parameter | Type | Required | Description |\n|-----------|------|----------|-------------|\n| `isId` | `boolean` | ✅ Yes | Marks this field as the primary key. Used for MongoDB `findOne` queries and as the Redis cache key suffix. **Exactly one field per addon must have `isId = true`.** |\n| `defaultValue` | `String` | ✅ Yes (if `isId = false`) | The value written to MongoDB when this field is not present in the incoming packet. Must be a parseable string representation of the field's type. |\n\n### Supported Field Types\n\n| Java Type | `defaultValue` example |\n|-----------|------------------------|\n| `String` | `\"unknown\"` |\n| `int` / `Integer` | `\"0\"` |\n| `long` / `Long` | `\"0\"` |\n| `double` / `Double` | `\"0.0\"` |\n| `boolean` / `Boolean` | `\"false\"` |\n\n---\n\n## 🔄 Request Lifecycle\n\nUnderstanding the exact order of operations is important for writing correct addon logic.\n\n```\nIncoming Redis Packet\n        │\n        ▼\n┌───────────────────┐\n│  Deserialize JSON  │\n│  Extract protocol  │\n└────────┬──────────┘\n         │\n         ▼\n┌───────────────────┐\n│  AddonRegistry    │      ┌─────────────┐\n│  lookup(protocol) │─────►│  Not found? │──► Log WARN, drop packet\n└────────┬──────────┘      └─────────────┘\n         │\n         ▼\n┌───────────────────┐\n│  handleRequest()  │      ┌─────────────┐\n│  (your code)      │─────►│  Returns    │──► Send empty response to source\n└────────┬──────────┘      │  false?     │\n         │                 └─────────────┘\n         │ true\n         ▼\n┌───────────────────┐\n│  Route by         │\n│  RequestType      │\n└────────┬──────────┘\n         │\n    ┌────┴────┬────────────┬──────────\n    ▼         ▼            ▼          \n  GET_DATA        SET_DATA        REMOVE_DATA    \n    │         │            │          \n    ▼         ▼            ▼          \n Check     Write to    Delete from  \n Redis     Mongo +     Mongo +      \n cache     Update      Invalidate   \n    │       cache       cache\n    ▼\n Cache hit?\n    │\n  No │\n    ▼\n Query Mongo\n Write cache\n    │\n    ▼\nSerialize response\nPublish to Redis\n(source channel)\n```\n\n---\n\n## 📦 Protocol \u0026 Packet Structure\n\n### Inbound Packet (Spigot → Redis → Nexus)\n\n```json\n{\n  \"protocol\": 100,\n  \"source\":   \"pvp-1\",\n  \"type\":     \"GET_DATA\",\n  \"data\": {\n    \"uuid\": \"550e8400-e29b-41d4-a716-446655440000\"\n  }\n}\n```\n\n### Outbound Packet (Nexus → Redis → Spigot)\n\n```json\n{\n  \"protocol\": 100,\n  \"source\":   \"nexus\",\n  \"type\":     \"BROADCAST\",\n  \"target\": \"pvp-1\",\n  \"data\": {\n    \"uuid\":      \"550e8400-e29b-41d4-a716-446655440000\",\n    \"kills\":     142,\n    \"deaths\":    38,\n    \"balance\":   2500.75,\n    \"isPremium\": true\n  }\n}\n```\n\n---\n\n## 🗝️ Redis Key Strategy\n\nNexus Core uses a simple, predictable key schema to prevent collisions between addons, databases, and environments:\n\n```\n{cacheKeyHeaderTag}_{idFieldValue}\n```\n\n### Examples\n\n| Addon | `cacheKeyHeaderTag` | ID Field Value | Full Redis Key |\n|-------|---------------------|----------------|----------------|\n| `PlayerStatsAddon` | `stats` | `Steve` | `stats:Steve` |\n| `GuildAddon` | `guild` | `Darkland` | `guild:Darkland` |\n| `EconomyAddon` | `eco` | `550e8400...` | `eco:550e8400...` |\n\n\u003e ⚠️ **Warning:** Two addons with the same `cacheKeyHeaderTag` will overwrite each other's cache entries. Always use unique prefixes.\n\nCache entries are stored as serialized JSON strings and are automatically invalidated on `SET` and `DELETE` operations.\n\n---\n\n## 📊 Dashboard \u0026 Monitoring\n\nThe **Nexus Core Dashboard** (`Main.java`) provides real-time visibility into the running engine. All rendering is done with Java2D — no external libraries.\n![Project Screenshot](src/main/resources/nexus-core.png)\n\n### Dashboard Metrics\n\n| Card | Source | Description |\n|------|--------|-------------|\n| **CPU LOAD** | `OperatingSystemMXBean.getProcessCpuLoad()` | JVM process CPU only — not system-wide |\n| **PROCESS RAM** | `Runtime.totalMemory() - freeMemory()` | Current JVM heap usage in MB |\n| **CACHE OBJECTS** | `NexusApplication.getDataSize()` | Number of documents currently in Redis cache |\n| **ACTIVE ADDONS** | `NexusApplication.getAddonSize()` | Number of registered `DataAddon` instances |\n\n---\n\n## ⚙️ Configuration\n\nConfiguration is entered via the login panel at startup. There is intentionally no config file — all connection parameters are live and validated at boot time.\n\n| Field | Example | Notes |\n|-------|---------|-------|\n| `REDIS HOST` | `127.0.0.1` | Hostname or IP of your Redis server. Port defaults to `6379`. |\n| `MONGO URI` | `mongodb://user:pass@host:27017` | Full MongoDB connection string. Supports auth and replica sets. |\n| `SERVER PORT` | `8080` | Port Nexus Core listens on for internal HTTP health checks. |\n\n---\n\n## ✅ Best Practices\n\n**1. Keep addon IDs in a constants file**\n```java\npublic final class AddonIds {\n    public static final int PLAYER_STATS = 100;\n    public static final int GUILDS       = 200;\n    public static final int ECONOMY      = 300;\n    public static final int EXAMPLE      = 500;\n}\n```\n\n**2. Use UUIDs as ID fields whenever possible**\nString names are not unique across time. A player rename will create a duplicate document. Prefer `uuid` as `isId = true`.\n\n**3. Keep `handleRequest()` fast**\nThis method runs synchronously before the operation. Any blocking call here stalls the entire request. Do validation only — no I/O.\n\n**4. Use distinct `cacheKeyHeaderTag` values**\nEven across different databases, share a global convention like `{moduleName}_{collection}` to guarantee uniqueness:\n```java\n// ✅ Good\npublic String cacheKeyHeaderTag() { return \"pvp_stats\"; }\n\n// ❌ Risky — collides with any other addon that uses \"stats\"\npublic String cacheKeyHeaderTag() { return \"stats\"; }\n```\n\n**5. Never call MongoDB directly from a Spigot plugin**\nThe entire point of Nexus Core is centralized data access. Bypassing it defeats cache coherency and defeats the architecture.\n\n---\n\n---\n\n## 🛡️ License\n\n**Mustafa Bingül — All Rights Reserved**\n\n---\n\n\u003cdiv align=\"center\"\u003e\n\n**⬡ NEXUS CORE v1.2**\n\n*Built for performance. Designed for scale.*\n\n\u003c/div\u003e\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmustafabinguldev%2Fnexus-cache-orchestrator","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmustafabinguldev%2Fnexus-cache-orchestrator","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmustafabinguldev%2Fnexus-cache-orchestrator/lists"}