[RFC] Database/ORM Module

[Evanion]

Overview

A module to integrate popular ORMs (TypeORM, Prisma, Drizzle, etc.) with NexusDI, providing injectable repositories/clients, lifecycle management, and a familiar, ergonomic API for developers.

Motivation

• Dependency injection for repositories/clients: Make it easy to inject and mock repositories or database clients in services.
• Centralized config and connection management: Manage database connections and ORM configuration in one place.
• Support for multiple ORMs and databases: Allow users to choose their preferred ORM and database backend.
• Ergonomic API: Use decorators like @InjectRepository to provide runtime metadata for entity injection.

Proposed Features

• Register ORM connections via config or async config (e.g., in container.json)
• Inject repositories/clients into services using an @InjectRepository decorator (for TypeORM/Drizzle) or direct injection (for Prisma)
• Support for transactions, migrations, and connection pooling
• Optional: adapters for multiple ORMs (TypeORM, Prisma, Drizzle, MikroORM, etc.)
• Support for custom repositories and query runners
• Easy mocking/overriding of repositories for testing

Example Workflow

1. Configure the ORM module in container.json:

   {
     "database": {
       "orm": "typeorm",
       "type": "postgres",
       "url": "postgres://user:pass@localhost:5432/mydb",
       "entities": ["src/entities/*.ts"],
       "synchronize": true
     }
   }

2. Register the ORM module:

   import { TypeOrmModule } from '@nexusdi/typeorm';
   
   container.set(TypeOrmModule.configFromFile('container.json'));

3. Inject repositories into services:

   import { InjectRepository } from '@nexusdi/typeorm';
   import { Repository } from 'typeorm';
   import { User } from '../entities/User';
   
   class UserService {
     constructor(
       @InjectRepository(User) private userRepo: Repository<User>
     ) {}
   
     async findUser(id: number) {
       return this.userRepo.findOneBy({ id });
     }
   }

4. For Prisma or other client-based ORMs:

   import { PrismaClient } from '@prisma/client';
   
   class ProductService {
     constructor(private prisma: PrismaClient) {}
   
     async getProduct(id: string) {
       return this.prisma.product.findUnique({ where: { id } });
     }
   }

Open Questions

• Which ORMs should be supported out of the box (TypeORM, Prisma, Drizzle, MikroORM, etc.)?
• How should migrations and transactions be handled (decorators, helpers, or manual)?
• Should we provide a unified repository interface for all ORMs, or keep ORM-specific APIs?
• How to handle async config and connection lifecycle (e.g., for serverless environments)?
• Should we support custom repositories and query runners?
• How to best support mocking/overriding repositories for testing?

API Sketch

// TypeORM example
import { InjectRepository } from '@nexusdi/typeorm';
import { Repository } from 'typeorm';
import { User } from '../entities/User';

class UserService {
  constructor(
    @InjectRepository(User) private userRepo: Repository<User>
  ) {}

  async findUser(id: number) {
    return this.userRepo.findOneBy({ id });
  }
}

// Prisma example
import { PrismaClient } from '@prisma/client';

class ProductService {
  constructor(private prisma: PrismaClient) {}

  async getProduct(id: string) {
    return this.prisma.product.findUnique({ where: { id } });
  }
}

Call for Feedback

• Which ORMs do you use or want supported?
• What features or patterns do you want for DI/ORM integration?
• Any pain points with existing DI/ORM integrations?
• How important is support for custom repositories, transactions, or advanced features?
• Any other features or decorator options you’d want?