@aponiajs/platform-elysia 0.3.22 → 0.5.0

package/README.md

@@ -15,6 +15,10 @@ The first Elysia platform slice for Aponia:
 - constructor-injected controllers;
 - Nest-style `@Module()`, `@Controller()`, route, and `@Injectable()` metadata;
 - automatic translation of decorated controllers into native Elysia routes;
+- Standard Schema route validation for `body`, `query`, `params`, `headers`,
+  and `response`;
+- Nest-style request parameter decorators — `@Body()`, `@Query()`, `@Param()`,
+  `@Headers()`, `@Cookie()`, `@Req()`, `@Res()`, and `@Ctx()`;
 - Nest-style startup logging for module initialization and route mapping;
 - controller factories that return native Elysia plugins;
 - `handle`, `listen`, and `close` application methods.
@@ -41,6 +45,41 @@ const application = await AponiaFactory.create(AppModule);
 await application.listen(3000);
 ```
 
+## Routes with the native Elysia context
+
+Controllers are Nest-shaped: a route decorator declares the method, path, and
+schema, and parameter decorators inject the request. Types come from the
+handler's own annotations.
+
+```ts
+import { Body, Controller, Ctx, Param, Post } from "@aponiajs/common";
+import { type ElysiaRouteContext } from "@aponiajs/platform-elysia";
+import { z } from "zod";
+
+const createUser = { body: z.object({ name: z.string().min(2) }) };
+type CreateUser = z.infer<(typeof createUser)["body"]>;
+
+@Controller("users")
+class UserController {
+  @Post("/", createUser)
+  createUser(@Body() body: CreateUser, @Param("tenant") tenant: string) {
+    return { tenant, name: body.name };
+  }
+
+  @Post("native", createUser)
+  createNatively(@Ctx() context: ElysiaRouteContext<typeof createUser>) {
+    context.set.headers["x-created"] = "1";
+    return context.body.name === "root"
+      ? context.status(403, "forbidden")
+      : { name: context.body.name };
+  }
+}
+```
+
+`ElysiaRouteContext<typeof schema>` is Elysia's own context type narrowed by the
+declared schema, so `status`, `set`, `cookie`, `store`, `redirect`, and plugin
+decorators behave exactly as they do in a plain Elysia handler.
+
 ## Native Elysia plugins
 
 Use existing Elysia plugins through Nest-style module imports:
@@ -50,8 +89,9 @@ bun add @elysiajs/cors @elysiajs/jwt
 ```
 
 ```ts
+import { Module } from "@aponiajs/common";
+import { ElysiaPluginModule } from "@aponiajs/platform-elysia";
 import { cors } from "@elysiajs/cors";
-import { jwt } from "@elysiajs/jwt";
 
 @Module({
   imports: [
@@ -67,6 +107,11 @@ The plugin is passed unchanged to Elysia's native `.use()` implementation. For
 plugins that depend on an injectable service, use an async registration:
 
 ```ts
