Legacy Lands Library

The mongodb module is a wrapper around Morphia designed specifically for Minecraft plugin development. It provides a MongoConfig implementation to simplify setup.

Note: This module is strictly tied to MongoDB. There is no support for other database types (like MySQL or PostgreSQL) because the design prioritizes MongoDB's schema-less nature, horizontal scalability (sharding), and document model which aligns with the dynamic and complex data structures found in Minecraft.

The AOP module uses a hybrid proxy pipeline that automatically selects the optimal strategy based on the target type:

• JDK Dynamic Proxies: Automatically used for interface types.
• ByteBuddy Class Proxies: Automatically used for concrete classes, which preserves field state through synchronized copy-on-invoke semantics.

Each plugin maintains its own aspect metadata via ClassLoader Isolation, preventing cross-plugin interference.

The proxy creation flow follows these steps:

1. AOPService receives a target object or class.
2. AspectProxyFactory determines the proxy type (JDK or ByteBuddy).
3. Applicable interceptors are gathered based on method annotations.
4. Interceptors are ordered by priority and wrapped into an execution chain.
5. The proxy is returned for transparent method interception.

PromptX is an AI capability enhancement framework used in this project to manage AI roles and long-term memory. It allows AI agents (primarily Claude Code) to switch into specific professional modes and persist project-specific knowledge, such as module architectures and API designs, to overcome context window limitations.

Key features include:

• Role System: Quickly switches the AI to a specific professional mode (e.g., java-backend-developer).
• Memory Management: Enables the AI to internalize and remember professional knowledge, best practices, and project structures for long-term use.

Use ScriptScope to isolate variable environments. This allows you to set, get, and remove variables that are only accessible within a specific execution context, preventing global namespace pollution.

Note: V8ScriptEngine does not support ScriptScope.

RhinoScriptEngine scriptEngine = new RhinoScriptEngine();
RhinoScriptScope scriptScope = RhinoScriptScope.of(scriptEngine);

// Set variables
scriptScope.setVariable("x", 10);
scriptScope.setVariable("name", "Legacy");

// Execute in scope
Object result = scriptEngine.execute("'Hello, ' + name + '! x = ' + x", scriptScope);

// Get/Remove variables
Object value = scriptScope.getVariable("name");
scriptScope.removeVariable("name");

The .iterator() method on a query returns a MorphiaCursor.

Warning: Iterators returned by this library are not thread-safe. You should consume the results (e.g., by calling .toList()) or manage synchronization manually if accessing the cursor across threads.

The @RateLimiter annotation provides multiple strategies to control the rate of requests. It supports different algorithms to handle traffic spikes or maintain constant throughput. You can also implement per-key rate limiting (e.g., per user) using keyExpression and provide fallback methods for when limits are exceeded.

public interface RateLimitService {

    @RateLimiter(limit = 5, period = 1000)
    String fixedWindowOperation(String input);

    @RateLimiter(
            limit = 2,
            period = 1000,
            keyExpression = "{#arg0}"
    )
    String perUserOperation(String userId, String data);
}