@aponiajs/platform-elysia 0.0.0

package/README.md

@@ -0,0 +1,23 @@
+# @aponiajs/platform-elysia
+
+The first Elysia platform slice for Aponia:
+
+- `AponiaFactory.create(AppModule)` application bootstrap;
+- module-owned controller discovery;
+- constructor-injected controllers;
+- Nest-style `@Module()`, `@Controller()`, route, and `@Injectable()` metadata;
+- automatic translation of decorated controllers into native Elysia routes;
+- Nest-style startup logging for module initialization and route mapping;
+- controller factories that return native Elysia plugins;
+- `handle`, `listen`, and `close` application methods.
+
+This package intentionally does not yet implement request scopes, lifecycle
+enhancers, schema aggregation, or the complete native-plugin compatibility
+contract from the roadmap.
+
+The decorator API is the default application authoring surface. The
+`defineElysiaController` API remains available as a low-level escape hatch for
+composing existing Elysia plugins without rewriting them.
+
+See `docs/logging.md` for logger configuration, JSON output, level filtering,
+and custom logger integration.

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import { Constructor, ControllerDefinition, LogLevel, LoggerService, ModuleClass, ModuleDefinition, Token, TokenValues } from "@aponiajs/common";
+import { AnyElysia, Elysia } from "elysia";
+//#region src/decorated-module.d.ts
+type AponiaRootModule = ModuleClass | ModuleDefinition;
+declare function compileRootModule(rootModule: AponiaRootModule): ModuleDefinition;
+//#endregion
+//#region src/application.d.ts
+declare class AponiaElysiaApplication {
+  #private;
+  constructor(nativeApplication: Elysia, logger: LoggerService | undefined);
+  getNativeApplication(): Elysia;
+  handle(request: Request): Response | Promise<Response>;
+  listen(port: number): Promise<void>;
+  getUrl(): string;
+  close(): Promise<void>;
+}
+interface AponiaApplicationOptions {
+  readonly logger?: false | LoggerService | readonly LogLevel[];
+}
+declare class AponiaFactory {
+  static create(rootModule: AponiaRootModule, options?: AponiaApplicationOptions): Promise<AponiaElysiaApplication>;
+}
+//#endregion
+//#region src/controller.d.ts
+declare const ELYSIA_CONTROLLER = "aponia.elysia.controller";
+interface ElysiaControllerDefinition<TController, TDependencies extends readonly Token<unknown>[], TPlugin extends AnyElysia> extends ControllerDefinition {
+  readonly kind: typeof ELYSIA_CONTROLLER;
+  readonly inject: TDependencies;
+  readonly useClass: Constructor<TController, TokenValues<TDependencies>>;
+  readonly buildPlugin: (controller: TController) => TPlugin;
+}
+declare function defineElysiaController<TController, const TDependencies extends readonly Token<unknown>[], const TPlugin extends AnyElysia>(useClass: Constructor<TController, TokenValues<TDependencies>>, options: {
+  readonly inject: TDependencies;
+  readonly buildPlugin: (controller: TController) => TPlugin;
+}): ElysiaControllerDefinition<TController, TDependencies, TPlugin>;
+//#endregion
+export { type AponiaApplicationOptions, AponiaElysiaApplication, AponiaFactory, type AponiaRootModule, ELYSIA_CONTROLLER, type ElysiaControllerDefinition, compileRootModule, defineElysiaController };

package/dist/index.mjs

