@asterflow/router 1.0.1

package/README.md

@@ -0,0 +1,256 @@
+<div align="center">
+
+# @asterflow/router
+
+![license-info](https://img.shields.io/github/license/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
+![stars-info](https://img.shields.io/github/stars/Ashu11-A/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+
+![last-commit](https://img.shields.io/github/last-commit/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=b4befe)
+![commit-activity](https://img.shields.io/github/commit-activity/y/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af)
+![code-size](https://img.shields.io/github/languages/code-size/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=90dceb)
+
+![top-language](https://img.shields.io/github/languages/top/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=90dceb)
+![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/request?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> Type-safe and flexible routing system for AsterFlow applications.
+
+## 📦 Installation
+
+```bash
+npm install @asterflow/router
+# or
+bun install @asterflow/router
+```
+
+## 💡 About
+
+@asterflow/router is the routing foundation of AsterFlow. It provides a powerful, type-safe routing system with support for middleware, parameter validation, and flexible route organization.
+
+## ✨ Features
+
+- **Complete Type Safety:** Full TypeScript support with type inference for routes, parameters, and responses
+- **Middleware System:** Support for middlewares with typed context and chaining
+- **Parameter Validation:** Built-in support for Zod and @caeljs/tsh
+- **URL Analysis:** Integrated URL parser with support for dynamic parameters, query strings, and fragments
+- **Standardized Responses:** Typed response system with helpers for common HTTP codes
+- **Flexible Organization:** Support for individual routes (Method) and grouped routes (Router)
+
+## 🚀 Usage
+
+### Basic Router Route
+
+```typescript
+import { Router } from '@asterflow/router'
+
+const router = new Router({
+  path: '/hello/:name',
+  methods: {
+    get({ response, url }) {
+      const params = url.getParams()
+      return response.success({ 
+        message: `Hello ${params.name}!` 
+      })
+    }
+  }
+})
+```
+
+### Using Middlewares
+
+```typescript
+import { Middleware, Router } from '@asterflow/router'
+
+const authMiddleware = new Middleware({
+  name: 'auth',
+  onRun({ next }) {
+    return next({
+      isAuthenticated: true,
+      user: { id: 1 }
+    })
+  }
+})
+
+const router = new Router({
+  path: '/protected',
+  use: [authMiddleware],
+  methods: {
+    get({ response, middleware }) {
+      if (!middleware.isAuthenticated) {
+        return response.unauthorized({ message: 'Not authenticated' })
+      }
+      return response.success({ user: middleware.user })
+    }
+  }
+})
+```
+
+### Validation with Zod
+
+```typescript
+import { Method } from '@asterflow/router'
+import { z } from 'zod'
+
+const createUser = new Method({
+  path: '/users',
+  method: 'post',
+  schema: z.object({
+    name: z.string(),
+    email: z.string().email()
+  }),
+  handler: ({ schema, response }) => {
+    return response.created({
+      user: {
+        name: schema.name,
+        email: schema.email
+      }
+    })
+  }
+})
+```
+
+### URL Parameters
+
+```typescript
+import { Router } from '@asterflow/router'
+
+const router = new Router({
+  // Supports dynamic parameters (:id), 
+  // query strings (?page) and 
+  // fragments (#section)
+  path: '/users/:id=number?page#section',
+  methods: {
+    get({ url, response }) {
+      console.log(url.getParams())      // { id: number }
+      console.log(url.getSearchParams()) // { page: string }
+      console.log(url.getFragment())     // 'section'
+      return response.success({ /* ... */ })
+    }
+  }
+})
+```
+
+### Integrating with Fastify
+
+```typescript
+import { adapters } from '@asterflow/adapter'
+import { AsterFlow } from '@asterflow/core'
+import fastify from 'fastify'
+
+const server = fastify()
+const app = new AsterFlow({ 
+  driver: adapters.fastify 
+})
+
+// Add routes
+app.controller(router)
+
+// Start the server
+app.listen(server, { port: 3333 }, (err) => {
+  if (err) {
+    console.error(err)
+    process.exit(1)
+  }
+  console.log('Server listening!')
+})
+```
+
+## 📚 API Reference
+
+### Router Class
+
+```typescript
+class Router<
+  Path extends string,
+  Method extends MethodKeys,
+  Schema extends SchemaDynamic<Method>,
+  Responder extends Responders,
+  Middlewares extends readonly Middleware[]
+> {
+  constructor(options: {
+    path: Path
+    name?: string
+    description?: string
+    use?: Middlewares
+    schema?: Schema
+    methods: {
+      [M in MethodKeys]?: RouteHandler
+    }
+  })
+}
+```
+
+### Method Class
+
+```typescript
+class Method<
+  Responder extends Responders,
+  Path extends string,
+  Method extends MethodKeys,
+  Schema extends AnySchema,
+  Middlewares extends readonly Middleware[]
+> {
+  constructor(options: {
+    path: Path
+    method: Method
+    name?: string
+    schema?: Schema
+    use?: Middlewares
+    handler: MethodHandler
+  })
+}
+```
+
+### Response Class
+
+```typescript
+class Response<Responder extends Responders> {
+  // Status Methods
+  success(data: Responder[200]): Response
+  created(data: Responder[201]): Response
+  noContent(data: Responder[204]): Response
+  badRequest(data: Responder[400]): Response
+  unauthorized(data: Responder[401]): Response
+  forbidden(data: Responder[403]): Response
+  notFound(data: Responder[404]): Response
+
+  // Headers and Cookies
+  setHeader(name: string, value: string): Response
+  setCookie(name: string, value: string): Response
+
+  // Conversion
+  toResponse(): globalThis.Response
+  toServerResponse(output: ServerResponse): void
+}
+```
+
+### Middleware Class
+
+```typescript
+class Middleware<
+  Responder extends Responders,
+  Schema extends AnySchema,
+  Name extends string,
+  Parameters extends Record<string, unknown>
+> {
+  constructor(options: {
+    name: Name
+    onRun: (args: {
+      request: Request
+      response: Response<Responder>
+      schema: InferSchema<Schema>
+      next: (params: Parameters) => MiddlewareOptions
+    }) => MiddlewareOptions
+  })
+}
+```
+
+## 🔗 Related Packages
+
+- [@asterflow/core](https://github.com/Ashu11-A/AsterFlow/tree/main/core) - Core framework
+- [@asterflow/adapter](https://github.com/Ashu11-A/AsterFlow/tree/main/packages/adapter) - Adapters for different HTTP servers
+
+## 📄 License
+
+MIT - See [LICENSE](https://github.com/Ashu11-A/AsterFlow/blob/main/LICENSE) for more details.

package/dist/cjs/index.cjs

@@ -0,0 +1,165 @@
+"use strict";
+var d = Object.defineProperty;
+var M = Object.getOwnPropertyDescriptor;
+var u = Object.getOwnPropertyNames;
+var w = Object.prototype.hasOwnProperty;
+var R = (n, e) => {
+  for (var t in e)
+    d(n, t, { get: e[t], enumerable: !0 });
+}, x = (n, e, t, o) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let s of u(e))
+      !w.call(n, s) && s !== t && d(n, s, { get: () => e[s], enumerable: !(o = M(e, s)) || o.enumerable });
+  return n;
+};
+var f = (n) => x(d({}, "__esModule", { value: !0 }), n);
+
+// packages/router/src/index.ts
+var g = {};
+R(g, {
+  Method: () => h,
+  MethodType: () => l,
+  Middleware: () => p,
+  Response: () => i,
+  Router: () => a
+});
+module.exports = f(g);
+
+// packages/router/src/controllers/Router.ts
+var c = require("url-ast"), a = class {
+  name;
+  path;
+  schema;
+  description;
+  methods;
+  use;
+  url;
+  constructor(e) {
+    let { name: t, path: o, schema: s, description: r, methods: y } = e;
+    this.name = t, this.path = o, this.schema = s, this.description = r, this.methods = y, this.use = e.use, this.url = new c.Analyze(this.path);
+  }
+};
+
+// packages/router/src/controllers/Response.ts
+var i = class n {
+  _status;
+  body;
+  header;
+  cookies;
+  constructor(e) {
+    this._status = e?.code ?? 200, this.body = e?.data, this.header = e?.header ?? /* @__PURE__ */ new Map(), this.cookies = e?.cookies ?? /* @__PURE__ */ new Map();
+  }
+  clone(e) {
+    return new n({
+      code: e.code !== void 0 ? e.code : this._status,
+      data: e.data !== void 0 ? e.data : this.body,
+      header: e.header !== void 0 ? e.header : this.header,
+      cookies: e.cookies !== void 0 ? e.cookies : this.cookies
+    });
+  }
+  // --- Core Methods ---
+  status(e) {
+    return this.clone({ code: e });
+  }
+  getStatus() {
+    return this._status;
+  }
+  code(e) {
+    return this.status(e);
+  }
+  send(e) {
+    return this.clone({ data: e });
+  }
+  json(e) {
+    let t = new Map(this.header);
+    return t.set("Content-Type", "application/json"), this.clone({ data: e, header: t });
+  }
+  // --- Response Helpers ---
+  success(e) {
+    return this.clone({ code: 200, data: e });
+  }
+  created(e) {
+    return this.clone({ code: 201, data: e });
+  }
+  noContent(e) {
+    return this.clone({ code: 204, data: e });
+  }
+  badRequest(e) {
+    return this.clone({ code: 400, data: e });
+  }
+  zodError(e) {
+    return this.clone({ code: 422, data: e });
+  }
+  unauthorized(e) {
+    return this.clone({ code: 401, data: e });
+  }
+  forbidden(e) {
+    return this.clone({ code: 403, data: e });
+  }
+  notFound(e) {
+    return this.clone({ code: 404, data: e });
+  }
+  setHeader(e, t) {
+    let o = new Map(this.header);
+    return o.set(e, t), this.clone({ header: o });
+  }
+  setCookie(e, t) {
+    let o = new Map(this.cookies);
+    return o.set(e, t), this.clone({ cookies: o });
+  }
+  toResponse() {
+    let e = new Headers();
+    e.set("Content-Type", "text/plain");
+    for (let [o, s] of this.header) e.set(o, s);
+    (typeof this.body == "object" || Array.isArray(this.body)) && e.set("Content-Type", "application/json");
+    for (let [o, s] of this.cookies) e.append("Set-Cookie", `${o}=${s}`);
+    let t = e.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    return new globalThis.Response(t, {
+      status: this._status,
+      headers: e
+    });
+  }
+  toServerResponse(e) {
+    let t = new Headers();
+    t.set("Content-Type", "text/plain");
+    for (let [s, r] of this.header) t.set(s, r);
+    (typeof this.body == "object" || Array.isArray(this.body)) && t.set("Content-Type", "application/json");
+    for (let [s, r] of this.cookies) t.append("Set-Cookie", `${s}=${r}`);
+    let o = t.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    e.writeHead(this._status, Object.fromEntries(t)), e.end(o);
+  }
+};
+
+// packages/router/src/controllers/Middleware.ts
+var p = class {
+  name;
+  onRun;
+  constructor(e) {
+    this.name = e.name, this.onRun = e.onRun;
+  }
+};
+
+// packages/router/src/controllers/Method.ts
+var m = require("url-ast"), h = class {
+  path;
+  url;
+  method;
+  schema;
+  name;
+  use;
+  handler;
+  constructor(e) {
+    this.path = e.path, this.url = new m.Analyze(this.path), this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
+  }
+};
+
+// packages/router/src/types/method.ts
+var N = require("url-ast"), l = /* @__PURE__ */ ((s) => (s.get = "get", s.post = "post", s.put = "put", s.delete = "delete", s))(l || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Method,
+  MethodType,
+  Middleware,
+  Response,
+  Router
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/mjs/index.js

@@ -0,0 +1,140 @@
+// packages/router/src/controllers/Router.ts
+import { Analyze as c } from "url-ast";
+var d = class {
+  name;
+  path;
+  schema;
+  description;
+  methods;
+  use;
+  url;
+  constructor(e) {
+    let { name: t, path: o, schema: s, description: n, methods: h } = e;
+    this.name = t, this.path = o, this.schema = s, this.description = n, this.methods = h, this.use = e.use, this.url = new c(this.path);
+  }
+};
+
+// packages/router/src/controllers/Response.ts
+var a = class r {
+  _status;
+  body;
+  header;
+  cookies;
+  constructor(e) {
+    this._status = e?.code ?? 200, this.body = e?.data, this.header = e?.header ?? /* @__PURE__ */ new Map(), this.cookies = e?.cookies ?? /* @__PURE__ */ new Map();
+  }
+  clone(e) {
+    return new r({
+      code: e.code !== void 0 ? e.code : this._status,
+      data: e.data !== void 0 ? e.data : this.body,
+      header: e.header !== void 0 ? e.header : this.header,
+      cookies: e.cookies !== void 0 ? e.cookies : this.cookies
+    });
+  }
+  // --- Core Methods ---
+  status(e) {
+    return this.clone({ code: e });
+  }
+  getStatus() {
+    return this._status;
+  }
+  code(e) {
+    return this.status(e);
+  }
+  send(e) {
+    return this.clone({ data: e });
+  }
+  json(e) {
+    let t = new Map(this.header);
+    return t.set("Content-Type", "application/json"), this.clone({ data: e, header: t });
+  }
+  // --- Response Helpers ---
+  success(e) {
+    return this.clone({ code: 200, data: e });
+  }
+  created(e) {
+    return this.clone({ code: 201, data: e });
+  }
+  noContent(e) {
+    return this.clone({ code: 204, data: e });
+  }
+  badRequest(e) {
+    return this.clone({ code: 400, data: e });
+  }
+  zodError(e) {
+    return this.clone({ code: 422, data: e });
+  }
+  unauthorized(e) {
+    return this.clone({ code: 401, data: e });
+  }
+  forbidden(e) {
+    return this.clone({ code: 403, data: e });
+  }
+  notFound(e) {
+    return this.clone({ code: 404, data: e });
+  }
+  setHeader(e, t) {
+    let o = new Map(this.header);
+    return o.set(e, t), this.clone({ header: o });
+  }
+  setCookie(e, t) {
+    let o = new Map(this.cookies);
+    return o.set(e, t), this.clone({ cookies: o });
+  }
+  toResponse() {
+    let e = new Headers();
+    e.set("Content-Type", "text/plain");
+    for (let [o, s] of this.header) e.set(o, s);
+    (typeof this.body == "object" || Array.isArray(this.body)) && e.set("Content-Type", "application/json");
+    for (let [o, s] of this.cookies) e.append("Set-Cookie", `${o}=${s}`);
+    let t = e.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    return new globalThis.Response(t, {
+      status: this._status,
+      headers: e
+    });
+  }
+  toServerResponse(e) {
+    let t = new Headers();
+    t.set("Content-Type", "text/plain");
+    for (let [s, n] of this.header) t.set(s, n);
+    (typeof this.body == "object" || Array.isArray(this.body)) && t.set("Content-Type", "application/json");
+    for (let [s, n] of this.cookies) t.append("Set-Cookie", `${s}=${n}`);
+    let o = t.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    e.writeHead(this._status, Object.fromEntries(t)), e.end(o);
+  }
+};
+
+// packages/router/src/controllers/Middleware.ts
+var i = class {
+  name;
+  onRun;
+  constructor(e) {
+    this.name = e.name, this.onRun = e.onRun;
+  }
+};
+
+// packages/router/src/controllers/Method.ts
+import { Analyze as m } from "url-ast";
+var p = class {
+  path;
+  url;
+  method;
+  schema;
+  name;
+  use;
+  handler;
+  constructor(e) {
+    this.path = e.path, this.url = new m(this.path), this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
+  }
+};
+
+// packages/router/src/types/method.ts
+import "url-ast";
+var l = /* @__PURE__ */ ((s) => (s.get = "get", s.post = "post", s.put = "put", s.delete = "delete", s))(l || {});
+export {
+  p as Method,
+  l as MethodType,
+  i as Middleware,
+  a as Response,
+  d as Router
+};

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/types/controllers/Method.d.ts

@@ -0,0 +1,16 @@
+import { Analyze } from 'url-ast';
+import type { MethodHandler, MethodKeys, MethodOptions } from '../types/method';
+import type { MiddlewareOutput } from '../types/mindleware';
+import type { Responders } from '../types/response';
+import type { AnySchema } from '../types/schema';
+import type { Middleware } from './Middleware';
+export declare class Method<Responder extends Responders, const Path extends string = string, const Method extends MethodKeys = MethodKeys, const Schema extends AnySchema = AnySchema, const Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Handler extends MethodHandler<Path, Responder, Schema, Middlewares, Context> = MethodHandler<Path, Responder, Schema, Middlewares, Context>> {
+    path: Path;
+    url: Analyze<Path>;
+    method: Method;
+    schema?: Schema;
+    name?: string;
+    use?: Middlewares;
+    handler: Handler;
+    constructor(options: MethodOptions<Responder, Path, Method, Schema, Middlewares, Context, Handler>);
+}

package/dist/types/controllers/Middleware.d.ts

@@ -0,0 +1,13 @@
+import type { MiddlewareOptions } from '../types/mindleware';
+import type { Responders } from '../types/response';
+import type { AnySchema } from '../types/schema';
+export declare class Middleware<Responder extends Responders, Schema extends AnySchema, const Name extends string = string, const Parameters extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: Name;
+    readonly onRun: <RequestType>(args: {
+        response: import("./Response").Response<Responder, import("..").BodyMap<Responder>, keyof Responder, Map<string, string>, Map<string, string>>;
+        request: import("@asterflow/request").Request<RequestType>;
+        schema: import("..").InferSchema<Schema>;
+        next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;
+    }) => MiddlewareOptions<Responder, Schema, Name, Parameters>;
+    constructor(options: MiddlewareOptions<Responder, Schema, Name, Parameters>);
+}

package/dist/types/controllers/Response.d.ts

@@ -0,0 +1,37 @@
+import type { BodyMap, Responders, ResponseOptions } from '../types/response';
+import { ServerResponse } from 'http';
+export declare class Response<Responder extends Responders = Responders, BM extends BodyMap<Responder> = BodyMap<Responder>, Status extends keyof BM = keyof BM, Header extends Map<string, string> = Map<string, string>, Cookies extends Map<string, string> = Map<string, string>> {
+    protected readonly _status: Status;
+    readonly body?: BM[Status];
+    readonly header: Header;
+    readonly cookies: Cookies;
+    constructor(options?: ResponseOptions<Responder, BM, Status, Header, Cookies>);
+    protected clone<NewHeader extends Map<string, string> = Header, NewCookies extends Map<string, string> = Cookies>(overrides: {
+        data?: BM[Status];
+        header?: NewHeader;
+        cookies?: NewCookies;
+    }): Response<Responder, BM, Status, NewHeader, NewCookies>;
+    protected clone<NewStatus extends keyof BM, NewCookies extends Map<string, string> = Cookies>(overrides: {
+        code: NewStatus;
+        data?: BM[NewStatus];
+        header?: Header;
+        cookies?: NewCookies;
+    }): Response<Responder, BM, NewStatus, Header, NewCookies>;
+    status<NS extends keyof BM>(code: NS): Response<Responder, BM, NS, Header, Cookies>;
+    getStatus(): Status;
+    code<NS extends keyof BM>(code: NS): Response<Responder, BM, NS, Header, Cookies>;
+    send(data: BM[Status]): Response<Responder, BM, Status, Header, Cookies>;
+    json(data: BM[Status]): Response<Responder, BM, Status, Header & Map<"Content-Type", "application/json">, Cookies>;
+    success(data: BM[200]): Response<Responder, BM, 200, Header, Cookies>;
+    created(data: BM[201]): Response<Responder, BM, 201, Header, Cookies>;
+    noContent(data: BM[204]): Response<Responder, BM, 204, Header, Cookies>;
+    badRequest(data: BM[400]): Response<Responder, BM, 400, Header, Cookies>;
+    zodError(data: BM[422]): Response<Responder, BM, 422, Header, Cookies>;
+    unauthorized(data: BM[401]): Response<Responder, BM, 401, Header, Cookies>;
+    forbidden(data: BM[403]): Response<Responder, BM, 403, Header, Cookies>;
+    notFound(data: BM[404]): Response<Responder, BM, 404, Header, Cookies>;
+    setHeader<Name extends string, Value extends string>(name: Name, value: Value): Response<Responder, BM, Status, Header & Map<Name, Value>, Cookies>;
+    setCookie<Name extends string, Value extends string>(name: Name, value: Value): Response<Responder, BM, Status, Header, Cookies & Map<Name, Value>>;
+    toResponse(): globalThis.Response;
+    toServerResponse(output: ServerResponse): void;
+}

package/dist/types/controllers/Router.d.ts

@@ -0,0 +1,19 @@
+import { Analyze } from 'url-ast';
+import type { MiddlewareOutput } from '../types/mindleware';
+import type { AnySchema, SchemaDynamic } from '../types/schema';
+import type { Middleware } from './Middleware';
+import type { MethodKeys } from '../types/method';
+import type { Responders } from '../types/response';
+import type { RouteHandler, RouterOptions } from '../types/router';
+export declare class Router<Path extends string, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Responder extends Responders, const Routers extends {
+    [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
+}, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[] = [], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>> {
+    readonly name?: string;
+    readonly path: Path;
+    readonly schema?: Schema;
+    readonly description?: string;
+    readonly methods: Routers;
+    readonly use?: Middlewares;
+    url: Analyze<Path>;
+    constructor(options: RouterOptions<Path, Method, Schema, Responder, Middlewares, Context, Routers>);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './controllers/Router';
+export * from './controllers/Response';
+export * from './controllers/Middleware';
+export * from './controllers/Method';
+export * from './types/router';
+export * from './types/schema';
+export * from './types/response';
+export * from './types/method';
+export * from './types/mindleware';

package/dist/types/types/method.d.ts

@@ -0,0 +1,33 @@
+import type { Request } from '@asterflow/request';
+import type { Middleware } from '../controllers/Middleware';
+import type { Response } from '../controllers/Response';
+import type { AnyMiddleware, MiddlewareOutput } from './mindleware';
+import type { Responders } from './response';
+import type { AnySchema, InferSchema } from './schema';
+import { Analyze, type ParsePath } from 'url-ast';
+export declare enum MethodType {
+    get = "get",
+    post = "post",
+    put = "put",
+    delete = "delete"
+}
+export type MethodKeys = keyof typeof MethodType;
+export type AnyMethodHandler = {
+    [Method in MethodKeys]?: MethodHandler<string, Responders, AnySchema, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>>;
+};
+export type MethodHandler<Path extends string, Responder extends Responders, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>> = <RequestType>(args: {
+    request: Request<RequestType>;
+    response: Response<Responder>;
+    url: Analyze<Path, ParsePath<Path>, Analyze<any>>;
+    schema: InferSchema<Schema>;
+    middleware: Context;
+}) => Promise<Response<Responder>> | Response<Responder>;
+export type MethodOptions<Responder extends Responders, Path extends string, Method extends MethodKeys, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Handler extends MethodHandler<Path, Responder, Schema, Middlewares, Context>> = {
+    path: Path;
+    name?: string;
+    description?: string;
+    use?: Middlewares;
+    method: Method;
+    schema?: Schema;
+    handler: Handler;
+};

package/dist/types/types/mindleware.d.ts

@@ -0,0 +1,19 @@
+import type { Request } from '@asterflow/request';
+import type { Middleware } from '../controllers/Middleware';
+import type { Response } from '../controllers/Response';
+import type { Responders } from './response';
+import type { AnySchema, InferSchema } from './schema';
+export type AnyMiddleware = Middleware<any, any, any, any>;
+/**
+ * Accumulate the output types (`P`) from an array of middlewares into a single object
+ */
+export type MiddlewareOutput<Ms extends readonly AnyMiddleware[]> = Ms extends readonly [infer First, ...infer Rest] ? First extends Middleware<any, any, any, infer P> ? Rest extends readonly AnyMiddleware[] ? P & MiddlewareOutput<Rest> : P : unknown : unknown;
+export type MiddlewareOptions<Responder extends Responders = Responders, Schema extends AnySchema = AnySchema, Name extends string = string, Parameters extends Record<string, unknown> = Record<string, unknown>> = {
+    name: Name;
+    onRun<RequestType>(args: {
+        response: Response<Responder>;
+        request: Request<RequestType>;
+        schema: InferSchema<Schema>;
+        next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;
+    }): MiddlewareOptions<Responder, Schema, Name, Parameters>;
+};

package/dist/types/types/response.d.ts

@@ -0,0 +1,12 @@
+export type Responders = {
+    [x in number]: unknown;
+};
+export type BodyMap<Responder extends Responders> = {
+    [S in keyof Responder]: Responder[S];
+};
+export type ResponseOptions<Responder extends Responders, BM extends BodyMap<Responder>, Status extends keyof BM, Header extends Map<string, string>, Cookies extends Map<string, string>> = {
+    data?: BM[Status];
+    code?: Status;
+    header?: Header;
+    cookies?: Cookies;
+};

package/dist/types/types/router.d.ts

@@ -0,0 +1,31 @@
+import type { Request } from '@asterflow/request';
+import type { Analyze, ParsePath } from 'url-ast';
+import type { Method } from '../controllers/Method';
+import type { Middleware } from '../controllers/Middleware';
+import type { Response } from '../controllers/Response';
+import type { Router } from '../controllers/Router';
+import type { MethodKeys } from './method';
+import type { AnyMiddleware, MiddlewareOutput } from './mindleware';
+import type { Responders } from './response';
+import type { AnySchema, InferredData, SchemaDynamic } from './schema';
+export type AnyRouteHandler = {
+    [Method in MethodKeys]?: RouteHandler<string, Responders, Method, SchemaDynamic<Method>, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>>;
+};
+export type AnyRouter = Router<string, MethodKeys, SchemaDynamic<MethodKeys>, Responders, AnyRouteHandler, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>> | Method<Responders, string, MethodKeys, AnySchema, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>, any>;
+export type RouteHandler<Path extends string, Responder extends Responders, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>> = <RequestType>(args: {
+    request: Request<RequestType>;
+    response: Response<Responder>;
+    url: Analyze<Path, ParsePath<Path>, Analyze<any>>;
+    schema: InferredData<Method, Schema>;
+    middleware: Context;
+}) => Promise<Response> | Response;
+export type RouterOptions<Path extends string, Method extends MethodKeys, Schema extends SchemaDynamic<Method>, Responder extends Responders, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Routers extends {
+    [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
+}> = {
+    name?: string;
+    description?: string;
+    path: Path;
+    use?: Middlewares;
+    schema?: Schema;
+    methods: Routers;
+};

package/dist/types/types/schema.d.ts

@@ -0,0 +1,9 @@
+import type { TshViewer, AbstractShape } from '@caeljs/tsh';
+import type { TypeOf, ZodTypeAny } from 'zod';
+import type { MethodKeys } from './method';
+export type AnySchema = AbstractShape<any> | ZodTypeAny;
+export type SchemaDynamic<Method extends MethodKeys> = {
+    [K in Method]?: AnySchema;
+};
+export type InferSchema<S> = S extends AbstractShape<any> ? TshViewer<ReturnType<S['parse']>> : S extends ZodTypeAny ? TypeOf<S> : never;
+export type InferredData<Method extends MethodKeys, Schema extends SchemaDynamic<Method>> = InferSchema<Schema[Method]>;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@asterflow/router",
+  "version": "1.0.1",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/mjs/index.js",
+  "types": "dist/types/index.d.ts",
+  "typings": "dist/types/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@asterflow/request": "workspace:^1.0.1",
+    "@caeljs/tsh": "^1.1.3",
+    "@types/bun": "latest",
+    "fastify": "^5.3.3",
+    "zod": "^3.25.57"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "url-ast": "^1.0.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": [
+    "dist"
+  ]
+}