Динамічні модулі

{
  module: SomeModule,
  providers: [...],
  imports: [...],
  exports: [...],
}

@Module({
  imports: [
    DatabaseModule.forRoot({
      databaseName: 'main',
    }),
  ],
})
export class AppModule {}

DatabaseModule.forRoot({
  databaseName: 'main',
});

DatabaseModule.forFeature([User, Order])

import {
  DynamicModule,
  Injectable,
  Module,
  Provider,
} from '@nestjs/common';

export interface DatabaseOptions {
  databaseName: string;
}

export const DATABASE_OPTIONS = Symbol('DATABASE_OPTIONS');
export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');

export type EntityClass<T> = new (...args: any[]) => T;

export function getRepositoryToken(
  entity: EntityClass<unknown>,
): string {
  return `Repository<${entity.name}>`;
}

export class InMemoryConnection {
  private readonly collections = new Map<string, unknown[]>();

  constructor(public readonly databaseName: string) {}

  getCollection(name: string): unknown[] {
    let collection = this.collections.get(name);

    if (!collection) {
      collection = [];
      this.collections.set(name, collection);
    }

    return collection;
  }
}

export class Repository<T extends object> {
  constructor(
    private readonly connection: InMemoryConnection,
    private readonly entity: EntityClass<T>,
  ) {}

  save(value: T): T {
    const collection = this.connection.getCollection(this.entity.name);
    collection.push(value);
    return value;
  }

  findAll(): T[] {
    const collection = this.connection.getCollection(this.entity.name);
    return collection as T[];
  }
}

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    const optionsProvider: Provider = {
      provide: DATABASE_OPTIONS,
      useValue: options,
    };

    const connectionProvider: Provider = {
      provide: DATABASE_CONNECTION,
      inject: [DATABASE_OPTIONS],
      useFactory: (databaseOptions: DatabaseOptions) => {
        return new InMemoryConnection(databaseOptions.databaseName);
      },
    };

    return {
      module: DatabaseModule,
      global: true,
      providers: [optionsProvider, connectionProvider],
      exports: [DATABASE_OPTIONS, DATABASE_CONNECTION],
    };
  }

  static forFeature(
    entities: EntityClass<unknown>[],
  ): DynamicModule {
    const repositoryProviders: Provider[] = entities.map((entity) => ({
      provide: getRepositoryToken(entity),
      inject: [DATABASE_CONNECTION],
      useFactory: (connection: InMemoryConnection) => {
        return new Repository(connection, entity);
      },
    }));

    return {
      module: DatabaseModule,
      providers: repositoryProviders,
      exports: repositoryProviders.map(
        (provider) => provider.provide,
      ),
    };
  }
}

static forRoot(options: DatabaseOptions): DynamicModule {
  // ...
}

const optionsProvider: Provider = {
  provide: DATABASE_OPTIONS,
  useValue: options,
};

const connectionProvider: Provider = {
  provide: DATABASE_CONNECTION,
  inject: [DATABASE_OPTIONS],
  useFactory: (databaseOptions: DatabaseOptions) => {
    return new InMemoryConnection(databaseOptions.databaseName);
  },
};

return {
  module: DatabaseModule,
  // ...
};

global: true

DatabaseModule.forFeature([User])

const repositoryProviders: Provider[] = entities.map((entity) => ({
  provide: getRepositoryToken(entity),
  inject: [DATABASE_CONNECTION],
  useFactory: (connection: InMemoryConnection) => {
    return new Repository(connection, entity);
  },
}));

Repository<User>

Repository<Order>

inject: [DATABASE_CONNECTION]

exports: repositoryProviders.map(
  (provider) => provider.provide,
),

export class User {
  constructor(
    public readonly id: number,
    public readonly name: string,
  ) {}
}

import {
  Inject,
  Injectable,
} from '@nestjs/common';

@Injectable()
export class UsersService {
  constructor(
    @Inject(getRepositoryToken(User))
    private readonly usersRepository: Repository<User>,
  ) {}

  create(user: User): User {
    return this.usersRepository.save(user);
  }

  findAll(): User[] {
    return this.usersRepository.findAll();
  }
}

import { Module } from '@nestjs/common';

