kryptovergleichde
commented
2 years ago So I successfully created some Types, which could be implemented by supabase-js.
What works:
- it infers the table names and column names completely automatic, so no duplicate definitions.
table(*)works- It even errors if for example you do define the relation string in a wrong format. Correct is
table(col, col), but if you do this with a table that doesn't exist or you do it with a wrong syntax liketable[col|col]it will error. - Determined by the second argument of
ResolveRelationQuery, you can change the relation type betweenone(which leads to an object) andmany(which leads to an array of objects). This is unfortunately impossible to detect via the types, as it is dependent on the database config (as far as I know)
What currently not works:
- currently, only the
table(col, col)format is supported. Missing support fortable ( col, col )(multiline)supplier:supplier_id ( name )users!inner(*)
So these types would need some fine-tuning for production.
You can try it out in any project: First implement this somewhere globally:
// lib/supabase.ts
import { createClient } from '@supabase/supabase-js'
import type { GetResult } from '@supabase/postgrest-js/dist/module/select-query-parser'
import type { Database } from '@/lib/database.types'
const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL as string
const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY as string
export const supabase = createClient<Database>(supabaseUrl, supabaseAnonKey)
type Tables = Database['public']['Tables']
type SplitRelStr_SuccessProps<T = keyof Tables, Q = string> = { table: T; query: Q }
type SplitRelStr<RelStr extends string> = RelStr extends `${infer T}(${infer Q})`
? T extends keyof Tables
? SplitRelStr_SuccessProps<T, Q>
: { error: 'Parsed `RelationString`, but the table name does not exist.' }
: { error: 'Cannot parse `RelationString`' }
type GetResolvedResult<SP extends SplitRelStr_SuccessProps> = GetResult<Tables[SP['table']]['Row'], SP['query']>
/**
* @template RelStr Supabase relation string, e.g. `tablename(colum, another_colum)`.
* @template RelType The type of relation. e.g. `one` or `many`. This decides if the returned relation is an array of objects/single object.
*/
export type ResolveRelationQuery<
RelStr extends string,
RelType extends 'one' | 'many' = 'many'
> = SplitRelStr<RelStr> extends SplitRelStr_SuccessProps
? {
[K in SplitRelStr<RelStr>['table']]: RelType extends 'one'
? GetResolvedResult<SplitRelStr<RelStr>> | null
: GetResolvedResult<SplitRelStr<RelStr>>[]
}
: { error: SplitRelStr<RelStr>['error'] }
/**
* @template R { data } response you get from `const { data, error } = await supabase.from('tablename').select(...)`
* @template RelObj Object that contains the table name and the resolved relation.
*/
export type ResolveResponse<R extends any[], RelObj extends object> = (R[0] & RelObj)[]And then when you want to use it:
import { supabase, ResolveRelationQuery, ResolveResponse } from '@/lib/supabase'
const loadData = async () => {
const actorsRelation = `actors(name, birth_date)`
const companiesRelation = `companies(*)`
const { data, error } = await supabase
.from('movies')
.select(`
name, id,
${actorsRelation},
${companiesRelation}
`)
if (!data?.length || error) return
type Actors = ResolveRelationQuery<typeof actorsRelation, 'many'>
type Companies = ResolveRelationQuery<typeof companiesRelation, 'many'>
type Response = ResolveResponse<typeof loadData, Actors & Companies>
return data as Response
}
const main = async () => {
const data = await loadData()
data?.map(entry => {
console.log(entry.id)
console.log(entry.actors) // -> now has resolved type, object or array of objects looking like this: `{ name: string | null, birth_date: string | null }`
})
}
main()
lorenzodejong
soedirgo
johanneskares
cdedreuille
samuba
Murkrage
pybuche
activenode
gluharry
amorfati254
gabrielsestrem
mihaiandrei97
thorwebdev
iolyd
kinolaev
samuel-bach
Jaaneek
rienheuver
bradennapier
github-actions[bot]
dhurbhat
whollacsek
okmaklad
3ru
davidchalifoux
chhuang
presedo93
Feature request
Is your feature request related to a problem? Please describe.
Hi there, I tried implementing supabase-js v2, and first was happy to see the type generation out of select queries. But the real issues I have are still not solved with the new approach, these are nested tables types.
So let's imagine you have this data structure
id, title, actors(name, birth_date), typescript will catch theidandtitle, of the movie, but not thenameandbirth_dateof the nested relation. If I am now going to add this info manually like this:there will be a lot of redunancy in the implementation. Since we have to define the table cols twice.
Describe the solution you'd like
Of course it would be perfect if nested relations would work out of the box. I see that this would be very difficult to do, and that's maybe why you didn't.
I would essentially suggest to export this type, to create something like this:
Describe alternatives you've considered
I peeked into the type definitions of the new supabase-js v2 library, and saw a
GetResulttype coming from@supabase/postgrest-js/dist/module/select-query-parser.I have implemented something with this, which technically works, but is not very developer friendly since everyone have to define lots of types in the repo. See https://github.com/supabase/postgrest-js/issues/303