feat(types): allow jsonpath selector types overrides

Author: avallete

src/select-query-parser/result.ts

@@ -15,6 +15,8 @@ import {
   GetFieldNodeResultName,
   IsAny,
   IsRelationNullable,
+  IsStringUnion,
+  JsonPathToType,
   ResolveRelationship,
   SelectQueryError,
 } from './utils'
@@ -239,6 +241,30 @@ type ProcessFieldNode<
   ? ProcessEmbeddedResource<Schema, Relationships, Field, RelationName>
   : ProcessSimpleField<Row, RelationName, Field>
 
+type ResolveJsonPathType<
+  Value,
+  Path extends string | undefined,
+  CastType extends PostgreSQLTypes
+> = Path extends string
+  ? JsonPathToType<Value, Path> extends never
+    ? // Always fallback if JsonPathToType returns never
+      TypeScriptTypes<CastType>
+    : JsonPathToType<Value, Path> extends infer PathResult
+    ? PathResult extends string
+      ? // Use the result if it's a string as we know that even with the string accessor ->> it's a valid type
+        PathResult
+      : IsStringUnion<PathResult> extends true
+      ? // Use the result if it's a union of strings
+        PathResult
+      : CastType extends 'json'
+      ? // If the type is not a string, ensure it was accessed with json accessor ->
+        PathResult
+      : // Otherwise it means non-string value accessed with string accessor ->> use the TypeScriptTypes result
+        TypeScriptTypes<CastType>
+    : TypeScriptTypes<CastType>
+  : // No json path, use regular type casting
+    TypeScriptTypes<CastType>
+
 /**
  * Processes a simple field (without embedded resources).
  *
@@ -261,8 +287,8 @@ type ProcessSimpleField<
       }
     : {
         // Aliases override the property name in the result
-        [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes // We apply the detected casted as the result type
-          ? TypeScriptTypes<Field['castType']>
+        [K in GetFieldNodeResultName<Field>]: Field['castType'] extends PostgreSQLTypes
+          ? ResolveJsonPathType<Row[Field['name']], Field['jsonPath'], Field['castType']>
           : Row[Field['name']]
       }
   : SelectQueryError<`column '${Field['name']}' does not exist on '${RelationName}'.`>

src/select-query-parser/utils.ts

@@ -546,9 +546,33 @@ export type FindFieldMatchingRelationships<
   : SelectQueryError<'Failed to find matching relation via name'>
 
 export type JsonPathToAccessor<Path extends string> = Path extends `${infer P1}->${infer P2}`
-  ? P2 extends `>${infer Rest}` // Check if P2 starts with > (from ->>)
+  ? P2 extends `>${infer Rest}` // Handle ->> operator
     ? JsonPathToAccessor<`${P1}.${Rest}`>
-    : JsonPathToAccessor<`${P1}.${P2}`>
+    : P2 extends string // Handle -> operator
+    ? JsonPathToAccessor<`${P1}.${P2}`>
+    : Path
+  : Path extends `>${infer Rest}` // Clean up any remaining > characters
+  ? JsonPathToAccessor<Rest>
   : Path extends `${infer P1}::${infer _}` // Handle type casting
-  ? JsonPathToAccessor<P1> // Process the path without the cast type
+  ? JsonPathToAccessor<P1>
   : Path
+
+export type JsonPathToType<T, Path extends string> = Path extends ''
+  ? T
+  : ContainsNull<T> extends true
+  ? JsonPathToType<Exclude<T, null>, Path>
+  : Path extends `${infer Key}.${infer Rest}`
+  ? Key extends keyof T
+    ? JsonPathToType<T[Key], Rest>
+    : never
+  : Path extends keyof T
+  ? T[Path]
+  : never
+
+export type IsStringUnion<T> = string extends T
+  ? false
+  : T extends string
+  ? [T] extends [never]
+    ? false
+    : true
+  : false

test/index.test-d.ts

@@ -214,11 +214,37 @@ const postgrest = new PostgrestClient<Database>(REST_URL)
 
 // Json Accessor with custom types overrides
 {
-  const { error } = await postgrest
+  const { data, error } = await postgrest
     .schema('personal')
     .from('users')
-    .select('data->foo->bar, data->foo->>baz')
+    .select('data->bar->baz, data->en, data->bar')
+  if (error) {
+    throw new Error(error.message)
+  }
+  expectType<
+    {
+      baz: number
+      en: 'ONE' | 'TWO' | 'THREE'
+      bar: {
+        baz: number
+      }
+    }[]
+  >(data)
+}
+// Json string Accessor with custom types overrides
+{
+  const { data, error } = await postgrest
+    .schema('personal')
+    .from('users')
+    .select('data->bar->>baz, data->>en, data->>bar')
   if (error) {
     throw new Error(error.message)
   }
+  expectType<
+    {
+      baz: string
+      en: 'ONE' | 'TWO' | 'THREE'
+      bar: string
+    }[]
+  >(data)
 }

test/select-query-parser/parser.test-d.ts

@@ -103,6 +103,31 @@ import { selectParams } from '../relationships'
     },
   ])
 }
+{
+  expectType<ParseQuery<'data->preferences->>theme, data->>some, data->foo->bar->>biz'>>([
+    {
+      type: 'field',
+      name: 'data',
+      alias: 'theme',
+      castType: 'text',
+      jsonPath: 'preferences.theme',
+    },
+    {
+      type: 'field',
+      name: 'data',
+      alias: 'some',
+      castType: 'text',
+      jsonPath: 'some',
+    },
+    {
+      type: 'field',
+      name: 'data',
+      alias: 'biz',
+      castType: 'text',
+      jsonPath: 'foo.bar.biz',
+    },
+  ])
+}
 // Select with spread
 {
   expectType<ParseQuery<'username, ...posts(id, title)'>>([

test/select-query-parser/result.test-d.ts

@@ -118,3 +118,34 @@ type SelectQueryFromTableResult<
   expectType<typeof result1>(result2!)
   expectType<typeof result2>(result3!)
 }
+
+{
+  type SelectQueryFromTableResult<
+    TableName extends keyof Database['personal']['Tables'],
+    Q extends string
+  > = GetResult<
+    Database['personal'],
+    Database['personal']['Tables'][TableName]['Row'],
+    TableName,
+    Database['personal']['Tables'][TableName]['Relationships'],
+    Q
+  >
+
+  let result: SelectQueryFromTableResult<'users', `data->bar->baz, data->en, data->bar`>
+  let expected: {
+    baz: number
+    en: 'ONE' | 'TWO' | 'THREE'
+    bar: {
+      baz: number
+    }
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+
+  let result2: SelectQueryFromTableResult<'users', `data->bar->>baz, data->>en, data->>bar`>
+  let expected2: {
+    baz: string
+    en: 'ONE' | 'TWO' | 'THREE'
+    bar: string
+  }
+  expectType<TypeEqual<typeof result2, typeof expected2>>(true)
+}