@coloneldev/framework 0.1.1 → 0.1.2

package/README.md

@@ -27,10 +27,11 @@ The package currently exports framework primitives from the root entry:
 ## Example
 
 ```ts
-import { Kernel, Router } from "@coloneldev/framework";
+import { Container, Kernel, Router } from "@coloneldev/framework";
 
 const router = new Router();
-const kernel = new Kernel(router);
+const container = new Container();
+const kernel = new Kernel(router, [], {}, container);
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coloneldev/framework",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/src/Container/Container.ts

@@ -0,0 +1,84 @@
+export type Newable<T> = new (...args: any[]) => T;
+export type Token<T = unknown> = string | symbol | Newable<T>;
+
+type InjectableNewable<T> = Newable<T> & {
+	inject?: Token[];
+};
+
+type Factory<T> = (container: Container) => T;
+
+
+
+interface Binding<T = unknown> {
+	factory: Factory<T>;
+	singleton: boolean;
+}
+
+const isNewable = <T>(value: Token<T>): value is Newable<T> => {
+	return typeof value === "function";
+};
+
+export class Container {
+	private bindings = new Map<Token, Binding>();
+	private instances = new Map<Token, unknown>();
+
+	bind<T>(token: Token<T>, factory: Factory<T>): this {
+		this.bindings.set(token, { factory, singleton: false });
+		this.instances.delete(token);
+		return this;
+	}
+
+	singleton<T>(token: Token<T>, factory: Factory<T>): this {
+		this.bindings.set(token, { factory, singleton: true });
+		return this;
+	}
+
+	instance<T>(token: Token<T>, value: T): this {
+		this.instances.set(token, value);
+		return this;
+	}
+
+	has<T>(token: Token<T>): boolean {
+		return this.instances.has(token) || this.bindings.has(token);
+	}
+
+	make<T>(token: Token<T>): T {
+		if (this.instances.has(token)) {
+			return this.instances.get(token) as T;
+		}
+
+		const binding = this.bindings.get(token);
+		if (binding) {
+			const value = binding.factory(this) as T;
+
+			if (binding.singleton) {
+				this.instances.set(token, value);
+			}
+
+			return value;
+		}
+
+		if (isNewable(token)) {
+			const injectableToken = token as InjectableNewable<T>;
+			const dependencies = (injectableToken.inject ?? []).map((dependencyToken) =>
+				this.make(dependencyToken)
+			);
+
+			return new injectableToken(...dependencies);
+		}
+
+		throw new Error(`Container binding not found for token: ${String(token)}`);
+	}
+
+	forget<T>(token: Token<T>): this {
+		this.bindings.delete(token);
+		this.instances.delete(token);
+		return this;
+	}
+
+	flush(): this {
+		this.bindings.clear();
+		this.instances.clear();
+		return this;
+	}
+}

package/src/Http/Kernel.container.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "bun:test";
+import { Container } from "../Container/Container";
+import { Kernel } from "./Kernel";
+import { Router } from "./Router";
+
+class MessageService {
+    value(): string {
+        return "resolved-via-container";
+    }
+}
+
+class HomeController {
+    static inject = [MessageService];
+
+    constructor(private messageService: MessageService) {}
+
+    index(): Record<string, string> {
+        return { message: this.messageService.value() };
+    }
+}
+
+describe("Kernel container integration", () => {
+    it("resolves controller dependencies via static inject during request dispatch", async () => {
+        const router = new Router();
+        router.get("/", "HomeController@index");
+
+        const container = new Container();
+        container.singleton(MessageService, () => new MessageService());
+
+        const kernel = new Kernel(
+            router,
+            [],
+            {
+                controllerResolver: async (name: string) => {
+                    if (name !== "HomeController") {
+                        throw new Error(`Unexpected controller: ${name}`);
+                    }
+
+                    return HomeController;
+                },
+            },
+            container
+        );
+
+        const response = await kernel.handle(new Request("http://localhost/"));
+        const body = await response.json();
+
+        expect(response.status).toBe(200);
+        expect(body).toEqual({ message: "resolved-via-container" });
+    });
+});

package/src/Http/Kernel.ts

@@ -1,12 +1,13 @@
 import { HttpRequest } from './HttpRequest';
 import { Router } from './Router';
-//import { Container } from '../Container/Container';
 import type { HttpMethod } from './types/HttpMethod';
 import { join, resolve } from 'node:path';
 import ejs from 'ejs';
 import type { RouteHandler } from './types/RouteHandler';
+import type { Container } from '../Container/Container';
 
-type ControllerClass = new () => Record<string, unknown>;
+
+type ControllerClass = new (...args: any[]) => object;
 type ControllerResolver = (name: string) => Promise<ControllerClass>;
 
 interface KernelOptions {
@@ -37,9 +38,9 @@ const safeViewPath = (view: string) => view.replace(/\.\./g, '').replace(/\/+/g,
 export class Kernel {
     constructor(
         private router = new Router(),
-        //private container = new Container(),
         private middleware: Array<Function> = [],
-        private options: KernelOptions = {}
+        private options: KernelOptions = {},
+        private container: Container,
     ) {}
 
     private async resolveController(name: string): Promise<ControllerClass> {
@@ -131,7 +132,7 @@ export class Kernel {
 
         const ImportedControllerClass = await this.resolveController(controllerName!);
 
-        const controllerInstance = new ImportedControllerClass();
+        const controllerInstance = this.container.make(ImportedControllerClass);
 
         const action = (controllerInstance as any)[method!] as (req: HttpRequest) => Promise<Response> | Response;
 

package/src/index.ts

@@ -3,3 +3,4 @@ export * from "./Http/Router";
 export * from "./Http/HttpRequest";
 export * from "./Http/HttpResponse";
 export * from "./Http/staticFiles";
+export * from "./Container/Container";