@aponiajs/core 0.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @aponiajs/core
+
+The initial Aponia runtime foundation:
+
+- deterministic module graph compilation;
+- explicit module imports and provider exports;
+- value, factory, class, and alias providers;
+- singleton dependency resolution without decorators or reflection;
+- stable diagnostics for invalid graphs and dependency cycles.
+
+Async providers, request scope, lifecycle hooks, HTTP, and Elysia integration are
+intentionally outside this first implementation.

package/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { ControllerDefinition, ModuleDefinition, Provider, Token } from "@aponiajs/common";
+//#region src/graph.d.ts
+interface ModuleInspection {
+  readonly id: string;
+  readonly imports: readonly string[];
+  readonly controllers: readonly string[];
+  readonly providers: readonly string[];
+  readonly exports: readonly string[];
+}
+interface GraphInspection {
+  readonly root: string;
+  readonly modules: readonly ModuleInspection[];
+}
+interface ProviderLocation {
+  readonly module: ModuleDefinition;
+  readonly provider: Provider;
+}
+declare class ModuleGraph {
+  #private;
+  readonly root: ModuleDefinition;
+  readonly modules: readonly ModuleDefinition[];
+  constructor(root: ModuleDefinition, modules: readonly ModuleDefinition[]);
+  inspect(): GraphInspection;
+  locate(module: ModuleDefinition, token: Token<unknown>): ProviderLocation;
+}
+declare function compileModuleGraph(root: ModuleDefinition): ModuleGraph;
+//#endregion
+//#region src/container.d.ts
+declare class AponiaContainer {
+  #private;
+  readonly graph: ModuleGraph;
+  constructor(graph: ModuleGraph);
+  get<T>(token: Token<T>): T;
+  initializeModule(module: ModuleDefinition): void;
+  instantiateController<T>(module: ModuleDefinition, controller: ControllerDefinition): T;
+}
+declare function createContainer(root: ModuleDefinition): AponiaContainer;
+//#endregion
+export { AponiaContainer, type GraphInspection, ModuleGraph, type ModuleInspection, type ProviderLocation, compileModuleGraph, createContainer };

package/dist/index.mjs

