elisvathi / typescript-injector-factory Goto Github PK

import { createInjectorFactory } from "./injectors/injectorFactory";

type Context = Record<string, unknown>; // The context can be any type
const factory = createInjectorFactory<Context>();

const ExtractValue = factory.createInjector(
	/*
	 * The extra parameters after the payload argument can be custom and the resulting
	 * curried decorator will require them
	 */
	(payload, key: string, options: { required: boolean }) => {
		const context: Context = payload.context;
		const value = context[key];
		if (!value && options.required) {
			throw new Error(`${key} is required!`);
		}
		return value;
	}
);


// This produces a decorator generator in the form:
@ExtractValue(key: string, options: {required: boolean})

const AccountValue = factory.createInjector((payload) => {
	const context: Context = payload.context.account;
});
class SampleClass {
	@AccountValue()
	private account: number;

	public constructor(
		@ExtractValue("name", { required: true }) private name: string,
		@ExtractValue("lastName", { required: true }) private lastName: string
	) {
			console.log(`First name: ${this.name} - Last name: ${this.lastName}`):
	}

	public someMethod(@ExtractValue("age", { required: false }) age: number) {
		console.log(`Age is ${age}`);
	}

	public logAccount() {
		console.log(`Account value is ${this.account}`);
	}
}

const concreteContext : Context = { name: "John", lastName: "Doe", age: 23, ... };
const someOtherContext: Context = { account: 100 };

// Construction
const instance: SampleClass = factory.with(concreteContext).construct(SampleClass);
// First name: John - Last name: Doe

// Method execution
factory.with(concreteContext).call(instance, "someMethod");
// Age is 23

// Method execution with another context
factory.with(someOtherContext).call(new SampleClass("John", "Doe"), "logAcount");
// Account value is 100

const factory = createInjectorFactory<Context>((payload) => undefined);

import { createInjectorFactory } from "./injectors/injectorFactory";
type Context = Record<string, unknown>; // The context can be any type
const factory = createInjectorFactory<Context>();

const CurrentUser = factory.createInjector(async ({context})=>{
	await fetchUserFromSource(...)
});

const DbConnection = factory.createInjector(async ({context})=>{
	await connectToDabase(...);
});

class Service {
	public constructor(@DbConnection() private dbConnection: Connection) {
	}

	public getProfile(@CurrentUser() user: User) {
		return user;
	}
}

async function main() {
	const service = factory.construct()
	const resolver = factory.with({...});
	const service: Service = await resolver.constructAsync(Service);
	const user = await resolver.callAsync(service, "getProfile");
	console.log(user);
}

main();

import { createInjectorFactory } from "../src";
import express from "express";

const app = express();

const factory = createInjectorFactory<express.Request>();

const headers = factory.createInjector((payload) => {
	return payload.context.headers;
});

class SimpleHandler {
	async handle(
		@headers() headers: Record<string, string | string[]>
	): Promise<Record<string, string | string[]>> {
		return headers;
	}
}

const handler = new SimpleHandler();

app.use("*", async (request, response) => {
	const result: string = await factory.with(request).call(handler, "handle");
	response.send(result);
});

app.listen(8080, "0.0.0.0", () => {
	console.log(`Listening to 8080`);
});