fix: self-referencing relation corner case

Related: #509

Author: avallete

src/select-query-parser/result.ts

@@ -164,7 +164,7 @@ export type ProcessEmbeddedResource<
 > = ResolveRelationship<Schema, Relationships, Field, CurrentTableOrView> extends infer Resolved
   ? Resolved extends {
       referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>
-      relation: GenericRelationship
+      relation: GenericRelationship & { match: 'refrel' | 'col' | 'fkname' }
       direction: string
     }
     ? ProcessEmbeddedResourceResult<Schema, Resolved, Field, CurrentTableOrView>
@@ -182,7 +182,7 @@ type ProcessEmbeddedResourceResult<
   Schema extends GenericSchema,
   Resolved extends {
     referencedTable: Pick<GenericTable, 'Row' | 'Relationships'>
-    relation: GenericRelationship
+    relation: GenericRelationship & { match: 'refrel' | 'col' | 'fkname' }
     direction: string
   },
   Field extends FieldNode,
@@ -207,7 +207,22 @@ type ProcessEmbeddedResourceResult<
           : Resolved['relation']['isOneToOne'] extends true
           ? ProcessedChildren | null
           : ProcessedChildren[]
-        : IsRelationNullable<
+        : // If the relation is a self-reference it'll always be considered as reverse relationship
+        Resolved['relation']['referencedRelation'] extends CurrentTableOrView
+        ? // It can either be a reverse reference via a column inclusion (eg: parent_id(*))
+          // in such case the result will be a single object
+          Resolved['relation']['match'] extends 'col'
+          ? IsRelationNullable<
+              TablesAndViews<Schema>[CurrentTableOrView],
+              Resolved['relation']
+            > extends true
+            ? ProcessedChildren | null
+            : ProcessedChildren
+          : // Or it can be a reference via the reference relation (eg: collections(*))
+            // in such case, the result will be an array of all the values (all collection with parent_id being the current id)
+            ProcessedChildren[]
+        : // Otherwise if it's a non self-reference reverse relationship it's a single object
+        IsRelationNullable<
             TablesAndViews<Schema>[CurrentTableOrView],
             Resolved['relation']
           > extends true

src/select-query-parser/utils.ts

@@ -251,20 +251,6 @@ type ResolveReverseRelationship<
     : false
   : false
 
-// Utility type to find embeded relationships by all their possibles references
-export type FindMatchingRelationships<
-  value extends string,
-  Relationships extends GenericRelationship[]
-> = Relationships extends [infer R, ...infer Rest extends GenericRelationship[]]
-  ? R extends { foreignKeyName: value }
-    ? R
-    : R extends { referencedRelation: value }
-    ? R
-    : R extends { columns: [value] }
-    ? R
-    : FindMatchingRelationships<value, Rest>
-  : false
-
 export type FindMatchingTableRelationships<
   Schema extends GenericSchema,
   Relationships extends GenericRelationship[],

test/db/00-schema.sql