@@ -0,0 +1,193 @@
+import { AponiaError, tokenName } from "@aponiajs/common";
+//#region src/graph.ts
+var ModuleGraph = class {
+	root;
+	modules;
+	#moduleSet;
+	constructor(root, modules) {
+		this.root = root;
+		this.modules = Object.freeze([...modules]);
+		this.#moduleSet = new Set(modules);
+	}
+	inspect() {
+		return Object.freeze({
+			root: this.root.id,
+			modules: Object.freeze(this.modules.map((module) => Object.freeze({
+				id: module.id,
+				imports: Object.freeze(module.imports.map((item) => item.id)),
+				controllers: Object.freeze(module.controllers.map((controller) => tokenName(controller.token))),
+				providers: Object.freeze(module.providers.map((provider) => tokenName(provider.provide))),
+				exports: Object.freeze(module.exports.map(tokenName))
+			})))
+		});
+	}
+	locate(module, token) {
+		if (!this.#moduleSet.has(module)) throw new AponiaError("MISSING_PROVIDER", `Module "${module.id}" is not part of the compiled graph.`, {
+			module: module.id,
+			token: tokenName(token)
+		});
+		return this.#locate(module, token, /* @__PURE__ */ new Set());
+	}
+	#locate(module, token, visited) {
+		const own = module.providers.find((provider) => provider.provide === token);
+		if (own) return {
+			module,
+			provider: own
+		};
+		if (visited.has(module)) throw missingProvider(module, token);
+		visited.add(module);
+		const candidates = /* @__PURE__ */ new Map();
+		for (const imported of module.imports) {
+			if (!imported.exports.includes(token)) continue;
+			const location = this.#locate(imported, token, new Set(visited));
+			candidates.set(location.provider, location);
+		}
+		if (candidates.size === 0) throw missingProvider(module, token);
+		if (candidates.size > 1) throw new AponiaError("AMBIGUOUS_PROVIDER", `Token "${tokenName(token)}" is exported by multiple imports of module "${module.id}".`, {
+			module: module.id,
+			token: tokenName(token),
+			candidates: [...candidates.values()].map((item) => item.module.id)
+		});
+		const location = candidates.values().next().value;
+		if (!location) throw missingProvider(module, token);
+		return location;
+	}
+};
+function compileModuleGraph(root) {
+	const modules = [];
+	const modulesById = /* @__PURE__ */ new Map();
+	const visiting = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (module) => {
+		const registered = modulesById.get(module.id);
+		if (registered && registered !== module) throw new AponiaError("DUPLICATE_MODULE", `Module id "${module.id}" belongs to more than one definition.`, { module: module.id });
+		modulesById.set(module.id, module);
+		const cycleIndex = visiting.indexOf(module);
+		if (cycleIndex >= 0) {
+			const cycle = [...visiting.slice(cycleIndex), module].map((item) => item.id);
+			throw new AponiaError("MODULE_CYCLE", `Module import cycle detected: ${cycle.join(" -> ")}.`, { cycle });
+		}
+		if (visited.has(module)) return;
+		visiting.push(module);
+		for (const imported of module.imports) visit(imported);
+		visiting.pop();
+		validateOwnProviders(module);
+		visited.add(module);
+		modules.push(module);
+	};
+	visit(root);
+	const graph = new ModuleGraph(root, modules);
+	validateExports(graph);
+	validateDependencies(graph);
+	validateControllers(graph);
+	return graph;
+}
+function validateOwnProviders(module) {
+	const tokens = /* @__PURE__ */ new Set();
+	for (const provider of module.providers) {
+		if (tokens.has(provider.provide)) throw new AponiaError("DUPLICATE_PROVIDER", `Module "${module.id}" declares token "${tokenName(provider.provide)}" more than once.`, {
+			module: module.id,
+			token: tokenName(provider.provide)
+		});
+		tokens.add(provider.provide);
+	}
+}
+function validateExports(graph) {
+	for (const module of graph.modules) for (const token of module.exports) try {
+		graph.locate(module, token);
+	} catch (error) {
+		if (error instanceof AponiaError && error.code === "MISSING_PROVIDER") throw new AponiaError("INVALID_EXPORT", `Module "${module.id}" cannot export missing token "${tokenName(token)}".`, {
+			module: module.id,
+			token: tokenName(token)
+		});
+		throw error;
+	}
+}
+function validateDependencies(graph) {
+	for (const module of graph.modules) for (const provider of module.providers) for (const dependency of providerDependencies(provider)) graph.locate(module, dependency);
+}
+function validateControllers(graph) {
+	for (const module of graph.modules) {
+		const controllerTokens = /* @__PURE__ */ new Set();
+		for (const controller of module.controllers) {
+			if (controllerTokens.has(controller.token)) throw new AponiaError("DUPLICATE_PROVIDER", `Module "${module.id}" declares controller "${tokenName(controller.token)}" more than once.`, {
+				module: module.id,
+				token: tokenName(controller.token)
+			});
+			controllerTokens.add(controller.token);
+			for (const dependency of controller.inject) graph.locate(module, dependency);
+		}
+	}
+}
+function providerDependencies(provider) {
+	switch (provider.kind) {
+		case "value": return [];
+		case "alias": return [provider.useExisting];
+		case "class":
+		case "factory": return provider.inject;
+	}
+}
+function missingProvider(module, token) {
+	return new AponiaError("MISSING_PROVIDER", `Module "${module.id}" cannot resolve token "${tokenName(token)}".`, {
+		module: module.id,
+		token: tokenName(token)
+	});
+}
+//#endregion
+//#region src/container.ts
+var AponiaContainer = class {
+	graph;
+	#instances = /* @__PURE__ */ new Map();
+	#controllers = /* @__PURE__ */ new Map();
+	#resolving = [];
+	constructor(graph) {
+		this.graph = graph;
+	}
+	get(token) {
+		const location = this.graph.locate(this.graph.root, token);
+		return this.#resolve(location);
+	}
+	initializeModule(module) {
+		for (const provider of module.providers) this.#resolve({
+			module,
+			provider
+		});
+	}
+	instantiateController(module, controller) {
+		if (this.#controllers.has(controller)) return this.#controllers.get(controller);
+		const dependencies = controller.inject.map((dependency) => this.#resolve(this.graph.locate(module, dependency)));
+		const instance = Reflect.construct(controller.useClass, dependencies);
+		this.#controllers.set(controller, instance);
+		return instance;
+	}
+	#resolve(location) {
+		if (this.#instances.has(location.provider)) return this.#instances.get(location.provider);
+		const cycleIndex = this.#resolving.findIndex((item) => item.provider === location.provider);
+		if (cycleIndex >= 0) {
+			const cycle = [...this.#resolving.slice(cycleIndex), location].map((item) => `${item.module.id}:${tokenName(item.provider.provide)}`);
+			throw new AponiaError("PROVIDER_CYCLE", `Provider dependency cycle detected: ${cycle.join(" -> ")}.`, { cycle });
+		}
+		this.#resolving.push(location);
+		try {
+			const dependencies = providerDependencies(location.provider).map((dependency) => this.#resolve(this.graph.locate(location.module, dependency)));
+			const instance = instantiate(location.provider, dependencies);
+			this.#instances.set(location.provider, instance);
+			return instance;
+		} finally {
+			this.#resolving.pop();
+		}
+	}
+};
+function createContainer(root) {
+	return new AponiaContainer(compileModuleGraph(root));
+}
+function instantiate(provider, dependencies) {
+	switch (provider.kind) {
+		case "value": return provider.useValue;
+		case "alias": return dependencies[0];
+		case "factory": return Reflect.apply(provider.useFactory, void 0, dependencies);
+		case "class": return Reflect.construct(provider.useClass, dependencies);
+	}
+}
+//#endregion
+export { AponiaContainer, ModuleGraph, compileModuleGraph, createContainer };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@aponiajs/core",
+  "version": "0.0.0",
+  "description": "Module graph and dependency injection runtime for Aponia.",
+  "homepage": "https://github.com/aponiajs/aponiajs#readme",
+  "bugs": {
+    "url": "https://github.com/aponiajs/aponiajs/issues"
+  },
+  "license": "MIT",
+  "author": "AponiaJS contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aponiajs/aponiajs.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bunx --bun vp pack",
+    "dev": "bunx --bun vp pack --watch",
+    "test": "bun test",
+    "test:vite-plus": "vp test",
+    "check": "bunx --bun vp check",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@aponiajs/common": "0.0.0"
+  }
+}