Add alias support for json columns

Author: jan-tennert

KSP/build.gradle.kts

@@ -17,4 +17,5 @@ dependencies {
 
 tasks.named<KotlinCompilationTask<*>>("compileKotlin").configure {
     compilerOptions.freeCompilerArgs.add("-opt-in=io.github.jan.supabase.annotations.SupabaseInternal")
+    compilerOptions.freeCompilerArgs.add("-opt-in=io.github.jan.supabase.annotations.SupabaseExperimental")
 }

KSP/src/main/kotlin/io/github/jan/supabase/ksp/ColumnOptions.kt

@@ -2,11 +2,12 @@ package io.github.jan.supabase.ksp
 
 data class ColumnOptions(
     val alias: String,
-    val columnName: String,
+    val columnName: String?,
     val isForeign: Boolean,
     val jsonPath: List<String>?,
     val returnAsText: Boolean,
     val function: String?,
     val cast: String?,
     val innerColumns: String,
+    val jsonKey: String?
 )

KSP/src/main/kotlin/io/github/jan/supabase/ksp/SelectableSymbolProcessor.kt

@@ -97,10 +97,11 @@ class SelectableSymbolProcessor(
         } else ""
         val alias = parameter.name!!.getShortName()
         val columnName = parameter.annotations.getAnnotationOrNull(ColumnName::class.java.simpleName)
-            ?.arguments?.getParameterValue<String>(ColumnName.NAME_PARAMETER_NAME) ?: alias
+            ?.arguments?.getParameterValue<String>(ColumnName.NAME_PARAMETER_NAME)
         val isForeign = parameter.annotations.getAnnotationOrNull(Foreign::class.java.simpleName) != null
         val jsonPathArguments = parameter.annotations.getAnnotationOrNull(JsonPath::class.java.simpleName)?.arguments
         val jsonPath = jsonPathArguments?.getParameterValue<ArrayList<String>>(JsonPath.PATH_PARAMETER_NAME)
+        val jsonKey = jsonPathArguments?.getParameterValue<String>(JsonPath.KEY_PARAMETER_NAME)
         val returnAsText = jsonPathArguments?.getParameterValue<Boolean>(JsonPath.RETURN_AS_TEXT_PARAMETER_NAME) == true
         val function = parameter.annotations.getAnnotationOrNull(ApplyFunction::class.java.simpleName)
             ?.arguments?.getParameterValue<String>(ApplyFunction.FUNCTION_PARAMETER_NAME)
@@ -111,6 +112,7 @@ class SelectableSymbolProcessor(
             columnName = columnName,
             isForeign = isForeign,
             jsonPath = jsonPath,
+            jsonKey = jsonKey,
             returnAsText = returnAsText,
             function = function,
             cast = cast,
@@ -143,8 +145,8 @@ class SelectableSymbolProcessor(
         if(options.jsonPath != null && options.function != null) {
             logger.error("Parameter $parameterName can't have both @JsonPath and @ApplyFunction annotation", symbol)
         }
-        if(options.jsonPath != null && options.jsonPath.isEmpty()) {
-            logger.error("Parameter $parameterName can't have an empty @JsonPath annotation. At least two elements (the column name and a key) are required.", symbol)
+        if(options.jsonKey != null && options.columnName == null) {
+            logger.error("Parameter $parameterName must have a @ColumnName annotation when using @JsonPath", symbol)
         }
     }
 
@@ -156,12 +158,15 @@ class SelectableSymbolProcessor(
     ): String {
         return buildString {
             if(options.jsonPath != null) {
-                append(buildJsonPath(options.jsonPath, options.returnAsText))
+                if(options.alias != options.jsonKey) {
+                    append("${options.alias}:")
+                }
+                append(buildJsonPath(options.columnName, options.jsonKey, options.jsonPath, options.returnAsText))
                 return@buildString
             }
 
-            //If the alias is the same as the column name, we can just assume parameter name (alias) is the column name
-            if(options.alias == options.columnName) {
+            //If the column name is not provided, use the alias (parameter name)
+            if(options.columnName == null) {
                 append(options.alias)
             } else {
                 append("${options.alias}:${options.columnName}")
@@ -188,11 +193,23 @@ class SelectableSymbolProcessor(
         }
     }
 
-    private fun buildJsonPath(jsonPath: List<String>, returnAsText: Boolean): String {
+    private fun buildJsonPath(
+        columnName: String?,
+        jsonKey: String?,
+        jsonPath: List<String>,
+        returnAsText: Boolean
+    ): String {
         val operator = if(returnAsText) "->>" else "->"
-        val formattedPath = if(jsonPath.size > 1) jsonPath.dropLast(1).joinToString("->") else ""
-        val key = jsonPath.last()
-        return "$formattedPath$operator$key"
+        return buildString {
+            append(columnName)
+            if(jsonPath.isNotEmpty()) {
+                jsonPath.forEach {
+                    append("->$it")
+                }
+            }
+            append(operator)
+            append(jsonKey)
+        }
     }
 
 }

Postgrest/src/commonMain/kotlin/io/github/jan/supabase/postgrest/annotations/JsonPath.kt

@@ -14,19 +14,25 @@ import io.github.jan.supabase.annotations.SupabaseInternal
  * ```
  * ```kotlin
  * @Selectable
- * data class Example(@JsonPath("data", "id") val id: Int)
+ * data class Example(
+ *     @ColumnName("data")
+ *     @JsonPath("id")
+ *     val id: Int
+ * )
  * ```
  *
- * @param path The path to the JSON property. The first element of the array is always the column name.
+ * @param key The key of the JSON property.
+ * @param path Additional path to the JSON property. If the JSON property is nested, you can specify the path to the property.
  * @param returnAsText Whether to return the JSON property as text. If `true`, the JSON property will be returned as a string. If `false`, the JSON property will be returned as JSON.
  *
  */
 @Target(AnnotationTarget.VALUE_PARAMETER)
 @Retention(AnnotationRetention.SOURCE)
-annotation class JsonPath(vararg val path: String, val returnAsText: Boolean = false) {
+annotation class JsonPath(val key: String, vararg val path: String, val returnAsText: Boolean = false) {
 
     companion object {
         @SupabaseInternal const val PATH_PARAMETER_NAME = "path"
+        @SupabaseInternal const val KEY_PARAMETER_NAME = "key"
         @SupabaseInternal const val RETURN_AS_TEXT_PARAMETER_NAME = "returnAsText"
     }
 

Postgrest/src/commonMain/kotlin/io/github/jan/supabase/postgrest/annotations/Selectable.kt

@@ -1,5 +1,6 @@
 package io.github.jan.supabase.postgrest.annotations
 
+import io.github.jan.supabase.annotations.SupabaseExperimental
 import io.github.jan.supabase.postgrest.query.PostgrestQueryBuilder
 
 /**
@@ -40,4 +41,5 @@ import io.github.jan.supabase.postgrest.query.PostgrestQueryBuilder
  */
 @Target(AnnotationTarget.CLASS)
 @Retention(AnnotationRetention.SOURCE)
+@SupabaseExperimental
 annotation class Selectable