Generate Lumberjack log driver with no custom options.

my-log-driver\my-log-driver-config.token.ts

import { inject, InjectionToken } from '@angular/core';

import { LumberjackLogDriverConfig, lumberjackLogDriverConfigToken } from '@ngworker/lumberjack';

export const myLogDriverConfigToken = new InjectionToken<LumberjackLogDriverConfig>('__MY_LOG_DRIVER_CONFIG__', {
  factory: () => inject(lumberjackLogDriverConfigToken),
});

my-log-driver\my-log-driver-root.module.spec.ts

import { MyLogDriverRootModule } from './my-log-driver-root.module';

const optionalAngularDependency = null;

describe(MyLogDriverRootModule.name, () => {
  it('guards against being registered in multiple injectors', () => {
    const rootInjectorInstance = new MyLogDriverRootModule(optionalAngularDependency as any);

    expect(() => new MyLogDriverRootModule(rootInjectorInstance)).toThrowError(/multiple injectors/);
  });

  it('does not guard the first injector that registers it', () => {
    expect(() => new MyLogDriverRootModule(optionalAngularDependency as any)).not.toThrow();
  });
});

my-log-driver\my-log-driver-root.module.ts

import { NgModule, Optional, SkipSelf } from '@angular/core';

import { lumberjackLogDriverToken } from '@ngworker/lumberjack';

import { MyLogDriver } from './my-log-driver.service';

@NgModule({
  providers: [
    {
      provide: lumberjackLogDriverToken,
      useClass: MyLogDriver,
      multi: true,
    },
  ],
})
export class MyLogDriverRootModule {
  constructor(@Optional() @SkipSelf() maybeNgModuleFromParentInjector?: MyLogDriverRootModule) {
    if (maybeNgModuleFromParentInjector) {
      throw new Error(
        'MyLogDriverModule.forRoot registered in multiple injectors. Only call it from your root injector such as in AppModule.'
      );
    }
  }
}

my-log-driver\my-log-driver.module.spec.ts

import { TestBed } from '@angular/core/testing';

import { MyLogDriverModule } from './my-log-driver.module';

describe(MyLogDriverModule.name, () => {
  it('is guarded against direct import', () => {
    TestBed.configureTestingModule({
      imports: [MyLogDriverModule],
    });

    expect(() => TestBed.inject(MyLogDriverModule))
      .withContext(`${MyLogDriverModule.name} must guard against direct import`)
      .toThrow();
  });
});

my-log-driver\my-log-driver.module.ts

import { ModuleWithProviders, NgModule } from '@angular/core';

import { LumberjackLogDriverConfig } from '@ngworker/lumberjack';

import { myLogDriverConfigToken } from './my-log-driver-config.token';
import { MyLogDriverRootModule } from './my-log-driver-root.module';

/**
 * Service module for `MyLogDriver`.
 *
 * Use `MyLogDriverModule.forRoot` to import.
 */
@NgModule()
export class MyLogDriverModule {
  static forRoot(config?: LumberjackLogDriverConfig): ModuleWithProviders<MyLogDriverRootModule> {
    return {
      ngModule: MyLogDriverRootModule,
      providers: (config && [{ provide: myLogDriverConfigToken, useValue: config }]) || [],
    };
  }

  constructor() {
    throw new Error('Do not import MyLogDriverModule directly. Use MyLogDriverModule.forRoot.');
  }
}

my-log-driver\my-log-driver.service.ts

import { Inject, Injectable } from '@angular/core';

import { LumberjackLog, LumberjackLogDriver, LumberjackLogDriverConfig } from '@ngworker/lumberjack';

import { myLogDriverConfigToken } from './my-log-driver-config.token';

/**
 * My log driver.
 */
@Injectable()
export class MyLogDriver implements LumberjackLogDriver<TLog extends LumberjackLog = LumberjackLog> {
  constructor(@Inject(myLogDriverConfigToken) public config: LumberjackLogDriverConfig) {}

  logCritical(logDriverLog: LumberjackLogDriverLog<TLog>): void {}

  logDebug(logDriverLog: LumberjackLogDriverLog<TLog>): void {}

  logError(logDriverLog: LumberjackLogDriverLog<TLog>): void {}

  logInfo(logDriverLog: LumberjackLogDriverLog<TLog>): void {}

  logTrace(logDriverLog: LumberjackLogDriverLog<TLog>): void {}

  logWarning(logDriverLog: LumberjackLogDriverLog<TLog>): void {}
}