Used inside {@link Migration#createTable} callbacks. Every column name
+ * is validated by {@link SqlIdentifier#requireIdentifier} before being
+ * interpolated into DDL.
+ */
+public class Blueprint {
+
+ private final List columns;
+ private final List constraints;
+ private final DatabaseType dbType;
+
+ /**
+ * Creates a Blueprint with separate column and constraint lists.
+ *
+ * @param columns column definitions list (mutated in place)
+ * @param constraints constraint definitions list (mutated in place)
+ * @param dbType target database type
+ */
+ public Blueprint(List columns, List constraints, DatabaseType dbType) {
+ this.columns = columns;
+ this.constraints = constraints;
+ this.dbType = dbType;
+ }
+
+ /**
+ * Creates a Blueprint without a constraint list.
+ *
+ * @param columns column definitions list
+ * @param dbType target database type
+ */
+ public Blueprint(List columns, DatabaseType dbType) {
+ this(columns, new ArrayList<>(), dbType);
+ }
+
+ // ─── INTERNAL ────────────────────────────────────────────
+
+ private Blueprint col(String name, String type) {
+ SqlIdentifier.requireIdentifier(name);
+ columns.add(name + " " + type);
+ return this;
+ }
+
+ 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;
+ }
+
+ private void modifyLast(String suffix) {
+ if (!columns.isEmpty()) {
+ int i = columns.size() - 1;
+ columns.set(i, columns.get(i) + suffix);
+ }
+ }
+
+ private void modifyLastConstraint(String suffix) {
+ if (!constraints.isEmpty()) {
+ int i = constraints.size() - 1;
+ constraints.set(i, constraints.get(i) + suffix);
+ }
+ }
+
+ // ─── PRIMARY KEY ─────────────────────────────────────────
+
+ /** Adds an auto-increment primary key column named id. */
+ public Blueprint id() { return id("id"); }
+
+ /**
+ * Adds an auto-increment primary key column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint id(String name) {
+ 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(name + " " + type);
+ return this;
+ }
+
+ /**
+ * Adds a UUID column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint uuid(String name) { return col(name, "VARCHAR(36)"); }
+
+ // ─── STRING / TEXT ───────────────────────────────────────
+
+ /**
+ * Adds a VARCHAR(255) / TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint string(String name) { return string(name, 255); }
+
+ /**
+ * Adds a VARCHAR(length) / TEXT column.
+ *
+ * @param name column name
+ * @param length max length
+ * @return this blueprint
+ */
+ public Blueprint string(String name, int length) {
+ return col(name, dbType == DatabaseType.SQLITE ? "TEXT" : "VARCHAR(" + length + ")");
+ }
+
+ /**
+ * Adds a TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint text(String name) { return col(name, "TEXT"); }
+
+ /**
+ * Adds a MEDIUMTEXT / TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint mediumText(String name) {
+ return col(name, dbType == DatabaseType.MYSQL ? "MEDIUMTEXT" : "TEXT");
+ }
+
+ /**
+ * Adds a LONGTEXT / TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint longText(String name) {
+ return col(name, dbType == DatabaseType.MYSQL ? "LONGTEXT" : "TEXT");
+ }
+
+ // ─── NUMERIC ─────────────────────────────────────────────
+
+ /**
+ * Adds an INT / INTEGER column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint integer(String name) {
+ return col(name, dbType == DatabaseType.POSTGRESQL ? "INTEGER" : "INT");
+ }
+
+ /**
+ * Adds a TINYINT / INTEGER column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint tinyInteger(String name) {
+ return col(name, dbType == DatabaseType.SQLITE ? "INTEGER" : "TINYINT");
+ }
+
+ /**
+ * Adds a SMALLINT / INTEGER column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint smallInteger(String name) {
+ return col(name, dbType == DatabaseType.SQLITE ? "INTEGER" : "SMALLINT");
+ }
+
+ /**
+ * Adds a BIGINT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint bigInteger(String name) { return col(name, "BIGINT"); }
+
+ /**
+ * Adds a DECIMAL(precision, scale) column.
+ *
+ * @param name column name
+ * @param precision total digits
+ * @param scale digits after the decimal point
+ * @return this blueprint
+ */
+ public Blueprint decimal(String name, int precision, int scale) {
+ return col(name, "DECIMAL(" + precision + "," + scale + ")");
+ }
+
+ /**
+ * Adds a DECIMAL(10,2) column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint decimal(String name) { return decimal(name, 10, 2); }
+
+ /**
+ * Adds a FLOAT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint floatCol(String name) { return col(name, "FLOAT"); }
+
+ /**
+ * Adds a DOUBLE column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint doubleCol(String name) { return col(name, "DOUBLE"); }
+
+ // ─── BOOLEAN ─────────────────────────────────────────────
+
+ /**
+ * Adds a BOOLEAN / INTEGER column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint bool(String name) {
+ return col(name, dbType == DatabaseType.SQLITE ? "INTEGER" : "BOOLEAN");
+ }
+
+ // ─── DATE / TIME ─────────────────────────────────────────
+
+ /**
+ * Adds a DATE column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint date(String name) { return col(name, "DATE"); }
+
+ /**
+ * Adds a DATETIME / TIMESTAMP / TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint dateTime(String name) {
+ return col(name, switch (dbType) {
+ case POSTGRESQL -> "TIMESTAMP";
+ case MYSQL -> "DATETIME";
+ default -> "TEXT";
+ });
+ }
+
+ /**
+ * Adds a TIMESTAMP column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint timestamp(String name) { return col(name, "TIMESTAMP"); }
+
+ /**
+ * Adds a TIME column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint time(String name) { return col(name, "TIME"); }
+
+ /**
+ * Adds created_at and updated_at columns with appropriate defaults.
+ *
+ * @return this blueprint
+ */
+ public Blueprint timestamps() {
+ if (dbType == DatabaseType.MYSQL) {
+ columns.add("created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
+ columns.add("updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP");
+ } else if (dbType == DatabaseType.POSTGRESQL) {
+ columns.add("created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
+ columns.add("updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
+ } else {
+ columns.add("created_at TEXT DEFAULT CURRENT_TIMESTAMP");
+ columns.add("updated_at TEXT DEFAULT CURRENT_TIMESTAMP");
+ }
+ return this;
+ }
+
+ /**
+ * Adds a nullable deleted_at column for soft deletes.
+ *
+ * @return this blueprint
+ */
+ public Blueprint softDeletes() {
+ dateTime("deleted_at");
+ nullable();
+ return this;
+ }
+
+ // ─── JSON / BLOB ─────────────────────────────────────────
+
+ /**
+ * Adds a JSON / TEXT column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint json(String name) {
+ return col(name, dbType == DatabaseType.SQLITE ? "TEXT" : "JSON");
+ }
+
+ /**
+ * Adds a BLOB column.
+ *
+ * @param name column name
+ * @return this blueprint
+ */
+ public Blueprint blob(String name) { return col(name, "BLOB"); }
+
+ // ─── ENUM ────────────────────────────────────────────────
+
+ /**
+ * Adds an ENUM / CHECK column.
+ *
+ * @param name column name
+ * @param values allowed enum values
+ * @return this blueprint
+ */
+ public Blueprint enumCol(String name, String... values) {
+ if (dbType == DatabaseType.MYSQL) {
+ col(name, "ENUM('" + String.join("', '", values) + "')");
+ } else {
+ col(name, "VARCHAR(50)");
+ constraints.add("CHECK (" + name + " IN ('" + String.join("', '", values) + "'))");
+ }
+ return this;
+ }
+
+ // ─── MODIFIERS ───────────────────────────────────────────
+
+ /** Appends NOT NULL to the last column. */
+ public Blueprint notNull() { modifyLast(" NOT NULL"); return this; }
+ /** Appends UNIQUE to the last column. */
+ public Blueprint unique() { modifyLast(" UNIQUE"); return this; }
+ /** Columns are nullable by default — no-op for readability. */
+ public Blueprint nullable() { return this; }
+ /** @param value default value string */
+ public Blueprint defaultValue(String value) { modifyLast(" DEFAULT " + value); return this; }
+ /** @param value default integer value */
+ public Blueprint defaultValue(int value) { modifyLast(" DEFAULT " + value); return this; }
+ /** @param value default boolean value (stored as 1 or 0) */
+ public Blueprint defaultValue(boolean value) { modifyLast(" DEFAULT " + (value ? "1" : "0")); return this; }
+
+ // ─── FOREIGN KEYS ────────────────────────────────────────
+
+ /**
+ * Adds a FOREIGN KEY constraint referencing the last column.
+ *
+ * @param refTable referenced table name
+ * @param refColumn referenced column name
+ * @return this blueprint
+ */
+ public Blueprint foreignKey(String refTable, String refColumn) {
+ if (!columns.isEmpty()) {
+ String colName = columns.get(columns.size() - 1).split("\\s+")[0];
+ fk(refTable, refColumn, colName);
+ }
+ return this;
+ }
+
+ /** Appends ON DELETE CASCADE to the last foreign key. */
+ public Blueprint cascadeOnDelete() { modifyLastConstraint(" ON DELETE CASCADE"); return this; }
+ /** Appends ON DELETE SET NULL to the last foreign key. */
+ public Blueprint nullOnDelete() { modifyLastConstraint(" ON DELETE SET NULL"); return this; }
+ /** Appends ON DELETE RESTRICT to the last foreign key. */
+ public Blueprint restrictOnDelete() { modifyLastConstraint(" ON DELETE RESTRICT"); return this; }
+ /** Appends ON UPDATE CASCADE to the last foreign key. */
+ public Blueprint cascadeOnUpdate() { modifyLastConstraint(" ON UPDATE CASCADE"); return this; }
+
+ // ─── INDEXES ─────────────────────────────────────────────
+
+ /**
+ * Adds a composite UNIQUE constraint.
+ *
+ * @param columnNames columns forming the unique index
+ * @return this blueprint
+ */
+ public Blueprint uniqueIndex(String... columnNames) {
+ for (String c : columnNames) SqlIdentifier.requireIdentifier(c);
+ constraints.add("UNIQUE (" + String.join(", ", columnNames) + ")");
+ return this;
+ }
+
+ /**
+ * Adds name_id (BIGINT NOT NULL) and name_type (VARCHAR NOT NULL) columns for polymorphic relations.
+ *
+ * @param name morph base name
+ * @return this blueprint
+ */
+ public Blueprint morphs(String name) {
+ bigInteger(name + "_id").notNull();
+ string(name + "_type").notNull();
+ return this;
+ }
+
+ // ─── ACCESSORS ───────────────────────────────────────────
+
+ /** @return column definitions list */
+ public List getColumns() { return columns; }
+
+ /** @return constraint definitions list */
+ public List getConstraints() { return constraints; }
+}
\ No newline at end of file
diff --git a/src/main/java/com/obsidian/core/database/DB.java b/src/main/java/com/obsidian/core/database/DB.java
index b0efedc..916961f 100644
--- a/src/main/java/com/obsidian/core/database/DB.java
+++ b/src/main/java/com/obsidian/core/database/DB.java
@@ -2,19 +2,59 @@
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
-import org.javalite.activejdbc.Base;
import org.slf4j.Logger;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
import java.util.concurrent.Callable;
/**
- * Database connection manager with support for SQLite, MySQL and PostgreSQL.
- * Provides connection pooling for MySQL/PostgreSQL and transaction management.
+ * Database connection manager with support for SQLite, MySQL, and PostgreSQL.
+ *
+ *
Security notes:
+ *
+ *
The singleton field is {@code volatile} to guarantee safe publication
+ * in multi-threaded environments without a full lock on every read.
+ *
MySQL/PostgreSQL connections require SSL by default. Set
+ * {@code OBSIDIAN_DB_DISABLE_SSL=true} (env or system property) only in
+ * local dev/test. System property takes priority over env variable.
+ *
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 +62,513 @@ 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);
+ }
+
+ /**
+ * Builds a JDBC URL for the given database type.
+ *
+ *
SSL is enabled for both MySQL and PostgreSQL by default.
+ * Disable only for local dev/test by setting {@code OBSIDIAN_DB_DISABLE_SSL=true}
+ * as an environment variable OR as a JVM system property ({@code -DOBSIDIAN_DB_DISABLE_SSL=true}).
+ * System property takes priority — this allows {@code exec-maven-plugin} to pass the flag
+ * via {@code } without relying on OS-level env injection, which does not
+ * work when Maven runs in-process.
+ */
+ private String buildJdbcUrl(DatabaseType type, String host, int port, String database) {
+ boolean disableSsl = isSslDisabled();
+ 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);
+ };
+ }
+
+ /**
+ * Returns true if SSL should be disabled.
+ *
+ *
Checks system property first (set via {@code -D} or {@code exec-maven-plugin}
+ * {@code }), then falls back to the OS environment variable.
+ * System property wins because {@code exec:java} runs in-process and cannot inject
+ * environment variables after JVM startup.
+ */
+ private boolean isSslDisabled() {
+ String sysProp = System.getProperty("OBSIDIAN_DB_DISABLE_SSL");
+ if (sysProp != null) return "true".equalsIgnoreCase(sysProp);
+ return "true".equalsIgnoreCase(System.getenv("OBSIDIAN_DB_DISABLE_SSL"));
+ }
+
+ // ─── 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 a task with database connection.
- * Opens connection if needed, closes it after execution.
+ * Executes {@code task} with an open connection, closing it afterwards
+ * only if this call was the one that opened it.
*
- * @param task Task to execute
- * @param Return type
- * @return Task result
+ * @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);
+ }
+ }
+
+ /**
+ * 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);
+ }
+ }
+
+ /**
+ * 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);
}
- if (pool != null) {
- pool.close();
- logger.info("Connection pool closed");
+ }
+
+ /**
+ * 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 ────────────────────────────────────
+
/**
- * Gets database type.
+ * 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..5211e29 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;
@@ -8,317 +8,140 @@
/**
* Base class for database migrations.
- * Provides schema modification methods with multi-database support.
+ *
+ * @see Blueprint
*/
public abstract class Migration
{
- /** Database type */
+
+ /** Database type — set by MigrationManager before calling up() / down(). */
protected DatabaseType type;
- /** Logger instance */
+ /** Logger — set by MigrationManager before calling up() / down(). */
protected Logger logger;
- /**
- * Executes migration (creates/modifies schema).
- */
+ /** Applies the migration. */
public abstract void up();
- /**
- * Reverts migration (rolls back changes).
- */
+ /** Reverts the migration. */
public abstract void down();
+ // ─── DDL ─────────────────────────────────────────────────
+
/**
- * Creates a new table with specified columns.
+ * Creates a table using a Blueprint callback.
*
- * @param tableName Name of table to create
- * @param builder Callback to define table structure
+ * @param tableName table name — must be a valid SQL identifier
+ * @param builder callback that receives a Blueprint to define columns
*/
- protected void createTable(String tableName, TableBuilder builder)
- {
- StringBuilder sql = new StringBuilder();
- sql.append("CREATE TABLE IF NOT EXISTS ").append(tableName).append(" (");
+ protected void createTable(String tableName, TableBuilder builder) {
+ SqlIdentifier.requireIdentifier(tableName);
- List columns = new ArrayList<>();
- builder.build(new Blueprint(columns, type));
+ List columns = new ArrayList<>();
+ List constraints = new ArrayList<>();
+ builder.build(new Blueprint(columns, constraints, type));
- sql.append(String.join(", ", columns));
- sql.append(")");
+ List allParts = new ArrayList<>(columns);
+ allParts.addAll(constraints);
- Base.exec(sql.toString());
- logger.info("Table created: " + tableName);
+ DB.exec("CREATE TABLE IF NOT EXISTS " + tableName +
+ " (" + String.join(", ", allParts) + ")");
+ logger.info("Table created: {}", tableName);
}
/**
* Drops a table if it exists.
*
- * @param tableName Name of table to drop
+ * @param tableName 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 table name
+ * @param columnName column name
+ * @param definition 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.
*
- * @param tableName Table name
- * @param columnName Column name
+ * @param tableName table name
+ * @param columnName column name
*/
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 — 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.
+ * Renames a table.
*
- * @param tableName Table name to check
- * @return true if table exists, false otherwise
+ * @param from current table name
+ * @param to new table name
*/
- protected boolean tableExists(String tableName)
- {
- String checkSQL = switch (type) {
- case MYSQL -> "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ?";
+ 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);
+ }
+
+ /**
+ * Returns true if the given table exists.
+ *
+ * @param tableName table name to check
+ * @return true if the table exists
+ */
+ protected boolean tableExists(String tableName) {
+ String sql = switch (type) {
+ 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(sql, tableName);
if (result == null) return false;
-
- long count = result instanceof Long ? (Long) result : Long.parseLong(result.toString());
+ long count = result instanceof Long l ? l : Long.parseLong(result.toString());
return count > 0;
}
/**
- * Functional interface for table building.
+ * Executes raw SQL with bound parameters.
+ *
+ * @param sql raw SQL — caller must ensure safety
+ * @param params values bound via PreparedStatement
*/
- @FunctionalInterface
- public interface TableBuilder {
- void build(Blueprint blueprint);
+ protected void raw(String sql, Object... params) {
+ DB.exec(sql, params);
}
- /**
- * Schema builder for defining table columns.
- * Provides fluent API for column definitions with database-specific syntax.
- */
- public static class Blueprint {
- private final List columns;
- private final DatabaseType dbType;
-
- public Blueprint(List columns, DatabaseType dbType) {
- this.columns = columns;
- this.dbType = dbType;
- }
-
- /**
- * Adds auto-incrementing primary key named "id".
- */
- public Blueprint id() {
- return id("id");
- }
-
- /**
- * Adds auto-incrementing primary key with custom name.
- *
- * @param name Column name
- */
- 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";
- };
- columns.add(column);
- return this;
- }
-
- /**
- * Adds VARCHAR/TEXT column with default length 255.
- *
- * @param name Column name
- */
- public Blueprint string(String name) {
- return string(name, 255);
- }
-
- /**
- * Adds VARCHAR/TEXT column with custom length.
- *
- * @param name Column name
- * @param length Maximum length
- */
- public Blueprint string(String name, int length) {
- String type = dbType == DatabaseType.SQLITE ? "TEXT" : "VARCHAR(" + length + ")";
- columns.add(name + " " + type);
- return this;
- }
-
- /**
- * Adds TEXT column.
- *
- * @param name Column name
- */
- public Blueprint text(String name) {
- columns.add(name + " TEXT");
- return this;
- }
-
- /**
- * Adds INTEGER column.
- *
- * @param name Column name
- */
- public Blueprint integer(String name) {
- String type = dbType == DatabaseType.POSTGRESQL ? "INTEGER" : "INT";
- columns.add(name + " " + type);
- return this;
- }
-
- /**
- * Adds BIGINT column.
- *
- * @param name Column name
- */
- public Blueprint bigInteger(String name) {
- columns.add(name + " BIGINT");
- return this;
- }
-
- /**
- * Adds DECIMAL column.
- *
- * @param name Column name
- * @param precision Total digits
- * @param scale Decimal places
- */
- public Blueprint decimal(String name, int precision, int scale) {
- columns.add(name + " DECIMAL(" + precision + "," + scale + ")");
- return this;
- }
-
- /**
- * Adds BOOLEAN column.
- *
- * @param name Column name
- */
- public Blueprint bool(String name) {
- String type = dbType == DatabaseType.SQLITE ? "INTEGER" : "BOOLEAN";
- columns.add(name + " " + type);
- return this;
- }
-
- /**
- * Adds DATE column.
- *
- * @param name Column name
- */
- public Blueprint date(String name) {
- columns.add(name + " DATE");
- return this;
- }
-
- /**
- * Adds DATETIME/TIMESTAMP column.
- *
- * @param name Column name
- */
- public Blueprint dateTime(String name) {
- String type = switch (dbType) {
- case POSTGRESQL -> "TIMESTAMP";
- case MYSQL -> "DATETIME";
- default -> "TEXT";
- };
- columns.add(name + " " + type);
- return this;
- }
-
- /**
- * Adds TIMESTAMP column.
- *
- * @param name Column name
- */
- public Blueprint timestamp(String name) {
- columns.add(name + " TIMESTAMP");
- return this;
- }
-
- /**
- * Adds created_at and updated_at timestamp columns.
- */
- public Blueprint timestamps()
- {
- if (dbType == DatabaseType.MYSQL) {
- columns.add("created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
- columns.add("updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP");
- } else if (dbType == DatabaseType.POSTGRESQL) {
- columns.add("created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
- columns.add("updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP");
- } else {
- columns.add("created_at TEXT DEFAULT CURRENT_TIMESTAMP");
- columns.add("updated_at TEXT DEFAULT CURRENT_TIMESTAMP");
- }
- return this;
- }
-
- /**
- * Adds NOT NULL constraint to last column.
- */
- public Blueprint notNull() {
- if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " NOT NULL");
- }
- return this;
- }
-
- /**
- * Adds UNIQUE constraint to last column.
- */
- public Blueprint unique() {
- if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " UNIQUE");
- }
- return this;
- }
+ // ─── FUNCTIONAL INTERFACE ────────────────────────────────
+ @FunctionalInterface
+ public interface TableBuilder {
/**
- * Adds DEFAULT value to last column.
+ * Defines columns on the given blueprint.
*
- * @param value Default value
+ * @param blueprint blueprint to configure
*/
- public Blueprint defaultValue(String value) {
- if (!columns.isEmpty()) {
- int lastIndex = columns.size() - 1;
- columns.set(lastIndex, columns.get(lastIndex) + " DEFAULT " + value);
- }
- return this;
- }
-
- /**
- * Marks last column as nullable (no-op, columns are nullable by default).
- */
- public Blueprint nullable() {
- return this;
- }
+ void build(Blueprint blueprint);
}
}
\ 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