Inspired by Nest.js structure

https://www.npmjs.com/package/@canmertinyo/fast-di

npm i @canmertinyo/fast-di

• Decorator-Based Injection: Use @Injectable to make classes injectable.
• Lifecycle Management: Manage service lifecycles as singleton or transient.
• Modular Architecture: Define and load modules dynamically.
• Dynamic Module Loading: Load modules on demand.

Container and Injectable The Container class is the core of this library, managing instances and dependencies of injectable classes. With @Injectable decorator marks a class as injectable.

import {Container, Injectable} from "@canmertinyo/fast-di";

@Injectable()
class ExampleService {
  public getMessage():string {
    return "Hello from ExampleService!";
  }
}

const exampleService = Container.get(ExampleService);
console.log(exampleService.getMessage());

You can specify the lifecycle of your services using the @Injectable decorator:

Singleton: A single instance is created and shared throughout the application.
Transient: A new instance is created every time

import {Lifecycle, Injectable} from "@canmertinyo/fast-di";


@Injectable({ lifecycle: Lifecycle.Transient })
class TransientService {
  public log(message: string):string {
    console.log(`[TransientService] ${message}`);
  }
}

In this example, TransientService is marked with a transient lifecycle, meaning a new instance will be created each time when it is requested.

You can define and load modules using the @Module decorator. This allows for organizing services and dependencies in a modular way...

import { Module} from "@canmertinyo/fast-di";
import { ExampleService } from "./services/example.service";

@Module({
  providers: [ExampleService]
})
class ExampleModule {}

Note : We have only the providers at this moment more coming in the way in advance.

Modules are loaded into the container as globally:

Container.loadModule(ExampleModule);

import { Injectable} from "@canmertinyo/fast-di";
import { DatabaseService } from "./services/database.service";
import { LoggerService } from "./services/logger.service";

@Injectable()
class UserService {
  constructor(
    private databaseService: DatabaseService,
    private loggerService: LoggerService
  ) {}

  public getUser(userName:string):string {
    this.loggerService.log("Fetching user...");
    return this.databaseService.query() + " User: " + userName;
  }
}

import {Injectable} from "@canmertinyo/fast-di";

@Injectable()
class AuthService {
  public authenticate():string {
    return "Authenticated!";
  }
}

import { Module } from "./decorators/module";

@Module({
  providers: [AuthService]
})
class AuthModule {}

Container.loadModule(AuthModule);
const authService = Container.get(AuthService);
console.log(authService.authenticate());

Project Architecture The project is structured as follows:

decorators: Contains decorators like @Injectable and @Module.
constants: Defines constants like Lifecycle.
container: Manages dependency injection and lifecycle management.
services: Contains example services and their implementations.
modules: Defines application modules and their configurations.

The project only for testing&improving myself so i appreciate it. issues or pull request are not going to accept by myside, Thank you for reading :)