DEV Community: Artem Korniev

Clawject: Dependency Injection with Beans

Artem Korniev — Mon, 21 Oct 2024 18:38:57 +0000

Cover photo by Jay Mantri on Unsplash

Outline

Greetings everyone! I am the creator of Clawject, dependency injection (DI) framework for TypeScript. If you've ever worked with complex applications written in OOP style, you know how hard it is to manage constructor dependencies across classes. Today, I want to share with you how Clawject solves complexities of dependency injection pattern.

Visit clawject.com to find docs.

What Is a Bean?

In Clawject, a Bean is an object that is managed and created by the Clawject container but defined by you. It can have its own dependencies and simultaneously be a dependency for other Beans. Think of it like gears in a machine working together to ensure the smooth operation of the entire application. Beans give you flexibility to assemble classes with just a few lines of code and guarantee type safety.

Clawject container

Defining a DI container with Clawject is really simple, you just need to add the @ClawjectApplication decorator on top of any class, and it will automatically become a DI container.

Read more about IoC container here

`@Bean` — Your Best Friend

With the @Bean decorator, you can turn any property, getter, or method into a Bean.

Try this example on StackBlitz.

interface Foo {
  name: string;
}

class FooImpl implements Foo {
  name = 'foo implementation name';
}

class Bar {
  constructor(foo: Foo) {
    console.log('Bar is created, fooName: ', foo.name);
  }

  /*...*/
}

@ClawjectApplication
class Application {
  @Bean
  foo = () => new FooImpl();

  @Bean
  bar = (foo: Foo) => new Bar(foo);
}

In this example, we declared a factory-method Bean foo that returns a new instance of the FooImpl class, and a Bean bar that depends on foo and console.logs its name. By declaring foo: Foo as a parameter of factory-function, we're telling the container that bar needs instance of a foo interface to be injected.
Clawject will take advantage of typescript's type system, will qualify that class FooImpl is an implementation of the Foo interface, and will inject instance into the bar bean as a parameter.

Tired of Extra Code? Use the `Bean` Function

If you have a lot of classes with multiple dependencies, listing them all can be tedious, especially when it comes to adding new constructor parameters, reordering, or removing them. The Bean function comes to the rescue by automatically creating an instance of the class with all the necessary dependencies. You can use @Bean decorator and Bean function together.

Try this example on StackBlitz.

interface Foo {}
interface Bar {}
interface Baz {}

class BarImpl implements Bar {/*...*/}
class BazImpl implements Baz {/*...*/}
class FooImpl implements Foo {
  constructor(
    dependency0: string,
    dependency1: number,
    dependency2: Bar,
    dependency3: Baz
  ) {}
  /*...*/
}

@ClawjectApplication
class Application {
  foo = Bean(FooImpl);

  @Bean
  stringBean = 'dependency0';
  @Bean
  numberBean = 1;
  barBean = Bean(BarImpl);
  bazBean = Bean(BazImpl);
}

Bean Types — Freedom of Choice

Clawject allows you to specify Beans with almost any type. You can explicitly specify the type or let TypeScript infer it for you. The main thing is to avoid some restricted types like undefined, null, or never.

Generic types

Generic types are a really powerful language feature that unleashes flexibility and reusability of code, but in traditional DI frameworks it's really painful to work with generics in types/interfaces/classes, because they require you to provide an injection token to use them; otherwise, the JS runtime will not know what to inject. Using injection tokens is not only tedious but also dangerous, the injection tokens could be mixed up, leading to the wrong object being injected. It's a nightmare.

Clawject, on the contrary, takes full advantage of typescripts powerful type system and allows you to harness their power without fear.

Let's take a look at how we can utilize generics with the typeorm package.

import { DataSource, Entity, Repository } from 'typeorm';

@Entity()
class User {/*...*/}
@Entity()
class Post {/*...*/}

class Service<T> {
  constructor(repository: Repository<T>) {}
}

@ClawjectApplication
class Application {
  @Bean dataSource = new DataSource(/*...*/).initialize();
  @Bean usersRepository = (ds: DataSource) => ds.getRepository(User);
  @Bean postsRepository = (ds: DataSource) => ds.getRepository(Post);

  userService = Bean(Service<User>);
  postService = Bean(Service<Post>);
}

We've defined dataSource alongside with usersRepository and postsRepository beans, then we've registered Service<User> and Service<Post> as a beans. Clawject will resolve all constructor parameter types together with generics and will inject them without any additional effort from your side!
Also, since Clawject utilises typescript's type system, you can use any third-party libraries to define your beans, all types will be resolved by Clawject.

Implementation and Inheritance types

TypeScript classes and interfaces have awesome features like inheritance and implementation:

Try this example on StackBlitz.

interface Foo {
  foo: string;
}

interface Bar extends Foo {
  bar: string;
}

class FooBarImpl implements Bar {
  foo = 'fooValue';
  bar = 'BarValue';
}

class Baz extends FooBarImpl { /*...*/ }

