Tsyringe optional dependencies (support transformer)

inject-optional.ts

import {
  type DependencyContainer,
  type InjectionToken,
  container,
  inject,
  injectable,
  injectWithTransform,
} from "tsyringe";
import type Transform from "tsyringe/dist/typings/types/transform";

container.register("TransientContainer", {useFactory: c => c});

@injectable()
class Optional {
  constructor(
    @inject("TransientContainer")
    private readonly container: DependencyContainer,
  ) {}

  getOptionalValue(token: InjectionToken): unknown {
    try {
      return this.container.resolve(token);
    } catch (e) {
      return null;
    }
  }
}

class OptionalTransformer implements Transform<Optional, unknown> {
  public transform(optional: Optional, token: InjectionToken): unknown {
    return optional.getOptionalValue(token);
  }
}

@injectable()
class OptionalTransformerWithTransformer<Tin, Tout>
  implements Transform<Optional, Tout | null>
{
  constructor(
    @inject("TransientContainer")
    private readonly container: DependencyContainer,
  ) {}

  public transform(
    optional: Optional,
    token: InjectionToken,
    transformer: InjectionToken<Transform<Tin, Tout>>,
    ...args: any[]
  ): Tout | null {
    const value = optional.getOptionalValue(token) as Tin | null;
    if (value === null) {
      return null;
    }

    return this.container.resolve(transformer).transform(value, ...args);
  }
}

export function injectOptional(token: InjectionToken) {
  return injectWithTransform(Optional, OptionalTransformer, token);
}

export function injectOptionalWithTransform<Tin, Tout>(
  token: InjectionToken,
  transformer: InjectionToken<Transform<Tin, Tout>>,
  ...args: any[]
) {
  return injectWithTransform(
    Optional,
    OptionalTransformWithTransformerer,
    token,
    transformer,
    ...args,
  );
}