The singleton field is {@code volatile} to guarantee safe publication
+ * in multi-threaded environments without a full lock on every read.
+ *
MySQL connections require SSL by default. Set
+ * {@code OBSIDIAN_DB_DISABLE_SSL=true} (env) only in local dev/test.
+ *
Credentials are never written to the log.
+ *
+ *
+ *
Pool tuning: explicit timeouts prevent the common failure mode
+ * where stale connections accumulate because Hikari never evicts them.
*/
public class DB
{
- /** Singleton instance */
- private static DB instance;
+ /** Volatile ensures the reference is safely visible across threads. */
+ private static volatile DB instance;
+
+ /**
+ * Thread-local connection — one JDBC connection per thread.
+ *
+ *
Leak risk in thread pools: threads in a pool are never destroyed, so
+ * {@link ThreadLocal} values survive indefinitely unless explicitly removed.
+ * A connection left in {@code threadConnection} after a request finishes holds a
+ * pooled connection open and prevents it from being returned to HikariCP.
+ *
+ *
Required usage contract — every code path that calls {@link #connect()}
+ * or {@link #getConnection()} MUST eventually call {@link #closeConnection()}, even
+ * on exception. The safe patterns are:
+ *
+ *
{@link #withConnection(Callable)} — opens and closes automatically.
+ *
{@link #withTransaction(Callable)} — same, with rollback on failure.
+ *
Servlet/request filters that call {@code DB.closeConnection()} in a
+ * {@code finally} block or via a framework lifecycle hook.
+ *
+ *
+ *
Never call {@link #getConnection()} directly in application code without one
+ * of the above wrappers. Direct calls that miss {@link #closeConnection()} will
+ * silently exhaust the pool under load.
+ */
+ private static final ThreadLocal threadConnection = new ThreadLocal<>();
/** Logger instance */
private final Logger logger;
@@ -22,247 +61,495 @@ public class DB
/** Database type */
private final DatabaseType type;
- /** Database path (for SQLite) or name (for MySQL/PostgreSQL) */
+ /** Database path (SQLite) or database name (MySQL/PostgreSQL) */
private final String dbPath;
+ /** JDBC URL for SQLite */
+ private String jdbcUrl;
+
/** Connection pool for MySQL/PostgreSQL */
private HikariDataSource pool;
+ // ─── STATIC FACTORY METHODS ──────────────────────────────
+
/**
- * Initializes SQLite database.
+ * Initialises a SQLite database.
*
- * @param path Path to SQLite database file
+ * @param path Path to the SQLite file
* @param logger Logger instance
- * @return DB instance
+ * @return The singleton DB instance
*/
public static DB initSQLite(String path, Logger logger) {
- instance = new DB(DatabaseType.SQLITE, path, null, 0, null, null, logger);
+ synchronized (DB.class) {
+ instance = new DB(DatabaseType.SQLITE, path, null, 0, null, null, logger);
+ }
return instance;
}
/**
- * Initializes MySQL database with connection pooling.
+ * Initialises a MySQL/MariaDB connection pool.
*
- * @param host Database host
- * @param port Database port
+ * @param host Database host
+ * @param port Database port
* @param database Database name
- * @param user Database user
+ * @param user Database user
* @param password Database password
- * @param logger Logger instance
- * @return DB instance
+ * @param logger Logger instance
+ * @return The singleton DB instance
*/
- public static DB initMySQL(String host, int port, String database, String user, String password, Logger logger) {
- instance = new DB(DatabaseType.MYSQL, database, host, port, user, password, logger);
+ public static DB initMySQL(String host, int port, String database,
+ String user, String password, Logger logger) {
+ synchronized (DB.class) {
+ instance = new DB(DatabaseType.MYSQL, database, host, port, user, password, logger);
+ }
return instance;
}
/**
- * Initializes PostgreSQL database with connection pooling.
+ * Initialises a PostgreSQL connection pool.
*
- * @param host Database host
- * @param port Database port
+ * @param host Database host
+ * @param port Database port
* @param database Database name
- * @param user Database user
+ * @param user Database user
* @param password Database password
- * @param logger Logger instance
- * @return DB instance
+ * @param logger Logger instance
+ * @return The singleton DB instance
*/
- public static DB initPostgreSQL(String host, int port, String database, String user, String password, Logger logger) {
- instance = new DB(DatabaseType.POSTGRESQL, database, host, port, user, password, logger);
+ public static DB initPostgreSQL(String host, int port, String database,
+ String user, String password, Logger logger) {
+ synchronized (DB.class) {
+ instance = new DB(DatabaseType.POSTGRESQL, database, host, port, user, password, logger);
+ }
return instance;
}
/**
- * Gets the singleton DB instance.
+ * Returns the singleton instance, throwing if not yet initialised.
*
- * @return DB instance
- * @throws IllegalStateException if database not initialized
+ * @return The DB instance
*/
public static DB getInstance() {
- if (instance == null) {
- throw new IllegalStateException("Database not initialized!");
+ DB db = instance; // single volatile read
+ if (db == null) {
+ throw new IllegalStateException(
+ "Database not initialised — call initSQLite / initMySQL / initPostgreSQL first.");
}
- return instance;
+ return db;
}
+ // ─── STATIC CONVENIENCE METHODS ──────────────────────────
+
/**
- * Executes a task with database connection.
- * Static convenience method.
+ * Borrows a connection for the duration of {@code task}, then returns it.
*
- * @param task Task to execute
- * @param Return type
- * @return Task result
+ * @param task The task
+ * @return The task's return value
*/
public static T withConnection(Callable task) {
return getInstance().executeWithConnection(task);
}
/**
- * Executes a task within a transaction.
- * Static convenience method.
+ * Wraps {@code task} in a database transaction, rolling back on any exception.
*
- * @param task Task to execute
- * @param Return type
- * @return Task result
+ * @param task The task
+ * @return The task's return value
*/
public static T withTransaction(Callable task) {
return getInstance().executeWithTransaction(task);
}
- /**
- * Private constructor.
- * Initializes database connection or connection pool.
- *
- * @param type Database type
- * @param database Database path/name
- * @param host Database host (null for SQLite)
- * @param port Database port (0 for SQLite)
- * @param user Database user (null for SQLite)
- * @param password Database password (null for SQLite)
- * @param logger Logger instance
- */
- private DB(DatabaseType type, String database, String host, int port, String user, String password, Logger logger)
+ // ─── CONSTRUCTOR ─────────────────────────────────────────
+
+ private DB(DatabaseType type, String database, String host, int port,
+ String user, String password, Logger logger)
{
- this.type = type;
+ this.type = type;
this.logger = logger;
this.dbPath = database;
if (type == DatabaseType.SQLITE) {
- logger.info("SQLite database initialized: " + database);
+ this.jdbcUrl = "jdbc:sqlite:" + database;
+ logger.info("SQLite database initialised: {}", database);
} else {
setupConnectionPool(type, host, port, database, user, password);
}
}
- /**
- * Sets up HikariCP connection pool for MySQL/PostgreSQL.
- *
- * @param type Database type
- * @param host Database host
- * @param port Database port
- * @param database Database name
- * @param user Database user
- * @param password Database password
- */
- private void setupConnectionPool(DatabaseType type, String host, int port, String database, String user, String password)
+ private void setupConnectionPool(DatabaseType type, String host, int port,
+ String database, String user, String password)
{
HikariConfig config = new HikariConfig();
- String url = switch (type) {
- case MYSQL -> String.format("jdbc:mysql://%s:%d/%s?useSSL=false", host, port, database);
- case POSTGRESQL -> String.format("jdbc:postgresql://%s:%d/%s", host, port, database);
- default -> throw new IllegalArgumentException("Unsupported type: " + type);
- };
-
+ String url = buildJdbcUrl(type, host, port, database);
config.setJdbcUrl(url);
config.setUsername(user);
config.setPassword(password);
+
+ // Pool sizing
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);
+ // ── Timeouts ────────────────────────────────────────
+ // How long a caller waits for a connection before an exception is thrown.
+ config.setConnectionTimeout(30_000); // 30 s
+ // How long an idle connection may sit in the pool before being evicted.
+ config.setIdleTimeout(600_000); // 10 min
+ // Maximum lifetime of any connection in the pool, regardless of activity.
+ // Must be shorter than the server's wait_timeout to avoid "Connection reset" errors.
+ config.setMaxLifetime(1_800_000); // 30 min
+ // How often Hikari probes idle connections to keep them alive.
+ config.setKeepaliveTime(60_000); // 1 min
+ // Warn if a connection is held for longer than this — catches ThreadLocal leaks
+ // where closeConnection() was never called after a request. Set to 0 to disable.
+ config.setLeakDetectionThreshold(5_000); // 5 s
+
+ config.setAutoCommit(true);
+ config.setPoolName("ObsidianDB-" + type.name());
+
pool = new HikariDataSource(config);
- logger.info("Connection pool initialized for " + type);
+ // Log host+database but NOT credentials
+ logger.info("Connection pool initialised for {} at {}:{}/{}", type, host, port, database);
}
/**
- * Executes a task with database connection.
- * Opens connection if needed, closes it after execution.
+ * Builds a JDBC URL for the given database type.
*
- * @param task Task to execute
- * @param Return type
- * @return Task result
+ *
SSL is enabled for both MySQL and PostgreSQL by default.
+ * Disable only for local dev/test by setting {@code OBSIDIAN_DB_DISABLE_SSL=true}.
+ */
+ private String buildJdbcUrl(DatabaseType type, String host, int port, String database) {
+ boolean disableSsl = "true".equalsIgnoreCase(System.getenv("OBSIDIAN_DB_DISABLE_SSL"));
+ return switch (type) {
+ case MYSQL -> {
+ if (disableSsl) {
+ logger.warn("MySQL SSL verification is DISABLED (OBSIDIAN_DB_DISABLE_SSL=true). " +
+ "Do not use this setting in production.");
+ yield String.format(
+ "jdbc:mysql://%s:%d/%s?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC",
+ host, port, database);
+ }
+ yield String.format(
+ "jdbc:mysql://%s:%d/%s?useSSL=true&verifyServerCertificate=true&serverTimezone=UTC",
+ host, port, database);
+ }
+ case POSTGRESQL -> {
+ if (disableSsl) {
+ logger.warn("PostgreSQL SSL verification is DISABLED (OBSIDIAN_DB_DISABLE_SSL=true). " +
+ "Do not use this setting in production.");
+ yield String.format("jdbc:postgresql://%s:%d/%s?ssl=false", host, port, database);
+ }
+ // sslmode=verify-full requires the server certificate to match the hostname
+ // and be signed by a trusted CA — equivalent to MySQL verifyServerCertificate=true.
+ yield String.format(
+ "jdbc:postgresql://%s:%d/%s?ssl=true&sslmode=verify-full",
+ host, port, database);
+ }
+ default -> throw new IllegalArgumentException("Unsupported database type: " + type);
+ };
+ }
+
+ // ─── CONNECTION MANAGEMENT ───────────────────────────────
+
+ /**
+ * Opens a connection for the current thread (no-op if already open).
+ */
+ public void connect()
+ {
+ try {
+ if (threadConnection.get() != null) return;
+
+ Connection conn;
+ if (type == DatabaseType.SQLITE) {
+ conn = DriverManager.getConnection(jdbcUrl);
+ } else if (pool != null) {
+ conn = pool.getConnection();
+ } else {
+ throw new IllegalStateException("No connection pool available");
+ }
+ threadConnection.set(conn);
+ } catch (SQLException e) {
+ logger.error("Connection failed: {}", e.getMessage());
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Returns true if the current thread holds an open connection.
+ */
+ public static boolean hasConnection() {
+ Connection conn = threadConnection.get();
+ if (conn == null) return false;
+ try {
+ return !conn.isClosed();
+ } catch (SQLException e) {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the current thread's connection, opening one if necessary.
+ */
+ public static Connection getConnection() {
+ Connection conn = threadConnection.get();
+ if (conn == null) {
+ getInstance().connect();
+ conn = threadConnection.get();
+ }
+ return conn;
+ }
+
+ /**
+ * Closes and removes the current thread's connection.
+ */
+ public static void closeConnection() {
+ Connection conn = threadConnection.get();
+ if (conn != null) {
+ try {
+ conn.close();
+ } catch (SQLException ignore) {}
+ threadConnection.remove();
+ }
+ }
+
+ // ─── EXECUTE WITH CONNECTION / TRANSACTION ───────────────
+
+ /**
+ * Executes {@code task} with an open connection, closing it afterwards
+ * only if this call was the one that opened it.
+ *
+ * @param task The task
+ * @return The task's return value
*/
public T executeWithConnection(Callable task)
{
boolean created = false;
try {
- if (!Base.hasConnection()) {
+ if (!hasConnection()) {
connect();
created = true;
}
return task.call();
} catch (Exception e) {
- logger.error("Database error: " + e.getMessage());
+ logger.error("Database error: {}", e.getMessage());
throw new RuntimeException(e);
} finally {
- if (created && Base.hasConnection()) {
- Base.close();
+ if (created && hasConnection()) {
+ closeConnection();
}
}
}
/**
- * Executes a task within a transaction.
- * Commits on success, rolls back on failure.
+ * Executes {@code task} inside a transaction.
+ * Rolls back and rethrows on any exception.
*
- * @param task Task to execute
- * @param Return type
- * @return Task result
+ * @param task The task
+ * @return The task's return value
*/
public T executeWithTransaction(Callable task)
{
boolean created = false;
try {
- if (!Base.hasConnection()) {
+ if (!hasConnection()) {
connect();
created = true;
}
- Base.openTransaction();
+ Connection conn = getConnection();
+ conn.setAutoCommit(false);
T result = task.call();
- Base.commitTransaction();
+ conn.commit();
+ conn.setAutoCommit(true);
return result;
} catch (Exception e) {
- if (Base.hasConnection()) {
- Base.rollbackTransaction();
+ try {
+ Connection conn = threadConnection.get();
+ if (conn != null) {
+ conn.rollback();
+ conn.setAutoCommit(true);
+ }
+ } catch (SQLException rollbackEx) {
+ logger.error("Rollback failed: {}", rollbackEx.getMessage());
}
- logger.error("Transaction failed: " + e.getMessage());
+ logger.error("Transaction failed: {}", e.getMessage());
throw new RuntimeException(e);
} finally {
- if (created && Base.hasConnection()) {
- Base.close();
+ if (created && hasConnection()) {
+ closeConnection();
}
}
}
+ // ─── RAW SQL EXECUTION ───────────────────────────────────
+
/**
- * Closes database connection and connection pool.
+ * Executes a DDL/DML statement (CREATE, INSERT, UPDATE, DELETE).
+ * All variable data must be passed as {@code params} — never interpolated.
*/
- public void close()
- {
- if (Base.hasConnection()) {
- Base.close();
+ public static void exec(String sql, Object... params) {
+ Connection conn = getConnection();
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ bindParams(stmt, params);
+ stmt.executeUpdate();
+ } catch (SQLException e) {
+ throw new RuntimeException("SQL exec failed: " + sql, e);
+ }
+ }
+
+ /**
+ * Executes a SELECT query and returns a list of rows.
+ * All variable data must be passed as {@code params} — never interpolated.
+ */
+ public static List> findAll(String sql, Object... params) {
+ Connection conn = getConnection();
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ bindParams(stmt, params);
+ try (ResultSet rs = stmt.executeQuery()) {
+ return resultSetToList(rs);
+ }
+ } catch (SQLException e) {
+ throw new RuntimeException("SQL query failed: " + sql, e);
}
- if (pool != null) {
- pool.close();
- logger.info("Connection pool closed");
+ }
+
+ /**
+ * Executes a SELECT and returns the first cell value, or {@code null}.
+ */
+ public static Object firstCell(String sql, Object... params) {
+ Connection conn = getConnection();
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ bindParams(stmt, params);
+ try (ResultSet rs = stmt.executeQuery()) {
+ if (rs.next()) {
+ return rs.getObject(1);
+ }
+ return null;
+ }
+ } catch (SQLException e) {
+ throw new RuntimeException("SQL firstCell failed: " + sql, e);
}
}
/**
- * Gets database type.
+ * Executes a SELECT and returns the first row as a map, or {@code null}.
+ */
+ public static Map firstRow(String sql, Object... params) {
+ Connection conn = getConnection();
+ try (PreparedStatement stmt = conn.prepareStatement(sql)) {
+ bindParams(stmt, params);
+ try (ResultSet rs = stmt.executeQuery()) {
+ List> rows = resultSetToList(rs);
+ return rows.isEmpty() ? null : rows.get(0);
+ }
+ } catch (SQLException e) {
+ throw new RuntimeException("SQL firstRow failed: " + sql, e);
+ }
+ }
+
+ /**
+ * Executes an INSERT and returns the generated key, or {@code null}.
+ */
+ public static Object insertAndGetKey(String sql, Object... params) {
+ Connection conn = getConnection();
+ try (PreparedStatement stmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
+ bindParams(stmt, params);
+ stmt.executeUpdate();
+ try (ResultSet keys = stmt.getGeneratedKeys()) {
+ if (keys.next()) {
+ return keys.getObject(1);
+ }
+ return null;
+ }
+ } catch (SQLException e) {
+ throw new RuntimeException("SQL insert failed: " + sql, e);
+ }
+ }
+
+ // ─── CLOSE / SHUTDOWN ────────────────────────────────────
+
+ /**
+ * Closes the current thread's connection and shuts down the pool.
*
- * @return Database type
+ *
Synchronized on {@code DB.class} for the same reason as the {@code init*} methods:
+ * a thread calling {@code close()} concurrently with another thread reading {@code instance}
+ * could observe a non-null instance whose pool has already been shut down. The lock ensures
+ * that once {@code close()} completes, any subsequent {@code getInstance()} either gets
+ * a valid instance or throws — never a half-closed one.
*/
- public DatabaseType getType() {
- return type;
+ public void close()
+ {
+ synchronized (DB.class) {
+ closeConnection();
+ if (pool != null) {
+ pool.close();
+ pool = null;
+ logger.info("Connection pool closed ({})", type);
+ }
+ instance = null;
+ }
}
+ // ─── ACCESSORS ───────────────────────────────────────────
+
/**
- * Opens database connection.
- * Uses JDBC for SQLite, connection pool for MySQL/PostgreSQL.
+ * Returns the database type.
+ *
+ * @return The database type
*/
- public void connect()
+ public DatabaseType getType() { return type; }
+
+ /**
+ * Returns the logger.
+ *
+ * @return The logger
+ */
+ public Logger getLogger() { return logger; }
+
+ // ─── INTERNAL HELPERS ────────────────────────────────────
+
+ private static void bindParams(PreparedStatement stmt, Object... params) throws SQLException {
+ for (int i = 0; i < params.length; i++) {
+ Object value = params[i];
+ if (value == null) {
+ stmt.setNull(i + 1, Types.NULL);
+ } else if (value instanceof String) {
+ stmt.setString(i + 1, (String) value);
+ } else if (value instanceof Integer) {
+ stmt.setInt(i + 1, (Integer) value);
+ } else if (value instanceof Long) {
+ stmt.setLong(i + 1, (Long) value);
+ } else if (value instanceof Double) {
+ stmt.setDouble(i + 1, (Double) value);
+ } else if (value instanceof Float) {
+ stmt.setFloat(i + 1, (Float) value);
+ } else if (value instanceof Boolean) {
+ stmt.setBoolean(i + 1, (Boolean) value);
+ } else if (value instanceof java.util.Date) {
+ stmt.setTimestamp(i + 1, new Timestamp(((java.util.Date) value).getTime()));
+ } else if (value instanceof java.time.LocalDateTime) {
+ stmt.setTimestamp(i + 1, Timestamp.valueOf((java.time.LocalDateTime) value));
+ } else if (value instanceof java.time.LocalDate) {
+ stmt.setDate(i + 1, Date.valueOf((java.time.LocalDate) value));
+ } else {
+ stmt.setObject(i + 1, value);
+ }
+ }
+ }
+
+ private static List> resultSetToList(ResultSet rs) throws SQLException
{
- try {
- if (type == DatabaseType.SQLITE) {
- String url = "jdbc:sqlite:" + dbPath;
- Base.open("org.sqlite.JDBC", url, "", "");
- } else if (pool != null) {
- Base.open(pool);
+ List> results = new ArrayList<>();
+ ResultSetMetaData meta = rs.getMetaData();
+ int colCount = meta.getColumnCount();
+
+ while (rs.next()) {
+ Map row = new LinkedHashMap<>();
+ for (int i = 1; i <= colCount; i++) {
+ row.put(meta.getColumnLabel(i), rs.getObject(i));
}
- } catch (Exception e) {
- logger.error("Connection failed: " + e.getMessage());
- throw new RuntimeException(e);
+ results.add(row);
}
+ return results;
}
}
\ No newline at end of file
diff --git a/src/main/java/com/obsidian/core/database/DatabaseLoader.java b/src/main/java/com/obsidian/core/database/DatabaseLoader.java
index eecbbb5..cce07a1 100644
--- a/src/main/java/com/obsidian/core/database/DatabaseLoader.java
+++ b/src/main/java/com/obsidian/core/database/DatabaseLoader.java
@@ -13,13 +13,11 @@
*/
public class DatabaseLoader
{
- /** Logger instance */
public final static Logger logger = LoggerFactory.getLogger(DatabaseLoader.class);
/**
- * Loads and initializes database connection from environment configuration.
+ * Load Database.
*
- * @throws IllegalArgumentException if database type is not supported
*/
public static void loadDatabase()
{
@@ -38,29 +36,52 @@ public static void loadDatabase()
DB.initSQLite(dbPath, logger);
break;
case MYSQL:
- String mysqlHost = env.get(EnvKeys.DB_HOST);
- String mysqlPort = env.get(EnvKeys.DB_PORT);
DB.initMySQL(
- mysqlHost != null ? mysqlHost : "localhost",
- Integer.parseInt(mysqlPort != null ? mysqlPort : "3306"),
- env.get(EnvKeys.DB_NAME),
- env.get(EnvKeys.DB_USER),
- env.get(EnvKeys.DB_PASSWORD),
+ resolveHost(env, "localhost"),
+ resolvePort(env, 3306),
+ requireEnv(env, EnvKeys.DB_NAME, "DB_NAME"),
+ requireEnv(env, EnvKeys.DB_USER, "DB_USER"),
+ requireEnv(env, EnvKeys.DB_PASSWORD, "DB_PASSWORD"),
logger
);
break;
case POSTGRESQL:
- String pgHost = env.get(EnvKeys.DB_HOST);
- String pgPort = env.get(EnvKeys.DB_PORT);
DB.initPostgreSQL(
- pgHost != null ? pgHost : "localhost",
- Integer.parseInt(pgPort != null ? pgPort : "5432"),
- env.get(EnvKeys.DB_NAME),
- env.get(EnvKeys.DB_USER),
- env.get(EnvKeys.DB_PASSWORD),
+ resolveHost(env, "localhost"),
+ resolvePort(env, 5432),
+ requireEnv(env, EnvKeys.DB_NAME, "DB_NAME"),
+ requireEnv(env, EnvKeys.DB_USER, "DB_USER"),
+ requireEnv(env, EnvKeys.DB_PASSWORD, "DB_PASSWORD"),
logger
);
break;
}
}
+
+ private static String resolveHost(EnvLoader env, String defaultHost) {
+ String host = env.get(EnvKeys.DB_HOST);
+ return (host != null && !host.isEmpty()) ? host : defaultHost;
+ }
+
+ private static int resolvePort(EnvLoader env, int defaultPort) {
+ String port = env.get(EnvKeys.DB_PORT);
+ if (port == null || port.isEmpty()) return defaultPort;
+ try {
+ return Integer.parseInt(port.trim());
+ } catch (NumberFormatException e) {
+ logger.warn("Invalid DB_PORT value '{}', using default {}", port, defaultPort);
+ return defaultPort;
+ }
+ }
+
+ private static String requireEnv(EnvLoader env, String key, String label) {
+ String value = env.get(key);
+ if (value == null || value.isEmpty()) {
+ throw new IllegalStateException(
+ "Missing required environment variable: " + label + ". " +
+ "Set it in your .env file or environment before starting the application."
+ );
+ }
+ return value;
+ }
}
\ No newline at end of file
diff --git a/src/main/java/com/obsidian/core/database/DatabaseType.java b/src/main/java/com/obsidian/core/database/DatabaseType.java
index ad5ef8e..2841e66 100644
--- a/src/main/java/com/obsidian/core/database/DatabaseType.java
+++ b/src/main/java/com/obsidian/core/database/DatabaseType.java
@@ -15,16 +15,20 @@ public enum DatabaseType
this.value = value;
}
+ /**
+ * Value.
+ *
+ * @return The string value
+ */
public String value() {
return value;
}
/**
- * Resolves a DatabaseType from a string value.
- * Defaults to SQLITE if null, empty, or unrecognized.
+ * From String.
*
- * @param value The string value (case-insensitive)
- * @return The matching DatabaseType
+ * @param value The value to compare against
+ * @return This instance for method chaining
*/
public static DatabaseType fromString(String value) {
if (value == null || value.isBlank()) return SQLITE;
@@ -33,4 +37,4 @@ public static DatabaseType fromString(String value) {
}
return SQLITE;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/com/obsidian/core/database/Migration.java b/src/main/java/com/obsidian/core/database/Migration.java
index 89f44fc..7451e38 100644
--- a/src/main/java/com/obsidian/core/database/Migration.java
+++ b/src/main/java/com/obsidian/core/database/Migration.java
@@ -1,6 +1,6 @@
package com.obsidian.core.database;
-import org.javalite.activejdbc.Base;
+import com.obsidian.core.database.orm.query.SqlIdentifier;
import org.slf4j.Logger;
import java.util.ArrayList;
@@ -9,6 +9,13 @@
/**
* Base class for database migrations.
* Provides schema modification methods with multi-database support.
+ * Uses DB.exec() instead of ActiveJDBC Base.exec().
+ *
+ *
Security: every table name and column name passed to DDL methods
+ * is validated by {@link SqlIdentifier#requireIdentifier(String)} before being
+ * interpolated into SQL. DDL statements cannot use PreparedStatement placeholders
+ * for identifiers, so this guard is the only defence against injection through
+ * dynamically-constructed migration names.
*/
public abstract class Migration
{
@@ -31,83 +38,118 @@ public abstract class Migration
/**
* Creates a new table with specified columns.
*
- * @param tableName Name of table to create
- * @param builder Callback to define table structure
+ * @param tableName the table name — must be a valid SQL identifier
+ * @param builder the column/constraint builder callback
*/
protected void createTable(String tableName, TableBuilder builder)
{
+ SqlIdentifier.requireIdentifier(tableName);
+
StringBuilder sql = new StringBuilder();
sql.append("CREATE TABLE IF NOT EXISTS ").append(tableName).append(" (");
List columns = new ArrayList<>();
- builder.build(new Blueprint(columns, type));
+ List constraints = new ArrayList<>();
+ builder.build(new Blueprint(columns, constraints, type));
+
+ List allParts = new ArrayList<>(columns);
+ allParts.addAll(constraints);
- sql.append(String.join(", ", columns));
+ sql.append(String.join(", ", allParts));
sql.append(")");
- Base.exec(sql.toString());
- logger.info("Table created: " + tableName);
+ DB.exec(sql.toString());
+ logger.info("Table created: {}", tableName);
}
/**
* Drops a table if it exists.
*
- * @param tableName Name of table to drop
+ * @param tableName the table name — must be a valid SQL identifier
*/
protected void dropTable(String tableName) {
- Base.exec("DROP TABLE IF EXISTS " + tableName);
- logger.info("Table dropped: " + tableName);
+ SqlIdentifier.requireIdentifier(tableName);
+ DB.exec("DROP TABLE IF EXISTS " + tableName);
+ logger.info("Table dropped: {}", tableName);
}
/**
- * Adds a column to existing table.
+ * Adds a column to an existing table.
*
- * @param tableName Table name
- * @param columnName Column name
- * @param definition Column definition (type and constraints)
+ * @param tableName the table name — must be a valid SQL identifier
+ * @param columnName the column name — must be a valid SQL identifier
+ * @param definition the raw column type definition (e.g. "VARCHAR(255) NOT NULL")
*/
protected void addColumn(String tableName, String columnName, String definition) {
- Base.exec(String.format("ALTER TABLE %s ADD COLUMN %s %s", tableName, columnName, definition));
- logger.info("Column added: " + tableName + "." + columnName);
+ SqlIdentifier.requireIdentifier(tableName);
+ SqlIdentifier.requireIdentifier(columnName);
+ DB.exec("ALTER TABLE " + tableName + " ADD COLUMN " + columnName + " " + definition);
+ logger.info("Column added: {}.{}", tableName, columnName);
}
/**
- * Drops a column from table.
- * Note: Not supported in SQLite.
+ * Drops a column from a table.
+ * No-op on SQLite (not supported).
*
- * @param tableName Table name
- * @param columnName Column name
+ * @param tableName the table name — must be a valid SQL identifier
+ * @param columnName the column name — must be a valid SQL identifier
*/
protected void dropColumn(String tableName, String columnName) {
if (type == DatabaseType.SQLITE) {
- logger.warn("SQLite does not support DROP COLUMN - migration skipped");
+ logger.warn("SQLite does not support DROP COLUMN — migration skipped for column: {}", columnName);
return;
}
- Base.exec(String.format("ALTER TABLE %s DROP COLUMN %s", tableName, columnName));
- logger.info("Column dropped: " + tableName + "." + columnName);
+ SqlIdentifier.requireIdentifier(tableName);
+ SqlIdentifier.requireIdentifier(columnName);
+ DB.exec("ALTER TABLE " + tableName + " DROP COLUMN " + columnName);
+ logger.info("Column dropped: {}.{}", tableName, columnName);
}
/**
- * Checks if a table exists in database.
+ * Checks if a table exists in the database.
*
- * @param tableName Table name to check
- * @return true if table exists, false otherwise
+ * @param tableName the table name to check (used as a bound parameter, not interpolated)
+ * @return {@code true} if the table exists
*/
protected boolean tableExists(String tableName)
{
String checkSQL = switch (type) {
- case MYSQL -> "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ?";
+ case MYSQL -> "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ?";
case POSTGRESQL -> "SELECT COUNT(*) FROM information_schema.tables WHERE table_name = ?";
- default -> "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?";
+ default -> "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?";
};
- Object result = Base.firstCell(checkSQL, tableName);
+ Object result = DB.firstCell(checkSQL, tableName);
if (result == null) return false;
long count = result instanceof Long ? (Long) result : Long.parseLong(result.toString());
return count > 0;
}
+ /**
+ * Executes raw SQL with bound parameters.
+ * The caller is responsible for ensuring {@code sql} is safe.
+ *
+ * @param sql raw SQL (trusted, not derived from user input)
+ * @param params values bound via PreparedStatement
+ */
+ protected void raw(String sql, Object... params) {
+ DB.exec(sql, params);
+ }
+
+ /**
+ * Renames a table.
+ *
+ * @param from the current table name — must be a valid SQL identifier
+ * @param to the new table name — must be a valid SQL identifier
+ */
+ protected void renameTable(String from, String to) {
+ SqlIdentifier.requireIdentifier(from);
+ SqlIdentifier.requireIdentifier(to);
+ DB.exec("ALTER TABLE " + from + " RENAME TO " + to);
+ logger.info("Table renamed: {} -> {}", from, to);
+ }
+
/**
* Functional interface for table building.
*/
@@ -119,150 +161,317 @@ public interface TableBuilder {
/**
* Schema builder for defining table columns.
* Provides fluent API for column definitions with database-specific syntax.
+ *
+ * Enhanced from original with:
+ * - foreignKey() support
+ * - cascadeOnDelete() / nullOnDelete()
+ * - softDeletes()
+ * - json() column type
+ * - Separate constraints list for foreign keys / composite indexes
*/
public static class Blueprint {
private final List columns;
+ private final List constraints;
private final DatabaseType dbType;
- public Blueprint(List columns, DatabaseType dbType) {
+ /**
+ * Creates a new Blueprint instance.
+ *
+ * @param columns column definitions list (mutated by builder methods)
+ * @param constraints constraint definitions list (mutated by builder methods)
+ * @param dbType the target database type
+ */
+ public Blueprint(List columns, List constraints, DatabaseType dbType) {
this.columns = columns;
+ this.constraints = constraints;
this.dbType = dbType;
}
/**
- * Adds auto-incrementing primary key named "id".
+ * Backward-compatible 2-arg constructor.
+ *
+ * @param columns column definitions list
+ * @param dbType the target database type
+ */
+ public Blueprint(List columns, DatabaseType dbType) {
+ this(columns, new ArrayList<>(), dbType);
+ }
+
+ // ─── INTERNAL COLUMN HELPERS ─────────────────────────
+
+ /**
+ * Central column-addition helper — validates the column name via
+ * {@link SqlIdentifier#requireIdentifier} before interpolating it
+ * into DDL. All public Blueprint methods that accept a column name
+ * must route through here instead of calling {@code columns.add}
+ * directly, preventing DDL injection via malformed column names.
+ *
+ *
{@code type} is always a hard-coded literal produced by this
+ * class (e.g. {@code "TEXT"}, {@code "VARCHAR(255)"}), never derived
+ * from caller input, so it does not need separate validation.
+ */
+ private Blueprint col(String name, String type) {
+ SqlIdentifier.requireIdentifier(name);
+ columns.add(name + " " + type);
+ return this;
+ }
+
+ /**
+ * Validates and records a FOREIGN KEY constraint for the last column.
+ * Both the referenced table and column are validated as identifiers.
+ */
+ private Blueprint fk(String refTable, String refColumn, String colName) {
+ SqlIdentifier.requireIdentifier(refTable);
+ SqlIdentifier.requireIdentifier(refColumn);
+ constraints.add("FOREIGN KEY (" + colName + ") REFERENCES " + refTable + "(" + refColumn + ")");
+ return this;
+ }
+
+ // ─── PRIMARY KEY ─────────────────────────────────────
+
+ /**
+ * Adds an auto-increment primary key column named {@code id}.
+ *
+ * @return This instance for method chaining
*/
public Blueprint id() {
return id("id");
}
/**
- * Adds auto-incrementing primary key with custom name.
+ * Adds an auto-increment primary key column with a custom name.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint id(String name) {
- String column = switch (dbType) {
- case MYSQL -> name + " INT AUTO_INCREMENT PRIMARY KEY";
- case POSTGRESQL -> name + " SERIAL PRIMARY KEY";
- default -> name + " INTEGER PRIMARY KEY AUTOINCREMENT";
+ SqlIdentifier.requireIdentifier(name);
+ String type = switch (dbType) {
+ case MYSQL -> "INT AUTO_INCREMENT PRIMARY KEY";
+ case POSTGRESQL -> "SERIAL PRIMARY KEY";
+ default -> "INTEGER PRIMARY KEY AUTOINCREMENT";
};
- columns.add(column);
+ columns.add(name + " " + type);
return this;
}
/**
- * Adds VARCHAR/TEXT column with default length 255.
+ * UUID primary key.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint uuid(String name) {
+ return col(name, "VARCHAR(36)");
+ }
+
+ // ─── STRING / TEXT ───────────────────────────────────
+
+ /**
+ * String column (VARCHAR 255 or TEXT on SQLite).
+ *
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint string(String name) {
return string(name, 255);
}
/**
- * Adds VARCHAR/TEXT column with custom length.
+ * String column with a custom length.
*
- * @param name Column name
- * @param length Maximum length
+ * @param name the column name
+ * @param length the maximum length
+ * @return This instance for method chaining
*/
public Blueprint string(String name, int length) {
String type = dbType == DatabaseType.SQLITE ? "TEXT" : "VARCHAR(" + length + ")";
- columns.add(name + " " + type);
- return this;
+ return col(name, type);
}
/**
- * Adds TEXT column.
+ * TEXT column.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint text(String name) {
- columns.add(name + " TEXT");
- return this;
+ return col(name, "TEXT");
}
/**
- * Adds INTEGER column.
+ * MEDIUMTEXT column (TEXT on non-MySQL).
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint mediumText(String name) {
+ String type = dbType == DatabaseType.MYSQL ? "MEDIUMTEXT" : "TEXT";
+ return col(name, type);
+ }
+
+ /**
+ * LONGTEXT column (TEXT on non-MySQL).
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint longText(String name) {
+ String type = dbType == DatabaseType.MYSQL ? "LONGTEXT" : "TEXT";
+ return col(name, type);
+ }
+
+ // ─── NUMERIC ─────────────────────────────────────────
+
+ /**
+ * INT / INTEGER column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint integer(String name) {
String type = dbType == DatabaseType.POSTGRESQL ? "INTEGER" : "INT";
- columns.add(name + " " + type);
- return this;
+ return col(name, type);
+ }
+
+ /**
+ * TINYINT column (INTEGER on SQLite).
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint tinyInteger(String name) {
+ String type = dbType == DatabaseType.SQLITE ? "INTEGER" : "TINYINT";
+ return col(name, type);
}
/**
- * Adds BIGINT column.
+ * SMALLINT column (INTEGER on SQLite).
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint smallInteger(String name) {
+ String type = dbType == DatabaseType.SQLITE ? "INTEGER" : "SMALLINT";
+ return col(name, type);
+ }
+
+ /**
+ * BIGINT column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint bigInteger(String name) {
- columns.add(name + " BIGINT");
- return this;
+ return col(name, "BIGINT");
}
/**
- * Adds DECIMAL column.
+ * DECIMAL column with explicit precision and scale.
*
- * @param name Column name
- * @param precision Total digits
- * @param scale Decimal places
+ * @param name the column name
+ * @param precision total digits
+ * @param scale digits after decimal point
+ * @return This instance for method chaining
*/
public Blueprint decimal(String name, int precision, int scale) {
- columns.add(name + " DECIMAL(" + precision + "," + scale + ")");
- return this;
+ return col(name, "DECIMAL(" + precision + "," + scale + ")");
+ }
+
+ /**
+ * DECIMAL(10,2) column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint decimal(String name) {
+ return decimal(name, 10, 2);
}
/**
- * Adds BOOLEAN column.
+ * FLOAT column.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint floatCol(String name) {
+ return col(name, "FLOAT");
+ }
+
+ /**
+ * DOUBLE column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint doubleCol(String name) {
+ return col(name, "DOUBLE");
+ }
+
+ // ─── BOOLEAN ─────────────────────────────────────────
+
+ /**
+ * BOOLEAN column (INTEGER on SQLite).
+ *
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint bool(String name) {
String type = dbType == DatabaseType.SQLITE ? "INTEGER" : "BOOLEAN";
- columns.add(name + " " + type);
- return this;
+ return col(name, type);
}
+ // ─── DATE / TIME ─────────────────────────────────────
+
/**
- * Adds DATE column.
+ * DATE column.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint date(String name) {
- columns.add(name + " DATE");
- return this;
+ return col(name, "DATE");
}
/**
- * Adds DATETIME/TIMESTAMP column.
+ * DATETIME / TIMESTAMP / TEXT column depending on database.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint dateTime(String name) {
String type = switch (dbType) {
case POSTGRESQL -> "TIMESTAMP";
- case MYSQL -> "DATETIME";
- default -> "TEXT";
+ case MYSQL -> "DATETIME";
+ default -> "TEXT";
};
- columns.add(name + " " + type);
- return this;
+ return col(name, type);
}
/**
- * Adds TIMESTAMP column.
+ * TIMESTAMP column.
*
- * @param name Column name
+ * @param name the column name
+ * @return This instance for method chaining
*/
public Blueprint timestamp(String name) {
- columns.add(name + " TIMESTAMP");
- return this;
+ return col(name, "TIMESTAMP");
}
/**
- * Adds created_at and updated_at timestamp columns.
+ * TIME column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint time(String name) {
+ return col(name, "TIME");
+ }
+
+ /**
+ * Adds {@code created_at} and {@code updated_at} columns with appropriate defaults.
+ *
+ * @return This instance for method chaining
*/
public Blueprint timestamps()
{
@@ -280,45 +489,227 @@ public Blueprint timestamps()
}
/**
- * Adds NOT NULL constraint to last column.
+ * Adds a nullable {@code deleted_at} column for soft deletes.
+ *
+ * @return This instance for method chaining
*/
- public Blueprint notNull() {
- if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " NOT NULL");
+ public Blueprint softDeletes() {
+ dateTime("deleted_at");
+ nullable();
+ return this;
+ }
+
+ // ─── JSON ────────────────────────────────────────────
+
+ /**
+ * JSON column (TEXT on SQLite).
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint json(String name) {
+ String type = dbType == DatabaseType.SQLITE ? "TEXT" : "JSON";
+ return col(name, type);
+ }
+
+ // ─── BLOB ────────────────────────────────────────────
+
+ /**
+ * BLOB column.
+ *
+ * @param name the column name
+ * @return This instance for method chaining
+ */
+ public Blueprint blob(String name) {
+ return col(name, "BLOB");
+ }
+
+ // ─── ENUM ────────────────────────────────────────────
+
+ /**
+ * ENUM column (CHECK constraint on PostgreSQL / SQLite).
+ *
+ * @param name the column name
+ * @param values allowed enum values
+ * @return This instance for method chaining
+ */
+ public Blueprint enumCol(String name, String... values) {
+ if (dbType == DatabaseType.MYSQL) {
+ String vals = "'" + String.join("', '", values) + "'";
+ col(name, "ENUM(" + vals + ")");
+ } else {
+ col(name, "VARCHAR(50)");
+ String vals = "'" + String.join("', '", values) + "'";
+ constraints.add("CHECK (" + name + " IN (" + vals + "))");
}
return this;
}
+ // ─── MODIFIERS ───────────────────────────────────────
+
+ /**
+ * Appends NOT NULL to the last column definition.
+ *
+ * @return This instance for method chaining
+ */
+ public Blueprint notNull() {
+ modifyLast(" NOT NULL");
+ return this;
+ }
+
/**
- * Adds UNIQUE constraint to last column.
+ * Appends UNIQUE to the last column definition.
+ *
+ * @return This instance for method chaining
*/
public Blueprint unique() {
- if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " UNIQUE");
- }
+ modifyLast(" UNIQUE");
return this;
}
/**
- * Adds DEFAULT value to last column.
+ * Appends a DEFAULT clause to the last column definition.
*
- * @param value Default value
+ * @param value the default value string (not quoted)
+ * @return This instance for method chaining
*/
public Blueprint defaultValue(String value) {
+ modifyLast(" DEFAULT " + value);
+ return this;
+ }
+
+ /**
+ * Appends a DEFAULT clause with an integer value.
+ *
+ * @param value the default integer value
+ * @return This instance for method chaining
+ */
+ public Blueprint defaultValue(int value) {
+ modifyLast(" DEFAULT " + value);
+ return this;
+ }
+
+ /**
+ * Appends a DEFAULT clause with a boolean value (1 or 0).
+ *
+ * @param value the default boolean value
+ * @return This instance for method chaining
+ */
+ public Blueprint defaultValue(boolean value) {
+ modifyLast(" DEFAULT " + (value ? "1" : "0"));
+ return this;
+ }
+
+ /**
+ * No-op: columns are nullable by default. Provided for readability.
+ *
+ * @return This instance for method chaining
+ */
+ public Blueprint nullable() {
+ return this;
+ }
+
+ /**
+ * Adds a FOREIGN KEY constraint referencing the last column.
+ *
+ * @param refTable the referenced table name
+ * @param refColumn the referenced column name
+ * @return This instance for method chaining
+ */
+ public Blueprint foreignKey(String refTable, String refColumn) {
if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " DEFAULT " + value);
+ String lastCol = columns.get(columns.size() - 1);
+ String colName = lastCol.split("\\s+")[0];
+ // colName is already validated (extracted from a col() call above)
+ // refTable and refColumn are validated inside fk()
+ fk(refTable, refColumn, colName);
}
return this;
}
/**
- * Marks last column as nullable (no-op, columns are nullable by default).
+ * Appends ON DELETE CASCADE to the last foreign key constraint.
+ *
+ * @return This instance for method chaining
*/
- public Blueprint nullable() {
+ public Blueprint cascadeOnDelete() {
+ modifyLastConstraint(" ON DELETE CASCADE");
+ return this;
+ }
+
+ /**
+ * Appends ON DELETE SET NULL to the last foreign key constraint.
+ *
+ * @return This instance for method chaining
+ */
+ public Blueprint nullOnDelete() {
+ modifyLastConstraint(" ON DELETE SET NULL");
+ return this;
+ }
+
+ /**
+ * Appends ON DELETE RESTRICT to the last foreign key constraint.
+ *
+ * @return This instance for method chaining
+ */
+ public Blueprint restrictOnDelete() {
+ modifyLastConstraint(" ON DELETE RESTRICT");
+ return this;
+ }
+
+ /**
+ * Appends ON UPDATE CASCADE to the last foreign key constraint.
+ *
+ * @return This instance for method chaining
+ */
+ public Blueprint cascadeOnUpdate() {
+ modifyLastConstraint(" ON UPDATE CASCADE");
+ return this;
+ }
+
+ // ─── INDEX SHORTCUTS ─────────────────────────────────
+
+ /**
+ * Adds a composite UNIQUE constraint.
+ *
+ * @param columnNames the columns forming the unique index
+ * @return This instance for method chaining
+ */
+ public Blueprint uniqueIndex(String... columnNames) {
+ for (String col : columnNames) {
+ SqlIdentifier.requireIdentifier(col);
+ }
+ constraints.add("UNIQUE (" + String.join(", ", columnNames) + ")");
+ return this;
+ }
+
+ /**
+ * Adds {@code name_id} (BIGINT NOT NULL) and {@code name_type} (VARCHAR NOT NULL) columns
+ * for polymorphic relations.
+ *
+ * @param name the morph base name
+ * @return This instance for method chaining
+ */
+ public Blueprint morphs(String name) {
+ bigInteger(name + "_id").notNull();
+ string(name + "_type").notNull();
return this;
}
+
+ // ─── INTERNAL HELPERS ────────────────────────────────
+
+ private void modifyLast(String suffix) {
+ if (!columns.isEmpty()) {
+ int lastIndex = columns.size() - 1;
+ columns.set(lastIndex, columns.get(lastIndex) + suffix);
+ }
+ }
+
+ private void modifyLastConstraint(String suffix) {
+ if (!constraints.isEmpty()) {
+ int lastIndex = constraints.size() - 1;
+ constraints.set(lastIndex, constraints.get(lastIndex) + suffix);
+ }
+ }
}
}
\ No newline at end of file
diff --git a/src/main/java/com/obsidian/core/database/MigrationManager.java b/src/main/java/com/obsidian/core/database/MigrationManager.java
index 9f1da46..de7322e 100644
--- a/src/main/java/com/obsidian/core/database/MigrationManager.java
+++ b/src/main/java/com/obsidian/core/database/MigrationManager.java
@@ -2,7 +2,6 @@
import com.obsidian.core.core.Obsidian;
import com.obsidian.core.di.ReflectionsProvider;
-import org.javalite.activejdbc.Base;
import org.slf4j.Logger;
import java.util.ArrayList;
@@ -14,26 +13,20 @@
/**
* Migration manager for database schema versioning.
* Discovers, executes and tracks migrations.
+ * Uses DB static methods instead of ActiveJDBC Base.
*/
public class MigrationManager
{
- /** Database instance */
private final DB database;
-
- /** Logger instance */
private final Logger logger;
-
- /** List of registered migrations */
private final List migrations;
-
- /** Database type */
private final DatabaseType dbType;
/**
- * Constructor.
+ * Creates a new MigrationManager instance.
*
- * @param database Database instance
- * @param logger Logger instance
+ * @param database The database
+ * @param logger The logger
*/
public MigrationManager(DB database, Logger logger) {
this.database = database;
@@ -43,10 +36,10 @@ public MigrationManager(DB database, Logger logger) {
}
/**
- * Adds a migration to the list.
+ * Add.
*
- * @param migration Migration instance
- * @return Current instance for chaining
+ * @param migration The migration
+ * @return This instance for method chaining
*/
public MigrationManager add(Migration migration) {
migration.type = this.dbType;
@@ -56,61 +49,66 @@ public MigrationManager add(Migration migration) {
}
/**
- * Auto-discovers migrations by scanning base package.
- * Finds all Migration subclasses and instantiates them.
+ * Discover.
*
- * @return Current instance for chaining
+ * @return This instance for method chaining
*/
public MigrationManager discover()
{
try {
+ String basePackage = Obsidian.getBasePackage();
Set> migrationClasses = ReflectionsProvider.getSubTypesOf(Migration.class);
List discoveredMigrations = new ArrayList<>();
for (Class migrationClass : migrationClasses) {
+ // Restrict to the application's own package — prevents third-party
+ // dependencies that happen to extend Migration from being executed.
+ if (!migrationClass.getName().startsWith(basePackage)) {
+ logger.debug("Skipping migration outside base package: {}", migrationClass.getName());
+ continue;
+ }
try {
Migration migration = migrationClass.getDeclaredConstructor().newInstance();
migration.type = this.dbType;
migration.logger = this.logger;
discoveredMigrations.add(migration);
} catch (Exception e) {
- logger.warn("Unable to instantiate the migration: " + migrationClass.getName() + " - " + e.getMessage());
+ logger.warn("Unable to instantiate migration {}: {}", migrationClass.getName(), e.getMessage());
}
}
discoveredMigrations.sort(Comparator.comparing(m -> m.getClass().getSimpleName()));
migrations.addAll(discoveredMigrations);
- logger.info(discoveredMigrations.size() + " migration(s) discovered in " + Obsidian.getBasePackage());
+ logger.info("{} migration(s) discovered in {}", discoveredMigrations.size(), basePackage);
} catch (Exception e) {
- logger.error("Error discovering migrations: " + e.getMessage());
+ logger.error("Error discovering migrations: {}", e.getMessage());
}
return this;
}
/**
- * Executes all pending migrations.
- * Loads executed migrations in a single query, then iterates locally.
- * Runs within a transaction.
+ * Migrate.
+ *
*/
public void migrate() {
database.executeWithTransaction(() -> {
createMigrationsTable();
Set executed = loadExecutedMigrations();
- for (int i = 0; i < migrations.size(); i++) {
- String migrationName = "migration_" + (i + 1);
+ for (Migration migration : migrations) {
+ String migrationName = migration.getClass().getSimpleName();
if (!executed.contains(migrationName)) {
- logger.info("Executing migration: " + migrationName);
- migrations.get(i).up();
+ logger.info("Executing migration: {}", migrationName);
+ migration.up();
recordMigration(migrationName);
- logger.info("✓ Migration completed: " + migrationName);
+ logger.info("Migration completed: {}", migrationName);
} else {
- logger.info("Migration already executed: " + migrationName);
+ logger.info("Migration already executed: {}", migrationName);
}
}
@@ -120,20 +118,22 @@ public void migrate() {
}
/**
- * Rolls back all migrations in reverse order.
+ * Rollback.
+ *
*/
public void rollback() {
database.executeWithTransaction(() -> {
Set executed = loadExecutedMigrations();
for (int i = migrations.size() - 1; i >= 0; i--) {
- String migrationName = "migration_" + (i + 1);
+ Migration migration = migrations.get(i);
+ String migrationName = migration.getClass().getSimpleName();
if (executed.contains(migrationName)) {
- logger.info("Rolling back migration: " + migrationName);
- migrations.get(i).down();
+ logger.info("Rolling back migration: {}", migrationName);
+ migration.down();
removeMigration(migrationName);
- logger.info("✓ Migration rolled back: " + migrationName);
+ logger.info("Migration rolled back: {}", migrationName);
}
}
@@ -143,20 +143,22 @@ public void rollback() {
}
/**
- * Rolls back only the last executed migration.
+ * Rollback Last.
+ *
*/
public void rollbackLast() {
database.executeWithTransaction(() -> {
Set executed = loadExecutedMigrations();
for (int i = migrations.size() - 1; i >= 0; i--) {
- String migrationName = "migration_" + (i + 1);
+ Migration migration = migrations.get(i);
+ String migrationName = migration.getClass().getSimpleName();
if (executed.contains(migrationName)) {
- logger.info("Rolling back last migration: " + migrationName);
- migrations.get(i).down();
+ logger.info("Rolling back last migration: {}", migrationName);
+ migration.down();
removeMigration(migrationName);
- logger.info("✓ Last migration rolled back");
+ logger.info("Last migration rolled back: {}", migrationName);
break;
}
}
@@ -165,8 +167,8 @@ public void rollbackLast() {
}
/**
- * Rolls back all migrations then re-runs them.
- * Useful for database reset.
+ * Fresh.
+ *
*/
public void fresh() {
rollback();
@@ -174,24 +176,24 @@ public void fresh() {
}
/**
- * Displays migration status (executed vs pending).
+ * Status.
+ *
*/
public void status() {
database.executeWithConnection(() -> {
Set executed = loadExecutedMigrations();
- for (int i = 0; i < migrations.size(); i++) {
- String migrationName = "migration_" + (i + 1);
- String status = executed.contains(migrationName) ? "✓ Executed" : "✗ Pending";
- logger.info("{} - {}", migrationName, status);
+ for (Migration migration : migrations) {
+ String migrationName = migration.getClass().getSimpleName();
+ String status = executed.contains(migrationName) ? "Executed" : "Pending";
+ logger.info("{} — {}", migrationName, status);
}
return null;
});
}
- /**
- * Creates migrations tracking table if not exists.
- */
+ // ─── PRIVATE HELPERS (using DB instead of Base) ──────────
+
private void createMigrationsTable() {
String idColumn = switch (dbType) {
case MYSQL -> "INT AUTO_INCREMENT PRIMARY KEY";
@@ -199,7 +201,7 @@ private void createMigrationsTable() {
default -> "INTEGER PRIMARY KEY AUTOINCREMENT";
};
- Base.exec(String.format("""
+ DB.exec(String.format("""
CREATE TABLE IF NOT EXISTS migrations (
id %s,
migration VARCHAR(255) NOT NULL,
@@ -208,34 +210,19 @@ migration VARCHAR(255) NOT NULL,
""", idColumn));
}
- /**
- * Loads all executed migration names in a single query.
- *
- * @return Set of executed migration names
- */
private Set loadExecutedMigrations() {
Set executed = new HashSet<>();
- Base.findAll("SELECT migration FROM migrations").forEach(row ->
+ DB.findAll("SELECT migration FROM migrations").forEach(row ->
executed.add(row.get("migration").toString())
);
return executed;
}
- /**
- * Records a migration as executed.
- *
- * @param migrationName Migration name
- */
private void recordMigration(String migrationName) {
- Base.exec("INSERT INTO migrations (migration) VALUES (?)", migrationName);
+ DB.exec("INSERT INTO migrations (migration) VALUES (?)", migrationName);
}
- /**
- * Removes a migration record.
- *
- * @param migrationName Migration name
- */
private void removeMigration(String migrationName) {
- Base.exec("DELETE FROM migrations WHERE migration = ?", migrationName);
+ DB.exec("DELETE FROM migrations WHERE migration = ?", migrationName);
}
}
\ No newline at end of file
diff --git a/src/main/java/com/obsidian/core/database/orm/model/Model.java b/src/main/java/com/obsidian/core/database/orm/model/Model.java
new file mode 100644
index 0000000..eca541c
--- /dev/null
+++ b/src/main/java/com/obsidian/core/database/orm/model/Model.java
@@ -0,0 +1,197 @@
+package com.obsidian.core.database.orm.model;
+
+import com.obsidian.core.database.orm.model.observer.ModelObserver;
+import com.obsidian.core.database.orm.query.QueryBuilder;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.function.Consumer;
+
+/**
+ * Base Model class — ActiveRecord pattern.
+ *
+ *
Behaviour is split across a chain of abstract superclasses, each owning
+ * one concern, so this file stays focused on the things that belong together:
+ * instance state, the per-class metadata cache, configuration overrides, and
+ * the static query/factory API.
+ *
+ *
+ *
{@link ModelAttributes} — get/set, type coercion, fill, dirty tracking