Mug

SafeSql is a compile-time checked SQL template library for Java designed to prevent accidental SQL injection while allowing developers to write direct, readable SQL. It uses a {placeholder} syntax to define parameters within a SQL string. These placeholders are automatically handled via JDBC PreparedStatement when executing queries, ensuring that parameter values are safely isolated from the SQL command structure.

// Construct a SafeSql with a template and two placeholder values {id} and {name}.
SafeSql sql = SafeSql.of(
    "select id, name, age from users where id = {id} OR name LIKE '%{name}%'",
    userId, userName);

// convenience method to map `ResultSet` to a list of records or Java beans.
List<User> users = sql.query(dataSource, User.class);

The mu.util package provides two complementary libraries for structured string processing in Java:

• StringFormat: Used for static, compile-time safe template formatting and parsing. It uses named placeholders (e.g., {id}) instead of positional specifiers.
• Substring: Used for dynamic, runtime composable substring extraction and splitting. It provides a chainable API for slicing strings safely using Optional-based returns.

Use StringFormat when you have a known structure to parse or format, and Substring when you need to extract ranges or split strings based on dynamic delimiters.

The com.google.common.labs.email package provides a modern, declarative, and secure email address parser and domain model. It is built using compact parser combinators from dot-parse and is designed as a lightweight, thread-safe, and secure alternative to javax.mail.InternetAddress or Apache EmailValidator.

Key characteristics include:

• Immutability: EmailAddress is an immutable record, making it inherently thread-safe.
• Canonicalization: It automatically strips quotes and unescapes characters during parsing. For example, quoted local parts are converted to their canonical form.
• Security-First Design: It rejects trailing unconsumed input (EOF-enforced) and defensively rejects RFC 2047 encoded words inside the local-part or domain to prevent spoofing attacks.

Mug's string processing utilities are designed for safety and clarity:

• StringFormat: Provides structured templates with named placeholders.
• Substring: Provides precise dynamic range selection.
• Both utilities support optional-safe composition, clear semantics, and testable behavior.

SafeSql is a library for writing injection-safe SQL templates in Java without using a DSL or XML. You should use SafeSql if you require:

• Systematically enforced safety: To prevent SQL injection in large-scale environments where developer vigilance is insufficient.
• Actual SQL syntax: To allow direct copy-pasting of queries between your Java code and database consoles for debugging.
• Low learning curve: A WYSIWYG approach that avoids learning a complex Domain Specific Language (DSL).
• Identifier parameterization: The ability to safely parameterize table and column names.
• Complex query composition: Managing dynamic subqueries and their associated parameters automatically.
• Compile-time semantic safety: Preventing accidental parameter misuse (e.g., using a name parameter where an ssn is expected) through type-safe parameter handling.

A BiStream is a specialized API designed for fluently streaming through Map or Multimap entries. While Java 8's Stream is powerful, it becomes verbose when performing operations specifically on Map entries (like transforming keys or filtering values). BiStream provides a more readable and concise alternative for these common Map-centric patterns, reducing boilerplate code required for transformations and flattening.

// Standard Java 8 boilerplate for transforming and filtering Map keys
map.entrySet().stream()
    .map(e -> Map.entry(transform(e.getKey()), e.getValue()))
    .filter(e -> isGood(e.getKey()))
    .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));

// Equivalent, more readable BiStream code
BiStream.from(map)
    .mapKeys(this::transform)
    .filterKeys(this::isGood)
    .toMap();