@@ -59,6 +59,20 @@ CREATE TABLE public.messages (
 ALTER TABLE public.messages REPLICA IDENTITY FULL; -- Send "previous data" to supabase
 COMMENT ON COLUMN public.messages.data IS 'For unstructured data and prototyping.';
 
+-- SELF REFERENCING TABLE
+CREATE TABLE public.collections (
+  id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+  description text,
+  parent_id bigint
+);
+ALTER TABLE public.messages REPLICA IDENTITY FULL; -- Send "previous data" to supabase
+-- SELF REFERENCE via parent_id
+ALTER TABLE public.collections
+ADD CONSTRAINT collections_parent_id_fkey
+FOREIGN KEY (parent_id)
+REFERENCES public.collections(id);
+COMMENT ON COLUMN public.messages.data IS 'For unstructured data and prototyping.';
+
 -- STORED FUNCTION
 CREATE FUNCTION public.get_status(name_param text)
 RETURNS user_status AS $$

test/db/01-dummy-data.sql

@@ -49,3 +49,12 @@ INSERT INTO best_friends(id, first_user, second_user, third_wheel)
 VALUES
   (1, 'supabot', 'kiwicopple', 'awailas'),
   (2, 'supabot', 'awailas', NULL);
+
+INSERT INTO public.collections (id, description, parent_id)
+VALUES
+  (1, 'Root Collection', NULL),
+  (2, 'Child of Root', 1),
+  (3, 'Another Child of Root', 1),
+  (4, 'Grandchild', 2),
+  (5, 'Sibling of Grandchild', 2),
+  (6, 'Child of Another Root', 3);

test/relationships.ts

@@ -169,6 +169,14 @@ export const selectParams = {
     from: 'channels',
     select: 'id, messages!channel_id!inner(id, username)',
   },
+  selfReferenceRelation: {
+    from: 'collections',
+    select: '*, collections(*)',
+  },
+  selfReferenceRelationViaColumn: {
+    from: 'collections',
+    select: '*, parent_id(*)',
+  },
 } as const
 
 export const selectQueries = {
@@ -335,6 +343,12 @@ export const selectQueries = {
   innerJoinOnManyRelation: postgrest
     .from(selectParams.innerJoinOnManyRelation.from)
     .select(selectParams.innerJoinOnManyRelation.select),
+  selfReferenceRelation: postgrest
+    .from(selectParams.selfReferenceRelation.from)
+    .select(selectParams.selfReferenceRelation.select),
+  selfReferenceRelationViaColumn: postgrest
+    .from(selectParams.selfReferenceRelationViaColumn.from)
+    .select(selectParams.selfReferenceRelationViaColumn.select),
 } as const
 
 test('nested query with selective fields', async () => {
@@ -1742,3 +1756,53 @@ test('inner join on many relation', async () => {
     }
   `)
 })
+
+test('self reference relation', async () => {
+  const res = await selectQueries.selfReferenceRelation.limit(1).single()
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": Object {
+        "collections": Array [
+          Object {
+            "description": "Child of Root",
+            "id": 2,
+            "parent_id": 1,
+          },
+          Object {
+            "description": "Another Child of Root",
+            "id": 3,
+            "parent_id": 1,
+          },
+        ],
+        "description": "Root Collection",
+        "id": 1,
+        "parent_id": null,
+      },
+      "error": null,
+      "status": 200,
+      "statusText": "OK",
+    }
+  `)
+})
+
+test('self reference relation via column', async () => {
+  const res = await selectQueries.selfReferenceRelationViaColumn.eq('id', 2).limit(1).single()
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": Object {
+        "description": "Child of Root",
+        "id": 2,
+        "parent_id": Object {
+          "description": "Root Collection",
+          "id": 1,
+          "parent_id": null,
+        },
+      },
+      "error": null,
+      "status": 200,
+      "statusText": "OK",
+    }
+  `)
+})

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

@@ -53,3 +53,20 @@ type SelectQueryFromTableResult<
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
+
+// Self referencing relation
+{
+  const { from, select } = selectParams.selfReferenceRelation
+  let result: SelectQueryFromTableResult<typeof from, typeof select>
+  let expected: {
+    id: number
+    description: string | null
+    parent_id: number | null
+    collections: {
+      id: number
+      description: string | null
+      parent_id: number | null
+    }[]
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}

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

@@ -701,3 +701,38 @@ type Schema = Database['public']
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
+
+// self reference relation
+{
+  const { data } = await selectQueries.selfReferenceRelation.limit(1).single()
+  let result: Exclude<typeof data, null>
+  let expected: {
+    id: number
+    description: string | null
+    parent_id: number | null
+    collections: {
+      id: number
+      description: string | null
+      parent_id: number | null
+    }[]
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
+// self reference relation via column
+{
+  const { data } = await selectQueries.selfReferenceRelationViaColumn.limit(1).single()
+  let result: Exclude<typeof data, null>
+  let expected: {
+    description: string | null
+    id: number
+    parent_id:
+      | (number & {
+          description: string | null
+          id: number
+          parent_id: number | null
+        })
+      | null
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}

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

@@ -8,7 +8,6 @@ import {
 import { expectType } from 'tsd'
 import { TypeEqual } from 'ts-expect'
 import {
-  FindMatchingRelationships,
   FindMatchingTableRelationships,
   IsRelationNullable,
 } from '../../src/select-query-parser/utils'
@@ -17,58 +16,37 @@ import { ParseQuery } from '../../src/select-query-parser/parser/parser'
 
 // This test file is here to ensure some of our helpers behave as expected for ease of development
 // and debugging purposes
-// Searching for an non-existing relationship should return never
-{
-  let result: FindMatchingRelationships<
-    'test',
-    Database['public']['Tables']['best_friends']['Relationships']
-  >
-  let expected: false
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
-}
+
 // Searching for a relationship by direct foreignkey name
 {
-  let result: FindMatchingRelationships<
-    'best_friends_first_user_fkey',
-    Database['public']['Tables']['best_friends']['Relationships']
+  let result: FindMatchingTableRelationships<
+    Database['public'],
+    Database['public']['Tables']['best_friends']['Relationships'],
+    'best_friends_first_user_fkey'
   >
   let expected: {
     foreignKeyName: 'best_friends_first_user_fkey'
     columns: ['first_user']
     isOneToOne: false
     referencedRelation: 'users'
     referencedColumns: ['username']
-  }
+  } & { match: 'fkname' }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 // Searching for a relationship by column hoding the value reference
 {
-  let result: FindMatchingRelationships<
-    'first_user',
-    Database['public']['Tables']['best_friends']['Relationships']
+  let result: FindMatchingTableRelationships<
+    Database['public'],
+    Database['public']['Tables']['best_friends']['Relationships'],
+    'first_user'
   >
   let expected: {
     foreignKeyName: 'best_friends_first_user_fkey'
     columns: ['first_user']
     isOneToOne: false
     referencedRelation: 'users'
     referencedColumns: ['username']
-  }
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
-}
-// Will find the first matching relationship
-{
-  let result: FindMatchingRelationships<
-    'username',
-    Database['public']['Tables']['user_profiles']['Relationships']
-  >
-  let expected: {
-    foreignKeyName: 'user_profiles_username_fkey'
-    columns: ['username']
-    isOneToOne: false
-    referencedRelation: 'non_updatable_view'
-    referencedColumns: ['username']
-  }
+  } & { match: 'col' }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 // should return the relation matching the "Tables" references
@@ -89,44 +67,48 @@ import { ParseQuery } from '../../src/select-query-parser/parser/parser'
 }
 // Searching for a relationship by referenced table name
 {
-  let result: FindMatchingRelationships<
-    'users',
-    Database['public']['Tables']['messages']['Relationships']
+  let result: FindMatchingTableRelationships<
+    Database['public'],
+    Database['public']['Tables']['messages']['Relationships'],
+    'users'
   >
   let expected: {
     foreignKeyName: 'messages_username_fkey'
     columns: ['username']
     isOneToOne: false
     referencedRelation: 'users'
     referencedColumns: ['username']
-  }
+  } & { match: 'refrel' }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 {
-  let result: FindMatchingRelationships<
-    'channels',
-    Database['public']['Tables']['messages']['Relationships']
+  let result: FindMatchingTableRelationships<
+    Database['public'],
+    Database['public']['Tables']['messages']['Relationships'],
+    'channels'
   >
   let expected: {
     foreignKeyName: 'messages_channel_id_fkey'
     columns: ['channel_id']
     isOneToOne: false
     referencedRelation: 'channels'
     referencedColumns: ['id']
-  }
+  } & { match: 'refrel' }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
 // IsRelationNullable
 {
   type BestFriendsTable = Database['public']['Tables']['best_friends']
-  type NonNullableRelation = FindMatchingRelationships<
-    'best_friends_first_user_fkey',
-    BestFriendsTable['Relationships']
+  type NonNullableRelation = FindMatchingTableRelationships<
+    Database['public'],
+    BestFriendsTable['Relationships'],
+    'best_friends_first_user_fkey'
   >
-  type NullableRelation = FindMatchingRelationships<
-    'best_friends_third_wheel_fkey',
-    BestFriendsTable['Relationships']
+  type NullableRelation = FindMatchingTableRelationships<
+    Database['public'],
+    BestFriendsTable['Relationships'],
+    'best_friends_third_wheel_fkey'
   >
   let nonNullableResult: IsRelationNullable<BestFriendsTable, NonNullableRelation>
   let nullableResult: IsRelationNullable<BestFriendsTable, NullableRelation>