fix: jsonpath accessor and filters

Author: avallete

src/PostgrestFilterBuilder.ts

@@ -1,4 +1,5 @@
 import PostgrestTransformBuilder from './PostgrestTransformBuilder'
+import { JsonPathToAccessor, JsonPathToType } from './select-query-parser/utils'
 import { GenericSchema } from './types'
 
 type FilterOperator =
@@ -40,6 +41,12 @@ type ResolveFilterValue<
     : ResolveFilterRelationshipValue<Schema, RelationshipTable, Remainder>
   : ColumnName extends keyof Row
   ? Row[ColumnName]
+  : // If the column selection is a jsonpath like `data->value` we attempt to match
+  // the expected type with the parsed custom json type
+  JsonPathToType<Row, JsonPathToAccessor<ColumnName>> extends infer JsonPathValue
+  ? JsonPathValue extends never
+    ? never
+    : JsonPathValue
   : never
 
 type ResolveFilterRelationshipValue<
@@ -73,11 +80,14 @@ export default class PostgrestFilterBuilder<
    */
   eq<ColumnName extends string>(
     column: ColumnName,
-    value: ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
-      ? ResolvedFilterValue extends never
-        ? unknown
-        : NonNullable<ResolvedFilterValue>
-      : unknown
+    value: ResolveFilterValue<Schema, Row, ColumnName> extends never
+      ? NonNullable<unknown>
+      : // We want to infer the type before wrapping it into a `NonNullable` to avoid too deep
+      // type resolution error
+      ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
+      ? NonNullable<ResolvedFilterValue>
+      : // We should never enter this case as all the branches are covered above
+        never
   ): this {
     this.url.searchParams.append(column, `eq.${value}`)
     return this
@@ -91,11 +101,11 @@ export default class PostgrestFilterBuilder<
    */
   neq<ColumnName extends string>(
     column: ColumnName,
-    value: ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
-      ? ResolvedFilterValue extends never
-        ? unknown
-        : NonNullable<ResolvedFilterValue>
-      : unknown
+    value: ResolveFilterValue<Schema, Row, ColumnName> extends never
+      ? unknown
+      : ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
+      ? ResolvedFilterValue
+      : never
   ): this {
     this.url.searchParams.append(column, `neq.${value}`)
     return this
@@ -274,11 +284,14 @@ export default class PostgrestFilterBuilder<
   in<ColumnName extends string>(
     column: ColumnName,
     values: ReadonlyArray<
-      ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
-        ? ResolvedFilterValue extends never
-          ? unknown[]
-          : ResolvedFilterValue
-        : never
+      ResolveFilterValue<Schema, Row, ColumnName> extends never
+        ? unknown
+        : // We want to infer the type before wrapping it into a `NonNullable` to avoid too deep
+        // type resolution error
+        ResolveFilterValue<Schema, Row, ColumnName> extends infer ResolvedFilterValue
+        ? ResolvedFilterValue
+        : // We should never enter this case as all the branches are covered above
+          never
     >
   ): this {
     const cleanedValues = Array.from(new Set(values))

test/issue-1354-d.ts

@@ -191,6 +191,35 @@ const postgrestOverrideTypes = new PostgrestClient<DatabaseOverride>('http://loc
   expectType<null>(result.data)
 }
 
+// basic types with postgres jsonpath selector
+{
+  const res = await postgrest.from('foo').select('id, bar, baz').eq('bar->version', 31).single()
+
+  const bar = {} as Json
+  const baz = {} as Json
+  if (res.error) {
+    throw new Error(res.error.message)
+  }
+  const result = await postgrest
+    .from('foo')
+    .update({
+      bar,
+      baz,
+    })
+    .eq('bar->version', 31)
+  expectType<null>(result.data)
+  const resIn = await postgrest
+    .from('foo')
+    .select('id, bar, baz')
+    .in('bar->version', [1, 2])
+    .single()
+
+  if (resIn.error) {
+    throw new Error(resIn.error.message)
+  }
+  expectType<{ id: string; bar: Json; baz: Json }>(resIn.data)
+}
+
 // extended types
 {
   const res = await postgrestOverrideTypes
@@ -226,3 +255,36 @@ const postgrestOverrideTypes = new PostgrestClient<DatabaseOverride>('http://loc
   }
   expectType<{ id: string; bar: Custom; baz: Custom }>(resIn.data)
 }
+
+// extended types with postgres jsonpath selector
+{
+  const res = await postgrestOverrideTypes
+    .from('foo')
+    .select('id, bar, baz')
+    .eq('bar->version', 31)
+    .single()
+
+  const bar = {} as Custom
+  const baz = {} as Custom
+  if (res.error) {
+    throw new Error(res.error.message)
+  }
+  const result = await postgrestOverrideTypes
+    .from('foo')
+    .update({
+      bar,
+      baz,
+    })
+    .eq('bar->version', res.data.bar.version)
+  expectType<null>(result.data)
+  const resIn = await postgrestOverrideTypes
+    .from('foo')
+    .select('id, bar, baz')
+    .in('bar->version', [1, 32])
+    .single()
+
+  if (resIn.error) {
+    throw new Error(resIn.error.message)
+  }
+  expectType<{ id: string; bar: Custom; baz: Custom }>(resIn.data)
+}

test/relationships.ts

@@ -1830,12 +1830,7 @@ test('self reference relation via column', async () => {
 })
 
 test('aggregate on missing column with alias', async () => {
-  const res = await selectQueries.aggregateOnMissingColumnWithAlias
-    // @ts-expect-error should not be able to eq 'id' since the column does not
-    // exist
-    .eq('id', 2)
-    .limit(1)
-    .single()
+  const res = await selectQueries.aggregateOnMissingColumnWithAlias.eq('id', 2).limit(1).single()
   expect(res).toMatchInlineSnapshot(`
     Object {
       "count": null,