class Fizz {
  constructor(
    foo: Foo,
    bar: Bar,
    fooBarImpl: FooBarImpl,
    baz: Baz
  ) { /*...*/ }
}

@ClawjectApplication
class Application {
  fooBarBaz = Bean(Baz);
  fizz = Bean(Fizz);
}

Clawject will qualify that Baz class extends FooBarImpl which is implements Bar which is extends Foo, so the same instance will be injected in fizz bean. It works great with generics as well.

Async Beans - Flexible way of configuring beans

Sometimes you need to fetch data and use it as a dependency in your constructor. It may be a secret or just a config value. In Clawject, you can easily create asynchronous Beans by simply assigning Promise to a Bean.

Try this example on StackBlitz.

interface Config {
  bar: string;
  baz: string;
}

class Foo {
  constructor(config: Config) { /*...*/ }
}

@ClawjectApplication
class Application {
  @Bean async config(): Promise<Config> { /*...*/ }

  foo = Bean(Foo);
}

Clawject will wait for asynchronous beans and only then create dependent beans.

Note that in class Foo you're just defining dependency type as Config and not Promise<Config>.

Conclusion

Clawject and its DI system are designed to make your life as a developer simpler and more enjoyable. Clawject strives to provide tools that not only speed up the development process but also make your code more reliable and resilient to changes.

Try Clawject in action and see for yourself how powerful and flexible this dependency management tool is for TypeScript.

Happy coding!

Clawject: Simplifying Dependency Injection in TypeScript

Artem Korniev — Sat, 06 Apr 2024 14:01:18 +0000

Outline

Greetings, I'm the creator of Clawject, a dependency injection framework for TypeScript. I'm here to introduce you to the world of effortless and type-safe dependency injection.

Have you ever thought that dependency injection in TypeScript could be easier?

Meet Clawject, the first truly type-safe dependency injection framework for TypeScript.

Visit clawject.com for more detailed API end examples.

You diligently write types, interfaces, generics, and all of that to ensure type safety, but it all comes to an end if you mix up an injection token.

@Injectable()
class CatsService {
  constructor(
    @Inject(InjectionTokens.DogsRepository)
    private catsRepository: Repository<Cat>
  ) {}
}

TypeScript will compile this code without any errors, it will execute, and you'll only find out at runtime that instead of cats, you're getting dogs. Dogs are also great, but in this case, we specifically need cats.

Now, let's define CatsService with Clawject.

class CatsService {
  constructor(
    private catsRepository: Repository<Cat>
  ) {}
}

As you can see, Clawject doesn't require you to attach the @Injectable decorator to the class or specify what exactly you want to inject. Instead, Clawject will take the type of your dependency and find the appropriate implementation at compile time.

If we wanted to avoid attaching the @Injectable decorator to the class without Clawject, you would use something like a Factory providers, but this is quite inconvenient. It requires changes if the class constructor changes and still leaves room for error by mixing up injection tokens. Besides, it's just not elegant.

const InjectionTokens = {
  DogsRepository: Symbol('dogsRepository'),
  CatsRepository: Symbol('catsRepository')
}

class CatsService {
  constructor(
    private catsRepository: Repository<Cat>
  ) {}
}

@Module({
  providers: [
    {
      provide: InjectionTokens.DogsRepository,
      useClass: Repository
    },
    {
      provide: InjectionTokens.CatsRepository,
      useClass: Repository
    },
    {
      provide: CatsService,
      useFactory: (catsRepository: Repository<Cat>) =>
        new CatsService(catsRepository),
              /*Oops, wrong injection token...*/
      inject: [InjectionTokens.DogsRepository]
    }
  ],
})
export class Application {}

Now, let's take a look at how you can create a CatsService with Clawject.

class CatsService {
  constructor(
    private catsRepository: Repository<Cat>
  ) {}
}

@ClawjectApplication
class Application {
  dogsRepository = Bean(Repository<Dog>);
  catsRepository = Bean(Repository<Cat>);

  catsService = Bean(CatsService);
}

And that's it! ✨

Clawject will resolve all dependencies based on types and notify you of errors such as missing dependencies, circular dependencies, and more, at compile time and directly in your favorite IDE!

Unleash the power of polymorphism with Clawject

Clawject works great with classes, interfaces, types, generics, and type inheritance, allowing you to describe dependencies very flexibly and simply.

Let's declare an interface ReadOnlyRepository<T>, interface Repository<T>, and a class HttpRepository<T> that implements both of these interfaces:

interface ReadOnlyRepository<T> { /*...*/ }

interface Repository<T> extends ReadOnlyRepository<T> { /*...*/ }

class HttpRepository<T> implements Repository<T> { /*...*/ }

We've created a polymorphic class and interfaces that allow reading and writing entities with the type <T>.

Now, let's declare the following services: ReadCatsService and WriteCatsService.

class ReadCatsService {
  constructor(
    private repository: ReadOnlyRepository<Cat>
  ) {}
}

class WriteCatsService {
  constructor(
    private repository: Repository<Cat>
  ) {}
}

