fix(types): computed field and star selector (#626)

* wip: reproduce typing error

* fix(types): exclude computed field with star selector

* chore: re-use generated types

Author: avallete

src/select-query-parser/result.ts

@@ -12,6 +12,7 @@ import {
 } from './types'
 import {
   CheckDuplicateEmbededReference,
+  GetComputedFields,
   GetFieldNodeResultName,
   IsAny,
   IsRelationNullable,
@@ -234,7 +235,12 @@ export type ProcessNode<
 > =
   // TODO: figure out why comparing the `type` property is necessary vs. `NodeType extends Ast.StarNode`
   NodeType['type'] extends Ast.StarNode['type'] // If the selection is *
-    ? Row
+    ? // If the row has computed field, postgrest will omit them from star selection per default
+      GetComputedFields<Schema, RelationName> extends never
+      ? // If no computed fields are detected on the row, we can return it as is
+        Row
+      : // otherwise we omit all the computed field from the star result return
+        Omit<Row, GetComputedFields<Schema, RelationName>>
     : NodeType['type'] extends Ast.SpreadNode['type'] // If the selection is a ...spread
     ? ProcessSpreadNode<
         ClientOptions,

src/select-query-parser/utils.ts

@@ -578,3 +578,25 @@ export type IsStringUnion<T> = string extends T
     ? false
     : true
   : false
+
+type ComputedField<
+  Schema extends GenericSchema,
+  RelationName extends keyof TablesAndViews<Schema>,
+  FieldName extends keyof TablesAndViews<Schema>[RelationName]['Row']
+> = FieldName extends keyof Schema['Functions']
+  ? Schema['Functions'][FieldName] extends {
+      Args: { '': TablesAndViews<Schema>[RelationName]['Row'] }
+      Returns: any
+    }
+    ? FieldName
+    : never
+  : never
+
+// Given a relation name (Table or View) extract all the "computed fields" based on the Row
+// object, and the schema functions definitions
+export type GetComputedFields<
+  Schema extends GenericSchema,
+  RelationName extends keyof TablesAndViews<Schema>
+> = {
+  [K in keyof TablesAndViews<Schema>[RelationName]['Row']]: ComputedField<Schema, RelationName, K>
+}[keyof TablesAndViews<Schema>[RelationName]['Row']]

test/db/00-schema.sql

@@ -163,9 +163,14 @@ $$ language sql immutable;
 create function public.function_with_array_param(param uuid[])
 returns void as '' language sql immutable;
 
-
 create table public.cornercase (
   id        int primary key,
   "column whitespace" text,
   array_column text[]
 );
+
+-- Function creating a computed field
+create function public.blurb_message(public.messages) returns character varying as
+$$
+select substring($1.message, 1, 3);
+$$ language sql stable;

test/relationships-join-operations.test.ts

@@ -171,7 +171,7 @@ test('!left oneToMany', async () => {
   `)
   let result: Exclude<typeof res.data, null>
   let expected: {
-    messages: Array<Database['public']['Tables']['messages']['Row']>
+    messages: Array<Omit<Database['public']['Tables']['messages']['Row'], 'blurb_message'>>
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 })

test/relationships.test.ts

@@ -205,7 +205,7 @@ test('one-to-many relationship', async () => {
   `)
   let result: Exclude<typeof res.data, null>
   let expected: {
-    messages: Database['public']['Tables']['messages']['Row'][]
+    messages: Array<Omit<Database['public']['Tables']['messages']['Row'], 'blurb_message'>>
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 })

test/resource-embedding.test.ts

@@ -6,6 +6,7 @@ import { TypeEqual } from 'ts-expect'
 const postgrest = new PostgrestClient<Database>('http://localhost:3000')
 
 test('embedded select', async () => {
+  // By default postgrest will omit computed field from "star" selector
   const res = await postgrest.from('users').select('messages(*)')
   expect(res).toMatchInlineSnapshot(`
     Object {
@@ -67,6 +68,73 @@ test('embedded select', async () => {
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 })
 
+test('embedded select with computed field explicit selection', async () => {
+  // If the computed field is explicitely requested on top of the star selector, it should be present in the result
+  const res = await postgrest.from('users').select('messages(*, blurb_message)')
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": Array [
+        Object {
+          "messages": Array [
+            Object {
+              "blurb_message": "Hel",
+              "channel_id": 1,
+              "data": null,
+              "id": 1,
+              "message": "Hello World 👋",
+              "username": "supabot",
+            },
+            Object {
+              "blurb_message": "Per",
+              "channel_id": 2,
+              "data": null,
+              "id": 2,
+              "message": "Perfection is attained, not when there is nothing more to add, but when there is nothing left to take away.",
+              "username": "supabot",
+            },
+            Object {
+              "blurb_message": "Som",
+              "channel_id": 3,
+              "data": null,
+              "id": 4,
+              "message": "Some message on channel wihtout details",
+              "username": "supabot",
+            },
+          ],
+        },
+        Object {
+          "messages": Array [],
+        },
+        Object {
+          "messages": Array [],
+        },
+        Object {
+          "messages": Array [],
+        },
+        Object {
+          "messages": Array [],
+        },
+      ],
+      "error": null,
+      "status": 200,
+      "statusText": "OK",
+    }
+  `)
+  let result: Exclude<typeof res.data, null>
+  let expected: {
+    messages: {
+      channel_id: number
+      data: unknown
+      id: number
+      message: string | null
+      username: string
+      blurb_message: string | null
+    }[]
+  }[]
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+})
+
 describe('embedded filters', () => {
   // TODO: Test more filters
   test('embedded eq', async () => {

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

@@ -1,6 +1,8 @@
 import { expectType } from 'tsd'
 import { TypeEqual } from 'ts-expect'
-import { DeduplicateRelationships } from '../../src/select-query-parser/utils'
+import { DeduplicateRelationships, GetComputedFields } from '../../src/select-query-parser/utils'
+import { Database } from '../types.generated'
+
 // Deduplicate exact sames relationships
 {
   type rels = [
@@ -53,3 +55,113 @@ import { DeduplicateRelationships } from '../../src/select-query-parser/utils'
   type result = DeduplicateRelationships<rels>
   expectType<TypeEqual<result, expected>>(true)
 }
+
+// Test GetComputedFields basic
+{
+  type Schema = Database['public']
+  type result = GetComputedFields<Schema, 'users'>
+  type expected = never
+  expectType<TypeEqual<result, expected>>(true)
+}
+
+// Test GetComputedFields multiples computed fields
+{
+  type Json = unknown
+
+  type Database = {
+    personal: {
+      Tables: {
+        [_ in never]: never
+      }
+      Views: {
+        [_ in never]: never
+      }
+      Functions: {
+        [_ in never]: never
+      }
+      Enums: {
+        user_status: 'ONLINE' | 'OFFLINE'
+      }
+      CompositeTypes: {
+        [_ in never]: never
+      }
+    }
+    public: {
+      Tables: {
+        messages: {
+          Row: {
+            channel_id: number
+            data: Json | null
+            id: number
+            message: string | null
+            username: string
+            blurb_message: string | null
+            blurb_message2: number | null
+            blurb_message3: null | null
+          }
+          Insert: {
+            channel_id: number
+            data?: Json | null
+            id?: number
+            message?: string | null
+            username: string
+          }
+          Update: {
+            channel_id?: number
+            data?: Json | null
+            id?: number
+            message?: string | null
+            username?: string
+          }
+          Relationships: []
+        }
+      }
+      Views: {
+        [_ in never]: never
+      }
+      Functions: {
+        blurb_message: {
+          Args: { '': Database['public']['Tables']['messages']['Row'] }
+          Returns: string
+        }
+        blurb_message2: {
+          Args: { '': Database['public']['Tables']['messages']['Row'] }
+          Returns: number
+        }
+        blurb_message3: {
+          Args: { '': Database['public']['Tables']['messages']['Row'] }
+          Returns: null
+        }
+        function_returning_row: {
+          Args: Record<PropertyKey, never>
+          Returns: {
+            age_range: unknown | null
+            catchphrase: unknown | null
+            data: Json | null
+            username: string
+          }
+        }
+        function_returning_set_of_rows: {
+          Args: Record<PropertyKey, never>
+          Returns: {
+            age_range: unknown | null
+            catchphrase: unknown | null
+            data: Json | null
+            username: string
+          }[]
+        }
+      }
+      Enums: {
+        [_ in never]: never
+      }
+      CompositeTypes: {
+        [_ in never]: never
+      }
+    }
+  }
+
+  type Schema = Database['public']
+  type result = GetComputedFields<Schema, 'messages'>
+  type expected = 'blurb_message' | 'blurb_message2' | 'blurb_message3'
+  expectType<TypeEqual<result, expected>>(true)
+}