RyoichiroNagami
commented
5 days ago @marcprux
I'm reading the source now and looking at it with a few modifications, but would like to discuss the direction.
I'm looking at two patterns that I'm considering as ways to implement this
The first is. It's a form that follows the Supabase swift call. I could reproduce this by mimicking the existing source.
Plan 1
public class SupabaseClient {
...etc codes
public func rpc(_ fn: String) async throws -> PostgrestResponse<Void> {
PostgrestResponse(result: await client.postgrest.rpc(fn))
}
}
public struct PostgrestResponse<T> {
private let result: io.github.jan.supabase.postgrest.result.PostgrestResult
init(result: io.github.jan.supabase.postgrest.result.PostgrestResult) {
self.result = result
}
// dummy function
// supabase-kt rpc not call execute
public func execute() -> PostgrestResponse {
return self
}
public var count: Int? {
result.countOrNull()?.toInt()
}
public var value: T? {
nil
}
public var data: Data {
let res: String = result.data
return res.data(using: String.Encoding.utf8) ?? Data()
}
//public let response: HTTPURLResponse
//public let count: Int?
//public let value: T
// public var status: Int {
// response.statusCode
// }
}
example calling
let value = try await client.rpc("function_name").execute().data
let dto: CodableStructureName = try JSONDecoder().decode(CodableStructureName.self, from: value)
I don't need the execute process after the ppc function call on the kotlin side.
This would require redundancy in the single point code.
// dummy function
// supabase-kt rpc not call execute
public func execute() -> PostgrestResponse {
return self
}
It could be implemented by adding an execute process to PostgrestResponse to return its own value, but I'm having a bit of trouble with that since it's a completely useless process.
If you want to solve that, I wonder if you could extend SupabaseClient and solve it in the following way? I think.
Plan 2
#if !SKIP
extension SupabaseClient {
public func skipRpc(_ fn: String) async throws -> Data {
return try await self.rpc(fn).execute().data
}
}
#endif
#if SKIP
public class SupabaseClient {
public func skipRpc(fn: String) async -> Data {
// SKIP INSERT:
// client.postgrest.rpc(fn).data().data(using = StringEncoding.utf8) ?: Data()
}
}
#endif
example calling
let value = try await client.skipRpc("function_name")
let res: CodableStructureName = try JSONDecoder().decode(CodableStructureName.self, from: value!)I feel like if you don't write documentation, they won't know how to use it, and it takes a little time for the user side to understand it.
Honestly, I could implement it either way, I just want to make sure we have a policy. Which one do you think is better?
*Personally, I think Plan1 is fine.
marcprux
lexum0
Currently
the supabase-skip package does not support the rpc function
Goal
Use supabase-skip package to call rpc function
Implementation Issues
Different way to call supabase rpc function in swift and kotlin example: swift requires a call to execute function when calling rpc function, but kotlin does not
The expected return type of PostgrestResponse.value is Generics, but skip-tool does not currently support decoding using Generics. skip-tools decode
Supabase Document