Dependency injection framework in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does constructor injection behave in this example?

Consider a class Service that depends on Repository. The dependency is injected via the constructor. What will be the output when calling service.getData()?

LLD

class Repository {
  getData() {
    return 'data from repo';
  }
}

class Service {
  constructor(repo) {
    this.repo = repo;
  }
  getData() {
    return this.repo.getData();
  }
}

const repo = new Repository();
const service = new Service(repo);
console.log(service.getData());

A TypeError: this.repo.getData is not a function

B "undefined"

C "data from repo"

D "null"

💡 Hint

Think about how the Service class uses the injected Repository instance.

The Service class receives a Repository instance via its constructor and calls its getData() method. Since repo is a valid instance, the output is "data from repo".

🧠 Conceptual

intermediate

Which option correctly registers a singleton in a dependency injection container?

Given a simple dependency injection container, which option correctly registers a singleton instance of Logger so that all requests get the same instance?

LLD

class Logger {}

class Container {
  constructor() {
    this.services = new Map();
  }
  registerSingleton(name, factory) {
    const instance = factory();
    this.services.set(name, () => instance);
  }
  resolve(name) {
    return this.services.get(name)();
  }
}

const container = new Container();

A container.registerSingleton('logger', new Logger());

B container.registerSingleton('logger', Logger);

C container.registerSingleton('logger', () => Logger);

D container.registerSingleton('logger', () => new Logger());

💡 Hint

The registerSingleton method expects a factory function that returns an instance.

Option D passes a function that creates a new Logger instance. The container calls it once and stores the instance. Other options either pass the class itself, a function returning the class, or an instance directly, which do not match the expected factory function pattern.

🔍 Analysis

advanced

Why does this circular dependency cause a runtime error?

Two classes A and B depend on each other via constructor injection. What error will occur when trying to instantiate A through the container?

LLD

class A {
  constructor(b) {
    this.b = b;
  }
}

class B {
  constructor(a) {
    this.a = a;
  }
}

class Container {
  constructor() {
    this.services = new Map();
  }
  register(name, factory) {
    this.services.set(name, factory);
  }
  resolve(name) {
    const factory = this.services.get(name);
    return factory(this.resolve(name === 'A' ? 'B' : 'A'));
  }
}

const container = new Container();
container.register('A', (b) => new A(b));
container.register('B', (a) => new B(a));
container.resolve('A');

A RangeError: Maximum call stack size exceeded

B ReferenceError: b is not defined

C TypeError: factory is not a function

D No error, returns instance of A

💡 Hint

Think about what happens when resolve calls itself recursively without a stop condition.

The resolve method calls itself infinitely because A depends on B and B depends on A. This causes a stack overflow error.

❓ state_output

advanced

What is the state of the container after registering and resolving a transient service?

Given a container that registers transient services (new instance every resolve), what will be the output of comparing two resolved instances?

LLD

class Service {}

class Container {
  constructor() {
    this.factories = new Map();
  }
  registerTransient(name, factory) {
    this.factories.set(name, factory);
  }
  resolve(name) {
    return this.factories.get(name)();
  }
}

const container = new Container();
container.registerTransient('service', () => new Service());
const s1 = container.resolve('service');
const s2 = container.resolve('service');
console.log(s1 === s2);

A undefined

B false

C true

D TypeError

💡 Hint

Transient services create a new instance each time they are resolved.

Since registerTransient creates a new instance on each resolve, s1 and s2 are different objects, so the comparison is false.

🧠 Conceptual

expert

Which option best describes the benefit of using dependency injection frameworks?

Why do developers use dependency injection frameworks in large applications?

A They allow components to be loosely coupled by managing dependencies externally, improving testability and flexibility.

B They replace the need for any manual object creation or configuration.

C They enforce strict type checking at runtime to prevent errors.

D They automatically optimize application performance by caching all objects globally.

💡 Hint

Think about how dependencies are managed and how that affects code structure and testing.

Dependency injection frameworks help by managing dependencies outside components, making code easier to test and change. They do not automatically optimize performance, enforce runtime type checks, or eliminate all manual configuration.