featwip: pretty departures

build.gradle.kts

@@ -7,7 +7,6 @@ plugins {
     alias(libs.plugins.composeCompiler) apply false
     alias(libs.plugins.kotlinJvm) apply false
     alias(libs.plugins.kotlinMultiplatform) apply false
-    alias(libs.plugins.sqldelight) apply false
     alias(libs.plugins.wire) apply false
 }
 

core/build.gradle.kts

@@ -4,6 +4,12 @@ plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.kotlinSerialization)
     alias(libs.plugins.androidMultiplatformLibrary)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.room)
+}
+
+room {
+    schemaDirectory("$projectDir/schemas")
 }
 
 kotlin {
@@ -40,9 +46,18 @@ kotlin {
             implementation(libs.kotlinx.datetime)
             implementation(libs.kotlinx.serialization.json)
             implementation(libs.kotlinx.serialization.protobuf)
+            implementation(libs.room.runtime)
+            implementation(libs.sqlite.bundled)
         }
         iosMain.dependencies {
             implementation(libs.ktor.client.darwin)
         }
     }
 }
+
+dependencies {
+    add("kspAndroid", libs.room.compiler)
+    add("kspIosArm64", libs.room.compiler)
+    add("kspIosSimulatorArm64", libs.room.compiler)
+    add("kspJvm", libs.room.compiler)
+}

core/data/build.gradle.kts

@@ -25,40 +25,8 @@ kotlin {
     jvm()
 
     sourceSets {
-        val clientMain by creating {
-            dependsOn(commonMain.get())
-        }
-
-        androidMain.get().dependsOn(clientMain)
-        iosArm64Main.get().dependsOn(clientMain)
-        iosSimulatorArm64Main.get().dependsOn(clientMain)
-
         commonMain.dependencies {
-            implementation(libs.koin.core)
             implementation(projects.core)
-            api(projects.core.stoptime)
-        }
-
-        androidMain.dependencies {
-            implementation(libs.koin.compose)
-            implementation(libs.ktor.client.okhttp)
-        }
-        commonMain.dependencies {
-            implementation(libs.okio)
-            implementation(libs.koin.core)
-            implementation(libs.ktor.client.core)
-            implementation(libs.ktor.client.contentnegotiation)
-            implementation(libs.ktor.serialization.kotlinx.json)
-            implementation(libs.kotlinx.coroutines.core)
-            implementation(libs.kotlinx.datetime)
-            implementation(libs.kotlinx.serialization.json)
-            implementation(libs.kotlinx.serialization.protobuf)
-
-            implementation(projects.core)
-            implementation(projects.core.sqld)
-        }
-        iosMain.dependencies {
-            implementation(libs.ktor.client.darwin)
         }
     }
 }