+import { Module } from "@aponiajs/common";
+import { ElysiaPluginModule } from "@aponiajs/platform-elysia";
+import { jwt } from "@elysiajs/jwt";
+import { ConfigModule, ConfigService } from "./config/config.module.ts";
+
 @Module({
   imports: [
     ElysiaPluginModule.registerAsync({

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { Constructor, ControllerDefinition, DynamicModule, LogLevel, LoggerService, ModuleDefinition, ModuleImport, Token, TokenValues } from "@aponiajs/common";
 import "@aponiajs/core";
-import { AnyElysia, Elysia } from "elysia";
+import { AnyElysia, Context, Elysia, InputSchema, UnwrapRoute } from "elysia";
 //#region src/decorated-module.d.ts
 type AponiaRootModule = ModuleImport;
 declare function compileRootModule(rootModule: AponiaRootModule): ModuleDefinition;
@@ -27,6 +27,15 @@ declare class AponiaFactory {
   static create(rootModule: AponiaRootModule, options?: AponiaApplicationOptions): Promise<AponiaElysiaApplication>;
 }
 //#endregion
+//#region src/route-context.d.ts
+/**
+ * The native Elysia request context for a declared route schema. Handlers that
+ * take the whole context — through `@Ctx()` or a single unannotated parameter —
+ * keep `status`, `set`, `cookie`, `store`, `redirect`, and plugin decorators
+ * fully typed.
+ */
+type ElysiaRouteContext<TSchema extends InputSchema = {}> = Context<UnwrapRoute<TSchema, {}, string>>;
+//#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 {
@@ -55,4 +64,4 @@ declare class ElysiaPluginModule {
   static registerAsync<const TDependencies extends readonly Token<unknown>[], const TPlugin extends NativeElysiaPlugin>(options: AsyncElysiaPluginModuleOptions<TDependencies, TPlugin>): DynamicModule;
 }
 //#endregion
-export { type AponiaApplicationOptions, AponiaElysiaApplication, AponiaFactory, type AponiaRootModule, type AsyncElysiaPluginModuleOptions, type ConfiguredAponiaApplicationOptions, ELYSIA_CONTROLLER, type ElysiaControllerDefinition, ElysiaPluginModule, type ElysiaPluginModuleOptions, type NativeElysiaConfigurator, type NativeElysiaPlugin, compileRootModule, defineElysiaController };
+export { type AponiaApplicationOptions, AponiaElysiaApplication, AponiaFactory, type AponiaRootModule, type AsyncElysiaPluginModuleOptions, type ConfiguredAponiaApplicationOptions, ELYSIA_CONTROLLER, type ElysiaControllerDefinition, ElysiaPluginModule, type ElysiaPluginModuleOptions, type ElysiaRouteContext, type NativeElysiaConfigurator, type NativeElysiaPlugin, compileRootModule, defineElysiaController };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { AponiaError, Logger, Module, createToken, getConstructorDependencies, getControllerMetadata, getModuleMetadata, getRouteMetadata, provideFactory, provideValue, tokenName } from "@aponiajs/common";
+import { AponiaError, Logger, Module, createToken, getConstructorDependencies, getControllerMetadata, getModuleMetadata, getRouteMetadata, getRouteParameterMetadata, isStandardSchema, provideFactory, provideValue, tokenName } from "@aponiajs/common";
 import { createContainer } from "@aponiajs/core";
 import { Elysia } from "elysia";
 //#region src/controller.ts
@@ -125,12 +125,60 @@ function compileDecoratedController(controller) {
 					controller: controller.name,
 					handler: String(route.propertyKey)
 				});
-				plugin.route(route.method, joinPaths(metadata.path, route.path), () => Reflect.apply(handler, instance, []));
+				const parameters = getRouteParameterMetadata(controller, route.propertyKey);
+				plugin.route(route.method, joinPaths(metadata.path, route.path), (context) => handler.call(instance, ...bindParameters(parameters, context)), toRouteHook(route.schema));
 			}
 			return plugin;
 		}
 	});
 }
+/**
+* Builds the handler arguments described by parameter decorators. A handler
+* without them receives the whole context, which keeps `@Ctx()` optional for
+* single-argument handlers.
+*/
+function bindParameters(parameters, context) {
+	if (parameters.length === 0) return [context];
+	const size = Math.max(...parameters.map((parameter) => parameter.index)) + 1;
+	const bound = Array.from({ length: size }, () => void 0);
+	for (const parameter of parameters) bound[parameter.index] = resolveParameter(parameter, context);
+	return bound;
+}
+function resolveParameter(parameter, context) {
+	const source = parameterSource(parameter, context);
+	if (parameter.property === void 0) return source;
+	if (typeof source !== "object" || source === null) return;
+	const value = source[parameter.property];
+	return parameter.kind === "cookie" ? value?.value : value;
+}
+function parameterSource(parameter, context) {
+	const contextRecord = context;
+	switch (parameter.kind) {
+		case "context": return context;
+		case "set": return context.set;
+		case "request": return context.request;
+		default: return contextRecord[parameter.kind];
+	}
+}
+function toRouteHook(schema) {
+	if (!schema) return;
+	const hook = {
+		...schema.body ? { body: toElysiaSchema(schema.body) } : {},
+		...schema.query ? { query: toElysiaSchema(schema.query) } : {},
+		...schema.params ? { params: toElysiaSchema(schema.params) } : {},
+		...schema.headers ? { headers: toElysiaSchema(schema.headers) } : {},
+		...schema.response ? { response: toElysiaSchema(schema.response) } : {}
+	};
+	return Object.keys(hook).length === 0 ? void 0 : hook;
+}
+/**
+* Standard Schema validators pass through unchanged. Platform-native TypeBox
+* validators reach the platform through the neutral `NativeSchema` contract,
+* which cannot describe TypeBox's `Kind` symbol, so they are restored here.
+*/
+function toElysiaSchema(validator) {
+	return isStandardSchema(validator) ? validator : validator;
+}
 function joinPaths(controllerPath, routePath) {
 	const segments = [controllerPath, routePath].map((path) => path.trim().replace(/^\/+|\/+$/g, "")).filter(Boolean);
 	return segments.length === 0 ? "/" : `/${segments.join("/")}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aponiajs/platform-elysia",
-  "version": "0.3.22",
+  "version": "0.5.0",
   "description": "Minimal Elysia application platform for Aponia modules and controllers.",
   "homepage": "https://github.com/aponiajs/aponiajs#readme",
   "bugs": {
@@ -33,11 +33,13 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@aponiajs/common": "0.3.22",
-    "@aponiajs/core": "0.3.22"
+    "@aponiajs/common": "0.5.0",
+    "@aponiajs/core": "0.5.0"
   },
   "devDependencies": {
-    "elysia": "^1.4.29"
+    "arktype": "^2.2.3",
+    "elysia": "^1.4.29",
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "elysia": "^1.4.29"