As you can see, we simply state that we need dependencies of types ReadOnlyRepository<Cat> and Repository<Cat>, and we don't care about the specific implementation that will be injected.

Now, let's declare the Application class and our Beans.

@ClawjectApplication
class Application {
  httpCatsRepository = Bean(HttpRepository<Cat>);

  readCatsService = Bean(ReadCatsService);
  writeCatsService = Bean(WriteCatsService);
}

As you can see, Clawject understands that the class HttpRepository<Cat> implements the interfaces ReadOnlyRepository<Cat> and Repository<Cat>, and will inject the httpCatsRepository bean instance as a dependency in both services.

If we were to do something similar with a more classical library, we would have to write a lot of boilerplate and non-type-safe code.

const InjectionTokens = {
  ReadOnlyCatsRepository: Symbol('ReadOnlyCatsRepository'),
  CatsRepository: Symbol('CatsRepository'),
  HttpCatsRepository: Symbol('HttpCatsRepository'),
}

@Injectable()
class ReadCatsService {
  constructor(
      @Inject(InjectionTokens.ReadOnlyCatsRepository)
      private repository: ReadOnlyRepository<Cat>
  ) {}
}

@Injectable()
class WriteCatsService {
  constructor(
      @Inject(InjectionTokens.CatsRepository)
      private repository: Repository<Cat>
  ) {}
}

@Module({
  providers: [
    {
      useClass: HttpRepository,
      provide: InjectionTokens.HttpCatsRepository,
    },
    {
      provide: InjectionTokens.ReadOnlyCatsRepository,
      useExisting: InjectionTokens.HttpCatsRepository,
    },
    {
      provide: InjectionTokens.CatsRepository,
      useExisting: InjectionTokens.HttpCatsRepository,
    },
    ReadCatsService,
    WriteCatsService,
  ],
})
class Application {}

Clean domain objects

The philosophy of Clawject revolves around the idea that dependency injection should be an external architectural layer, while all domain objects should describe their dependencies without any framework references.

Clawject allows you to extract absolutely all DI-related things from your classes, simplifying your code and reducing the probability of mistakes. Because Clawject is a very external component, you can work with any classes from external libraries just as easily as with your own.

Let's imagine we have an npm package called data-access.

/* node_modules/data-access/repositories.d.ts */

export interface Repository<T> { /*...*/ }
export declare class HttpRepository<T> implements Repository<T> {
  private readonly baseUrl;
  constructor(baseUrl: string);
}

Now, let's declare the CatsService that uses the repository from data-access package.

/* src/cat/CatsService.ts */

import { Repository } from 'data-access';
import { Cat } from './models/Cat';

class CatsService {
  constructor(
    private repository: Repository<Cat>
  ) {}
}

Now, let's declare beans for our classes.

/* src/Application.ts */

import { HttpRepository } from 'data-access';
import { Cat } from './cat/models/Cat';
import { CatsService } from './cat/CatsService';

@ClawjectApplication
class Application {
  @Bean catsApiBaseUrl = '/api/cat';

  httpCatsRepository = Bean(HttpRepository<Cat>);
  catsService = Bean(CatsService);
}

As you can see, the classes remain clean and literally know nothing about being part of a dependency injection container. Moreover, you don't need to manually write factory functions to keep your classes clean and framework-independent.

Split container by features

Clawject allows you to break down parts of the container into separate classes and even share them via npm packages.

Let's declare the CatsConfiguration class, which will contain beans related only to cats.

@Configuration
export class CatsConfiguration {
  @Bean apiBaseUrl = '/api/cat';

  httpCatsRepository = Bean(HttpRepository<Cat>);
  catsService = Bean(CatsService);
}

Now we can import the configuration classes into our Application class or other configuration classes.

import { CatsConfiguration } from './cat/CatsConfiguration';
import { DogsConfiguration } from './dog/DogsConfiguration';
import { BirdsConfiguration } from './bird/BirdsConfiguration';

@ClawjectApplication
class Application {
  catsConfiguration = Import(CatsConfiguration);
  dogsConfiguration = Import(DogsConfiguration);
  birdsConfiguration = Import(BirdsConfiguration);
}

Clawject will assemble the entire container, instantiate all classes with the necessary dependencies, and inform you in a very developer-friendly manner if anything is missing.

Thanks for reading this article. If you're interested, visit Clawject's website for more examples and learn how to install and use it in your project.

DEV Community: Artem Korniev

Clawject: Dependency Injection with Beans

Outline

What Is a Bean?

Clawject container

@Bean — Your Best Friend

Tired of Extra Code? Use the Bean Function

Bean Types — Freedom of Choice

Generic types

Implementation and Inheritance types

Async Beans - Flexible way of configuring beans

Conclusion

Happy coding!

Clawject: Simplifying Dependency Injection in TypeScript

Outline

Unleash the power of polymorphism with Clawject

Clean domain objects

Split container by features

`@Bean` — Your Best Friend

Tired of Extra Code? Use the `Bean` Function