DI Framework

import { Injector, Inject, Provide, getInjectAnnotation, getProvideAnnotation } from "di";

const { Injector, InjectAnnotation, ProvideAnnotation, annotate } = require("di");
// Note: InjectAnnotation and ProvideAnnotation are the class constructors
// Inject and Provide are the same classes, available as aliases in ES6 imports
// Helper functions getInjectAnnotation and getProvideAnnotation are not available in Node.js exports

import { Injector, Inject, Provide, annotate, InjectAnnotation } from "di";

// Define dependencies using decorators (ES6)
class Engine {
  start() {
    console.log("Engine started");
  }
}

@Inject(Engine)
class Car {
  constructor(engine) {
    this.engine = engine;
  }

  start() {
    this.engine.start();
    console.log("Car is running");
  }
}

// Create injector and resolve dependencies
const injector = new Injector();
const car = injector.get(Car);
car.start();

// Alternative: programmatic annotations (ES5 compatible)
function MockEngine() {
  this.start = () => console.log("Mock engine started");
}

function MockCar(engine) {
  this.engine = engine;
  this.start = () => {
    this.engine.start();
    console.log("Mock car is running");
  };
}

annotate(MockCar, new InjectAnnotation(MockEngine));
const mockInjector = new Injector([MockEngine, MockCar]);
const mockCar = mockInjector.get(MockCar);
mockCar.start();

class Injector {
  /**
   * Create a new injector instance
   * @param modules - Array of provider functions or module objects
   * @param parentInjector - Optional parent injector for hierarchical injection
   */
  constructor(modules = [], parentInjector = null);

  /**
   * Resolve and return instance for the given token
   * @param token - Token to resolve (string, function, or class)
   * @param resolving - Internal parameter for cycle detection
   * @returns Resolved instance
   * @throws Error if no provider found or cyclic dependency detected
   */
  get(token, resolving = []);

  /**
   * Create a child injector with additional modules
   * @param modules - Array of additional modules for child injector
   * @returns New Injector instance with current injector as parent
   */
  createChild(modules = []);

  /**
   * Return debug information about injector state
   * @returns Object with id, parent_id, and providers information
   * @note Current implementation has a bug - uses Object.keys() on Map which returns empty array
   */
  dump();

  /**
   * Invoke function with dependency injection
   * @param fn - Function to invoke
   * @param context - Execution context
   * @note This method is currently not implemented in the source code
   */
  invoke(fn, context);
}

// Basic injector usage
const injector = new Injector([]);
const instance = injector.get(SomeClass);

// Injector with modules
const injector = new Injector([MockEngine, {Car: MockCar}]);

// Hierarchical injectors
const parent = new Injector([Engine]);
const child = parent.createChild([MockEngine]); // MockEngine overrides Engine

/**
 * Annotation class for specifying dependencies
 */
class InjectAnnotation {
  /**
   * Create inject annotation with dependency tokens
   * @param params - Variable number of dependency tokens
   */
  constructor(...params);
}

/**
 * Annotation class for specifying provider tokens
 */
class ProvideAnnotation {
  /**
   * Create provide annotation with provider token
   * @param id - Token that this provider satisfies
   */
  constructor(id);
}

// Convenient aliases
const Inject = InjectAnnotation;
const Provide = ProvideAnnotation;

// Using decorators (ES6)
@Inject(Engine, Radio)
@Provide('Car')
class Car {
  constructor(engine, radio) {
    this.engine = engine;
    this.radio = radio;
  }
}

// Using programmatic annotations (ES5)
function Car(engine, radio) {
  this.engine = engine;
  this.radio = radio;
}
annotate(Car, new InjectAnnotation(Engine, Radio));
annotate(Car, new ProvideAnnotation('Car'));

/**
 * Add annotation to function or class
 * @param fn - Function or class to annotate
 * @param annotation - Annotation instance to add
 */
function annotate(fn, annotation);

