Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/toxicmushroom/kord-kommons

provides database code generators and utility functions for dealing with discord and users
https://github.com/toxicmushroom/kord-kommons

kotlin

Last synced: about 1 month ago
JSON representation

provides database code generators and utility functions for dealing with discord and users

Awesome Lists containing this project

README

        

### **this project is still in WIP, changes may be breaking**

All artifacts can be found on https://reposilite.melijn.com/

## Module info
- _kommons_ is for discord bot and java utilities
- _kord-kommons_ is for kord and kord-ex utilities
- _redgres-kommons_ is a redis-postgres utility library, it depends on Exposed, hikariCP, postgresql and lettuce
- _ap_ is an annotation processor using KSP
- _ap-kordex_ is an annotation processor using KSP and depends on kordex
- _ap-redgres_ is an annotation processor for database DAO generation

**Examples:**
- [loading koin injection](README.md#loading-koin-injection)
- [initalizing redgres driverManager](README.md#initializing-redgres-drivermanager)
- [using settings template](README.md#using-settings-template)

**More example usage can be found here:** [melijn-bot](https://github.com/Melijn/melijn-bot/)

## Gradle
```kt
repositories {
// Snapshots
maven("https://reposilite.melijn.com/snapshots/")
// Releases repo
maven("https://reposilite.melijn.com/releases/")
}

// modules can be added individually
dependencies {
implementation("me.melijn.kordkommons:kommons:LATEST") // see repo above for version
implementation("me.melijn.kordkommons:kord-kommons:LATEST")
implementation("me.melijn.kordkommons:redgres-kommons:LATEST")
}
```
**Gradle annotation processing**
```kt
plugins {
id("com.google.devtools.ksp") version "1.7.20-1.0.6"
}

dependencies {
val apKord = "me.melijn.kordkommons:ap:LATEST"
val apKordex = "me.melijn.kordkommons:apkordex:LATEST"
val apRedgres = "me.melijn.kordkommons:apredgres:LATEST"
implementation(apKord)
implementation(apKord)
implementation(apRedgres)
ksp(apKord)
ksp(apKordex)
ksp(apRedgres)
}

ksp {
// these are arguments for ksp and configurable but required
arg("ap_kordex_package", "me.melijn.gen")
arg("ap_redgres_package", "me.melijn.gen")
arg("ap_redgres_redis_key_prefix", "melijn:")
arg("ap_package", "me.melijn.gen")
arg("ap_imports", "import org.koin.core.context.GlobalContext; import org.koin.core.parameter.ParametersHolder;")
arg("ap_interfaces", "")
arg("ap_init_placeholder", "GlobalContext.get().get<%className%> { ParametersHolder() }")
}
```

## Examples
### loading koin injection
```kt
val injectorInterface = ReflectUtil.getInstanceOfKspClass(
"me.melijn.gen", "InjectionKoinModule"
)
loadKoinModules(injectorInterface.module)
```

### Initializing redgres driverManager
```kt
val settings // your settings object
val redisConfig = settings.redis.run { RedisConfig(enabled, host, port, user, pass) }
val hikariConfig = settings.database.run {
ConfigUtil.generateDefaultHikariConfig(host, port, name, user, pass)
}

val createTableInterface = ReflectUtil.getInstanceOfKspClass(
"me.melijn.gen", "CreateTablesModule"
)
val driverManager = DriverManager(hikariConfig, redisConfig) { createTableInterface.createTables() }

```

### Using settings template
```kt
@SettingsTemplate("import me.melijn.bot.model.Environment")
private class Template {

class Database : BotSettings("db") {
/** postgres://user:pass@host:port/name **/
val host by string("host", "localhost")
val port by int("port", 5432)
val user by string("user", "postgres")
val pass by string("pass")
val name by string("name", "melijn-bot") // db name
}

class Redis : BotSettings("redis") {
val enabled by boolean("enabled", true)
val host by string("host", "localhost")
val port by int("port", 6379)
val user by stringN("user")
val pass by string("pass")
}

class Api : BotSettings("api") {

// nesting support
class Discord : BotSettings("discord") {
val token by string("token")
val gateway by string("gateway", "")
}
}
}
```

### Using database model and createTable
```kt
@CreateTable // this will make exposed run `create table if not exists ...` for this model
@TableModel(true) // this wil create a matching data class and abstractManager class with helper functions
object Attendance: Table("attendance") {

val attendanceId = long("attendance_id").autoIncrement()

val guildId = long("guild_id")
val channelId = long("channel_id")
val messageId = long("message_id").nullable()

// given to attendees for this attendance event
val roleId = long("role_id").nullable()

// At (nextMoment - closeOffset) we should stop accepting new attendees
val closeOffset = duration("close_offset").nullable()

val notifyAttendees = bool("notify_attendees")
// (nextMoment - notifyOffset) is when attendees are pinged
val notifyOffset = duration("notify_offset").nullable()

val topic = text("topic")
val description = text("description").nullable()

val repeating = bool("repeating")
val nextMoment = timestamp("next_moment")
// cron format
val schedule = text("schedule").nullable()

// time between last moment and starting the next attendance occurrence
// attendees are cleared when nextMoment + schedule_timeout is hit
val scheduleTimeout = duration("schedule_timeout").nullable()

override val primaryKey: PrimaryKey = PrimaryKey(guildId, channelId, messageId)

init {
index(true, attendanceId) // name = attendance_key
index(false, guildId) // name = guild_key
}
}
```