@@ -0,0 +1,172 @@
+import { AponiaError, Logger, getConstructorDependencies, getControllerMetadata, getModuleMetadata, getRouteMetadata, tokenName } from "@aponiajs/common";
+import { createContainer } from "@aponiajs/core";
+import { Elysia } from "elysia";
+//#region src/controller.ts
+const ELYSIA_CONTROLLER = "aponia.elysia.controller";
+function defineElysiaController(useClass, options) {
+	return Object.freeze({
+		kind: ELYSIA_CONTROLLER,
+		token: useClass,
+		inject: Object.freeze([...options.inject]),
+		useClass,
+		buildPlugin: options.buildPlugin
+	});
+}
+function isElysiaController(controller) {
+	return controller.kind === ELYSIA_CONTROLLER;
+}
+//#endregion
+//#region src/decorated-module.ts
+function compileRootModule(rootModule) {
+	if (typeof rootModule !== "function") return rootModule;
+	const compiled = /* @__PURE__ */ new Map();
+	const visiting = [];
+	const compile = (moduleClass) => {
+		const cached = compiled.get(moduleClass);
+		if (cached) return cached;
+		const cycleIndex = visiting.indexOf(moduleClass);
+		if (cycleIndex >= 0) {
+			const cycle = [...visiting.slice(cycleIndex), moduleClass].map((item) => item.name);
+			throw new AponiaError("MODULE_CYCLE", `Module import cycle detected: ${cycle.join(" -> ")}.`, { cycle });
+		}
+		const metadata = getModuleMetadata(moduleClass);
+		if (!metadata) throw new AponiaError("INVALID_MODULE", `Class "${moduleClass.name}" is missing the @Module() decorator.`, { module: moduleClass.name });
+		visiting.push(moduleClass);
+		try {
+			const definition = Object.freeze({
+				id: moduleClass.name,
+				imports: Object.freeze((metadata.imports ?? []).map((moduleImport) => typeof moduleImport === "function" ? compile(moduleImport) : moduleImport)),
+				controllers: Object.freeze((metadata.controllers ?? []).map(compileDecoratedController)),
+				providers: Object.freeze((metadata.providers ?? []).map(compileProvider)),
+				exports: Object.freeze([...metadata.exports ?? []])
+			});
+			compiled.set(moduleClass, definition);
+			return definition;
+		} finally {
+			visiting.pop();
+		}
+	};
+	return compile(rootModule);
+}
+function compileProvider(provider) {
+	if (typeof provider !== "function") return provider;
+	const inject = getConstructorDependencies(provider);
+	return Object.freeze({
+		kind: "class",
+		provide: provider,
+		inject,
+		useClass: provider
+	});
+}
+function compileDecoratedController(controller) {
+	const metadata = getControllerMetadata(controller);
+	if (!metadata) throw new AponiaError("INVALID_CONTROLLER", `Class "${controller.name}" is missing the @Controller() decorator.`, { controller: controller.name });
+	const routes = getRouteMetadata(controller);
+	return Object.freeze({
+		kind: ELYSIA_CONTROLLER,
+		token: controller,
+		path: joinPaths(metadata.path, ""),
+		inject: getConstructorDependencies(controller),
+		useClass: controller,
+		buildPlugin: (instance) => {
+			const plugin = new Elysia();
+			for (const route of routes) {
+				const handler = instance[route.propertyKey];
+				if (typeof handler !== "function") throw new AponiaError("INVALID_CONTROLLER", `Route handler "${String(route.propertyKey)}" is not callable.`, {
+					controller: controller.name,
+					handler: String(route.propertyKey)
+				});
+				plugin.route(route.method, joinPaths(metadata.path, route.path), () => Reflect.apply(handler, instance, []));
+			}
+			return plugin;
+		}
+	});
+}
+function joinPaths(controllerPath, routePath) {
+	const segments = [controllerPath, routePath].map((path) => path.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean);
+	return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+//#endregion
+//#region src/application.ts
+var AponiaElysiaApplication = class {
+	#nativeApplication;
+	#logger;
+	constructor(nativeApplication, logger) {
+		this.#nativeApplication = nativeApplication;
+		this.#logger = logger;
+	}
+	getNativeApplication() {
+		return this.#nativeApplication;
+	}
+	handle(request) {
+		return this.#nativeApplication.handle(request);
+	}
+	async listen(port) {
+		try {
+			this.#nativeApplication.listen(port);
+			await this.#nativeApplication.modules;
+			this.#logger?.log("Aponia application successfully started", "AponiaApplication");
+			this.#logger?.log(`Application is running on: ${this.getUrl()}`, "AponiaApplication");
+		} catch (error) {
+			this.#logger?.error(error, "AponiaApplication");
+			throw error;
+		}
+	}
+	getUrl() {
+		const server = this.#nativeApplication.server;
+		if (!server) throw new AponiaError("APPLICATION_NOT_LISTENING", "app.listen() needs to be called before calling app.getUrl().");
+		return server.url.origin;
+	}
+	async close() {
+		if (this.#nativeApplication.server) await this.#nativeApplication.stop();
+	}
+};
+var AponiaFactory = class {
+	static async create(rootModule, options = {}) {
+		const logger = createSystemLogger(options.logger);
+		logger?.log("Starting Aponia application...", "AponiaFactory");
+		const compiledRootModule = compileRootModule(rootModule);
+		const container = createContainer(compiledRootModule);
+		const nativeApplication = new Elysia({ name: compiledRootModule.id });
+		for (const module of container.graph.modules) {
+			container.initializeModule(module);
+			logger?.log(`${module.id} dependencies initialized`, "InstanceLoader");
+		}
+		for (const module of container.graph.modules) for (const controller of module.controllers) {
+			if (!isElysiaController(controller)) {
+				const controllerName = tokenName(controller.token);
+				throw new AponiaError("UNSUPPORTED_CONTROLLER", `Controller "${controllerName}" is not supported by the Elysia platform.`, {
+					module: module.id,
+					controller: controllerName
+				});
+			}
+			const instance = container.instantiateController(module, controller);
+			const plugin = Reflect.apply(controller.buildPlugin, void 0, [instance]);
+			if (!(plugin instanceof Elysia)) throw new AponiaError("UNSUPPORTED_CONTROLLER", `Controller "${tokenName(controller.token)}" did not build an Elysia plugin.`, {
+				module: module.id,
+				controller: tokenName(controller.token)
+			});
+			const controllerName = tokenName(controller.token);
+			const controllerPath = controller.path ?? inferControllerPath(plugin);
+			logger?.log(`${controllerName} {${controllerPath}}:`, "RoutesResolver");
+			for (const route of plugin.routes) logger?.log(`Mapped {${route.path}, ${String(route.method).toUpperCase()}} route`, "RouterExplorer");
+			nativeApplication.use(plugin);
+		}
+		await nativeApplication.modules;
+		return new AponiaElysiaApplication(nativeApplication, logger);
+	}
+};
+function createSystemLogger(loggerOption) {
+	if (loggerOption === false) return;
+	if (Array.isArray(loggerOption)) return new Logger("AponiaFactory", {
+		logLevels: loggerOption,
+		timestamp: true
+	});
+	if (loggerOption) return loggerOption;
+	return new Logger("AponiaFactory", { timestamp: true });
+}
+function inferControllerPath(plugin) {
+	return plugin.routes[0]?.path ?? "/";
+}
+//#endregion
+export { AponiaElysiaApplication, AponiaFactory, ELYSIA_CONTROLLER, compileRootModule, defineElysiaController };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@aponiajs/platform-elysia",
+  "version": "0.0.0",
+  "description": "Minimal Elysia application platform for Aponia modules and controllers.",
+  "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/platform-elysia"
+  },
+  "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",
+    "@aponiajs/core": "0.0.0"
+  },
+  "devDependencies": {
+    "elysia": "^1.4.29"
+  },
+  "peerDependencies": {
+    "elysia": "^1.4.29"
+  }
+}