@asterflow/router 1.0.7 → 1.0.8

package/README.md

@@ -4,12 +4,8 @@
 
 ![license-info](https://img.shields.io/github/license/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
 ![stars-info](https://img.shields.io/github/stars/AsterFlow/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=packages%2Frequest&style=for-the-badge&colorA=302D41&colorB=b4befe)
 
-![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=b4befe)
-![commit-activity](https://img.shields.io/github/commit-activity/y/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af)
-![code-size](https://img.shields.io/github/languages/code-size/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=90dceb)
-
-![top-language](https://img.shields.io/github/languages/top/AsterFlow/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>

package/dist/cjs/index.cjs

@@ -1,30 +1,29 @@
 "use strict";
-var a = Object.defineProperty;
+var d = Object.defineProperty;
 var w = Object.getOwnPropertyDescriptor;
 var u = Object.getOwnPropertyNames;
 var M = Object.prototype.hasOwnProperty;
-var R = (t, e) => {
+var x = (t, e) => {
   for (var n in e)
-    a(t, n, { get: e[n], enumerable: !0 });
-}, x = (t, e, n, d) => {
+    d(t, n, { get: e[n], enumerable: !0 });
+}, R = (t, e, n, o) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let s of u(e))
-      !M.call(t, s) && s !== n && a(t, s, { get: () => e[s], enumerable: !(d = w(e, s)) || d.enumerable });
+      !M.call(t, s) && s !== n && d(t, s, { get: () => e[s], enumerable: !(o = w(e, s)) || o.enumerable });
   return t;
 };
-var f = (t) => x(a({}, "__esModule", { value: !0 }), t);
+var f = (t) => R(d({}, "__esModule", { value: !0 }), t);
 // packages/router/src/index.ts
 var A = {};
-R(A, {
-  Method: () => m,
+x(A, {
+  Method: () => p,
   MethodType: () => l,
-  Middleware: () => p,
-  Router: () => o,
-  createRouter: () => S
+  Middleware: () => i,
+  Router: () => a
 });
 module.exports = f(A);
 // packages/router/src/controllers/Router.ts
-var i = require("@asterflow/url-parser"), o = class {
+var m = require("@asterflow/url-parser"), a = class t {
   name;
   path;
   schema;
@@ -33,12 +32,15 @@ var i = require("@asterflow/url-parser"), o = class {
   use;
   url;
   constructor(e) {
-    let { name: n, path: d, schema: s, description: c, methods: y } = e;
-    this.name = n, this.path = d, this.schema = s, this.description = c, this.methods = y, this.use = e.use, this.url = new i.Analyze(this.path);
+    let { name: n, path: o, schema: s, description: c, methods: y } = e;
+    this.name = n, this.path = o, this.schema = s, this.description = c, this.methods = y, this.use = e.use, this.url = new m.Analyze(this.path);
+  }
+  static create() {
+    return (e) => new t(e);
   }
 };
 // packages/router/src/controllers/Middleware.ts
-var p = class {
+var i = class {
   name;
   onRun;
   constructor(e) {
@@ -46,7 +48,7 @@ var p = class {
   }
 };
 // packages/router/src/controllers/Method.ts
-var h = require("@asterflow/url-parser"), m = class {
+var h = require("@asterflow/url-parser"), p = class {
   path;
   url;
   method;
@@ -58,16 +60,11 @@ var h = require("@asterflow/url-parser"), m = class {
     this.path = e.path, this.url = new h.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 S() {
-  return (t) => new o(t);
-}
 // packages/router/src/types/method.ts
 var l =  ((r) => (r.all = "all", r.get = "get", r.post = "post", r.put = "put", r.delete = "delete", r.options = "options", r.head = "head", r.patch = "patch", r))(l || {});
 0 && (module.exports = {
   Method,
   MethodType,
   Middleware,
-  Router,
-  createRouter
+  Router
 });

package/dist/mjs/index.js

@@ -1,6 +1,6 @@
 // packages/router/src/controllers/Router.ts
 import { Analyze as h } from "@asterflow/url-parser";
-var s = class {
+var s = class r {
   name;
   path;
   schema;
@@ -9,8 +9,11 @@ var s = class {
   use;
   url;
   constructor(e) {
-    let { name: d, path: a, schema: p, description: m, methods: i } = e;
-    this.name = d, this.path = a, this.schema = p, this.description = m, this.methods = i, this.use = e.use, this.url = new h(this.path);
+    let { name: d, path: a, schema: i, description: p, methods: m } = e;
+    this.name = d, this.path = a, this.schema = i, this.description = p, this.methods = m, this.use = e.use, this.url = new h(this.path);
+  }
+  static create() {
+    return (e) => new r(e);
   }
 };
 // packages/router/src/controllers/Middleware.ts
@@ -35,16 +38,11 @@ var o = class {
     this.path = e.path, this.url = new l(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 (r) => new s(r);
-}
 // packages/router/src/types/method.ts
 var c =  ((t) => (t.all = "all", t.get = "get", t.post = "post", t.put = "put", t.delete = "delete", t.options = "options", t.head = "head", t.patch = "patch", t))(c || {});
 export {
   o as Method,
   c as MethodType,
   n as Middleware,
-  s as Router,
-  f as createRouter
+  s as Router
 };

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

@@ -1,3 +1,4 @@
+import type { Runtime } from '@asterflow/adapter';
 import type { AnyAsterflow } from '@asterflow/core';
 import type { Responders } from '@asterflow/response';
 import { Analyze } from '@asterflow/url-parser';
@@ -5,7 +6,7 @@ import type { MethodHandler, MethodKeys, MethodOptions } from '../types/method';
 import type { MiddlewareOutput } from '../types/mindleware';
 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 Instance extends AnyAsterflow = AnyAsterflow, const Handler extends MethodHandler<Path, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Responder, Schema, Middlewares, Context, Instance>> {
+export declare class Method<Responder extends Responders, const Path extends string = string, const Drive extends Runtime = Runtime, 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 Instance extends AnyAsterflow = AnyAsterflow, const Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> {
     path: Path;
     url: Analyze<Path>;
     method: Method;
@@ -13,5 +14,5 @@ export declare class Method<Responder extends Responders, const Path extends str
     name?: string;
     use?: Middlewares;
     handler: Handler;
-    constructor(options: MethodOptions<Responder, Path, Method, Schema, Middlewares, Context, Instance, Handler>);
+    constructor(options: MethodOptions<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler>);
 }

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

@@ -1,11 +1,11 @@
-import type { MiddlewareOptions } from '../types/mindleware';
 import type { Responders } from '@asterflow/response';
+import type { MiddlewareOptions } from '../types/mindleware';
 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("@asterflow/response").Response<Responder, import("@asterflow/response").BodyMap<Responder>, keyof Responder, Map<string, string>, Map<string, string>>;
-        request: import("@asterflow/request").Request<RequestType>;
+    readonly onRun: <RequestType extends import("@asterflow/adapter").Runtime>(args: {
+        response: import("@asterflow/response").AsterResponse<Responder, import("@asterflow/response").BodyMap<Responder>, keyof Responder, import("@asterflow/response").BaseContext>;
+        request: import("@asterflow/request").AsterRequest<RequestType, {}>;
         schema: import("..").InferSchema<Schema>;
         next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;
     }) => MiddlewareOptions<Responder, Schema, Name, Parameters>;

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

@@ -18,4 +18,5 @@ export declare class Router<Responder extends Responders, const Path extends str
     use?: Middlewares;
     url: Analyze<Path>;
     constructor(options: RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>);
+    static create<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,7 +1,6 @@
 export * from './controllers/Router';
 export * from './controllers/Middleware';
 export * from './controllers/Method';
-export * from './controllers/createRouter';
 export * from './types/router';
 export * from './types/schema';
 export * from './types/method';

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

@@ -1,6 +1,7 @@
-import type { AnyAsterflow, AsterFlow } from '@asterflow/core';
-import type { Request } from '@asterflow/request';
-import type { Responders, Response } from '@asterflow/response';
+import type { Runtime } from '@asterflow/adapter';
+import type { AnyAsterflow } from '@asterflow/core';
+import type { AsterRequest } from '@asterflow/request';
+import type { Responders, AsterResponse } from '@asterflow/response';
 import type { Analyze, ParsePath } from '@asterflow/url-parser';
 import type { Middleware } from '../controllers/Middleware';
 import type { AnyMiddleware, MiddlewareOutput } from './mindleware';
@@ -15,17 +16,17 @@ export declare enum MethodType {
     head = "head",
     patch = "patch"
 }
-export type AnyMethodHandler = MethodHandler<string, Responders, AnySchema, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>, AsterFlow>;
+export type AnyMethodHandler = MethodHandler<string, Runtime, Responders, AnySchema, AnyMiddleware[], MiddlewareOutput<AnyMiddleware[]>, AnyAsterflow>;
 export type MethodKeys = keyof typeof MethodType;
-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>, Instance extends AnyAsterflow> = <RequestType>(args: {
+export type MethodHandler<Path extends string, Drive extends Runtime, Responder extends Responders, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Instance extends AnyAsterflow> = (args: {
     instance: Instance;
-    request: Request<RequestType>;
-    response: Response<Responder>;
+    request: AsterRequest<Drive>;
+    response: AsterResponse<Responder>;
     url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
     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>, Instance extends AnyAsterflow, Handler extends MethodHandler<Path, Responder, Schema, Middlewares, Context, Instance>> = {
+}) => Promise<AsterResponse<Responder>> | AsterResponse<Responder>;
+export type MethodOptions<Responder extends Responders, Path extends string, Drive extends Runtime, Method extends MethodKeys, Schema extends AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Instance extends AnyAsterflow, Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> = {
     path: Path;
     name?: string;
     description?: string;

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

@@ -1,6 +1,7 @@
+import type { Runtime } from '@asterflow/adapter';
 import type { Request } from '@asterflow/request';
+import type { Responders, AsterResponse } from '@asterflow/response';
 import type { Middleware } from '../controllers/Middleware';
-import type { Response, Responders } from '@asterflow/response';
 import type { AnySchema, InferSchema } from './schema';
 export type AnyMiddleware = Middleware<any, any, any, any>;
 /**
@@ -9,8 +10,8 @@ export type AnyMiddleware = Middleware<any, any, any, any>;
 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>;
+    onRun<RequestType extends Runtime>(args: {
+        response: AsterResponse<Responder>;
         request: Request<RequestType>;
         schema: InferSchema<Schema>;
         next: <Parameter extends Record<string, unknown>>(params: Parameter) => MiddlewareOptions<Responder, Schema, Name, Parameter>;

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

@@ -1,5 +1,6 @@
+import type { Runtime } from '@asterflow/adapter';
 import type { Request } from '@asterflow/request';
-import type { Responders, Response } from '@asterflow/response';
+import type { AsterResponse, Responders } from '@asterflow/response';
 import type { Analyze, ParsePath } from '@asterflow/url-parser';
 import type { Method } from '../controllers/Method';
 import type { Middleware } from '../controllers/Middleware';
@@ -10,10 +11,10 @@ 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<any, any, any, any, any, any> | Method<any, any, any, any, any, any, 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: {
+export type AnyRouter = Router<any, any, any, any, any, any> | Method<any, any, any, any, any, any, any, any, 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 extends Runtime>(args: {
     request: Request<RequestType>;
-    response: Response<Responder>;
+    response: AsterResponse<Responder>;
     url: Analyze<Path, ParsePath<Path>, Analyze<Path>>;
     schema: InferredData<Method, Schema>;
     middleware: Context;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asterflow/router",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -18,9 +18,9 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@asterflow/request": "1.0.7",
-    "@asterflow/response": "1.0.4",
-    "@asterflow/core": "1.0.7"
+    "@asterflow/request": "1.0.8",
+    "@asterflow/response": "1.0.5",
+    "@asterflow/core": "1.0.8"
   },
   "peerDependencies": {
     "@caeljs/tsh": "^1.1.3",

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

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