core/data/client/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 
 kotlin {
     android {
-        namespace = "moe.lava.banksia.core.stoptime"
+        namespace = "moe.lava.banksia.core.data.client"
         compileSdk = libs.versions.android.compileSdk.get().toInt()
 
         compilerOptions {
@@ -19,7 +19,6 @@ kotlin {
 
     compilerOptions {
         freeCompilerArgs.add("-opt-in=kotlin.time.ExperimentalTime")
-        freeCompilerArgs.add("-Xexpect-actual-classes")
     }
 
     iosArm64()
@@ -28,18 +27,13 @@ kotlin {
     jvm()
 
     sourceSets {
-        val clientMain by creating {
-            dependsOn(commonMain.get())
-        }
-
-        androidMain.get().dependsOn(clientMain)
-        iosArm64Main.get().dependsOn(clientMain)
-        iosSimulatorArm64Main.get().dependsOn(clientMain)
-
         androidMain.dependencies {
+            implementation(libs.koin.compose)
             implementation(libs.ktor.client.okhttp)
         }
         commonMain.dependencies {
+            api(projects.core.data)
+
             implementation(libs.okio)
             implementation(libs.koin.core)
             implementation(libs.ktor.client.core)
@@ -51,14 +45,10 @@ kotlin {
             implementation(libs.kotlinx.serialization.protobuf)
 
             implementation(projects.core)
-            implementation(projects.core.sqld)
+            implementation(projects.core.room)
         }
         iosMain.dependencies {
             implementation(libs.ktor.client.darwin)
         }
-        jvmMain.dependencies {
-            implementation(libs.koin.ktor)
-            implementation(libs.ktor.server.core)
-        }
     }
 }

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/ClientDataDiModule.kt

@@ -10,19 +10,26 @@ import kotlinx.serialization.json.Json
 import moe.lava.banksia.core.Constants
 import moe.lava.banksia.core.data.repositories.ClientRouteRepository
 import moe.lava.banksia.core.data.repositories.ClientStopRepository
+import moe.lava.banksia.core.data.repositories.ClientStopTimeRepository
 import moe.lava.banksia.core.data.repositories.RouteRepository
 import moe.lava.banksia.core.data.repositories.StopRepository
+import moe.lava.banksia.core.data.repositories.StopTimeRepository
 import moe.lava.banksia.core.data.sources.route.RouteLocalDataSource
 import moe.lava.banksia.core.data.sources.route.RouteRemoteDataSource
 import moe.lava.banksia.core.data.sources.stop.StopLocalDataSource
 import moe.lava.banksia.core.data.sources.stop.StopRemoteDataSource
+import moe.lava.banksia.core.data.sources.stoptime.StopTimeLocalDataSource
+import moe.lava.banksia.core.data.sources.stoptime.StopTimeRemoteDataSource
+import moe.lava.banksia.core.room.roomDiModule
 import moe.lava.banksia.core.util.log
 import moe.lava.banksia.data.ptv.PtvService
 import org.koin.core.module.dsl.singleOf
 import org.koin.dsl.bind
 import org.koin.dsl.module
 
-actual val platformModule = module {
+val clientDataDiModule = module {
+    includes(roomDiModule)
+
     // HTTP Clients
     singleOf(::PtvService)
     single {
@@ -49,8 +56,11 @@ actual val platformModule = module {
     singleOf(::RouteRemoteDataSource)
     singleOf(::StopLocalDataSource)
     singleOf(::StopRemoteDataSource)
+    singleOf(::StopTimeLocalDataSource)
+    singleOf(::StopTimeRemoteDataSource)
 
     // Repositories
     singleOf(::ClientRouteRepository) bind RouteRepository::class
     singleOf(::ClientStopRepository) bind StopRepository::class
+    singleOf(::ClientStopTimeRepository) bind StopTimeRepository::class
 }

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/ClientRouteRepository.kt

@@ -5,7 +5,6 @@ import kotlinx.coroutines.sync.withLock
 import moe.lava.banksia.core.data.sources.route.RouteLocalDataSource
 import moe.lava.banksia.core.data.sources.route.RouteRemoteDataSource
 import moe.lava.banksia.core.model.Route
-import moe.lava.banksia.core.sqld.mappers.asModel
 
 internal class ClientRouteRepository internal constructor(
     private val local: RouteLocalDataSource,
@@ -23,14 +22,14 @@ internal class ClientRouteRepository internal constructor(
             }
     }
 
-    private val tripRouteMap = mutableMapOf<Long, Route>()
+    private val tripRouteMap = mutableMapOf<String, Route>()
 
     override suspend fun get(id: String) = mutex.withLock { local.get(id)?.asModel() ?: remote.get(id) }
-    override suspend fun getByPattern(patternId: Long) = mutex.withLock {
+    override suspend fun getByTrip(tripId: String) = mutex.withLock {
-        tripRouteMap[patternId]
+        tripRouteMap[tripId]
-            ?: remote.getByPattern(patternId).also {
+            ?: remote.getByTrip(tripId).also {
                 local.save(it)
-                tripRouteMap[patternId] = it
+                tripRouteMap[tripId] = it
             }
     }
 }

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/ClientStopRepository.kt

@@ -4,7 +4,6 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import moe.lava.banksia.core.data.sources.stop.StopLocalDataSource
 import moe.lava.banksia.core.data.sources.stop.StopRemoteDataSource
-import moe.lava.banksia.core.sqld.mappers.asModel
 
 internal class ClientStopRepository internal constructor(
     private val local: StopLocalDataSource,

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/ClientStopTimeRepository.kt

@@ -0,0 +1,16 @@
+package moe.lava.banksia.core.data.repositories
+
+import moe.lava.banksia.core.data.sources.stoptime.StopTimeLocalDataSource
+import moe.lava.banksia.core.data.sources.stoptime.StopTimeRemoteDataSource
+import moe.lava.banksia.core.model.StopTimeDated
+
+internal class ClientStopTimeRepository internal constructor(
+    private val local: StopTimeLocalDataSource,
+    private val remote: StopTimeRemoteDataSource,
+) : StopTimeRepository {
+    override suspend fun getForStop(id: String): List<StopTimeDated> {
+        return local
+            .getAtStop(id)
+            .ifEmpty { remote.getAtStop(id) }
+    }
+}

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/route/RouteLocalDataSource.kt

@@ -0,0 +1,12 @@
+package moe.lava.banksia.core.data.sources.route
+
+import moe.lava.banksia.core.model.Route
+import moe.lava.banksia.core.room.dao.RouteDao
+import moe.lava.banksia.core.room.entity.asEntity
+
+internal class RouteLocalDataSource(private val dao: RouteDao) {
+    suspend fun get(id: String) = dao.get(id)
+    suspend fun getAll() = dao.getAll()
+    suspend fun getByTrip(tripId: String) = dao.getByTrip(tripId)
+    suspend fun save(vararg routes: Route) = dao.insertOrReplaceAll(*routes.map { it.asEntity() }.toTypedArray())
+}

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/route/RouteRemoteDataSource.kt

@@ -7,6 +7,6 @@ import moe.lava.banksia.core.model.Route
 
 internal class RouteRemoteDataSource(val client: HttpClient) {
     suspend fun get(id: String) = client.get("routes/${id}").body<Route>()
-    suspend fun getByPattern(patternId: Long) = client.get("routes/by_pattern/${patternId}").body<Route>()
+    suspend fun getByTrip(tripId: String) = client.get("routes/by_trip/${tripId}").body<Route>()
     suspend fun getAll() = client.get("routes").body<List<Route>>()
 }

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/stop/StopLocalDataSource.kt

@@ -0,0 +1,12 @@
+package moe.lava.banksia.core.data.sources.stop
+
+import moe.lava.banksia.core.model.Stop
+import moe.lava.banksia.core.room.dao.RouteDao
+import moe.lava.banksia.core.room.dao.StopDao
+import moe.lava.banksia.core.room.entity.asEntity
+
+internal class StopLocalDataSource(private val dao: StopDao, private val routeDao: RouteDao) {
+    suspend fun get(id: String) = dao.get(id)
+    suspend fun getByRoute(id: String) = routeDao.stops(id)
+    suspend fun save(vararg stops: Stop) = dao.insertOrReplaceAll(*stops.map { it.asEntity() }.toTypedArray())
+}

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/stoptime/StopTimeLocalDataSource.kt

@@ -0,0 +1,28 @@
+package moe.lava.banksia.core.data.sources.stoptime
+
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.todayIn
+import moe.lava.banksia.core.model.StopTimeDated
+import moe.lava.banksia.core.model.atDate
+import moe.lava.banksia.core.room.dao.StopTimeDao
+import moe.lava.banksia.core.util.serialise
+import kotlin.time.Clock
+
+internal class StopTimeLocalDataSource(
+    private val stopTimeDao: StopTimeDao,
+) {
+    suspend fun getAtStop(
+        stopId: String,
+        date: LocalDate = Clock.System.todayIn(TimeZone.currentSystemDefault()),
+    ): List<StopTimeDated> {
+        return stopTimeDao
+            .getForStopDated(
+                stopId,
+                listOf(date.dayOfWeek).serialise(),
+                date.toEpochDays().toInt(),
+            )
+            .map { it.asModel().atDate(date) }
+            .sortedBy { it.departureTime }
+    }
+}

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/stoptime/StopTimeRemoteDataSource.kt

@@ -0,0 +1,36 @@
+package moe.lava.banksia.core.data.sources.stoptime
+
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.request.get
+import io.ktor.client.request.parameter
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.todayIn
+import moe.lava.banksia.core.model.StopTimeDated
+import kotlin.time.Clock
+
+internal class StopTimeRemoteDataSource(
+    private val client: HttpClient,
+) {
+    suspend fun getAtStop(
+        stopId: String,
+        date: LocalDate? = Clock.System.todayIn(TimeZone.currentSystemDefault()),
+    ): List<StopTimeDated> {
+        return client.get("stoptimes/by_stop/${stopId}") {
+            parameter("date", date)
+        }.body<List<StopTimeDated>>()
+    }
+
+    /*suspend fun get(
+        stop: String? = null,
+        trip: String? = null,
+        day: DayOfWeek? = Clock.System.todayIn(TimeZone.currentSystemDefault()).dayOfWeek,
+    ): List<StopTime> {
+        return client.get("stoptimes") {
+            stop?.let { parameter("stop", it) }
+            trip?.let { parameter("trip", it) }
+            day?.let { parameter("day", it) }
+        }.body<List<StopTime>>()
+    }*/
+}

core/data/client/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/trip/TripRemoteDataSource.kt

@@ -0,0 +1,18 @@
+package moe.lava.banksia.core.data.sources.trip
+
+import io.ktor.client.HttpClient
+import kotlinx.datetime.DayOfWeek
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.todayIn
+import moe.lava.banksia.core.model.Trip
+import kotlin.time.Clock
+
+internal class TripRemoteDataSource(
+    private val client: HttpClient,
+) {
+    suspend fun get(
+        day: DayOfWeek? = Clock.System.todayIn(TimeZone.currentSystemDefault()).dayOfWeek,
+    ): List<Trip> {
+        return listOf()
+    }
+}

core/data/server/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    alias(libs.plugins.kotlinJvm)
+    alias(libs.plugins.kotlinSerialization)
+}
+
+kotlin {
+    compilerOptions {
+        freeCompilerArgs.add("-opt-in=kotlin.time.ExperimentalTime")
+    }
+}
+
+dependencies {
+    implementation(libs.okio)
+    implementation(libs.koin.core)
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.kotlinx.datetime)
+
+    api(projects.core.data)
+    implementation(projects.core)
+    implementation(projects.core.room)
+}

core/data/src/clientMain/kotlin/moe/lava/banksia/core/data/sources/route/RouteLocalDataSource.kt

@@ -1,23 +0,0 @@
-package moe.lava.banksia.core.data.sources.route
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.IO
-import kotlinx.coroutines.withContext
-import moe.lava.banksia.core.model.Route
-import moe.lava.banksia.core.sqld.RouteQueries
-import moe.lava.banksia.core.sqld.mappers.asDb
-
-internal class RouteLocalDataSource(private val queries: RouteQueries) {
-    suspend fun get(id: String) = withContext(Dispatchers.IO) { queries.get(id).executeAsOneOrNull() }
-    suspend fun getAll() = withContext(Dispatchers.IO) { queries.getAll().executeAsList() }
-//    suspend fun getByTrip(tripId: String) = dao.getByTrip(tripId)
-    suspend fun save(vararg routes: Route) {
-        withContext(Dispatchers.IO) {
-            queries.transaction {
-                routes.forEach {
-                    queries.insert(it.asDb())
-                }
-            }
-        }
-    }
-}

core/data/src/clientMain/kotlin/moe/lava/banksia/core/data/sources/stop/StopLocalDataSource.kt

@@ -1,22 +0,0 @@
-package moe.lava.banksia.core.data.sources.stop
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.IO
-import kotlinx.coroutines.withContext
-import moe.lava.banksia.core.model.Stop
-import moe.lava.banksia.core.sqld.StopQueries
-import moe.lava.banksia.core.sqld.mappers.asDb
-
-internal class StopLocalDataSource(private val queries: StopQueries) {
-    suspend fun get(id: String) = withContext(Dispatchers.IO) { queries.get(id).executeAsOneOrNull() }
-    suspend fun getByRoute(id: String) = withContext(Dispatchers.IO) { queries.getByRoute(id).executeAsList() }
-    suspend fun save(vararg stops: Stop) {
-        withContext(Dispatchers.IO) {
-            queries.transaction {
-                stops.forEach {
-                    queries.insert(it.asDb())
-                }
-            }
-        }
-    }
-}

core/data/src/commonMain/kotlin/moe/lava/banksia/core/data/DataDiModule.kt

@@ -1,13 +0,0 @@
-package moe.lava.banksia.core.data
-
-import moe.lava.banksia.core.sqld.sqldDiModule
-import org.koin.core.module.Module
-import org.koin.dsl.module
-
-internal expect val platformModule: Module
-
-val dataDiModule = module {
-    includes(platformModule)
-    includes(sqldDiModule)
-    includes(stopTimeDataDiModule)
-}

core/data/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/RouteRepository.kt

@@ -4,6 +4,6 @@ import moe.lava.banksia.core.model.Route
 
 interface RouteRepository {
     suspend fun get(id: String): Route?
-    suspend fun getByPattern(patternId: Long): Route?
+    suspend fun getByTrip(tripId: String): Route?
     suspend fun getAll(): List<Route>
 }

core/data/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/StopTimeRepository.kt

@@ -0,0 +1,7 @@
+package moe.lava.banksia.core.data.repositories
+
+import moe.lava.banksia.core.model.StopTimeDated
+
+interface StopTimeRepository {
+    suspend fun getForStop(id: String): List<StopTimeDated>
+}

core/data/src/jvmMain/kotlin/moe/lava/banksia/core/data/DataDiModule.jvm.kt

@@ -1,7 +0,0 @@
-package moe.lava.banksia.core.data
-
-import org.koin.dsl.module
-
-internal actual val platformModule = module {
-
-}

core/room/build.gradle.kts

@@ -4,12 +4,17 @@ plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.kotlinSerialization)
     alias(libs.plugins.androidMultiplatformLibrary)
-    alias(libs.plugins.sqldelight)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.room)
+}
+
+room {
+    schemaDirectory("$projectDir/schemas")
 }
 
 kotlin {
     android {
-        namespace = "moe.lava.banksia.core.sqld"
+        namespace = "moe.lava.banksia.core.room"
         compileSdk = libs.versions.android.compileSdk.get().toInt()
 
         compilerOptions {
@@ -17,37 +22,33 @@ kotlin {
         }
     }
 
+    compilerOptions {
+        freeCompilerArgs.add("-opt-in=kotlin.time.ExperimentalTime")
+    }
+
     iosArm64()
     iosSimulatorArm64()
 
     jvm()
 
     sourceSets {
-        androidMain.dependencies {
-            implementation(libs.sqldelight.driver.android)
-        }
         commonMain.dependencies {
             implementation(libs.okio)
             implementation(libs.koin.core)
             implementation(libs.kotlinx.coroutines.core)
             implementation(libs.kotlinx.datetime)
+            implementation(libs.kotlinx.serialization.json)
+            implementation(libs.room.runtime)
+            implementation(libs.sqlite.bundled)
 
             implementation(projects.core)
         }
-        nativeMain.dependencies {
-            implementation(libs.sqldelight.driver.native)
-        }
-        jvmMain.dependencies {
-            implementation(libs.sqldelight.driver.jvm)
-        }
     }
 }
 
-sqldelight {
+dependencies {
-    databases {
+    add("kspAndroid", libs.room.compiler)
-        register("BanksiaDatabase") {
+    add("kspIosArm64", libs.room.compiler)
-            packageName.set("moe.lava.banksia.core.sqld")
+    add("kspIosSimulatorArm64", libs.room.compiler)
-            schemaOutputDirectory.set(file("src/commonMain/sqldelight/schema"))
+    add("kspJvm", libs.room.compiler)
-        }
-    }
 }

core/room/schemas/moe.lava.banksia.core.room.Database/1.json

@@ -0,0 +1,72 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "e536f5a9b1408377bcc449195169648c",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e536f5a9b1408377bcc449195169648c')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/10.json

@@ -0,0 +1,477 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 10,
+    "identityHash": "5b90bc800bfae6d22124ea0a6a906ca7",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `days` INTEGER NOT NULL, `start` INTEGER NOT NULL, `end` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "start",
+            "columnName": "start",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "end",
+            "columnName": "end",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Service_days",
+            "unique": false,
+            "columnNames": [
+              "days"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Service_days` ON `${TABLE_NAME}` (`days`)"
+          }
+        ]
+      },
+      {
+        "tableName": "ServiceException",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`serviceId` TEXT NOT NULL, `date` INTEGER NOT NULL, `type` INTEGER NOT NULL, PRIMARY KEY(`serviceId`, `date`))",
+        "fields": [
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "date",
+            "columnName": "date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "serviceId",
+            "date"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_ServiceException_serviceId",
+            "unique": false,
+            "columnNames": [
+              "serviceId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_ServiceException_serviceId` ON `${TABLE_NAME}` (`serviceId`)"
+          },
+          {
+            "name": "index_ServiceException_type",
+            "unique": false,
+            "columnNames": [
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_ServiceException_type` ON `${TABLE_NAME}` (`type`)"
+          }
+        ]
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`serviceId`) REFERENCES `Service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5b90bc800bfae6d22124ea0a6a906ca7')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/11.json

@@ -0,0 +1,498 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 11,
+    "identityHash": "c4be3d0c2a25f8c5c33132646a070d0e",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `days` INTEGER NOT NULL, `start` INTEGER NOT NULL, `end` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "start",
+            "columnName": "start",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "end",
+            "columnName": "end",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Service_days",
+            "unique": false,
+            "columnNames": [
+              "days"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Service_days` ON `${TABLE_NAME}` (`days`)"
+          }
+        ]
+      },
+      {
+        "tableName": "ServiceException",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`serviceId` TEXT NOT NULL, `date` INTEGER NOT NULL, `type` INTEGER NOT NULL, PRIMARY KEY(`serviceId`, `date`))",
+        "fields": [
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "date",
+            "columnName": "date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "serviceId",
+            "date"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_ServiceException_serviceId",
+            "unique": false,
+            "columnNames": [
+              "serviceId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_ServiceException_serviceId` ON `${TABLE_NAME}` (`serviceId`)"
+          },
+          {
+            "name": "index_ServiceException_type",
+            "unique": false,
+            "columnNames": [
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_ServiceException_type` ON `${TABLE_NAME}` (`type`)"
+          }
+        ]
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`parent`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Stop",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "parent"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`serviceId`) REFERENCES `Service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_serviceId",
+            "unique": false,
+            "columnNames": [
+              "serviceId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_serviceId` ON `${TABLE_NAME}` (`serviceId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'c4be3d0c2a25f8c5c33132646a070d0e')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/2.json

@@ -0,0 +1,315 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "83ece554400bb035c267dc2414c23293",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '83ece554400bb035c267dc2414c23293')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/3.json

@@ -0,0 +1,339 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 3,
+    "identityHash": "5a7252ab3bcae4d0d0950024b19ba002",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5a7252ab3bcae4d0d0950024b19ba002')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/4.json

@@ -0,0 +1,368 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 4,
+    "identityHash": "4426fd2ccc826d9d9d9021546b105850",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": true,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": true,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '4426fd2ccc826d9d9d9021546b105850')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/5.json

@@ -0,0 +1,368 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 5,
+    "identityHash": "4426fd2ccc826d9d9d9021546b105850",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": true,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": true,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '4426fd2ccc826d9d9d9021546b105850')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/6.json

@@ -0,0 +1,368 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 6,
+    "identityHash": "5f52de4cc0ddbcf02a0d8be4cf4d4cfd",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '5f52de4cc0ddbcf02a0d8be4cf4d4cfd')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/7.json

@@ -0,0 +1,415 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 7,
+    "identityHash": "15c94df0a62438ff28d451c074c94c59",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `days` INTEGER NOT NULL, `start` INTEGER NOT NULL, `end` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "start",
+            "columnName": "start",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "end",
+            "columnName": "end",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Service_days",
+            "unique": false,
+            "columnNames": [
+              "days"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Service_days` ON `${TABLE_NAME}` (`days`)"
+          }
+        ]
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '15c94df0a62438ff28d451c074c94c59')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/8.json

@@ -0,0 +1,426 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 8,
+    "identityHash": "6e0f07bf1af88b2e37b5ad7c38a3fb2a",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `days` INTEGER NOT NULL, `start` INTEGER NOT NULL, `end` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "start",
+            "columnName": "start",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "end",
+            "columnName": "end",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Service_days",
+            "unique": false,
+            "columnNames": [
+              "days"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Service_days` ON `${TABLE_NAME}` (`days`)"
+          }
+        ]
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`serviceId`) REFERENCES `Service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6e0f07bf1af88b2e37b5ad7c38a3fb2a')"
+    ]
+  }
+}

core/room/schemas/moe.lava.banksia.core.room.Database/9.json

@@ -0,0 +1,426 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 9,
+    "identityHash": "6e0f07bf1af88b2e37b5ad7c38a3fb2a",
+    "entities": [
+      {
+        "tableName": "Route",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `type` INTEGER NOT NULL, `number` TEXT, `name` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "number",
+            "columnName": "number",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `days` INTEGER NOT NULL, `start` INTEGER NOT NULL, `end` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "days",
+            "columnName": "days",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "start",
+            "columnName": "start",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "end",
+            "columnName": "end",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Service_days",
+            "unique": false,
+            "columnNames": [
+              "days"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Service_days` ON `${TABLE_NAME}` (`days`)"
+          }
+        ]
+      },
+      {
+        "tableName": "Shape",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `path` BLOB NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "path",
+            "columnName": "path",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "Stop",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT NOT NULL, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lat",
+            "columnName": "lat",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lng",
+            "columnName": "lng",
+            "affinity": "REAL",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parent",
+            "columnName": "parent",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasWheelChairBoarding",
+            "columnName": "hasWheelChairBoarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "level",
+            "columnName": "level",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "platformCode",
+            "columnName": "platformCode",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Stop_parent",
+            "unique": false,
+            "columnNames": [
+              "parent"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `${TABLE_NAME}` (`parent`)"
+          }
+        ]
+      },
+      {
+        "tableName": "StopTime",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tripId` TEXT NOT NULL, `stopId` TEXT NOT NULL, `arrivalTime` INTEGER NOT NULL, `departureTime` INTEGER NOT NULL, `headsign` TEXT, `pickupType` INTEGER NOT NULL, `dropOffType` INTEGER NOT NULL, PRIMARY KEY(`tripId`, `stopId`), FOREIGN KEY(`tripId`) REFERENCES `Trip`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`stopId`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "tripId",
+            "columnName": "tripId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "stopId",
+            "columnName": "stopId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "arrivalTime",
+            "columnName": "arrivalTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "departureTime",
+            "columnName": "departureTime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "headsign",
+            "columnName": "headsign",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pickupType",
+            "columnName": "pickupType",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "dropOffType",
+            "columnName": "dropOffType",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "tripId",
+            "stopId"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_StopTime_tripId",
+            "unique": false,
+            "columnNames": [
+              "tripId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_tripId` ON `${TABLE_NAME}` (`tripId`)"
+          },
+          {
+            "name": "index_StopTime_stopId",
+            "unique": false,
+            "columnNames": [
+              "stopId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_StopTime_stopId` ON `${TABLE_NAME}` (`stopId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Trip",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "tripId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Stop",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "stopId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "Trip",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `routeId` TEXT NOT NULL, `serviceId` TEXT NOT NULL, `shapeId` TEXT, `tripHeadsign` TEXT NOT NULL, `directionId` TEXT NOT NULL, `blockId` TEXT NOT NULL, `wheelchairAccessible` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`routeId`) REFERENCES `Route`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`serviceId`) REFERENCES `Service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`shapeId`) REFERENCES `Shape`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "routeId",
+            "columnName": "routeId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "shapeId",
+            "columnName": "shapeId",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "tripHeadsign",
+            "columnName": "tripHeadsign",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directionId",
+            "columnName": "directionId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "blockId",
+            "columnName": "blockId",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wheelchairAccessible",
+            "columnName": "wheelchairAccessible",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_Trip_shapeId",
+            "unique": false,
+            "columnNames": [
+              "shapeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_shapeId` ON `${TABLE_NAME}` (`shapeId`)"
+          },
+          {
+            "name": "index_Trip_routeId",
+            "unique": false,
+            "columnNames": [
+              "routeId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_Trip_routeId` ON `${TABLE_NAME}` (`routeId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "Route",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "routeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "Shape",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "shapeId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "VersionMetadata",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`type` TEXT NOT NULL, `lastUpdated` INTEGER NOT NULL, PRIMARY KEY(`type`))",
+        "fields": [
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUpdated",
+            "columnName": "lastUpdated",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "type"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6e0f07bf1af88b2e37b5ad7c38a3fb2a')"
+    ]
+  }
+}

core/room/src/androidMain/kotlin/moe/lava/banksia/core/room/DatabaseManager.android.kt

@@ -0,0 +1,22 @@
+package moe.lava.banksia.core.room
+
+import android.content.Context
+import androidx.room.Room
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.get
+import org.koin.core.component.inject
+
+actual class DatabaseManager actual constructor() : KoinComponent {
+    private val ctx by inject<Context>()
+
+    actual val database by lazy {
+        val ctx = get<Context>().applicationContext
+        val dbFile = ctx.getDatabasePath("room.db")
+        val builder = Room.databaseBuilder<Database>(
+            context = ctx,
+            name = dbFile.absolutePath,
+        )
+
+        Database.build(builder)
+    }
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/Database.kt

@@ -0,0 +1,83 @@
+package moe.lava.banksia.core.room
+
+import androidx.room.AutoMigration
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import androidx.room.migration.Migration
+import androidx.room.util.foreignKeyCheck
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.driver.bundled.BundledSQLiteDriver
+import androidx.sqlite.execSQL
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.IO
+import moe.lava.banksia.core.room.converter.RouteTypeConverter
+import moe.lava.banksia.core.room.dao.RouteDao
+import moe.lava.banksia.core.room.dao.ServiceDao
+import moe.lava.banksia.core.room.dao.ServiceExceptionDao
+import moe.lava.banksia.core.room.dao.ShapeDao
+import moe.lava.banksia.core.room.dao.StopDao
+import moe.lava.banksia.core.room.dao.StopTimeDao
+import moe.lava.banksia.core.room.dao.TripDao
+import moe.lava.banksia.core.room.dao.VersionMetadataDao
+import moe.lava.banksia.core.room.entity.RouteEntity
+import moe.lava.banksia.core.room.entity.ServiceEntity
+import moe.lava.banksia.core.room.entity.ServiceExceptionEntity
+import moe.lava.banksia.core.room.entity.ShapeEntity
+import moe.lava.banksia.core.room.entity.StopEntity
+import moe.lava.banksia.core.room.entity.StopTimeEntity
+import moe.lava.banksia.core.room.entity.TripEntity
+import moe.lava.banksia.core.room.entity.VersionMetadataEntity
+import androidx.room.Database as DatabaseAnnotation
+
+@DatabaseAnnotation(
+    version = 11,
+    entities = [
+        RouteEntity::class,
+        ServiceEntity::class,
+        ServiceExceptionEntity::class,
+        ShapeEntity::class,
+        StopEntity::class,
+        StopTimeEntity::class,
+        TripEntity::class,
+        VersionMetadataEntity::class,
+    ],
+    autoMigrations = [
+        AutoMigration(from = 1, to = 2),
+        AutoMigration(from = 2, to = 3),
+        AutoMigration(from = 9, to = 10),
+    ]
+)
+@TypeConverters(RouteTypeConverter::class)
+abstract class Database : RoomDatabase() {
+    abstract val versionMetadataDao: VersionMetadataDao
+    abstract val routeDao: RouteDao
+    abstract val serviceDao: ServiceDao
+    abstract val serviceExceptionDao: ServiceExceptionDao
+    abstract val shapeDao: ShapeDao
+    abstract val stopDao: StopDao
+    abstract val stopTimeDao: StopTimeDao
+    abstract val tripDao: TripDao
+
+    companion object {
+        fun build(base: Builder<Database>) =
+            base.fallbackToDestructiveMigration(true)
+                .setDriver(BundledSQLiteDriver())
+                .setQueryCoroutineContext(Dispatchers.IO)
+                .addMigrations(MIGRATION_10_11)
+//                .fallbackToDestructiveMigration(true)
+                .build()
+    }
+}
+
+val MIGRATION_10_11 = object : Migration(10, 11) {
+    override fun migrate(connection: SQLiteConnection) {
+        connection.execSQL("CREATE TABLE IF NOT EXISTS `_new_Stop` (`id` TEXT NOT NULL, `name` TEXT NOT NULL, `lat` REAL NOT NULL, `lng` REAL NOT NULL, `parent` TEXT, `hasWheelChairBoarding` INTEGER NOT NULL, `level` TEXT NOT NULL, `platformCode` TEXT NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`parent`) REFERENCES `Stop`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL DEFERRABLE INITIALLY DEFERRED)")
+        connection.execSQL("INSERT INTO `_new_Stop` (`id`,`name`,`lat`,`lng`,`parent`,`hasWheelChairBoarding`,`level`,`platformCode`) SELECT `id`,`name`,`lat`,`lng`,`parent`,`hasWheelChairBoarding`,`level`,`platformCode` FROM `Stop`")
+        connection.execSQL("UPDATE `_new_Stop` SET `parent` = NULL WHERE `parent` == \"\"")
+        connection.execSQL("DROP TABLE `Stop`")
+        connection.execSQL("ALTER TABLE `_new_Stop` RENAME TO `Stop`")
+        connection.execSQL("CREATE INDEX IF NOT EXISTS `index_Stop_parent` ON `Stop` (`parent`)")
+        connection.execSQL("CREATE INDEX IF NOT EXISTS `index_Trip_serviceId` ON `Trip` (`serviceId`)")
+        foreignKeyCheck(connection, "Stop")
+    }
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/DatabaseManager.kt

@@ -0,0 +1,7 @@
+package moe.lava.banksia.core.room
+
+import org.koin.core.component.KoinComponent
+
+expect class DatabaseManager() : KoinComponent {
+    val database: Database
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/RoomDiModule.kt

@@ -0,0 +1,18 @@
+package moe.lava.banksia.core.room
+
+import org.koin.core.module.dsl.singleOf
+import org.koin.dsl.module
+
+val roomDiModule = module {
+    singleOf(::DatabaseManager)
+    factory { get<DatabaseManager>().database }
+
+    factory { get<Database>().versionMetadataDao }
+    factory { get<Database>().routeDao }
+    factory { get<Database>().serviceDao }
+    factory { get<Database>().serviceExceptionDao }
+    factory { get<Database>().shapeDao }
+    factory { get<Database>().stopDao }
+    factory { get<Database>().stopTimeDao }
+    factory { get<Database>().tripDao }
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/converter/RouteTypeConverter.kt

@@ -0,0 +1,12 @@
+package moe.lava.banksia.core.room.converter
+
+import androidx.room.TypeConverter
+import moe.lava.banksia.core.model.RouteType
+
+object RouteTypeConverter {
+    @TypeConverter
+    fun from(value: Int) = RouteType.from(value)
+
+    @TypeConverter
+    fun to(routeType: RouteType) = routeType.value
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/converter/ShapePathConverter.kt

@@ -0,0 +1,43 @@
+package moe.lava.banksia.core.room.converter
+
+import androidx.room.TypeConverter
+import moe.lava.banksia.core.model.ShapePath
+import moe.lava.banksia.core.util.Point
+
+object ShapePathConverter {
+    @TypeConverter
+    fun from(value: ByteArray): ShapePath {
+        return value
+            .asIterable()
+            .chunked(8) {
+                (it[0].toLong() and 0xFF) or
+                (it[1].toLong() and 0xFF shl 8) or
+                (it[2].toLong() and 0xFF shl 16) or
+                (it[3].toLong() and 0xFF shl 24) or
+                (it[4].toLong() and 0xFF shl 32) or
+                (it[5].toLong() and 0xFF shl 40) or
+                (it[6].toLong() and 0xFF shl 48) or
+                (it[7].toLong() and 0xFF shl 56)
+            }
+            .map { Double.fromBits(it) }
+            .chunked(2)
+            .map { (lat, lng) -> Point(lat, lng) }
+    }
+
+    @TypeConverter
+    fun to(path: ShapePath): ByteArray {
+        return path
+            .flatMap { (lat, lng) -> listOf(lat.toBits(), lng.toBits()) }
+            .flatMap { i -> listOf(
+                i.toByte(),
+                (i shr 8).toByte(),
+                (i shr 16).toByte(),
+                (i shr 24).toByte(),
+                (i shr 32).toByte(),
+                (i shr 40).toByte(),
+                (i shr 48).toByte(),
+                (i shr 56).toByte(),
+            ) }
+            .toByteArray()
+    }
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/RouteDao.kt

@@ -0,0 +1,61 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.RouteEntity
+import moe.lava.banksia.core.room.entity.StopEntity
+
+@Dao
+interface RouteDao {
+    @Query("SELECT * FROM Route")
+    suspend fun getAll(): List<RouteEntity>
+
+    @Query("SELECT * FROM Route WHERE id == :id")
+    suspend fun get(id: String): RouteEntity?
+
+    @Insert
+    suspend fun insertAll(vararg routes: RouteEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg routes: RouteEntity)
+
+    @Delete
+    suspend fun delete(route: RouteEntity)
+
+    @Query("DELETE FROM Route")
+    suspend fun deleteAll()
+
+    @Query("SELECT * FROM Route INNER JOIN Trip on Route.id == Trip.routeId WHERE Trip.id == :tripId")
+    suspend fun getByTrip(tripId: String): RouteEntity?
+
+    @Query("""
+        SELECT Stop.* FROM Stop
+        INNER JOIN StopTime ON StopTime.stopId == Stop.id
+        INNER JOIN Trip ON Trip.id == StopTime.tripId
+        WHERE Trip.routeId == :id
+        GROUP BY Stop.id
+    """)
+    suspend fun stops(id: String): List<StopEntity>
+
+    // I vibecoded this, sorry
+    @Query("""
+        WITH Tree AS (
+            SELECT Stop.* FROM Stop
+            INNER JOIN StopTime ON StopTime.stopId == Stop.id
+            INNER JOIN Trip ON Trip.id == StopTime.tripId
+            WHERE Trip.routeId == :id
+            GROUP BY Stop.id
+
+            UNION ALL
+
+            SELECT s.*
+            FROM Stop s
+            INNER JOIN Tree t ON s.id = t.parent
+        )
+        SELECT DISTINCT * FROM Tree WHERE parent IS NULL;
+    """)
+    suspend fun stopsParent(id: String): List<StopEntity>
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/ServiceDao.kt

@@ -0,0 +1,29 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.ServiceEntity
+
+@Dao
+interface ServiceDao {
+    @Query("SELECT * FROM Service")
+    suspend fun getAll(): List<ServiceEntity>
+
+    @Query("SELECT * FROM Service WHERE id == :id")
+    suspend fun get(id: String): ServiceEntity?
+
+    @Insert
+    suspend fun insertAll(vararg services: ServiceEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg services: ServiceEntity)
+
+    @Delete
+    suspend fun delete(service: ServiceEntity)
+
+    @Query("DELETE FROM Service")
+    suspend fun deleteAll()
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/ServiceExceptionDao.kt

@@ -0,0 +1,29 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.ServiceExceptionEntity
+
+@Dao
+interface ServiceExceptionDao {
+    @Query("SELECT * FROM ServiceException")
+    suspend fun getAll(): List<ServiceExceptionEntity>
+
+    @Query("SELECT * FROM ServiceException WHERE serviceId == :id")
+    suspend fun get(id: String): List<ServiceExceptionEntity>
+
+    @Insert
+    suspend fun insertAll(vararg exceptions: ServiceExceptionEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg exceptions: ServiceExceptionEntity)
+
+    @Delete
+    suspend fun delete(service: ServiceExceptionEntity)
+
+    @Query("DELETE FROM ServiceException")
+    suspend fun deleteAll()
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/ShapeDao.kt

@@ -0,0 +1,26 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.ShapeEntity
+
+@Dao
+interface ShapeDao {
+    @Query("SELECT * FROM Shape WHERE id == :id")
+    suspend fun get(id: String): ShapeEntity?
+
+    @Insert
+    suspend fun insertAll(vararg shapes: ShapeEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg shapes: ShapeEntity)
+
+    @Delete
+    suspend fun delete(shape: ShapeEntity)
+
+    @Query("DELETE FROM Shape")
+    suspend fun deleteAll()
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/StopDao.kt

@@ -0,0 +1,42 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.StopEntity
+
+@Dao
+interface StopDao {
+    @Query("SELECT * FROM Stop")
+    suspend fun getAll(): List<StopEntity>
+
+    @Query("""
+        SELECT * FROM Stop
+        WHERE platformCode <> ""
+        AND parent IS NULL
+    """)
+    suspend fun getAllParentless(): List<StopEntity>
+
+    @Query("SELECT * FROM Stop WHERE id == :id")
+    suspend fun get(id: String): StopEntity?
+
+    @Query("SELECT * FROM Stop WHERE id IN (:ids)")
+    suspend fun get(ids: List<String>): List<StopEntity>
+
+    @Insert
+    suspend fun insertAll(vararg stops: StopEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg stops: StopEntity)
+
+    @Delete
+    suspend fun delete(stop: StopEntity)
+
+    @Query("DELETE FROM Stop")
+    suspend fun deleteAll()
+
+    @Query("UPDATE Stop SET parent = :parent WHERE id IN (:ids)")
+    suspend fun updateParents(ids: List<String>, parent: String)
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/StopTimeDao.kt

@@ -0,0 +1,46 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.StopTimeEntity
+
+@Dao
+interface StopTimeDao {
+    @Query("SELECT * FROM StopTime")
+    suspend fun getAll(): List<StopTimeEntity>
+
+    @Query("SELECT * FROM StopTime WHERE tripId == :tripId")
+    suspend fun getForTrip(tripId: String): StopTimeEntity?
+
+    @Query("SELECT * FROM StopTime WHERE tripId IN (:tripIds)")
+    suspend fun getForTrips(tripIds: List<String>): List<StopTimeEntity>
+
+    @Query("SELECT * FROM StopTime WHERE stopId == :stopId")
+    suspend fun getForStop(stopId: String): List<StopTimeEntity>
+
+    @Query("""
+        SELECT DISTINCT StopTime.* FROM StopTime
+        INNER JOIN Service ON Service.days & :days = :days AND :date BETWEEN Service.start AND Service.`end`
+        INNER JOIN Trip ON Trip.serviceId == Service.id
+        LEFT JOIN ServiceException ON ServiceException.serviceId == Service.id AND ServiceException.date == :date
+        WHERE StopTime.tripId == Trip.id
+            AND StopTime.stopId IN (SELECT Stop.id FROM Stop WHERE Stop.parent == :stopId OR Stop.id == :stopId)
+            AND ServiceException.type IS NULL
+    """)
+    suspend fun getForStopDated(stopId: String, days: Int, date: Int): List<StopTimeEntity>
+
+    @Insert
+    suspend fun insertAll(vararg stopTimes: StopTimeEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg stopTimes: StopTimeEntity)
+
+    @Delete
+    suspend fun delete(stopTime: StopTimeEntity)
+
+    @Query("DELETE FROM StopTime")
+    suspend fun deleteAll()
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/TripDao.kt

@@ -0,0 +1,32 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.TripEntity
+
+@Dao
+interface TripDao {
+    @Query("SELECT * FROM Trip")
+    suspend fun getAll(): List<TripEntity>
+
+    @Query("SELECT * FROM Trip WHERE id == :id")
+    suspend fun get(id: String): TripEntity?
+
+    @Query("SELECT * FROM Trip WHERE routeId == :id")
+    suspend fun getByRoute(id: String): List<TripEntity>
+
+    @Insert
+    suspend fun insertAll(vararg trips: TripEntity)
+
+    @Insert(onConflict = REPLACE)
+    suspend fun insertOrReplaceAll(vararg trips: TripEntity)
+
+    @Delete
+    suspend fun delete(trip: TripEntity)
+
+    @Query("DELETE FROM Trip")
+    suspend fun deleteAll()
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/dao/VersionMetadataDao.kt

@@ -0,0 +1,27 @@
+package moe.lava.banksia.core.room.dao
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy.Companion.REPLACE
+import androidx.room.Query
+import moe.lava.banksia.core.room.entity.VersionMetadataEntity
+
+@Dao
+interface VersionMetadataDao {
+    @Query("SELECT * FROM VersionMetadata WHERE type == :type")
+    suspend fun get(type: String): VersionMetadataEntity?
+
+    @Query("SELECT * FROM VersionMetadata")
+    suspend fun getAll(): List<VersionMetadataEntity>
+
+    @Insert(onConflict = REPLACE)
+    suspend fun update(vararg data: VersionMetadataEntity)
+
+    suspend fun update(vararg data: Pair<String, Long>) {
+        update(*data.map { (type, lastUpdated) -> VersionMetadataEntity(type, lastUpdated) }.toTypedArray())
+    }
+
+    suspend fun update(lastUpdated: Long, types: Collection<String>) {
+        update(*types.map { VersionMetadataEntity(it, lastUpdated) }.toTypedArray())
+    }
+}

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/RouteEntity.kt

@@ -0,0 +1,18 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import moe.lava.banksia.core.model.Route
+import moe.lava.banksia.core.model.RouteType
+
+@Entity("Route")
+data class RouteEntity(
+    @PrimaryKey val id: String,
+    val type: RouteType,
+    val number: String?,
+    val name: String,
+) {
+    fun asModel() = Route(id, type, number, name)
+}
+
+fun Route.asEntity() = RouteEntity(id, type, number, name)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/ServiceEntity.kt

@@ -0,0 +1,31 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.datetime.LocalDate
+import moe.lava.banksia.core.model.Service
+import moe.lava.banksia.core.util.deserialiseDaysBitflag
+import moe.lava.banksia.core.util.serialise
+
+@Entity("Service")
+data class ServiceEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(index = true) val days: Int,
+    val start: Int,
+    val end: Int,
+) {
+    fun asModel() = Service(
+        id,
+        days.deserialiseDaysBitflag(),
+        LocalDate.fromEpochDays(start),
+        LocalDate.fromEpochDays(end),
+    )
+}
+
+fun Service.asEntity() = ServiceEntity(
+    id,
+    days.serialise(),
+    start.toEpochDays().toInt(),
+    end.toEpochDays().toInt(),
+)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/ServiceExceptionEntity.kt

@@ -0,0 +1,28 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import kotlinx.datetime.LocalDate
+import moe.lava.banksia.core.model.ServiceException
+
+@Entity(
+    "ServiceException",
+    primaryKeys = ["serviceId", "date"]
+)
+data class ServiceExceptionEntity(
+    @ColumnInfo(index = true) val serviceId: String,
+    val date: Int,
+    @ColumnInfo(index = true) val type: Int,
+) {
+    fun asModel() = ServiceException(
+        serviceId,
+        LocalDate.fromEpochDays(date),
+        type,
+    )
+}
+
+fun ServiceException.asEntity() = ServiceExceptionEntity(
+    serviceId,
+    date.toEpochDays().toInt(),
+    type,
+)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/ShapeEntity.kt

@@ -0,0 +1,19 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import androidx.room.TypeConverters
+import moe.lava.banksia.core.model.Shape
+import moe.lava.banksia.core.model.ShapePath
+import moe.lava.banksia.core.room.converter.ShapePathConverter
+
+@Entity("Shape")
+@TypeConverters(ShapePathConverter::class)
+data class ShapeEntity(
+    @PrimaryKey val id: String,
+    val path: ShapePath,
+) {
+    fun asModel() = Shape(id, path)
+}
+
+fun Shape.asEntity() = ShapeEntity(id, path)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/StopEntity.kt

@@ -0,0 +1,36 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.ForeignKey.Companion.SET_NULL
+import androidx.room.PrimaryKey
+import moe.lava.banksia.core.model.Stop
+import moe.lava.banksia.core.util.Point
+
+@Entity(
+    "Stop",
+    foreignKeys = [
+        ForeignKey(
+            StopEntity::class,
+            parentColumns = ["id"],
+            childColumns = ["parent"],
+            onDelete = SET_NULL,
+            deferred = true,
+        ),
+    ]
+)
+data class StopEntity(
+    @PrimaryKey val id: String,
+    val name: String,
+    val lat: Double,
+    val lng: Double,
+    @ColumnInfo(index = true) val parent: String?,
+    val hasWheelChairBoarding: Boolean,
+    val level: String,
+    val platformCode: String,
+) {
+    fun asModel() = Stop(id, name, Point(lat, lng), parent, hasWheelChairBoarding, level, platformCode)
+}
+
+fun Stop.asEntity() = StopEntity(id, name, pos.lat, pos.lng, parent, hasWheelChairBoarding, level, platformCode)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/StopTimeEntity.kt

@@ -0,0 +1,53 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.ForeignKey.Companion.CASCADE
+import androidx.room.Index
+import kotlinx.serialization.ExperimentalSerializationApi
+import moe.lava.banksia.core.model.FutureTime
+import moe.lava.banksia.core.model.FutureTime.Companion.asInt
+import moe.lava.banksia.core.model.StopTime
+
+@Entity(
+    "StopTime",
+    primaryKeys = ["tripId", "stopId"],
+    indices = [
+        Index("tripId", unique = false),
+        Index("stopId", unique = false),
+    ],
+    foreignKeys = [
+        ForeignKey(TripEntity::class, parentColumns = ["id"], childColumns = ["tripId"], onDelete = CASCADE),
+        ForeignKey(StopEntity::class, parentColumns = ["id"], childColumns = ["stopId"], onDelete = CASCADE),
+    ]
+)
+data class StopTimeEntity(
+    val tripId: String,
+    val stopId: String,
+    val arrivalTime: Int,
+    val departureTime: Int,
+    val headsign: String?,
+    val pickupType: Int,
+    val dropOffType: Int,
+) {
+    fun asModel() = StopTime(
+        tripId,
+        stopId,
+        FutureTime.fromInt(arrivalTime),
+        FutureTime.fromInt(departureTime),
+        headsign,
+        pickupType,
+        dropOffType,
+    )
+}
+
+@OptIn(ExperimentalSerializationApi::class)
+fun StopTime.asEntity() = StopTimeEntity(
+    tripId,
+    stopId,
+    arrivalTime.asInt(),
+    departureTime.asInt(),
+    headsign,
+    pickupType,
+    dropOffType,
+)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/TripEntity.kt

@@ -0,0 +1,49 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.ForeignKey.Companion.CASCADE
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import moe.lava.banksia.core.model.Trip
+
+@Entity(
+    "Trip",
+    foreignKeys = [
+        ForeignKey(RouteEntity::class, parentColumns = ["id"], childColumns = ["routeId"], onDelete = CASCADE),
+        ForeignKey(ServiceEntity::class, parentColumns = ["id"], childColumns = ["serviceId"], onDelete = CASCADE),
+        ForeignKey(ShapeEntity::class, parentColumns = ["id"], childColumns = ["shapeId"], onDelete = CASCADE),
+    ],
+    indices = [Index("shapeId"), Index("serviceId")],
+)
+data class TripEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(index = true) val routeId: String,
+    val serviceId: String,
+    val shapeId: String?,
+    val tripHeadsign: String,
+    val directionId: String,
+    val blockId: String,
+    val wheelchairAccessible: String,
+)
+
+fun Trip.Companion.from(tripEntity: TripEntity, serviceEntity: ServiceEntity): Trip {
+    if (tripEntity.serviceId != serviceEntity.id) {
+        throw IllegalArgumentException("trip and service id mismatch (${tripEntity.serviceId} != ${serviceEntity.id})")
+    }
+    return with(tripEntity) {
+        Trip(
+            id = id,
+            routeId = routeId,
+            service = serviceEntity.asModel(),
+            shapeId = shapeId,
+            tripHeadsign = tripHeadsign,
+            directionId = directionId,
+            blockId = blockId,
+            wheelchairAccessible = wheelchairAccessible
+        )
+    }
+}
+
+fun Trip.asEntity() = TripEntity(id, routeId, service.id, shapeId, tripHeadsign, directionId, blockId, wheelchairAccessible)

core/room/src/commonMain/kotlin/moe/lava/banksia/core/room/entity/VersionMetadataEntity.kt

@@ -0,0 +1,19 @@
+package moe.lava.banksia.core.room.entity
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import moe.lava.banksia.core.model.VersionMetadata
+
+@Entity(
+    "VersionMetadata",
+)
+data class VersionMetadataEntity(
+    /** Entity type this metadata applies to */
+    @PrimaryKey val type: String,
+    /** Last updated */
+    val lastUpdated: Long,
+) {
+    fun asModel() = VersionMetadata(type, lastUpdated)
+}
+
+fun VersionMetadata.asEntity() = VersionMetadataEntity(type, lastUpdated)

core/room/src/iosMain/kotlin/moe/lava/banksia/core/room/DatabaseManager.ios.kt

@@ -0,0 +1,8 @@
+package moe.lava.banksia.core.room
+
+import org.koin.core.component.KoinComponent
+
+actual class DatabaseManager actual constructor() : KoinComponent {
+    actual val database: Database
+        get() = TODO("Not yet implemented")
+}

core/room/src/jvmMain/kotlin/moe/lava/banksia/core/room/DatabaseManager.jvm.kt

@@ -0,0 +1,69 @@
+package moe.lava.banksia.core.room
+
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import moe.lava.banksia.core.util.error
+import org.koin.core.component.KoinComponent
+import java.io.File
+import kotlin.system.exitProcess
+
+actual class DatabaseManager : KoinComponent {
+    private var liveDatabase: Database = Database.build(getBuilder())
+    actual val database get() = liveDatabase
+
+    private fun getBuilder(path: String = "./data/room.db"): RoomDatabase.Builder<Database> {
+        val dbFile = File(path)
+        return Room.databaseBuilder<Database>(
+            name = dbFile.absolutePath,
+        ).setJournalMode(RoomDatabase.JournalMode.TRUNCATE)
+    }
+
+    fun makeAlt() = Database.build(getBuilder("./data/room_alt.db"))
+
+    private fun deleteAll(file: File): Boolean {
+        val r1 = file.takeIf { it.exists() }?.delete()
+        val r2 = File(file.parentFile, file.name + ".lck").takeIf { it.exists() }?.delete()
+        val r3 = File(file.parentFile, file.name + "-journal").takeIf { it.exists() }?.delete()
+        return r1 != false && r2 != false && r3 != false
+    }
+
+    private fun renameAll(from: File, to: File): Boolean {
+        val r1 = from.takeIf { it.exists() }?.renameTo(to)
+        val r2 = File(from.parentFile, from.name + ".lck").takeIf { it.exists() }?.renameTo(File(to.parentFile, to.name + ".lck"))
+        val r3 = File(from.parentFile, from.name + "-journal").takeIf { it.exists() }?.renameTo(File(to.parentFile, to.name + "-journal"))
+        return r1 != false && r2 != false && r3 != false
+    }
+
+    fun swap(scope: CoroutineScope = CoroutineScope(Dispatchers.IO)) {
+        val live = File("./data/room.db")
+        val alt = File("./data/room_alt.db")
+        val old = File("./data/room_old.db")
+
+        if (!renameAll(live, old)) {
+            error("DatabaseManager", "Failed to rename database from live to old (${live.absolutePath} -> ${old.absolutePath})")
+            return
+        }
+        if (!renameAll(alt, live)) {
+            error("DatabaseManager", "Failed to rename database from alt to live, trying to undo.. (${alt.absolutePath} -> ${live.absolutePath})")
+            if (!live.renameTo(old)) {
+                error("DatabaseManager", "Failed to undo, critical failure, exiting..")
+                exitProcess(1)
+            }
+            return
+        }
+        val oldDatabase = liveDatabase
+        liveDatabase = Database.build(getBuilder())
+
+        scope.launch {
+            delay(5000)
+            if (!deleteAll(old)) {
+                error("DatabaseManager", "Failed to unlink old database, stray files! (${old.absolutePath})")
+            }
+            oldDatabase.close()
+        }
+    }
+}

core/sqld/src/androidMain/kotlin/moe/lava/banksia/core/sqld/DatabaseManager.android.kt

@@ -1,14 +0,0 @@
-package moe.lava.banksia.core.sqld
-
-import android.content.Context
-import app.cash.sqldelight.driver.android.AndroidSqliteDriver
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.get
-
-actual class DatabaseManager : KoinComponent {
-    actual val database by lazy {
-        val ctx = get<Context>().applicationContext
-        val driver = AndroidSqliteDriver(BanksiaDatabase.Schema, ctx, "${DBNAME}.db")
-        BanksiaDatabase(driver)
-    }
-}

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/DatabaseManager.kt

@@ -1,7 +0,0 @@
-package moe.lava.banksia.core.sqld
-
-internal const val DBNAME = "timetable"
-
-expect class DatabaseManager() {
-    val database: BanksiaDatabase
-}

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/SqldDiModule.kt

@@ -1,17 +0,0 @@
-package moe.lava.banksia.core.sqld
-
-import org.koin.core.module.dsl.singleOf
-import org.koin.dsl.module
-
-val sqldDiModule = module {
-    singleOf(::DatabaseManager)
-    factory { get<DatabaseManager>().database }
-    factory { get<BanksiaDatabase>().routeQueries }
-    factory { get<BanksiaDatabase>().serviceQueries }
-    factory { get<BanksiaDatabase>().serviceExceptionQueries }
-    factory { get<BanksiaDatabase>().shapeQueries }
-    factory { get<BanksiaDatabase>().stopQueries }
-    factory { get<BanksiaDatabase>().stoppingPatternQueries }
-    factory { get<BanksiaDatabase>().stopTimeQueries }
-    factory { get<BanksiaDatabase>().tripQueries }
-}

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/Route.kt

@@ -1,14 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.Route
-import moe.lava.banksia.core.model.RouteType
-import moe.lava.banksia.core.sqld.Route as DbRoute
-
-fun DbRoute.asModel() = Route(
-    id = id,
-    type = RouteType.from(type.toInt()),
-    number = number,
-    name = name,
-)
-
-fun Route.asDb() = DbRoute(id, type.value.toLong(), number, name)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/Service.kt

@@ -1,21 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import kotlinx.datetime.LocalDate
-import moe.lava.banksia.core.model.Service
-import moe.lava.banksia.core.util.deserialiseDaysBitflag
-import moe.lava.banksia.core.util.serialise
-import moe.lava.banksia.core.sqld.Service as DbService
-
-fun DbService.asModel() = Service(
-    id = id,
-    days = days.toInt().deserialiseDaysBitflag(),
-    start = LocalDate.fromEpochDays(start),
-    end = LocalDate.fromEpochDays(end),
-)
-
-fun Service.asDb() = DbService(
-    id = id,
-    days = days.serialise().toLong(),
-    start = start.toEpochDays(),
-    end = end.toEpochDays(),
-)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/ServiceException.kt

@@ -1,17 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import kotlinx.datetime.LocalDate
-import moe.lava.banksia.core.model.ServiceException
-import moe.lava.banksia.core.sqld.ServiceException as DbServiceException
-
-fun DbServiceException.asModel() = ServiceException(
-    serviceId = serviceId,
-    date = LocalDate.fromEpochDays(date),
-    type = type.toInt(),
-)
-
-fun ServiceException.asDb() = DbServiceException(
-    serviceId = serviceId,
-    type = date.toEpochDays(),
-    date = type.toLong(),
-)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/Shape.kt

@@ -1,52 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.Shape
-import moe.lava.banksia.core.model.ShapePath
-import moe.lava.banksia.core.util.Point
-import moe.lava.banksia.core.sqld.Shape as DbShape
-
-fun DbShape.asModel() = Shape(
-    id = id,
-    path = bytesToPath(path),
-)
-
-fun Shape.asDb() = DbShape(
-    id = id,
-    path = bytesFromPath(path),
-)
-
-private fun bytesToPath(value: ByteArray): ShapePath {
-    return value
-        .asSequence()
-        .asIterable()
-        .chunked(8) {
-            (it[0].toLong() and 0xFF) or
-                    (it[1].toLong() and 0xFF shl 8) or
-                    (it[2].toLong() and 0xFF shl 16) or
-                    (it[3].toLong() and 0xFF shl 24) or
-                    (it[4].toLong() and 0xFF shl 32) or
-                    (it[5].toLong() and 0xFF shl 40) or
-                    (it[6].toLong() and 0xFF shl 48) or
-                    (it[7].toLong() and 0xFF shl 56)
-        }
-        .map { Double.fromBits(it) }
-        .chunked(2)
-        .map { (lat, lng) -> Point(lat, lng) }
-        .toList()
-}
-
-private fun bytesFromPath(path: ShapePath): ByteArray {
-    return path
-        .flatMap { (lat, lng) -> listOf(lat.toBits(), lng.toBits()) }
-        .flatMap { i -> listOf(
-            i.toByte(),
-            (i shr 8).toByte(),
-            (i shr 16).toByte(),
-            (i shr 24).toByte(),
-            (i shr 32).toByte(),
-            (i shr 40).toByte(),
-            (i shr 48).toByte(),
-            (i shr 56).toByte(),
-        ) }
-        .toByteArray()
-}

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/Stop.kt

@@ -1,26 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.Stop
-import moe.lava.banksia.core.util.Point
-import moe.lava.banksia.core.sqld.Stop as DbStop
-
-fun DbStop.asModel() = Stop(
-    id = id,
-    name = name,
-    pos = Point(lat, lng),
-    parent = parent,
-    hasWheelChairBoarding = hasWheelChairBoarding == 1L,
-    level = level,
-    platformCode = platformCode,
-)
-
-fun Stop.asDb() = DbStop(
-    id = id,
-    name = name,
-    lat = pos.lat,
-    lng = pos.lng,
-    parent = parent,
-    hasWheelChairBoarding = if (hasWheelChairBoarding) 1L else 0L,
-    level = level,
-    platformCode = platformCode
-)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/StopTime.kt

@@ -1,27 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.FutureTime
-import moe.lava.banksia.core.model.FutureTime.Companion.asInt
-import moe.lava.banksia.core.model.StopTime
-import moe.lava.banksia.core.model.TimeType
-import moe.lava.banksia.core.sqld.StopTime as DbStopTime
-
-fun DbStopTime.asModel() = StopTime(
-    patternId = patternId,
-    stopId = stopId,
-    time = TimeType.Undated(
-        arrival = FutureTime.fromInt((departureTime + arrivalDelta).toInt()),
-        departure = FutureTime.fromInt(departureTime.toInt()),
-    ),
-    pickupType = pickupType.toInt(),
-    dropOffType = dropOffType.toInt(),
-)
-
-fun StopTime.Undated.asDb() = DbStopTime(
-    patternId = patternId,
-    stopId = stopId,
-    arrivalDelta = (time.arrival.asInt() - time.departure.asInt()).toLong(),
-    departureTime = time.departure.asInt().toLong(),
-    pickupType = pickupType.toLong(),
-    dropOffType = dropOffType.toLong(),
-)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/StoppingPattern.kt

@@ -1,23 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.StopTime
-import moe.lava.banksia.core.model.StoppingPattern
-import moe.lava.banksia.core.model.TimeType
-import moe.lava.banksia.core.sqld.StoppingPattern as DbStoppingPattern
-
-fun <T: TimeType> DbStoppingPattern.asModel(stoptimes: List<StopTime<T>>) = StoppingPattern(
-    id = id,
-    routeId = routeId,
-    shapeId = shapeId,
-    headsign = headsign,
-    wheelchairAccessible = wheelchairAccessible == 1L,
-    stoptimes = stoptimes,
-)
-
-fun StoppingPattern<*>.asDb() = DbStoppingPattern(
-    id = id,
-    routeId = routeId,
-    shapeId = shapeId,
-    headsign = headsign,
-    wheelchairAccessible = if (wheelchairAccessible) 1L else 0L,
-)

core/sqld/src/commonMain/kotlin/moe/lava/banksia/core/sqld/mappers/Trip.kt

@@ -1,27 +0,0 @@
-package moe.lava.banksia.core.sqld.mappers
-
-import moe.lava.banksia.core.model.Service
-import moe.lava.banksia.core.model.StoppingPattern
-import moe.lava.banksia.core.model.Trip
-import moe.lava.banksia.core.sqld.Trip as DbTrip
-
-fun DbTrip.asModel(pattern: StoppingPattern.Undated, service: Service): Trip.Undated {
-    if (serviceId != service.id) {
-        throw IllegalArgumentException("trip and service id mismatch (${serviceId} != ${service.id})")
-    }
-    return Trip(
-        id = gtfsId,
-        pattern = pattern,
-        service = service,
-        directionId = directionId.toInt(),
-        blockId = blockId.toString(),
-    )
-}
-
-fun Trip.Undated.asDb() = DbTrip(
-    gtfsId = id,
-    patternId = pattern.id,
-    serviceId = service.id,
-    directionId = directionId.toLong(),
-    blockId = blockId?.toLong(),
-)

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/Route.sq

@@ -1,20 +0,0 @@
-CREATE TABLE Route (
-    id TEXT PRIMARY KEY NOT NULL,
-    type INTEGER NOT NULL,
-    number TEXT,
-    name TEXT NOT NULL
-);
-
-getAll:
-SELECT * FROM Route;
-
-get:
-SELECT * FROM Route WHERE id == ?;
-
-getByPattern:
-SELECT Route.* FROM Route
-INNER JOIN StoppingPattern ON Route.id == StoppingPattern.routeId
-WHERE StoppingPattern.id == :patternId;
-
-insert:
-INSERT OR REPLACE INTO Route VALUES ?;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/Service.sq

@@ -1,11 +0,0 @@
-CREATE TABLE Service (
-    id TEXT PRIMARY KEY NOT NULL,
-    days INTEGER NOT NULL,
-    start INTEGER NOT NULL,
-    end INTEGER NOT NULL
-);
-
-CREATE INDEX idx_Service_days ON Service (days);
-
-insert:
-INSERT INTO Service VALUES ?;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/ServiceException.sq

@@ -1,9 +0,0 @@
-CREATE TABLE ServiceException (
-    serviceId TEXT NOT NULL,
-    type INTEGER NOT NULL,
-    date INTEGER NOT NULL,
-    PRIMARY KEY (serviceId, type)
-);
-
-insert:
-INSERT INTO ServiceException VALUES ?;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/Shape.sq

@@ -1,7 +0,0 @@
-CREATE TABLE Shape (
-    id TEXT PRIMARY KEY NOT NULL,
-    path BLOB NOT NULL
-);
-
-insert:
-INSERT INTO Shape VALUES ?;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/Stop.sq

@@ -1,54 +0,0 @@
-CREATE TABLE Stop (
-    id TEXT PRIMARY KEY NOT NULL,
-    name TEXT NOT NULL,
-    lat REAL NOT NULL,
-    lng REAL NOT NULL,
-    parent TEXT REFERENCES Stop(id),
-    hasWheelChairBoarding INTEGER NOT NULL,
-    level TEXT,
-    platformCode TEXT
-);
-
-CREATE INDEX idx_Stop_parent ON Stop (parent);
-
-getAll:
-SELECT * FROM Stop;
-
-getAllParentless:
-SELECT * FROM Stop WHERE platformCode IS NOT NULL AND parent IS NULL;
-
-get:
-SELECT * FROM Stop WHERE id == ?;
-
-getMany:
-SELECT * FROM Stop WHERE id IN ?;
-
-insert:
-INSERT INTO Stop VALUES ?;
-
-updateParents:
-UPDATE Stop SET parent = ? WHERE id IN ?;
-
-getByRoute:
-SELECT Stop.* FROM Stop
-INNER JOIN StopTime ON StopTime.stopId == Stop.id
-INNER JOIN StoppingPattern ON StoppingPattern.id == StopTime.patternId
-WHERE StoppingPattern.routeId == :id
-GROUP BY Stop.id;
-
--- I vibecoded this, sorry
-getParentsByRoute:
-WITH RECURSIVE Tree AS (
-    SELECT Stop.* FROM Stop
-    INNER JOIN StopTime ON StopTime.stopId == Stop.id
-    INNER JOIN StoppingPattern ON StoppingPattern.id == StopTime.patternId
-    WHERE StoppingPattern.routeId == :id
-    GROUP BY Stop.id
-
-    UNION ALL
-
-    SELECT s.*
-    FROM Stop s
-    INNER JOIN Tree t ON s.id = t.parent
-)
-SELECT DISTINCT * FROM Tree WHERE parent IS NULL;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/StopTime.sq

@@ -1,45 +0,0 @@
-CREATE TABLE StopTime (
-    patternId INTEGER NOT NULL REFERENCES StoppingPattern (id),
-    stopId TEXT NOT NULL REFERENCES Stop (id),
-    arrivalDelta INTEGER NOT NULL,
-    departureTime INTEGER NOT NULL,
-    pickupType INTEGER NOT NULL,
-    dropOffType INTEGER NOT NULL,
-    PRIMARY KEY (patternId, stopId)
-) WITHOUT ROWID;
-
-CREATE INDEX idx_StopTime_stopId ON StopTime (stopId);
-
-insert:
-INSERT OR REPLACE INTO StopTime VALUES ?;
-
-getForStopDated:
-SELECT DISTINCT StopTime.* FROM StopTime
-INNER JOIN Service ON Service.days & :days = :days AND :date BETWEEN Service.start AND Service.`end`
-LEFT JOIN ServiceException ON ServiceException.serviceId == Service.id AND ServiceException.date == :date
-INNER JOIN Trip ON Trip.serviceId == Service.id
-INNER JOIN StoppingPattern ON StoppingPattern.id == Trip.patternId
-WHERE StopTime.patternId == StoppingPattern.id
-    AND StopTime.stopId IN (SELECT Stop.id FROM Stop WHERE Stop.parent == :stopId OR Stop.id == :stopId)
-    AND ServiceException.type IS NULL;
-
-getExtendedForStop:
-SELECT DISTINCT
-    StopTime.patternId,
-    StopTime.arrivalDelta,
-    StopTime.departureTime,
-    StoppingPattern.headsign,
-    Route.type AS routeType,
-    Route.number AS routeNumber,
-    Route.name AS routeName,
-    Stop.platformCode AS stopPlatformCode
-FROM StopTime
-INNER JOIN Service ON Service.days & :days = :days AND :date BETWEEN Service.start AND Service.`end`
-LEFT JOIN ServiceException ON ServiceException.serviceId == Service.id AND ServiceException.date == :date
-INNER JOIN Trip ON Trip.serviceId == Service.id
-INNER JOIN StoppingPattern ON StoppingPattern.id == Trip.patternId
-INNER JOIN Route ON Route.id == StoppingPattern.routeId
-INNER JOIN Stop ON Stop.id == StopTime.stopId
-WHERE StopTime.patternId == StoppingPattern.id
-    AND StopTime.stopId IN (SELECT Stop.id FROM Stop WHERE Stop.parent == :stopId OR Stop.id == :stopId)
-    AND ServiceException.type IS NULL;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/StoppingPattern.sq

@@ -1,13 +0,0 @@
-CREATE TABLE StoppingPattern (
-    id INTEGER PRIMARY KEY NOT NULL,
-    routeId TEXT NOT NULL REFERENCES Route (id),
-    shapeId TEXT NOT NULL REFERENCES Shape (id),
-    headsign TEXT NOT NULL,
-    wheelchairAccessible INTEGER NOT NULL
-);
-
-insert:
-INSERT OR REPLACE INTO StoppingPattern VALUES ?;
-
-get:
-SELECT * FROM StoppingPattern WHERE id == :id;

core/sqld/src/commonMain/sqldelight/moe/lava/banksia/core/sqld/Trip.sq

@@ -1,13 +0,0 @@
-CREATE TABLE Trip (
-    gtfsId TEXT PRIMARY KEY NOT NULL,
-    patternId INTEGER NOT NULL REFERENCES StoppingPattern (id),
-    serviceId TEXT NOT NULL REFERENCES Service (id),
-    blockId INTEGER,
-    directionId INTEGER NOT NULL
-);
-
-CREATE INDEX idx_Trip_patternId ON Trip (patternId);
-CREATE INDEX idx_Trip_serviceId ON Trip (serviceId);
-
-insert:
-INSERT OR REPLACE INTO Trip VALUES ?;

core/sqld/src/iosMain/kotlin/moe/lava/banksia/core/sqld/DatabaseManager.ios.kt

@@ -1,11 +0,0 @@
-package moe.lava.banksia.core.sqld
-
-import app.cash.sqldelight.driver.native.NativeSqliteDriver
-import org.koin.core.component.KoinComponent
-
-actual class DatabaseManager : KoinComponent {
-    actual val database by lazy {
-        val driver = NativeSqliteDriver(BanksiaDatabase.Schema, "${DBNAME}.db")
-        BanksiaDatabase(driver)
-    }
-}

core/sqld/src/jvmMain/kotlin/moe/lava/banksia/core/sqld/DatabaseManager.jvm.kt

@@ -1,56 +0,0 @@
-package moe.lava.banksia.core.sqld
-
-import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import moe.lava.banksia.core.util.error
-import org.koin.core.component.KoinComponent
-import java.io.File
-import java.util.Properties
-import kotlin.system.exitProcess
-
-actual class DatabaseManager : KoinComponent {
-    private var driver = connect()
-    actual val database get() = BanksiaDatabase(driver)
-
-    private fun connect(path: String = "./data/${DBNAME}.db") =
-        JdbcSqliteDriver("jdbc:sqlite:${path}", Properties(), BanksiaDatabase.Schema)
-            .apply { execute(null, "PRAGMA journal_mode = OFF;", 0) }
-
-    fun makeAlt() = run {
-        File("./data/${DBNAME}_alt.db").takeIf { it.exists() }?.delete()
-        val driver = connect("./data/${DBNAME}_alt.db")
-        BanksiaDatabase(driver) to { driver.close() }
-    }
-
-    fun swap(scope: CoroutineScope = CoroutineScope(Dispatchers.IO)) {
-        val live = File("./data/${DBNAME}.db")
-        val alt = File("./data/${DBNAME}_alt.db")
-        val old = File("./data/${DBNAME}_old.db")
-
-        if (live.takeIf { it.exists() }?.renameTo(old) == false) {
-            error("DatabaseManager", "Failed to rename database from live to old (${live.absolutePath} -> ${old.absolutePath})")
-            return
-        }
-        if (alt.takeIf { it.exists() }?.renameTo(live) == false) {
-            error("DatabaseManager", "Failed to rename database from alt to live, trying to undo.. (${alt.absolutePath} -> ${live.absolutePath})")
-            if (!live.renameTo(old)) {
-                error("DatabaseManager", "Failed to undo, critical failure, exiting..")
-                exitProcess(1)
-            }
-            return
-        }
-        val oldDriver = driver
-        driver = connect()
-
-        scope.launch {
-            delay(5000)
-            if (old.takeIf { it.exists() }?.delete() == false) {
-                error("DatabaseManager", "Failed to unlink old database, stray files! (${old.absolutePath})")
-            }
-            oldDriver.close()
-        }
-    }
-}

core/src/commonMain/kotlin/moe/lava/banksia/core/Constants.kt.skeleton

@@ -6,7 +6,7 @@ object Constants {
     const val opendataKey: String = ""
     const val serverUrl: String = "https://banksia.lava.moe/api/"
     // TODO
-    var devMode: Boolean = false
+    const val devMode: Boolean = false
     const val updateKey: String = ""
     const val protomapsKey: String = ""
 }

core/src/commonMain/kotlin/moe/lava/banksia/core/endpoints/Endpoint.kt

@@ -1,3 +0,0 @@
-package moe.lava.banksia.core.endpoints
-
-object Endpoint

core/src/commonMain/kotlin/moe/lava/banksia/core/model/Stop.kt

@@ -10,6 +10,6 @@ data class Stop(
     val pos: Point,
     val parent: String?,
     val hasWheelChairBoarding: Boolean,
-    val level: String?,
+    val level: String,
-    val platformCode: String?,
+    val platformCode: String,
 )

core/src/commonMain/kotlin/moe/lava/banksia/core/model/StopTime.kt

@@ -1,45 +1,14 @@
 package moe.lava.banksia.core.model
 
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
 import kotlinx.serialization.Serializable
 
 @Serializable
-data class StopTime<T: TimeType>(
+data class StopTime(
-    val patternId: Long,
+    val tripId: String,
     val stopId: String,
-    val time: T,
+    val arrivalTime: FutureTime,
+    val departureTime: FutureTime,
+    val headsign: String?,
     val pickupType: Int,
     val dropOffType: Int,
-) {
-    typealias Dated = StopTime<TimeType.Dated>
-    typealias Undated = StopTime<TimeType.Undated>
-}
-
-@Serializable
-sealed class TimeType {
-    @Serializable
-    data class Undated(
-        val arrival: FutureTime,
-        val departure: FutureTime,
-    ) : TimeType()
-
-    @Serializable
-    data class Dated(
-        val arrival: LocalDateTime,
-        val departure: LocalDateTime,
-    ) : TimeType()
-}
-
-fun TimeType.Undated.atDate(date: LocalDate) = TimeType.Dated(
-    arrival = arrival.atDate(date),
-    departure = departure.atDate(date),
-)
-
-fun StopTime<TimeType.Undated>.atDate(date: LocalDate) = StopTime(
-    patternId = patternId,
-    stopId = stopId,
-    time = time.atDate(date),
-    pickupType = pickupType,
-    dropOffType = dropOffType,
 )

core/src/commonMain/kotlin/moe/lava/banksia/core/model/StopTimeDated.kt

@@ -0,0 +1,26 @@
+package moe.lava.banksia.core.model
+
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class StopTimeDated(
+    val tripId: String,
+    val stopId: String,
+    val arrivalTime: LocalDateTime,
+    val departureTime: LocalDateTime,
+    val headsign: String?,
+    val pickupType: Int,
+    val dropOffType: Int,
+)
+
+fun StopTime.atDate(date: LocalDate) = StopTimeDated(
+    tripId = tripId,
+    stopId = stopId,
+    arrivalTime = arrivalTime.atDate(date),
+    departureTime = departureTime.atDate(date),
+    headsign = headsign,
+    pickupType = pickupType,
+    dropOffType = dropOffType,
+)

core/src/commonMain/kotlin/moe/lava/banksia/core/model/StoppingPattern.kt

@@ -1,16 +0,0 @@
-package moe.lava.banksia.core.model
-
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class StoppingPattern<T: TimeType>(
-    val id: Long,
-    val routeId: String,
-    val shapeId: String,
-    val headsign: String,
-    val wheelchairAccessible: Boolean,
-    val stoptimes: List<StopTime<T>>,
-) {
-    typealias Dated = StoppingPattern<TimeType.Dated>
-    typealias Undated = StoppingPattern<TimeType.Undated>
-}

core/src/commonMain/kotlin/moe/lava/banksia/core/model/Trip.kt

@@ -3,13 +3,13 @@ package moe.lava.banksia.core.model
 import kotlinx.serialization.Serializable
 
 @Serializable
-data class Trip<T: TimeType>(
+data class Trip(
     val id: String,
-    val pattern: StoppingPattern<T>,
+    val routeId: String,
     val service: Service,
-    val directionId: Int,
+    val shapeId: String?,
-    val blockId: String?,
+    val tripHeadsign: String,
-) {
+    val directionId: String,
-    typealias Dated = Trip<TimeType.Dated>
+    val blockId: String,
-    typealias Undated = Trip<TimeType.Undated>
+    val wheelchairAccessible: String,
-}
+)

core/stoptime/src/clientMain/kotlin/moe/lava/banksia/core/data/StopTimeDataDiModule.client.kt

@@ -1,11 +0,0 @@
-package moe.lava.banksia.core.data
-
-import moe.lava.banksia.core.data.repositories.StopTimeRepository
-import moe.lava.banksia.core.data.sources.stoptime.StopTimeRemoteDataSource
-import org.koin.core.module.dsl.singleOf
-import org.koin.dsl.module
-
-internal actual val platformModule = module {
-    singleOf(::StopTimeRepository)
-    singleOf(::StopTimeRemoteDataSource)
-}

core/stoptime/src/clientMain/kotlin/moe/lava/banksia/core/data/repositories/StopTimeRepository.client.kt

@@ -1,19 +0,0 @@
-package moe.lava.banksia.core.data.repositories
-
-import kotlinx.coroutines.flow.flow
-import kotlinx.datetime.LocalDate
-import moe.lava.banksia.core.data.sources.stoptime.StopTimeLocalDataSource
-import moe.lava.banksia.core.data.sources.stoptime.StopTimeRemoteDataSource
-
-actual class StopTimeRepository internal constructor(
-    private val local: StopTimeLocalDataSource,
-    private val remote: StopTimeRemoteDataSource,
-) {
-    actual suspend fun getForStop(id: String, date: LocalDate) = flow {
-        emit(local.getAtStop(id, date))
-
-        remote.getAtStop(id, date)
-            .takeIf { it.isNotEmpty() }
-            ?.let { emit(it) }
-    }
-}

core/stoptime/src/clientMain/kotlin/moe/lava/banksia/core/data/sources/stoptime/StopTimeRemoteDataSource.kt

@@ -1,26 +0,0 @@
-package moe.lava.banksia.core.data.sources.stoptime
-
-import io.ktor.client.HttpClient
-import io.ktor.client.call.body
-import io.ktor.client.request.get
-import io.ktor.client.request.parameter
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.todayIn
-import moe.lava.banksia.core.data.dto.ExtendedStopTime
-import moe.lava.banksia.core.endpoints.Endpoint
-import moe.lava.banksia.core.endpoints.stopTimeByStop
-import kotlin.time.Clock
-
-internal class StopTimeRemoteDataSource(
-    private val client: HttpClient,
-) {
-    suspend fun getAtStop(
-        stopId: String,
-        date: LocalDate? = Clock.System.todayIn(TimeZone.currentSystemDefault()),
-    ): List<ExtendedStopTime> {
-        return client.get(Endpoint.stopTimeByStop(stopId)) {
-            parameter("date", date)
-        }.body<List<ExtendedStopTime>>()
-    }
-}

core/stoptime/src/commonMain/kotlin/moe/lava/banksia/core/data/StopTimeDataDiModule.kt

@@ -1,13 +0,0 @@
-package moe.lava.banksia.core.data
-
-import moe.lava.banksia.core.data.sources.stoptime.StopTimeLocalDataSource
-import org.koin.core.module.Module
-import org.koin.core.module.dsl.singleOf
-import org.koin.dsl.module
-
-internal expect val platformModule: Module;
-
-val stopTimeDataDiModule = module {
-    includes(platformModule)
-    singleOf(::StopTimeLocalDataSource)
-}

core/stoptime/src/commonMain/kotlin/moe/lava/banksia/core/data/dto/ExtendedStopTime.kt

@@ -1,34 +0,0 @@
-package moe.lava.banksia.core.data.dto
-
-import kotlinx.datetime.LocalDate
-import kotlinx.serialization.Serializable
-import moe.lava.banksia.core.model.FutureTime
-import moe.lava.banksia.core.model.RouteType
-import moe.lava.banksia.core.model.TimeType
-import moe.lava.banksia.core.model.atDate
-import moe.lava.banksia.core.sqld.GetExtendedForStop
-
-@Serializable
-data class ExtendedStopTime(
-    val patternId: Long,
-    val stopPlatformCode: String?,
-    val time: TimeType.Dated,
-    val headsign: String?,
-    val routeType: RouteType,
-    val routeNumber: String?,
-    val routeName: String,
-)
-
-// TODO: This probably doesn't belong here
-fun GetExtendedForStop.asModel(date: LocalDate) = ExtendedStopTime(
-    patternId = patternId,
-    stopPlatformCode = stopPlatformCode,
-    time = TimeType.Undated(
-        arrival = FutureTime.fromInt((departureTime + arrivalDelta).toInt()),
-        departure = FutureTime.fromInt(departureTime.toInt()),
-    ).atDate(date),
-    headsign = headsign,
-    routeType = RouteType.from(routeType.toInt()),
-    routeNumber = routeNumber,
-    routeName = routeName,
-)

core/stoptime/src/commonMain/kotlin/moe/lava/banksia/core/data/repositories/StopTimeRepository.kt

@@ -1,15 +0,0 @@
-package moe.lava.banksia.core.data.repositories
-
-import kotlinx.coroutines.flow.Flow
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.todayIn
-import moe.lava.banksia.core.data.dto.ExtendedStopTime
-import kotlin.time.Clock
-
-expect class StopTimeRepository {
-    suspend fun getForStop(
-        id: String,
-        date: LocalDate = Clock.System.todayIn(TimeZone.currentSystemDefault()),
-    ): Flow<List<ExtendedStopTime>>
-}

core/stoptime/src/commonMain/kotlin/moe/lava/banksia/core/data/sources/stoptime/StopTimeLocalDataSource.kt

@@ -1,30 +0,0 @@
-package moe.lava.banksia.core.data.sources.stoptime
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.IO
-import kotlinx.coroutines.withContext
-import kotlinx.datetime.LocalDate
-import moe.lava.banksia.core.data.dto.ExtendedStopTime
-import moe.lava.banksia.core.data.dto.asModel
-import moe.lava.banksia.core.sqld.StopTimeQueries
-import moe.lava.banksia.core.util.serialise
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.get
-
-internal class StopTimeLocalDataSource : KoinComponent {
-    private val queries get() = get<StopTimeQueries>()
-
-    suspend fun getAtStop(stopId: String, date: LocalDate): List<ExtendedStopTime> {
-        return withContext(context = Dispatchers.IO) {
-            queries
-                .getExtendedForStop(
-                    listOf(date.dayOfWeek).serialise().toLong(),
-                    date.toEpochDays(),
-                    stopId,
-                )
-                .executeAsList()
-                .map { it.asModel(date) }
-                .sortedBy { it.time.departure }
-        }
-    }
-}

core/stoptime/src/commonMain/kotlin/moe/lava/banksia/core/endpoints/StopTimeEndpoints.kt

@@ -1,3 +0,0 @@
-package moe.lava.banksia.core.endpoints
-
-fun Endpoint.stopTimeByStop(stopId: String) = "stoptimes/by_stop/${stopId}"

core/stoptime/src/jvmMain/kotlin/moe/lava/banksia/core/data/StopTimeDataDiModule.jvm.kt

@@ -1,9 +0,0 @@
-package moe.lava.banksia.core.data
-
-import moe.lava.banksia.core.data.repositories.StopTimeRepository
-import org.koin.core.module.dsl.singleOf
-import org.koin.dsl.module
-
-internal actual val platformModule = module {
-    singleOf(::StopTimeRepository)
-}

core/stoptime/src/jvmMain/kotlin/moe/lava/banksia/core/data/repositories/StopTimeRepository.jvm.kt

@@ -1,13 +0,0 @@
-package moe.lava.banksia.core.data.repositories
-
-import kotlinx.coroutines.flow.flow
-import kotlinx.datetime.LocalDate
-import moe.lava.banksia.core.data.sources.stoptime.StopTimeLocalDataSource
-
-actual class StopTimeRepository internal constructor(
-    private val local: StopTimeLocalDataSource,
-) {
-    actual suspend fun getForStop(id: String, date: LocalDate) = flow {
-        emit(local.getAtStop(id, date))
-    }
-}

core/stoptime/src/jvmMain/kotlin/moe/lava/banksia/server/routes/StopTimeRoute.kt

@@ -1,27 +0,0 @@
-package moe.lava.banksia.server.routes
-
-import io.ktor.server.response.respond
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.get
-import kotlinx.coroutines.flow.first
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.todayIn
-import moe.lava.banksia.core.data.repositories.StopTimeRepository
-import moe.lava.banksia.core.endpoints.Endpoint
-import moe.lava.banksia.core.endpoints.stopTimeByStop
-import org.koin.ktor.ext.inject
-import kotlin.time.Clock
-
-fun Route.stopTimeRoutes() {
-    val repo by inject<StopTimeRepository>()
-
-    get(Endpoint.stopTimeByStop("{stop_id}")) {
-        val stopId = call.parameters["stop_id"]!!
-        val date = call.queryParameters["date"]
-            ?.let { LocalDate.parse(it, LocalDate.Formats.ISO) }
-            ?: Clock.System.todayIn(TimeZone.currentSystemDefault())
-        val data = repo.getForStop(stopId, date).first()
-        call.respond(data)
-    }
-}

gradle/libs.versions.toml

@@ -1,11 +1,11 @@
 [versions]
 agp = "9.1.0"
-android-compileSdk = "37"
+android-compileSdk = "36"
 android-minSdk = "24"
-android-targetSdk = "37"
+android-targetSdk = "36"
 androidx-activity= "1.13.0"
 androidx-lifecycle = "2.10.0"
-compose-multiplatform = "1.12.0-alpha02"
+compose-multiplatform = "1.11.0-alpha04"
 composeunstyled = "1.49.6"
 coroutines = "1.10.2"
 geo = "0.8.0"
@@ -19,11 +19,12 @@ ktor = "3.4.1"
 logback = "1.5.32"
 maplibre = "0.12.1"
 material = "1.7.3"
-material3 = "1.11.0-alpha07"
+material3 = "1.11.0-alpha04"
 okio = "3.17.0"
 playServicesLocation = "21.3.0"
+sqlite = "2.6.2"
+room = "2.8.4"
 secretsGradlePlugin = "2.0.1"
-sqldelight = "2.3.2"
 wire = "6.1.0"
 
 [libraries]
@@ -66,10 +67,10 @@ moko-geo = { module = "dev.icerock.moko:geo", version.ref = "geo" }
 moko-geo-compose = { module = "dev.icerock.moko:geo-compose", version.ref = "geo" }
 okio = { module = "com.squareup.okio:okio", version.ref = "okio" }
 play-services-location = { module = "com.google.android.gms:play-services-location", version.ref = "playServicesLocation" }
+room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
+room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
+sqlite-bundled = { group = "androidx.sqlite", name = "sqlite-bundled", version.ref = "sqlite" }
 secrets-gradle-plugin = { module = "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin", version.ref = "secretsGradlePlugin" }
-sqldelight-driver-android = { module = "app.cash.sqldelight:android-driver", version.ref = "sqldelight" }
-sqldelight-driver-jvm = { module = "app.cash.sqldelight:sqlite-driver", version.ref = "sqldelight" }
-sqldelight-driver-native = { module = "app.cash.sqldelight:native-driver", version.ref = "sqldelight" }
 ui-backhandler = { module = "org.jetbrains.compose.ui:ui-backhandler", version.ref = "compose-multiplatform" }
 
 [plugins]
@@ -82,6 +83,6 @@ kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref =
 kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 ktor = { id = "io.ktor.plugin", version.ref = "ktor" }
+room = { id = "androidx.room", version.ref = "room" }
 secretsGradle = { id = "com.google.android.libraries.mapsplatform.secrets-gradle-plugin" }
-sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" }
 wire = { id = "com.squareup.wire", version.ref = "wire" }

server/build.gradle.kts

@@ -20,9 +20,7 @@ kotlin {
 
 dependencies {
     implementation(projects.core)
-    implementation(projects.core.data)
+    implementation(projects.core.room)
-    implementation(projects.core.sqld)
-    implementation(projects.core.stoptime)
     implementation(projects.server.gtfs)
     implementation(projects.server.gtfsRt)
 
@@ -38,6 +36,8 @@ dependencies {
     implementation(libs.ktor.server.contentnegotiation)
     implementation(libs.ktor.server.core)
     implementation(libs.ktor.server.netty)
+    implementation(libs.room.runtime)
+    implementation(libs.sqlite.bundled)
     testImplementation(libs.ktor.server.tests)
     testImplementation(libs.kotlin.test.junit)
 }