vorarbeiter

alt="Vorarbeiter"
src="https://repository-images.githubusercontent.com/914847479/afa74c78-891d-4717-a0ca-9470ee294d63"
/>

A simple service container

$3

``shell
npm install vorarbeiter
`

$3

1. Create some services:
`typescript
interface Car {
getDriverName(): string;
}

class CarImpl implements Car {
constructor(private readonly driver: Driver) {}
getDriverName() {
return this.driver.getName();
}
}

interface Driver {
getName(): string;
}

class DriverImpl implements Driver {
getName() {
return "Michael Schumacher";
}
}
`

2. Explain to _Service Container_ how to create services, use factories for this:
`typescript
class CarFactory implements ServiceFactory {
create(container: ServiceContainer): CarImpl {
const driver = container.get("driver");
return new CarImpl(driver);
}
}
`

3. Create _Service Specification_:

`typescript
import { createServiceSpecBuilder } from "vorarbeiter";

const specBuilder = createServiceSpecBuilder();

specBuilder.set("car", new CarFactory());
specBuilder.set("driver", () => new DriverImpl());

const spec = specBuilder.getServiceSpec();
`
If creating a service is trivial, as for driver, we can simply pass a function as a factory.
As for class based factory we can pass ServiceContainer as a function parameter.

4. Create _Service Container_ with this _Service Specification_:

`typescript
import { createServiceContainer } from "vorarbeiter";

const serviceContainer = createServiceContainer(spec);
`

5. Get some service and call its method:
`typescript
const car: Car = serviceContainer.get("car");

console.log(car.getDriverName());
`

6. Get string "Michael Schumacher".

$3

#### Shared

By default, services have global scope. It means that the same service will be shared across whole application.

Example:
`typescript
let serviceInstance1;
let serviceInstance2;
// In some part of our application we get a service
serviceInstance1 = serviceContainer.get("myService");
// In some another part of our application we get a service again
serviceInstance2 = serviceContainer.get("myService");

console.log(serviceInstance1 === serviceInstance2); // true
`

#### Scoped

Sometimes we need to have service uniqueness within a specific scope, for example, within one user request.
To do that we should specify the _Context Resolver_ when configure _Service Specification_. Resolving result of the _Context Resolver_ should be any object.
To imitate situation when we have two different contexts we can use AsyncLocalStorage from "node:async_hooks" package.

Example:
`typescript
const asyncLocalStorage = new AsyncLocalStorage