fix(typegen): infinite recursion error

Fixes regression introduced in #625
While fixing the invalid intersection for conflicting keys case
the Omit did lead to a huge increase in the recursive type complexity
Removing it bring back the corner case, but allow much more longer queries.

A test is now in place to ensure minimal coverage over the query complexities
we can handle before reaching infinite recursion errors.

Author: avallete

package.json

@@ -40,8 +40,8 @@
     "test": "run-s format:check test:types db:clean db:run test:run db:clean && node test/smoke.cjs && node test/smoke.mjs",
     "test:run": "jest --runInBand --coverage",
     "test:update": "run-s db:clean db:run db:generate-test-types && jest --runInBand --updateSnapshot && run-s db:clean",
-    "test:types": "tsd --files 'test/**/*.test*.ts'",
-    "test:types:watch": "tsd --files 'test/**/*.test*.ts' --watch",
+    "test:types": "run-s build && tsd --files 'test/**/*.test-d.ts'",
+    "test:types:watch": "run-s build && tsd --files 'test/**/*.test-d.ts' --watch",
     "type-check": "tsc --noEmit --project tsconfig.json",
     "type-check:test": "tsc --noEmit --project tsconfig.test.json",
     "db:clean": "cd test/db && docker compose down --volumes",

src/select-query-parser/result.ts

@@ -167,89 +167,6 @@ export type RPCCallNodes<
     : SelectQueryError<'Invalid first node in RPC call'>
   : Prettify<Acc>
 
