Getting started

This chapter builds a single Services layer end to end. Four steps: define the layer, write factories, assemble, start.

1. Define the layer

// layers.ts
import { type FromLayer, type Layer, makeLayer } from '@atom-forge/laminar';
import type { Config } from './config';
import type { Services } from './services';

// Layer<CreatorArgs, SelfType, FactoryArgs>
type ServicesLayer = Layer<[Config], Services, [Config, Services]>;

export const servicesLayer: ServicesLayer = makeLayer<FromLayer<ServicesLayer>>(
  ([config], self) => [config, self],
);

export const [defineService, serviceCreatorFactory] = servicesLayer;

The resolver ([config], self) => [config, self] says: every factory in this layer receives the config and the container being built.

2. Write a factory

// services/my-service.ts
import { defineService } from '../layers';

export const myService = defineService((config, services) => {
  return {
    doSomething: () => console.log(config.someValue),
  };
});

defineService only fixes the factory's parameter types; it returns the function unchanged.

3. Assemble the container

// services/index.ts
import { type Unit } from '@atom-forge/laminar';
import { serviceCreatorFactory } from '../layers';
import { myService } from './my-service';
import { otherService } from './other-service';

export type Services = {
  myService: Unit<typeof myService>;
  otherService: Unit<typeof otherService>;
};

export const createServices = serviceCreatorFactory({ myService, otherService });

4. Start the application

// main.ts
import { init } from '@atom-forge/laminar';
import { createServices } from './services';
import { config } from './config';

const services = createServices(config); // synchronous
await init(services);                    // asynchronous hooks
services.myService.doSomething();