Refactor package structure and update dependencies

Renamed package structure to `nl.astraeus.tmpl` for consistency and modified the repository name placeholder. Updated Kotlin and library dependencies, removed unused imports, and adjusted Gradle settings for better project clarity.

src/jvmMain/kotlin/nl/astraeus/tmpl/Main.kt

@@ -0,0 +1,39 @@
+package nl.astraeus.tmpl
+
+import com.zaxxer.hikari.HikariConfig
+import nl.astraeus.logger.Logger
+import nl.astraeus.tmpl.db.Database
+
+val log = Logger()
+
+val REPO_NAME = "dummy so the gitea template compiles, please remove"
+
+fun main() {
+  Thread.currentThread().uncaughtExceptionHandler = Thread.UncaughtExceptionHandler { t, e ->
+    log.warn(e) {
+      e.message
+    }
+  }
+
+  Runtime.getRuntime().addShutdownHook(
+    object : Thread() {
+      override fun run() {
+        Database.vacuumDatabase()
+        Database.closeDatabase()
+      }
+    }
+  )
+
+  Class.forName("nl.astraeus.jdbc.Driver")
+  Database.initialize(HikariConfig().apply {
+    driverClassName = "nl.astraeus.jdbc.Driver"
+    jdbcUrl = "jdbc:stat:webServerPort=6001:jdbc:sqlite:data/${REPO_NAME}.db"
+    username = "sa"
+    password = ""
+    maximumPoolSize = 25
+    isAutoCommit = false
+
+    validate()
+  })
+
+}

src/jvmMain/kotlin/nl/astraeus/tmpl/db/Database.kt

@@ -0,0 +1,73 @@
+package nl.astraeus.tmpl.db
+
+import com.zaxxer.hikari.HikariConfig
+import com.zaxxer.hikari.HikariDataSource
+import java.sql.Connection
+import java.util.*
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.collections.set
+import kotlin.use
+
+private val currentConnection = ThreadLocal<Connection>()
+
+fun <T> transaction(
+  block: (Connection) -> T
+): T {
+  val hasConnection = currentConnection.get() != null
+  var oldConnection: Connection? = null
+
+  if (!hasConnection) {
+    currentConnection.set(Database.getConnection())
+  }
+
+  val connection = currentConnection.get()
+
+  try {
+    val result = block(connection)
+
+    connection.commit()
+
+    return result
+  } finally {
+    if (!hasConnection) {
+      currentConnection.set(oldConnection)
+      connection.close()
+    }
+  }
+}
+
+object Database {
+
+  var ds: HikariDataSource? = null
+
+  fun initialize(config: HikariConfig) {
+    val properties = Properties()
+    properties["journal_mode"] = "WAL"
+
+    config.dataSourceProperties = properties
+    config.addDataSourceProperty("cachePrepStmts", "true")
+    config.addDataSourceProperty("prepStmtCacheSize", "250")
+    config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048")
+
+    ds = HikariDataSource(config)
+    Migrations.databaseVersionTableCreated = AtomicBoolean(false)
+    Migrations.updateDatabaseIfNeeded()
+  }
+
+  fun getConnection() = ds?.connection ?: error("Database has not been initialized!")
+
+  fun vacuumDatabase() {
+    getConnection().use {
+      it.autoCommit = true
+
+      it.prepareStatement("VACUUM").use { ps ->
+        ps.executeUpdate()
+      }
+    }
+  }
+
+  fun closeDatabase() {
+    ds?.close()
+  }
+
+}

src/jvmMain/kotlin/nl/astraeus/tmpl/db/Migrations.kt

@@ -0,0 +1,105 @@
+package nl.astraeus.tmpl.db
+
+import nl.astraeus.tmpl.log
+import java.sql.Connection
+import java.sql.SQLException
+import java.sql.Timestamp
+import java.util.concurrent.atomic.AtomicBoolean
+
+sealed class Migration {
+  class Query(
+    val query: String
+  ) : Migration() {
+    override fun toString(): String {
+      return query
+    }
+  }
+
+  class Code(
+    val code: (Connection) -> Unit
+  ) : Migration() {
+    override fun toString(): String {
+      return code.toString()
+    }
+  }
+}
+
+val DATABASE_MIGRATIONS = arrayOf<Migration>(
+  Migration.Query(
+    """
+  CREATE TABLE DATABASE_VERSION (
+    ID INTEGER PRIMARY KEY,
+    QUERY TEXT,
+    EXECUTED TIMESTAMP
+  )
+  """.trimIndent()
+  ),
+  Migration.Query("SELECT sqlite_version()"),
+)
+
+object Migrations {
+  var databaseVersionTableCreated = AtomicBoolean(false)
+
+  fun updateDatabaseIfNeeded() {
+    try {
+      transaction { con ->
+        con.prepareStatement(
+          """
+            SELECT MAX(ID) FROM DATABASE_VERSION
+          """.trimIndent()
+        ).use { ps ->
+          ps.executeQuery().use { rs ->
+            databaseVersionTableCreated.compareAndSet(false, true)
+
+            if(rs.next()) {
+              val maxId = rs.getInt(1)
+
+              for (index in maxId + 1..<DATABASE_MIGRATIONS.size) {
+                executeMigration(index)
+              }
+            }
+          }
+        }
+      }
+    } catch (e: SQLException) {
+      if (databaseVersionTableCreated.compareAndSet(false, true)) {
+        executeMigration(0)
+        updateDatabaseIfNeeded()
+      } else {
+        throw e
+      }
+    }
+  }
+
+  private fun executeMigration(index: Int) {
+    transaction { con ->
+      log.debug {
+        "Executing migration $index - [${DATABASE_MIGRATIONS[index]}]"
+      }
+      val description = when(
+        val migration = DATABASE_MIGRATIONS[index]
+      ) {
+        is Migration.Query -> {
+          con.prepareStatement(migration.query).use { ps ->
+            ps.execute()
+          }
+
+          migration.query
+        }
+        is Migration.Code -> {
+          migration.code(con)
+
+          migration.code.toString()
+        }
+      }
+      con.prepareStatement("INSERT INTO DATABASE_VERSION VALUES (?, ?, ?)").use { ps ->
+        ps.setInt(1, index)
+        ps.setString(2, description)
+        ps.setTimestamp(3, Timestamp(System.currentTimeMillis()))
+
+        ps.execute()
+      }
+    }
+  }
+
+}