@asterflow/router 1.0.2 → 1.0.4

package/README.md

@@ -156,100 +156,12 @@ app.listen(server, { port: 3333 }, (err) => {
 })
 ```
 
-## 📚 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
+- [@asterflow/core](https://www.npmjs.com/package/@asterflow/core) - Core framework
+- [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - Adapters for different HTTP servers
+- [@asterflow/response](https://www.npmjs.com/package/@asterflow/response) - Type-safe HTTP response system
+- [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - Unified HTTP request system
 
 ## 📄 License
 

package/dist/cjs/index.cjs

@@ -1,32 +1,32 @@
 "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) => {
+var n = Object.defineProperty;
+var y = Object.getOwnPropertyDescriptor;
+var M = Object.getOwnPropertyNames;
+var u = Object.prototype.hasOwnProperty;
+var w = (t, e) => {
+  for (var s in e)
+    n(t, s, { get: e[s], enumerable: !0 });
+}, R = (t, e, s, d) => {
   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;
+    for (let r of M(e))
+      !u.call(t, r) && r !== s && n(t, r, { get: () => e[r], enumerable: !(d = y(e, r)) || d.enumerable });
+  return t;
 };
-var f = (n) => x(d({}, "__esModule", { value: !0 }), n);
+var x = (t) => R(n({}, "__esModule", { value: !0 }), t);
 
 // packages/router/src/index.ts
-var g = {};
-R(g, {
-  Method: () => h,
-  MethodType: () => l,
-  Middleware: () => p,
-  Response: () => i,
-  Router: () => a
+var S = {};
+w(S, {
+  Method: () => p,
+  MethodType: () => h,
+  Middleware: () => a,
+  Router: () => o,
+  createRouter: () => f
 });
-module.exports = f(g);
+module.exports = x(S);
 
 // packages/router/src/controllers/Router.ts
-var c = require("url-ast"), a = class {
+var m = require("url-ast"), o = class {
   name;
   path;
   schema;
@@ -35,103 +35,13 @@ var c = require("url-ast"), a = class {
   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);
+    let { name: s, path: d, schema: r, description: l, methods: c } = e;
+    this.name = s, this.path = d, this.schema = r, this.description = l, this.methods = c, this.use = e.use, this.url = new m.Analyze(this.path);
   }
 };
 
 // packages/router/src/controllers/Middleware.ts
-var p = class {
+var a = class {
   name;
   onRun;
   constructor(e) {
@@ -140,7 +50,7 @@ var p = class {
 };
 
 // packages/router/src/controllers/Method.ts
-var m = require("url-ast"), h = class {
+var i = require("url-ast"), p = class {
   path;
   url;
   method;
@@ -149,17 +59,22 @@ var m = require("url-ast"), h = class {
   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;
+    this.path = e.path, this.url = new i.Analyze(this.path), this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
   }
 };
 
+// packages/router/src/controllers/createRouter.ts
+function f() {
+  return (t) => new o(t);
+}
+
 // 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 || {});
+var h = /* @__PURE__ */ ((r) => (r.get = "get", r.post = "post", r.put = "put", r.delete = "delete", r))(h || {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Method,
   MethodType,
   Middleware,
-  Response,
-  Router
+  Router,
+  createRouter
 });

package/dist/mjs/index.js

@@ -1,6 +1,6 @@
 // packages/router/src/controllers/Router.ts
-import { Analyze as c } from "url-ast";
-var d = class {
+import { Analyze as i } from "url-ast";
+var s = class {
   name;
   path;
   schema;
@@ -9,103 +9,13 @@ var d = class {
   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);
+    let { name: n, path: a, schema: t, description: p, methods: m } = e;
+    this.name = n, this.path = a, this.schema = t, this.description = p, this.methods = m, this.use = e.use, this.url = new i(this.path);
   }
 };
 
 // packages/router/src/controllers/Middleware.ts
-var i = class {
+var o = class {
   name;
   onRun;
   constructor(e) {
@@ -114,8 +24,8 @@ var i = class {
 };
 
 // packages/router/src/controllers/Method.ts
-import { Analyze as m } from "url-ast";
-var p = class {
+import { Analyze as h } from "url-ast";
+var d = class {
   path;
   url;
   method;
@@ -124,17 +34,21 @@ var p = class {
   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;
+    this.path = e.path, this.url = new h(this.path), this.method = e.method, this.schema = e.schema, this.handler = e.handler, this.use = e.use;
   }
 };
 
+// packages/router/src/controllers/createRouter.ts
+function x() {
+  return (r) => new s(r);
+}
+
 // 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 || {});
+var l = /* @__PURE__ */ ((t) => (t.get = "get", t.post = "post", t.put = "put", t.delete = "delete", t))(l || {});
 export {
-  p as Method,
+  d as Method,
   l as MethodType,
-  i as Middleware,
-  a as Response,
-  d as Router
+  o as Middleware,
+  s as Router,
+  x as createRouter
 };

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

@@ -1,7 +1,7 @@
+import type { Responders } from '@asterflow/response';
 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>> {

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

@@ -1,10 +1,10 @@
 import type { MiddlewareOptions } from '../types/mindleware';
-import type { Responders } from '../types/response';
+import type { Responders } from '@asterflow/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>>;
+        response: import("@asterflow/response").Response<Responder, import("@asterflow/response").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>;

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

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

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

@@ -0,0 +1,12 @@
+import type { Responders } from '@asterflow/response';
+import type { AnySchema, SchemaDynamic } from '../types/schema';
+import type { Middleware } from './Middleware';
+import type { MethodKeys } from '../types/method';
+import type { MiddlewareOutput } from '../types/mindleware';
+import type { RouteHandler, RouterOptions } from '../types/router';
+import { Router } from './Router';
+/**
+ * Starts building a Router, setting the expected response types.
+ * @returns An object with the `from` method to define the router options.
+ */
+export declare function createRouter<Responder extends Responders>(): <const Path extends string, const Schema extends SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], const Context extends MiddlewareOutput<Middlewares>, const Routers extends { [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>; }>(options: RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>) => Router<Responder, Path, Schema, Middlewares, Context, Routers>;

package/dist/types/index.d.ts

@@ -1,9 +1,8 @@
 export * from './controllers/Router';
-export * from './controllers/Response';
 export * from './controllers/Middleware';
 export * from './controllers/Method';
+export * from './controllers/createRouter';
 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

@@ -1,10 +1,9 @@
 import type { Request } from '@asterflow/request';
+import type { Responders, Response } from '@asterflow/response';
+import type { Analyze, ParsePath } from 'url-ast';
 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",
@@ -18,7 +17,7 @@ export type AnyMethodHandler = {
 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>>;
+    url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
     schema: InferSchema<Schema>;
     middleware: Context;
 }) => Promise<Response<Responder>> | Response<Responder>;

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

@@ -1,7 +1,6 @@
 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 { Response, Responders } from '@asterflow/response';
 import type { AnySchema, InferSchema } from './schema';
 export type AnyMiddleware = Middleware<any, any, any, any>;
 /**

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

@@ -1,25 +1,24 @@
 import type { Request } from '@asterflow/request';
+import type { Responders, Response } from '@asterflow/response';
 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 AnyRouter = Router<Responders, string, SchemaDynamic<MethodKeys>, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>, AnyRouteHandler> | 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>>;
+    url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
     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 {
+export type RouterOptions<Path extends string, Schema extends SchemaDynamic<MethodKeys>, 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asterflow/router",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -18,16 +18,17 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@asterflow/request": "1.0.2",
+    "@asterflow/request": "1.0.4",
+    "@asterflow/response": "1.0.1",
     "@caeljs/tsh": "^1.1.3",
     "@types/bun": "latest",
     "fastify": "^5.3.3",
-    "zod": "^3.25.57"
+    "zod": "^3.25.62"
   },
   "peerDependencies": {
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "url-ast": "^1.0.2"
+    "url-ast": "^1.0.3"
   }
 }

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

@@ -1,37 +0,0 @@
-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/types/response.d.ts

@@ -1,12 +0,0 @@
-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;
-};