@Module({
  imports: [
    DatabaseModule.forFeature([User]),
  ],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

import {
  Controller,
  DynamicModule,
  Get,
  Injectable,
  Inject,
  Module,
  Post,
  Body,
  Provider,
} from '@nestjs/common';
import { NestFactory } from '@nestjs/core';

export interface DatabaseOptions {
  databaseName: string;
}

export const DATABASE_OPTIONS = Symbol('DATABASE_OPTIONS');
export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');

export type EntityClass<T> = new (...args: any[]) => T;

export function getRepositoryToken(
  entity: EntityClass<unknown>,
): string {
  return `Repository<${entity.name}>`;
}

export class InMemoryConnection {
  private readonly collections = new Map<string, unknown[]>();

  constructor(public readonly databaseName: string) {}

  getCollection(name: string): unknown[] {
    let collection = this.collections.get(name);

    if (!collection) {
      collection = [];
      this.collections.set(name, collection);
    }

    return collection;
  }
}

export class Repository<T extends object> {
  constructor(
    private readonly connection: InMemoryConnection,
    private readonly entity: EntityClass<T>,
  ) {}

  save(value: T): T {
    const collection = this.connection.getCollection(this.entity.name);
    collection.push(value);
    return value;
  }

  findAll(): T[] {
    const collection = this.connection.getCollection(this.entity.name);
    return collection as T[];
  }
}

@Module({})
export class DatabaseModule {
  static forRoot(options: DatabaseOptions): DynamicModule {
    const optionsProvider: Provider = {
      provide: DATABASE_OPTIONS,
      useValue: options,
    };

    const connectionProvider: Provider = {
      provide: DATABASE_CONNECTION,
      inject: [DATABASE_OPTIONS],
      useFactory: (databaseOptions: DatabaseOptions) => {
        return new InMemoryConnection(databaseOptions.databaseName);
      },
    };

    return {
      module: DatabaseModule,
      global: true,
      providers: [optionsProvider, connectionProvider],
      exports: [DATABASE_OPTIONS, DATABASE_CONNECTION],
    };
  }

  static forFeature(
    entities: EntityClass<unknown>[],
  ): DynamicModule {
    const repositoryProviders: Provider[] = entities.map((entity) => ({
      provide: getRepositoryToken(entity),
      inject: [DATABASE_CONNECTION],
      useFactory: (connection: InMemoryConnection) => {
        return new Repository(connection, entity);
      },
    }));

    return {
      module: DatabaseModule,
      providers: repositoryProviders,
      exports: repositoryProviders.map(
        (provider) => provider.provide,
      ),
    };
  }
}

export class User {
  constructor(
    public readonly id: number,
    public readonly name: string,
  ) {}
}

@Injectable()
export class UsersService {
  constructor(
    @Inject(getRepositoryToken(User))
    private readonly usersRepository: Repository<User>,
  ) {}

  create(user: User): User {
    return this.usersRepository.save(user);
  }

  findAll(): User[] {
    return this.usersRepository.findAll();
  }
}

@Controller('users')
export class UsersController {
  constructor(
    private readonly usersService: UsersService,
  ) {}

  @Get()
  findAll(): User[] {
    return this.usersService.findAll();
  }

  @Post()
  create(@Body() body: { id: number; name: string }): User {
    return this.usersService.create(
      new User(body.id, body.name),
    );
  }
}

@Module({
  imports: [
    DatabaseModule.forFeature([User]),
  ],
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

@Module({
  imports: [
    DatabaseModule.forRoot({
      databaseName: 'application',
    }),
    UsersModule,
  ],
})
export class AppModule {}

async function bootstrap(): Promise<void> {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}

void bootstrap();

POST /users
Content-Type: application/json

{
  "id": 1,
  "name": "Olena"
}

GET /users

static forRoot(): DynamicModule {
  return {
    module: SomeModule,
    imports: [ConfigModule],
    providers: [SomeProvider],
    exports: [SomeProvider],
  };
}

{
  provide: DATABASE_OPTIONS,
  useValue: options,
}

const optionsProvider: Provider = {
  provide: DATABASE_OPTIONS,
  inject: [ConfigService],
  useFactory: (configService: ConfigService) => ({
    databaseName: configService.getOrThrow<string>('DATABASE_NAME'),
  }),
};

export const DATABASE_CONNECTION = Symbol('DATABASE_CONNECTION');

getRepositoryToken(User)

@Module({
  imports: [
    DatabaseModule.forRoot(options),
    UsersModule,
    OrdersModule,
  ],
})
export class AppModule {}

@Module({
  imports: [
    DatabaseModule.forFeature([User]),
  ],
})
export class UsersModule {}

return {
  module: DatabaseModule,
  providers: [repositoryProvider],
  exports: [getRepositoryToken(User)],
};

// Реєстрація
provide: 'USER_REPOSITORY'

// Ін'єкція за іншим токеном
@Inject('Repository<User>')

provide: getRepositoryToken(User)

@Inject(getRepositoryToken(User))

forRoot() → DATABASE_CONNECTION
forFeature() → Repository<User> → DATABASE_CONNECTION

@Module({})
export class DatabaseModule {}