feat(postgrest): leave computed fields out of select('*') and resolve no-argument rpc overloads for postgrest-typegen output (#2730)

Author: spydon

packages/core/postgrest-js/src/select-query-parser/result.ts

@@ -383,6 +383,7 @@ export type ProcessEmbeddedResource<
         }
       : Resolved extends {
             referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>
+            relationName: string
             relation: GenericRelationship & { match: 'refrel' | 'col' | 'fkname' | 'func' }
             direction: string
           }
@@ -412,6 +413,7 @@ type ProcessEmbeddedResourceResult<
   Schema extends GenericSchema,
   Resolved extends {
     referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>
+    relationName: string
     relation: GenericRelationship & {
       match: 'refrel' | 'col' | 'fkname' | 'func'
       isNotNullable?: boolean
@@ -427,11 +429,9 @@ type ProcessEmbeddedResourceResult<
     ClientOptions,
     Schema,
     Resolved['referencedTable']['Row'],
-    // For embeded function selection, the source of truth is the 'referencedRelation'
-    // coming from the SetofOptions.to parameter
-    Resolved['relation']['match'] extends 'func'
-      ? Resolved['relation']['referencedRelation']
-      : Field['name'],
+    // The embedded relation's own name, which differs from the field name when the embed
+    // goes through a column or foreign key name (`username(*)`) or an embedded function
+    Resolved['relationName'],
     Resolved['referencedTable']['Relationships'],
     Field['children'] extends undefined
       ? []

packages/core/postgrest-js/src/select-query-parser/utils.ts

@@ -266,6 +266,7 @@ type ResolveReverseRelationship<
               FoundRelation extends { hint: string } | { match: 'col' }
               ? {
                   referencedTable: TablesAndViews<Schema>[RelatedRelationName]
+                  relationName: RelatedRelationName
                   relation: FoundRelation
                   direction: 'reverse'
                   from: CurrentTableOrView
@@ -275,6 +276,7 @@ type ResolveReverseRelationship<
                 ? SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`>
                 : {
                     referencedTable: TablesAndViews<Schema>[RelatedRelationName]
+                    relationName: RelatedRelationName
                     relation: FoundRelation
                     direction: 'reverse'
                     from: CurrentTableOrView
@@ -428,6 +430,7 @@ export type ResolveForwardRelationship<
     ? FoundByName extends GenericRelationship
       ? {
           referencedTable: TablesAndViews<Schema>[Field['name']]
+          relationName: Field['name']
           relation: FoundByName
           direction: 'forward'
           from: Field['name']
@@ -443,6 +446,7 @@ export type ResolveForwardRelationship<
           }
           ? {
               referencedTable: TablesAndViews<Schema>[FoundByMatch['from']]
+              relationName: FoundByMatch['from'] & string
               relation: FoundByMatch
               direction: 'forward'
               from: CurrentTableOrView
@@ -456,6 +460,7 @@ export type ResolveForwardRelationship<
             ? FoundByJoinTable extends GenericRelationship
               ? {
                   referencedTable: TablesAndViews<Schema>[FoundByJoinTable['referencedRelation']]
+                  relationName: FoundByJoinTable['referencedRelation']
                   relation: FoundByJoinTable & { match: 'refrel' }
                   direction: 'forward'
                   from: CurrentTableOrView
@@ -491,6 +496,7 @@ export type ResolveForwardRelationship<
                           scalarType: FoundEmbededFunctionJoinTableRelation['Returns']
                           direction: 'forward'
                           from: CurrentTableOrView
+                          relationName: ''
                           type: 'found-by-embeded-scalar-function'
                         }
                       : // Table-valued function: `to` names the target table/view.
@@ -515,6 +521,7 @@ export type ResolveForwardRelationship<
                           }
                           direction: 'forward'
                           from: CurrentTableOrView
+                          relationName: FoundEmbededFunctionJoinTableRelation['SetofOptions']['to']
                           type: 'found-by-embeded-function'
                         }
                     : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>
@@ -681,26 +688,73 @@ type FindMatchingFunctionBySetofFrom<
   ? MatchingFunctionBySetofFrom<Fn, TableName>
   : false
 
+type IsUnion<T, U = T> = [T] extends [never]
+  ? false
+  : T extends U
+    ? [U] extends [T]
+      ? false
+      : true
+    : never
+
+type SameKeys<A, B> = [keyof A] extends [keyof B]
+  ? [keyof B] extends [keyof A]
+    ? true
+    : false
+  : false
+
+// The type of a function's only argument when it has exactly one and it is required,
+// whatever the argument is called. `Args: never` (a zero-argument function in older
+// generated types), `Args: Record<PropertyKey, never>`, an optional argument and several
+// arguments all resolve to `never`.
+type SoleRequiredArgument<Args> = [Args] extends [never]
+  ? never
+  : IsUnion<keyof Args> extends true
+    ? never
+    : {} extends Args
+      ? never
+      : Args[keyof Args]
+
+// Whether one signature of a function (one member of an overload union, as `Fn` is a
+// naked type parameter and distributes) is a computed field of a relation: PostgREST
+// treats a function whose only argument is the relation's row type as one. The argument
+// is matched on its keys rather than its exact type, so that a `Row` whose column types
+// were overridden (`MergeDeep`) still matches the generated `Row` the argument references.
+type IsComputedFieldFunction<Fn, Row> = Fn extends { Args: infer Args }
+  ? [SoleRequiredArgument<Args>] extends [never]
+    ? false
+    : SameKeys<SoleRequiredArgument<Args>, Row>
+  : 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]['Args']] extends [never]
-    ? never
-    : Schema['Functions'][FieldName] extends {
-          Args: { '': TablesAndViews<Schema>[RelationName]['Row'] }
-          Returns: any
-        }
-      ? FieldName
-      : never
+  ? true extends IsComputedFieldFunction<
+      Schema['Functions'][FieldName],
+      TablesAndViews<Schema>[RelationName]['Row']
+    >
+    ? 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<
+// Computed fields of a relation inferred from its `Row` keys and the schema functions, for
+// types generated before the relation declared them in `ComputedFields`.
+type InferredComputedFields<
   Schema extends GenericSchema,
   RelationName extends keyof TablesAndViews<Schema>,
 > = {
   [K in keyof TablesAndViews<Schema>[RelationName]['Row']]: ComputedField<Schema, RelationName, K>
 }[keyof TablesAndViews<Schema>[RelationName]['Row']]
+
+// Given a relation name (Table or View) extract all the "computed fields", which PostgREST
+// leaves out of a `*` selection: the names the relation declares in `ComputedFields`, or
+// otherwise the ones inferred from the schema functions definitions.
+export type GetComputedFields<
+  Schema extends GenericSchema,
+  RelationName extends keyof TablesAndViews<Schema>,
+> = 'ComputedFields' extends keyof TablesAndViews<Schema>[RelationName]
+  ? TablesAndViews<Schema>[RelationName] extends { ComputedFields?: infer Fields extends string }
+    ? Fields
+    : never
+  : InferredComputedFields<Schema, RelationName>

packages/core/postgrest-js/src/types/common/common.ts

@@ -42,18 +42,26 @@ export type GenericTable = {
   Insert: Record<string, unknown>
   Update: Record<string, unknown>
   Relationships: GenericRelationship[]
+  /**
+   * Names of the `Row` keys that are computed fields (functions taking the row), which
+   * PostgREST leaves out of `select('*')`. Generated types declare it; when absent, the
+   * computed fields are inferred from `Functions`.
+   */
+  ComputedFields?: string
 }
 
 export type GenericUpdatableView = {
   Row: Record<string, unknown>
   Insert: Record<string, unknown>
   Update: Record<string, unknown>
   Relationships: GenericRelationship[]
+  ComputedFields?: string
 }
 
 export type GenericNonUpdatableView = {
   Row: Record<string, unknown>
   Relationships: GenericRelationship[]
+  ComputedFields?: string
 }
 
 export type GenericView = GenericUpdatableView | GenericNonUpdatableView

packages/core/postgrest-js/src/types/common/rpc.ts

@@ -76,10 +76,16 @@ export type GetRpcFunctionFilterBuilderByArgs<
   1: IsAny<Schema> extends true
     ? any
     : IsNever<Args> extends true
-      ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
-        // we fallback to the last function definition matched by name
+      ? // Generated types spell a zero-argument definition either `Args: never` or
+        // `Args: Record<PropertyKey, never>`, so both are matched before falling back to the last
+        // function definition matched by name, which is for retro compatibility with a single
+        // return and an union of Args
         IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true
-        ? LastOf<Schema['Functions'][FnName]>
+        ? IsNever<
+            ExtractExactFunction<Schema['Functions'][FnName], Record<PropertyKey, never>>
+          > extends true
+          ? LastOf<Schema['Functions'][FnName]>
+          : ExtractExactFunction<Schema['Functions'][FnName], Record<PropertyKey, never>>
         : ExtractExactFunction<Schema['Functions'][FnName], Args>
       : Args extends Record<PropertyKey, never>
         ? LastOf<Schema['Functions'][FnName]>

packages/core/postgrest-js/test/rpc-no-args.test-d.ts

@@ -0,0 +1,52 @@
+import { expectType, TypeEqual } from './types'
+import { PostgrestClient } from '../src/index'
+
+type Database = {
+  public: {
+    Tables: {
+      [_ in never]: never
+    }
+    Views: {
+      [_ in never]: never
+    }
+    Functions: {
+      overloaded_never: { Args: never; Returns: number } | { Args: { a: string }; Returns: string }
+      overloaded_record:
+        | { Args: Record<PropertyKey, never>; Returns: number }
+        | { Args: { a: string }; Returns: string }
+      single_record: { Args: Record<PropertyKey, never>; Returns: boolean }
+    }
+    Enums: {
+      [_ in never]: never
+    }
+    CompositeTypes: {
+      [_ in never]: never
+    }
+  }
+}
+
+const postgrest = new PostgrestClient<Database>('http://localhost:54321/rest/v1')
+
+// A zero-argument overload typed `Args: never` resolves for a call without arguments
+{
+  const { data } = await postgrest.rpc('overloaded_never')
+  expectType<TypeEqual<typeof data, number | null>>(true)
+}
+
+// A zero-argument overload typed `Args: Record<PropertyKey, never>` resolves the same way
+{
+  const { data } = await postgrest.rpc('overloaded_record')
+  expectType<TypeEqual<typeof data, number | null>>(true)
+}
+
+// Passing arguments still selects the matching overload
+{
+  const { data } = await postgrest.rpc('overloaded_record', { a: 'value' })
+  expectType<TypeEqual<typeof data, string | null>>(true)
+}
+
+// A function that is not overloaded is unaffected
+{
+  const { data } = await postgrest.rpc('single_record')
+  expectType<TypeEqual<typeof data, boolean | null>>(true)
+}