import { createLilith, singleton, service, inject } from '@noelware/lilith';

const container = createLilith({
  singletons: [
    // Defines a path to load singletons from
    { path: './path/to/singletons' },
    singleton<Logger>({
      provide() { return Logger.create(); }
      onLoad(logger /*: Logger */) { /* ran once singleton is loaded into the container */ },
      onDestroy(logger /*: Logger */) { /* destroy singleton */ }
    })
  ],

  services: [
    // Defines a path to load services from
    { path: './path/to/services' },
    service({
      name: 'myservice',
      children: [/* list of children that this service has control over */],
      onLoad() { /* called for loading the service (i.e, start http server/load config) */ },
      onDestroy() { /* called for destroying the service (i.e, stopping http service) */ },
      onChildLoad(child /*: any */) { /* called for loading children into the service scope */ },
      onChildDestroy(child /*: any */) { /* called for destroying children into the service scope */ },
    })
  ]
});

const logger = inject('logger');
// => Logger

const service = inject('myservice');
// => Service

import { Service, Inject, createLilith } from '@noelware/lilith';

@Service({ name: 'a name' })
class MyService {
  @Inject
  private readonly other!: OtherService;

  onLoad() {
    console.log('I have loaded!');
  }
}

@Service({ name: 'another name', priority: 10 })
class OtherService {
  private readonly lucky: number = 42;

  get luckyNumber() {
    return this.lucky;
  }
}

const container = createLilith({
  services: [MyService, OtherService]
});

container.start();

import { Service, Inject, createLilith } from '@noelware/lilith';
import { LogService, type Logger } from '@noelware/lilith-logging';
import { WinstonBackend } from '@noelware/lilith-logging-winston';
import winston from 'winston';

@Service({ name: 'my service name' })
class MyService {
  @Inject
  private readonly logging!: LogService<WinstonBackend>;
  private readonly logger!: Logger;

  onLoad() {
    this.logger = this.logging.loggerFactory.get('my', 'service', 'info');
    this.logger.info('I am loading stuff!');
  }
}

const container = createLilith({
  services: [
    new LogService({
      defaultLevel: 'debug',
      backend: new WinstonBackend({
        transports: [new winston.transports.Console()]
      })
    }),
    MyService
  ]
});

container.start();

import { Service, Inject, createLilith } from '@noelware/lilith';
import { ConfigService, YamlLoader } from '@noelware/lilith-config';
import z from 'zod';

export interface Config {
  lol: boolean;
}

@Service({ name: 'my service' })
class MyService {
  @Inject
  private readonly config!: ConfigService<Config>;

  onLoad() {
    const shouldLol = this.config.get('lol');
    if (shouldLol) {
      console.log('lol!!!!');
    }
  }
}

const container = createLilith({
  services: [
    new ConfigService<Config>({
      schema: z
        .object({
          lol: z.boolean()
        })
        .strict(),

      loader: new YamlLoader()
    }),
    MyService
  ]
});

container.start();
const service = container.inject(MyService);