luvies / deno_di Goto Github PK

const token ExampleToken = new Token<IExample>("example") // Internally just has a Symbol("example")

interface IExample {
  run(): void;
}

@Service()
class A implements Iexample {
  public run(): void {
    console.log("A");
  }
}

// Service collection setup.
const serviceCollection = new ServiceCollection();
serviceCollection.addTransient(ExampleToken, A); // IExample is inferred as T from Token<T>

const services = serviceCollection.get(ExampleToken); // sevices is inferred as IExample

import "https://cdn.pika.dev/@abraham/reflection@^0.7.0";

import { Inject, Service, ServiceCollection } from "https://deno.land/x/[email protected]/mod.ts";

@Service()
class A {}

// Constructor injection
@Service()
class B {
  constructor(public a: A) {}
}

// Property injection.
@Service()
class C {
  @Inject(A)
  a!: A;
}

// Service collection setup.
const serviceCollection = new ServiceCollection();
serviceCollection.addTransient(A);
serviceCollection.addTransient(B);
serviceCollection.addTransient(C);

const b = serviceCollection.get(B);
console.log(b instanceof B);  // true
console.log(b.a instanceof A);  // true

const c = serviceCollection.get(C);
console.log(c instanceof C);  // true
console.log(c.a instanceof A);  // true with deno run, false in bundle

import "https://cdn.skypack.dev/@abraham/[email protected]";
import { assert } from "https://deno.land/[email protected]/testing/asserts.ts";
import { Service, ServiceCollection } from "https://deno.land/x/di/mod.ts";

abstract class IA {
    abstract foo(): string;
}

abstract class IB {
    abstract IndirectFoo(): string;
    abstract bar(): string;
}

@Service()
class A implements IA {
    public foo(): string {
        return "foo";
    }
}

@Service()
class B implements IB {
    constructor(
        private a: IA
    ) {}

    public IndirectFoo(): string {
        return this.a.foo();
    }

    public bar(): string {
        return "bar";
    }
}

const serviceCollection = new ServiceCollection();
serviceCollection.addTransient(IA, A);
serviceCollection.addTransient(IB, B);

const ib = serviceCollection.get(IB);

Deno.test("Is expected type", () => {
    assert(ib instanceof B);
});

Deno.test("Expects 'bar'", () => {
    assert(ib.bar() == "bar");
});

Deno.test("Expects 'foo'", () => {
    assert(ib.IndirectFoo() == "foo");
});

const types = {
  IA: Symbol("IA")
};

// Interfaces
interface IA {
  foo(): void;
}

// Implementations
@Service()
class A implements IA {
  public foo(): void {
    console.log("A");
  }
}

@Service()
class B implements IA {
  public foo(): void {
    console.log("B");
  }
}

// Service collection setup.
const serviceCollection = new ServiceCollection();
serviceCollection.pushTransient<IA>(types.IA, A);
serviceCollection.pushTransient<IA>(types.IA, B);

const services = serviceCollection.getMany(types.IA);