TS2589 ("Type instantiation is excessively deep and possibly infinite") when passing generated *UpsertArgs to db.<model>.upsert() with many-to-many relations

[IanvanZyl636]

I've encountered what appears to be a TypeScript type recursion issue in the generated ZenStack types.

When a schema contains a many-to-many relationship, simply passing a generated TagUpsertArgs (or equivalent *UpsertArgs) into db.tag.upsert() causes TypeScript to recurse until it throws:

TS2589: Type instantiation is excessively deep and possibly infinite.

This also causes the TypeScript language service (VS Code/WebStorm) to consume excessive memory and eventually become unusable.

Environment

• ZenStack ORM: 3.8.3
• TypeScript: (latest)
• Node: (latest LTS)
• VS Code: 1.131
• WebStorm: (latest)
• PostgreSQL

Minimal schema

datasource db {
 provider = "postgresql"
 url = env("DATABASE_URL")
}

model Tag {
 id String @id @default(uuid())
 name String @unique

 products Product[]
}

model Product {
 id String @id @default(uuid())
 name String

 tags Tag[]
}

Removing the many-to-many relationship (or removing one side of it) causes the issue to disappear.

Reproduction

Generated type:

import { TagUpsertArgs } from "./zenstack/input";
import { db } from "./zenstack";

export function upsertTag(data: TagUpsertArgs) {
 return db.tag.upsert(data);
}

Produces:

TS2589: Type instantiation is excessively deep and possibly infinite.
Expected behaviour

The generated TagUpsertArgs type should be directly usable as the parameter type for db.tag.upsert().

Since ZenStack generates

export type TagUpsertArgs = $UpsertArgs<$Schema, "Tag">;

I would expect the following to compile without additional type coercion:

export function upsertTag(data: TagUpsertArgs) {
 return db.tag.upsert(data);
}

Interesting observations

The generated type itself appears to be valid.

For example, all of the following compile successfully:

type UpsertArg = Parameters<typeof db.tag.upsert>[0];

const x: TagUpsertArgs = {} as any;

const y: UpsertArg = {} as any;

type IsAssignable =
 TagUpsertArgs extends Parameters<typeof db.tag.upsert>[0]
 ? true
 : false;

IsAssignable

correctly evaluates to true.

Workaround

Interestingly, if I first assign to the method's parameter type, everything compiles:

export function upsertTag(data: any) {
 const args: Parameters<typeof db.tag.upsert>[0] = data;

 return db.tag.upsert(args);
}

This suggests the issue is not that TagUpsertArgs is incompatible with the method parameter, but rather that TypeScript enters an excessively deep generic instantiation path during inference when TagUpsertArgs is used directly.

Additional observations

The issue only appears when recursive model relationships exist (specifically many-to-many).

Without the relationship, the exact same code compiles successfully.

Impact

Besides the compiler error, this also causes severe IDE issues:

• VS Code TypeScript server repeatedly hangs or runs out of memory
• IntelliSense stops working
• Error reporting disappears
• WebStorm reports the TypeScript service running out of memory

Initially this appeared to be an IDE issue, but after reducing the project it appears to originate from the generated types.

Reproduction project

A minimal reproduction project is attached.

zenstack_test.zip

Commands to reproduce

npm i
npm run zenstack:generate
npm run build