https://github.com/c4nzin/fastdi
FastDI is a Dependency Injection Library
https://github.com/c4nzin/fastdi
Last synced: 8 months ago
JSON representation
FastDI is a Dependency Injection Library
- Host: GitHub
- URL: https://github.com/c4nzin/fastdi
- Owner: c4nzin
- Created: 2024-09-12T11:29:05.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2024-09-16T11:12:49.000Z (about 1 year ago)
- Last Synced: 2024-09-17T08:33:01.770Z (about 1 year ago)
- Language: TypeScript
- Homepage:
- Size: 204 KB
- Stars: 2
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
## FastDI a Dependency Injection Library
Inspired by Nest.js structure
## Installation
https://www.npmjs.com/package/@canmertinyo/fast-di
```bash
npm i @canmertinyo/fast-di
```
## Features
- **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.
## Examples
```typescript
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());
```
# Lifecycle Management
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
```typescript
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.
# Modular Architecture
You can define and load modules using the @Module decorator. This allows for organizing services and dependencies in a modular way...
```typescript
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:
```typescript
Container.loadModule(ExampleModule);
```
## More Realworld Examples
```typescript
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;
}
}
```
## AuthService example
```typescript
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.
# Contributing
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 :)