/**
 * Extract provide annotation from a provider function or class
 * @param provider - Function or class to inspect
 * @returns Token that this provider satisfies, or null if none found
 */
function getProvideAnnotation(provider);

/**
 * Extract inject annotation from a provider function or class
 * @param provider - Function or class to inspect
 * @returns Array of dependency tokens, or null if none found
 */
function getInjectAnnotation(provider);

// Programmatic annotation (ES5 compatible)
function Engine() {}
annotate(Engine, new ProvideAnnotation('Engine'));

function Car(engine) {
  this.engine = engine;
}
annotate(Car, new InjectAnnotation('Engine'));

const injector = new Injector([Engine, Car]);
const car = injector.get(Car);

// Using helper functions to inspect annotations
console.log(getProvideAnnotation(Engine)); // 'Engine'
console.log(getInjectAnnotation(Car)); // ['Engine']

// Dynamic provider inspection
function inspectProvider(provider) {
  const provideToken = getProvideAnnotation(provider);
  const dependencies = getInjectAnnotation(provider);
  
  return {
    provides: provideToken,
    requires: dependencies || []
  };
}

console.log(inspectProvider(Engine)); // { provides: 'Engine', requires: [] }
console.log(inspectProvider(Car)); // { provides: null, requires: ['Engine'] }

// Register class directly
const injector = new Injector([Engine, Car]);

// Register with explicit token
@Provide('MockEngine')
class TestEngine {}
const injector = new Injector([TestEngine]);

// Module as object with string keys
const carModule = {
  'Engine': Engine,
  'Car': Car,
  'Radio': Radio
};

const injector = new Injector([carModule]);
const car = injector.get('Car'); // resolves using string token

@Inject(Engine, Radio)
class Car {
  constructor(engine, radio) {
    // dependencies injected in order
  }
}

class Car {
  constructor(engine: Engine, radio: Radio) {
    // types used for dependency resolution
  }
}

class Car {
  constructor(
    engine: Engine,
    @Inject(MockRadio) radio
  ) {
    // Mixed type annotations and explicit injection
  }
}

function Car(engine, radio) {
  this.engine = engine;
  this.radio = radio;
}
annotate(Car, new InjectAnnotation(Engine, Radio));

const injector = new Injector([]);
try {
  injector.get('NonExistentService');
} catch (error) {
  // Error: "No provider for NonExistentService!"
}

@Inject('Car')
class Engine {
  constructor(car) {}
}

@Inject(Engine)
class Car {
  constructor(engine) {}
}

const injector = new Injector([Engine, Car]);
try {
  injector.get(Car);
} catch (error) {
  // Error: "Cannot instantiate cyclic dependency! (Car -> Engine -> Car)"
}

// When dependency chain fails deep in the hierarchy
try {
  injector.get('House');
} catch (error) {
  // Error: "No provider for Sink! (House -> Kitchen -> Sink)"
}

// Parent injector with base providers
const parent = new Injector([RealEngine, RealRadio]);

// Child injector with test overrides
const child = parent.createChild([MockEngine]);

// Child gets MockEngine, but inherits RealRadio from parent
const testCar = child.get(Car);

const parent = new Injector([SharedService]);
const child = parent.createChild([]);

// Same instance returned from both injectors
const service1 = parent.get(SharedService);
const service2 = child.get(SharedService);
console.log(service1 === service2); // true

/**
 * Annotation instance containing dependency tokens
 */
interface InjectAnnotation {
  params: any[];
}

/**
 * Annotation instance containing provider token
 */
interface ProvideAnnotation {
  id: any;
}

/**
 * Debug information from injector dump
 */
interface InjectorDump {
  id: number;
  parent_id: number | null;
  providers: {
    [token: string]: {
      name: string;
      dependencies: any[];
    };
  };
}

<script src="traceur-runtime.js"></script>
<script src="di.js"></script>

node --harmony_collections your-app.js