-type SplitArray<
-  T extends readonly unknown[],
-  N extends number,
-  Acc extends readonly unknown[] = []
-> = Acc['length'] extends N
-  ? [Acc, T]
-  : T extends readonly [infer Head, ...infer Tail]
-  ? SplitArray<Tail, N, [...Acc, Head]>
-  : [Acc, T]
-
-type ProcessBatch<
-  ClientOptions extends ClientServerOptions,
-  Schema extends GenericSchema,
-  Row extends Record<string, unknown>,
-  RelationName extends string,
-  Relationships extends GenericRelationship[],
-  Batch extends Ast.Node[],
-  Acc extends Record<string, unknown>
-> = Batch extends [infer Head, ...infer Tail]
-  ? Head extends Ast.Node
-    ? Tail extends Ast.Node[]
-      ? ProcessNode<
-          ClientOptions,
-          Schema,
-          Row,
-          RelationName,
-          Relationships,
-          Head
-        > extends infer Result
-        ? Result extends Record<string, unknown>
-          ? ProcessBatch<
-              ClientOptions,
-              Schema,
-              Row,
-              RelationName,
-              Relationships,
-              Tail,
-              Omit<Acc, keyof Result> & Result
-            >
-          : Result
-        : SelectQueryError<'Node processing failed'>
-      : Acc
-    : Acc
-  : Acc
-
-type ProcessNodesBatched<
-  ClientOptions extends ClientServerOptions,
-  Schema extends GenericSchema,
-  Row extends Record<string, unknown>,
-  RelationName extends string,
-  Relationships extends GenericRelationship[],
-  Nodes extends Ast.Node[],
-  Acc extends Record<string, unknown> = {}
-> = Nodes extends []
-  ? Prettify<Acc>
-  : SplitArray<Nodes, 5> extends [infer Batch, infer Remaining]
-  ? Batch extends Ast.Node[]
-    ? Remaining extends Ast.Node[]
-      ? ProcessBatch<
-          ClientOptions,
-          Schema,
-          Row,
-          RelationName,
-          Relationships,
-          Batch,
-          Acc
-        > extends infer BatchResult
-        ? BatchResult extends Record<string, unknown>
-          ? ProcessNodesBatched<
-              ClientOptions,
-              Schema,
-              Row,
-              RelationName,
-              Relationships,
-              Remaining,
-              BatchResult
-            >
-          : BatchResult
-        : SelectQueryError<'Batch processing failed'>
-      : SelectQueryError<'Invalid remaining nodes'>
-    : SelectQueryError<'Invalid batch nodes'>
-  : SelectQueryError<'Array splitting failed'>
-
 /**
  * Recursively processes an array of Nodes and accumulates the resulting TypeScript type.
  *
@@ -266,9 +183,48 @@ export type ProcessNodes<
   Row extends Record<string, unknown>,
   RelationName extends string,
   Relationships extends GenericRelationship[],
-  Nodes extends Ast.Node[]
+  Nodes extends Ast.Node[],
+  Acc extends Record<string, unknown> = {} // Acc is now an object
 > = CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes> extends false
-  ? ProcessNodesBatched<ClientOptions, Schema, Row, RelationName, Relationships, Nodes>
+  ? Nodes extends [infer FirstNode, ...infer RestNodes]
+    ? FirstNode extends Ast.Node
+      ? RestNodes extends Ast.Node[]
+        ? ProcessNode<
+            ClientOptions,
+            Schema,
+            Row,
+            RelationName,
+            Relationships,
+            FirstNode
+          > extends infer FieldResult
+          ? FieldResult extends Record<string, unknown>
+            ? ProcessNodes<
+                ClientOptions,
+                Schema,
+                Row,
+                RelationName,
+                Relationships,
+                RestNodes,
+                // TODO:
+                // This SHOULD be `Omit<Acc, keyof FieldResult> & FieldResult` since in the case where the key
+                // is present in the Acc already, the intersection will create bad intersection types
+                // (eg: `{ a: number } & { a: { property } }` will become `{ a: number & { property } }`)
+                // but using Omit here explode the inference complexity resulting in "infinite recursion error" from typescript
+                // very early (see: 'Check that selecting many fields doesn't yield an possibly infinite recursion error') test
+                // in this case we can't get above ~10 fields before reaching the recursion error
+                // If someone find a better way to do this, please do it !
+                // It'll also allow to fix those two tests:
+                // - `'join over a 1-M relation with both nullables and non-nullables fields using column name hinting on nested relation'`
+                // - `'self reference relation via column''`
+                Acc & FieldResult
+              >
+            : FieldResult extends SelectQueryError<infer E>
+            ? SelectQueryError<E>
+            : SelectQueryError<'Could not retrieve a valid record or error value'>
+          : SelectQueryError<'Processing node failed.'>
+        : SelectQueryError<'Invalid rest nodes array type in ProcessNodes'>
+      : SelectQueryError<'Invalid first node type in ProcessNodes'>
+    : Prettify<Acc>
   : Prettify<CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes>>
 
 /**

src/types.ts

@@ -194,7 +194,7 @@ type MergeExplicit<New, Row> = {
     : never
 }
 
-export type MergeDeep<New, Row> = Simplify<
+type MergeDeep<New, Row> = Simplify<
   MergeExplicit<New, Row> &
     // Intersection here is to restore dynamic keys into the merging result
     // eg:

test/relationships-join-operations.test.ts

@@ -625,7 +625,20 @@ test('join over a 1-M relation with both nullables and non-nullables fields usin
   // TODO: older versions of zod require this trick for non optional unknown data type
   // newer version of zod don't have this issue but require an upgrade of typescript minimal version
   let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
+  // TODO: fix this type, property merging override give invalid intersection types
+  // See: result.ts#ProcessNodes comment for more details
+  let crippledExpected: {
+    first_friend_of: {
+      id: (typeof expected)['first_friend_of'][number]['id']
+      second_user: (typeof expected)['first_friend_of'][number]['second_user']
+      third_wheel: (typeof expected)['first_friend_of'][number]['third_wheel']
+      // This intersection shouldn't exist
+      first_user: string & (typeof expected)['first_friend_of'][number]['first_user']
+    }[]
+    second_friend_of: (typeof expected)['second_friend_of']
+    third_wheel_of: (typeof expected)['third_wheel_of']
+  }
+  expectType<TypeEqual<typeof result, typeof crippledExpected>>(true)
   ExpectedSchema.parse(res.data)
 })
 

test/relationships.test.ts

@@ -493,7 +493,14 @@ test('self reference relation via column', async () => {
       .nullable(),
   })
   let expected: z.infer<typeof ExpectedSchema>
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
+  // TODO: fix this type, property merging override give invalid intersection types
+  // See: result.ts#ProcessNodes comment for more details
+  let crippledExpected: {
+    description: (typeof expected)['description']
+    id: (typeof expected)['id']
+    parent_id: (number & (typeof expected)['parent_id']) | null
+  }
+  expectType<TypeEqual<typeof result, typeof crippledExpected>>(true)
   ExpectedSchema.parse(res.data)
 })
 

test/returns.test-d.ts

@@ -194,7 +194,9 @@ const postgrest = new PostgrestClient<Database>(REST_URL)
 {
   const result = await postgrest
     .from('users')
-    // Maximum reached was one hundred seventy six fields before the recursion too deep error
+    // Maximum reached was one hundred seventy six fields
+    // Without the Omit<Acc, keyof FieldResult> & FieldResult
+    // With it, it raise as soon as after 12 fields only
     .select(
       `username,
       catchphrase,