TypeORM module setup in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this TypeORM connection setup in NestJS?

Consider this NestJS module setup using TypeORM. What will be the behavior when the application starts?

NestJS

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: ':memory:',
      entities: [User],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

A The app connects to an in-memory SQLite database and auto-creates the User table on startup.

B The app throws a runtime error because ':memory:' is not a valid database path.

C The app connects but does not create any tables because synchronize is false by default.

D The app connects to a file-based SQLite database named ':memory:' on disk.

💡 Hint

Check the meaning of 'synchronize' and the special SQLite ':memory:' database.

The TypeOrmModule.forRoot configures a SQLite in-memory database with synchronize: true. This means the database schema is auto-created on app start. The ':memory:' path tells SQLite to use RAM, not disk.

📝 Syntax

intermediate

Which option correctly imports TypeORM entities in NestJS module?

You want to register multiple entities in your TypeORM module. Which import syntax is correct?

NestJS

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { Post } from './post.entity';

@Module({
  imports: [
    TypeOrmModule.forFeature(_____)
  ],
})
export class AppModule {}

A [User; Post]

B {User, Post}

C [User, Post]

D User, Post

💡 Hint

Remember how arrays are declared in JavaScript/TypeScript.

The forFeature method expects an array of entity classes. The correct syntax is [User, Post]. Curly braces or semicolons are invalid here.

🔧 Debug

advanced

Why does this TypeORM module setup cause a runtime error?

Examine the following NestJS TypeORM configuration. Why will it fail at runtime?

NestJS

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'user',
      password: 'pass',
      database: 'testdb',
      entities: [User],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

A The 'entities' array must contain strings with file paths, not classes.

B The app will fail if the PostgreSQL server is not running or credentials are wrong.

C The app will fail because the 'password' field is missing in the config.

D The 'synchronize' option cannot be true for PostgreSQL databases.

💡 Hint

Check the database server status and credentials correctness.

The configuration is valid syntax-wise. However, if the PostgreSQL server is down or credentials are incorrect, the app will throw a connection error at runtime.

❓ state_output

advanced

What is the value of 'connection.isConnected' after this setup?

Given this NestJS TypeORM setup, what will be the value of connection.isConnected after app initialization?

NestJS

import { Injectable } from '@nestjs/common';
import { DataSource } from 'typeorm';

@Injectable()
export class DatabaseService {
  constructor(private dataSource: DataSource) {}

  async checkConnection() {
    return this.dataSource.isInitialized && this.dataSource.isConnected;
  }
}

// AppModule setup
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { DatabaseService } from './database.service';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: ':memory:',
      entities: [],
      synchronize: true,
    }),
  ],
  providers: [DatabaseService],
})
export class AppModule {}

A true

B false

C undefined

D throws an error

💡 Hint

Consider what happens when TypeORM finishes initialization successfully.

When TypeORM finishes initializing the DataSource, isInitialized and isConnected are both true. Since the app uses an in-memory SQLite with synchronize, connection is established immediately.

🧠 Conceptual

expert

Which statement about TypeORM module setup in NestJS is correct?

Select the one correct statement about configuring TypeORM in a NestJS application.

A The synchronize option should always be set to false in development to avoid data loss.

B TypeOrmModule.forFeature() is used to configure global database connection options.

C Entities must be registered only in forFeature(), not in forRoot().

D TypeOrmModule.forRoot() must be called only once in the root module to establish a single database connection.

💡 Hint

Think about the purpose of forRoot() vs forFeature() methods.

forRoot() sets up the main database connection and should be called once. forFeature() registers entities for injection in feature modules. Synchronize can be true in development but should be false in production.