Change license to GPLv3

README.md

@@ -22,4 +22,4 @@ Check out the [documentation](https://koala-ts.github.io/).
 
 ## License
 
-KoalaTS is [MIT licensed](/LICENSE).
+KoalaTS is [GPLv3 licensed](/LICENSE).

package.json

@@ -46,7 +46,7 @@
     "email": "imdhemy@gmail.com",
     "url": "https://imdhemy.com"
   },
-  "license": "MIT",
+  "license": "GPL-3.0-only",
   "engines": {
     "node": ">=24",
     "npm": ">=11"

src/routing/definition/create-route-definition.ts

@@ -1,27 +1,28 @@
-import type { HttpMiddleware } from '@/Http';
+import type { HttpMiddleware, HttpRequest } from '@/Http';
 import type { HttpMethod } from '@/routing/http-method';
 import type { RouteOptions } from '@/routing/route-options';
 import { resolveRouteOptions } from '@/routing/definition/resolve-route-options';
 import type { RouterMethod } from '@/routing/router-method';
 import type { RouteDefinition } from './route-definition';
+import type { Request } from 'koa';
 
-interface RouteDefinitionInput {
+interface RouteDefinitionInput<TRequest extends Request = HttpRequest> {
   name?: string;
   method: HttpMethod | HttpMethod[];
   path: string;
-  handler: HttpMiddleware;
-  middleware?: HttpMiddleware[];
+  handler: HttpMiddleware<TRequest>;
+  middleware?: HttpMiddleware<TRequest>[];
   options?: RouteOptions;
 }
 
-export function createRouteDefinition({
+export function createRouteDefinition<TRequest extends Request = HttpRequest>({
   name,
   method,
   path,
   handler,
   middleware = [],
   options = {},
-}: RouteDefinitionInput): RouteDefinition {
+}: RouteDefinitionInput<TRequest>): RouteDefinition<TRequest> {
   const routeOptions = resolveRouteOptions(options);
 
   return {

src/routing/definition/route-definition.ts

@@ -1,13 +1,14 @@
-import type { HttpMiddleware } from '@/Http';
+import type { HttpRequest, HttpMiddleware } from '@/Http';
 import type { RouterMethod } from '@/routing/router-method';
+import type { Request } from 'koa';
 import type { KoaBodyMiddlewareOptions } from 'koa-body';
 
-export interface RouteDefinition {
+export interface RouteDefinition<TRequest extends Request = HttpRequest> {
   name?: string;
   path: string;
   methods: RouterMethod[];
-  handler: HttpMiddleware;
-  middleware: HttpMiddleware[];
+  handler: HttpMiddleware<TRequest>;
+  middleware: HttpMiddleware<TRequest>[];
   parseBody: boolean;
   bodyOptions: Partial<KoaBodyMiddlewareOptions>;
 }

src/routing/helpers/http-verb-helpers.ts

@@ -1,42 +1,60 @@
-import type { HttpMiddleware } from '@/Http';
+import type { HttpMiddleware, HttpRequest } from '@/Http';
 import type { HttpMethod } from '@/routing/http-method';
 import type { RouteDefinition } from '@/routing/definition/route-definition';
 import { Route } from '@/routing/route';
+import type { Request } from 'koa';
 
-type RouteHandler = HttpMiddleware;
-type MiddlewareAndHandler = [...middleware: HttpMiddleware[], handler: RouteHandler];
-type NamedMiddlewareAndHandler = [name: string, ...middlewareAndHandler: MiddlewareAndHandler];
-type VerbHelperRouteArguments = MiddlewareAndHandler | NamedMiddlewareAndHandler;
-type UnsafeVerbHelperRouteArguments = VerbHelperRouteArguments | [name: string] | [];
+type RouteHandler<TRequest extends Request = HttpRequest> = HttpMiddleware<TRequest>;
+type MiddlewareAndHandler<TRequest extends Request = HttpRequest> = [
+  ...middleware: HttpMiddleware<TRequest>[],
+  handler: RouteHandler<TRequest>,
+];
+type NamedMiddlewareAndHandler<TRequest extends Request = HttpRequest> = [
+  name: string,
+  ...middlewareAndHandler: MiddlewareAndHandler<TRequest>,
+];
+type VerbHelperRouteArguments<TRequest extends Request = HttpRequest> =
+  | MiddlewareAndHandler<TRequest>
+  | NamedMiddlewareAndHandler<TRequest>;
+type UnsafeVerbHelperRouteArguments<TRequest extends Request = HttpRequest> =
+  | VerbHelperRouteArguments<TRequest>
+  | [name: string]
+  | [];
 
-interface VerbHelperArguments {
+interface VerbHelperArguments<TRequest extends Request = HttpRequest> {
   path: string;
   name?: string;
-  middleware: HttpMiddleware[];
-  handler: RouteHandler;
+  middleware: HttpMiddleware<TRequest>[];
+  handler: RouteHandler<TRequest>;
 }
 
-type NamedVerbHelper = {
-  (path: string, ...middlewareAndHandler: MiddlewareAndHandler): RouteDefinition;
-  (path: string, name: string, ...middlewareAndHandler: MiddlewareAndHandler): RouteDefinition;
+type NamedVerbHelper<TRequest extends Request = HttpRequest> = {
+  (path: string, ...middlewareAndHandler: MiddlewareAndHandler<TRequest>): RouteDefinition<TRequest>;
+  (path: string, name: string, ...middlewareAndHandler: MiddlewareAndHandler<TRequest>): RouteDefinition<TRequest>;
 };
 
 function createVerbHelper(method: HttpMethod): NamedVerbHelper {
-  return (path: string, ...routeArguments: UnsafeVerbHelperRouteArguments) =>
+  return <TRequest extends Request = HttpRequest>(
+    path: string,
+    ...routeArguments: UnsafeVerbHelperRouteArguments<TRequest>
+  ) =>
     Route({
       method,
       ...resolveVerbHelperArguments(path, routeArguments),
     });
 }
 
-function resolveVerbHelperArguments(path: string, routeArguments: UnsafeVerbHelperRouteArguments): VerbHelperArguments {
+function resolveVerbHelperArguments<TRequest extends Request = HttpRequest>(
+  path: string,
+  routeArguments: UnsafeVerbHelperRouteArguments<TRequest>,
+): VerbHelperArguments<TRequest> {
   const isNamedRoute = isNamedVerbHelperRouteArguments(routeArguments);
   const name = isNamedRoute ? routeArguments[0] : undefined;
   const routeMiddlewareAndHandler = isNamedRoute
-    ? (routeArguments.slice(1) as MiddlewareAndHandler | [])
+    ? (routeArguments.slice(1) as MiddlewareAndHandler<TRequest> | [])
     : routeArguments;
   const handler = requireVerbHelperHandler(routeMiddlewareAndHandler, isNamedRoute);
-  const middleware = routeMiddlewareAndHandler.slice(0, -1) as HttpMiddleware[];
+  const middleware = routeMiddlewareAndHandler.slice(0, -1) as HttpMiddleware<TRequest>[];
 
   return {
     path,
@@ -46,17 +64,17 @@ function resolveVerbHelperArguments(path: string, routeArguments: UnsafeVerbHelp
   };
 }
 
-function isNamedVerbHelperRouteArguments(
-  routeArguments: UnsafeVerbHelperRouteArguments,
-): routeArguments is NamedMiddlewareAndHandler | [name: string] {
+function isNamedVerbHelperRouteArguments<TRequest extends Request = HttpRequest>(
+  routeArguments: UnsafeVerbHelperRouteArguments<TRequest>,
+): routeArguments is NamedMiddlewareAndHandler<TRequest> | [name: string] {
   return typeof routeArguments[0] === 'string';
 }
 
-function requireVerbHelperHandler(
-  middlewareAndHandler: MiddlewareAndHandler | [],
+function requireVerbHelperHandler<TRequest extends Request = HttpRequest>(
+  middlewareAndHandler: MiddlewareAndHandler<TRequest> | [],
   isNamedRoute: boolean,
-): RouteHandler {
-  const handler = middlewareAndHandler.at(-1) as RouteHandler | undefined;
+): RouteHandler<TRequest> {
+  const handler = middlewareAndHandler.at(-1) as RouteHandler<TRequest> | undefined;
 
   if (handler === undefined && isNamedRoute) {
     throw new Error('Named verb helpers require a handler.');

src/routing/route.ts

@@ -1,18 +1,21 @@
-import type { HttpMiddleware } from '@/Http';
+import type { HttpMiddleware, HttpRequest } from '@/Http';
 import { createRouteDefinition } from '@/routing/definition/create-route-definition';
 import type { RouteDefinition } from '@/routing/definition/route-definition';
 import type { HttpMethod } from '@/routing/http-method';
 import type { RouteOptions } from '@/routing/route-options';
+import type { Request } from 'koa';
 
-export interface RouteDeclaration {
+export interface RouteDeclaration<TRequest extends Request = HttpRequest> {
   name?: string;
   path: string;
   method: HttpMethod | HttpMethod[];
-  handler: HttpMiddleware;
-  middleware?: HttpMiddleware[];
+  handler: HttpMiddleware<TRequest>;
+  middleware?: HttpMiddleware<TRequest>[];
   options?: RouteOptions;
 }
 
-export function Route(route: RouteDeclaration): RouteDefinition {
+export function Route<TRequest extends Request = HttpRequest>(
+  route: RouteDeclaration<TRequest>,
+): RouteDefinition<TRequest> {
   return createRouteDefinition(route);
 }

tests/function-first-routing.e2e.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from 'vitest';
 import { koalaDefaultConfig } from '../src/config/default-config';
 import type { HttpMiddleware, HttpRequest, HttpScope, NextMiddleware, UploadedFile } from '../src/Http';
 import { Any, Get, Post, Route, RouteGroup } from '../src/routing';
-import { createTestAgent } from '../src/Testing';
+import { createTestAgent } from '../src/Testing/TestAgentFactory';
 import { exclusiveRoutingModeError } from '../src/routing/verify-routing-mode';
 
 interface FunctionFirstRoutingRequest extends HttpRequest {
@@ -252,6 +252,41 @@ describe('Function First Routing E2E Test', () => {
     expect(response.body).toEqual([{ id: 1 }]);
   });
 
+  test('it should register request typed handlers through named verb helpers', async () => {
+    interface CreateSourceRequest extends HttpRequest {
+      body: { name: string };
+      params: { workspaceId: string };
+    }
+    const validateCreateSourceRequest: HttpMiddleware<CreateSourceRequest> = async (_scope, next) => {
+      await next();
+    };
+    const createSourceHandler = async ({ request, response }: HttpScope<CreateSourceRequest>): Promise<void> => {
+      response.body = {
+        name: request.body.name,
+        workspaceId: request.params.workspaceId,
+      };
+    };
+    const agent = createTestAgent({
+      ...koalaDefaultConfig,
+      routes: [
+        Post<CreateSourceRequest>(
+          '/workspaces/:workspaceId/sources',
+          'create',
+          validateCreateSourceRequest,
+          createSourceHandler,
+        ),
+      ],
+    });
+
+    const response = await agent.post('/workspaces/framework/sources').send({ name: 'Koala' });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      name: 'Koala',
+      workspaceId: 'framework',
+    });
+  });
+
   test('it should apply middleware declared through a verb helper in order', async () => {
     const authMiddleware: HttpMiddleware = async (scope: HttpScope, next: NextMiddleware) => {
       scope.response.append('x-middleware-order', 'auth');
@@ -378,6 +413,7 @@ describe('Function First Routing E2E Test', () => {
                     await next();
                   },
                 ],
+                options: {},
               },
             },
           },
@@ -416,7 +452,10 @@ describe('Function First Routing E2E Test', () => {
           {
             routeConfig: {
               upload: {
-                options: { multipart: true },
+                options: {
+                  multipart: true,
+                },
+                middleware: [],
               },
             },
           },