fix(typegen): avoid possible infinite recursion error

- Add a fixed max depth to recursive types allowing Typescript to not raise
possible infinite recursion error too early.
- Add test to ensure that the provided fix remove this error from a recursive embeding

Related:
supabase/supabase-js#1354
supabase/supabase-js#1372
supabase/supabase-js#808

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": "run-s build && tsd --files 'test/**/*.test-d.ts'",
-    "test:types:watch": "run-s build && tsd --files 'test/**/*.test-d.ts' --watch",
+    "test:types": "tsd --files 'test/**/*.test*.ts'",
+    "test:types:watch": "tsd --files 'test/**/*.test*.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,6 +167,89 @@ 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.
  *
@@ -183,38 +266,9 @@ export type ProcessNodes<
   Row extends Record<string, unknown>,
   RelationName extends string,
   Relationships extends GenericRelationship[],
-  Nodes extends Ast.Node[],
-  Acc extends Record<string, unknown> = {} // Acc is now an object
+  Nodes extends Ast.Node[]
 > = CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes> extends false
-  ? 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,
-                // Replace fields that exist in both Acc and FieldResult instead of intersecting
-                Omit<Acc, keyof FieldResult> & 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>
+  ? ProcessNodesBatched<ClientOptions, Schema, Row, RelationName, Relationships, Nodes>
   : Prettify<CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes>>
 
 /**

src/types.ts

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