The main problem I had when finding a suitable solution was, that the prisma client in the lambda of an interactive transaction is not a fully fledged Client, but just Prisma.TransactionClient, which is missing connect, $disconnect, transaction methods. If prisma would provide a full Client at this place, all you could do to solve the problem was just doing transactions like this:

**THIS DOES NOT WORK BECAUSE prismaServiceBoundToTransaction IS JUST OF TYPE Prisma.TransactionClient!!!**
return await this.prismaService.$transaction(async (prismaServiceBoundToTransaction): Promise<any> => {
      const userService = new UserService(prismaServiceBoundToTransaction)
      const otherService = new OtherService(prismaServiceBoundToTransaction)
      
      //Following calls will use prismaServiceBoundToTransaction internally
      await userService.update()
      await otherService.delete()
    }

Of course above only works, if UserService and OtherService are stateless.

So for my solution I created a new Interface that will offer all methods of Prisma.TransactionClient, but also a custom method to create a transaction. All of the services like your UserService will only retrieve this exact interface, so they can't call $transaction but only my interactiveTransaction method!

export interface PrismaClientWithCustomTransaction
  extends Readonly<Prisma.TransactionClient> {
  interactiveTransaction<F>(
    fn: (prisma: Prisma.TransactionClient) => Promise<F>,
    options?: {
      maxWait?: number | undefined;
      timeout?: number | undefined;
      isolationLevel?: Prisma.TransactionIsolationLevel | undefined;
    }
  ): Promise<F>;
}

We then create a concrete class TransactionalPrismaClient that implements the mentioned interface and delivers it, by retrieving a Prisma.TransactionClient in it's constructor and forwarding all of its methods. Additionally we also just implement the interactiveTransaction method by executing the lambda method with the Prisma.TransactionClient

export class TransactionalPrismaClient<
  T extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  U = 'log' extends keyof T
    ? T['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition>
      ? Prisma.GetEvents<T['log']>
      : never
    : never,
  GlobalReject extends
    | Prisma.RejectOnNotFound
    | Prisma.RejectPerOperation
    | false
    | undefined = 'rejectOnNotFound' extends keyof T
    ? T['rejectOnNotFound']
    : false
> implements PrismaClientWithCustomTransaction
{
  constructor(private readonly transactionalClient: Prisma.TransactionClient) {}

  $executeRaw<T = unknown>(
    query: TemplateStringsArray | Prisma.Sql,
    ...values: any[]
  ): PrismaPromise<number> {
    return this.transactionalClient.$executeRaw(query, ...values);
  }
  $executeRawUnsafe<T = unknown>(
    query: string,
    ...values: any[]
  ): PrismaPromise<number> {
    return this.transactionalClient.$executeRawUnsafe(query, ...values);
  }
  $queryRaw<T = unknown>(
    query: TemplateStringsArray | Prisma.Sql,
    ...values: any[]
  ): PrismaPromise<T> {
    return this.transactionalClient.$queryRaw(query, ...values);
  }
  $queryRawUnsafe<T = unknown>(
    query: string,
    ...values: any[]
  ): PrismaPromise<T> {
    return this.transactionalClient.$queryRawUnsafe(query, ...values);
  }
  get otherEntity(): Prisma.OtherEntityDelegate<GlobalReject> {
    return this.transactionalClient.otherEntity;
  }
  get userEntity(): Prisma.UserEntityDelegate<GlobalReject> {
    return this.transactionalClient.userEntity;
  }

  async interactiveTransaction<F>(
    fn: (prisma: Prisma.TransactionClient) => Promise<F>,
    options?: {
      maxWait?: number | undefined;
      timeout?: number | undefined;
      isolationLevel?: Prisma.TransactionIsolationLevel | undefined;
    }
  ): Promise<F> {
    return await fn(this.transactionalClient);
  }
}

And in your PrismaService we also need to implement the interactiveTransaction method, so that it satifies our defined interface PrismaClientWithCustomTransaction.

@Injectable()
export class PrismaService
  extends PrismaClient
  implements OnModuleInit, PrismaClientWithCustomTransaction
{
  private readonly logger = new ConsoleLogger(PrismaService.name);

  async onModuleInit() {
    this.logger.log('Trying to connect to db.');
    await this.$connect();
  }

  async enableShutdownHooks(app: INestApplication) {
    this.$on('beforeExit', async () => {
      await app.close();
    });
  }

  interactiveTransaction<R>(
    fn: (prisma: Prisma.TransactionClient) => Promise<R>,
    options?: {
      maxWait?: number | undefined;
      timeout?: number | undefined;
      isolationLevel?: Prisma.TransactionIsolationLevel | undefined;
    },
    numRetries = 1
  ): Promise<R> {
    let result: Promise<R> | null = null;

    for (let i = 0; i < numRetries; i++) {
      try {
        result = this.$transaction(fn, options);
      } catch (e) {
        if (e instanceof Prisma.PrismaClientKnownRequestError) {
          //TODO?
        } else {
          throw e;
        }
      }

      if (result != null) {
        return result;
      }
    }

    throw new Error(
      'No result in transaction after maximum number of retries.'
    );
  }
}

Because in our services we now expect the PrismaClientWithCustomTransaction interface, the auto injecting of NestJs wont work anymore and we have to provide PrismaService using a token:

providers: [
    {
      provide: 'PRISMA_SERVICE_TOKEN',
      useClass: PrismaService,
    },
  ],

exportt class UserService{
    constructor(@Inject('PRISMA_SERVICE_TOKEN') private readonly prisma: PrismaClientWithCustomTransaction){}
}

Alright so now we can do the following:

@Injectable()
export class OrdersService {
  constructor( @Inject('PRISMA_SERVICE_TOKEN')
    private readonly prisma: PrismaClientWithCustomTransaction, ...) {}

  async someFn() {
    return await this.prisma.interactiveTransaction(
      async (client) => {
        //You can still use client directly, if you dont need nested transaction logic
        return client.userEntity.create(...)

 
        //Or create services for nested usage
        const transactionalClient = new TransactionalPrismaClient(client);
        const userService = new UserService(transactionalClient);
        return userService.createUser(...);
        });
      },
      { isolationLevel: Prisma.TransactionIsolationLevel.RepeatableRead }
    );
  }
}

And if you need the connect, $disconnect, $use, you can of course still inject the original PrismaService with its regular interface.