asterflow 0.0.6 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-# Asterflow
+# AsterFlow
 
 ![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)
@@ -10,122 +10,78 @@
 
 </div>
 
-> The heart of the AsterFlow framework, providing server initialization and configuration with strong typing.
+> The core framework - ties together adapters, routing, plugins and responses into one typed `AsterFlow` app.
 
 ## 📦 Installation
 
 ```bash
-npm install asterflow
-# or
 bun install asterflow
 ```
 
-## 💡 About
+### ✨ Features
 
-Asterflow is the central package of the AsterFlow framework. It provides server initialization, integration with different HTTP adapters, and a typed routing system. The package brings together all other AsterFlow components into a cohesive framework.
+- **`new AsterFlow(options)`** - creates an app around a `driver` (an `@asterflow/adapter` instance, defaults to `adapters.node`)
+- **`.method(...)` / `.router(...)`** - define a single-verb route or a multi-verb route group directly on the app, backed by `@asterflow/router`'s `Method`/`Router`
+- **`.controller(route)`** - registers an already-built `Method` or `Router` instance
+- **`.middleware({ basePath, controllers })`** - registers a group of controllers under a shared path prefix
+- **Route `use` middlewares run first** - a route's middleware chain runs before schema validation, and any middleware can return a response to short-circuit the request before the body is even parsed
+- **Schema validation** - if the route has a schema, the parsed body is validated after middlewares pass and before the handler runs
+- **Plugin system** - `.use(plugin, config)` registers an `@asterflow/plugin` instance, applies its instance extensions, and wires up its `beforeInitialize`/`afterInitialize`/`onRequest`/`onResponse` hooks
+- **Merged plugin context** - every plugin's context is resolved once, when `.listen()` is called, and handed to every handler as `context.plugins` (not recomputed per request)
+- **Trie-based route matching** - routes are stored and matched with `reminist`, keyed by HTTP method
+- **Full type inference** - registering a route narrows the app's type so its path, params, schema and middleware context are known at every call site
 
-## ✨ Features
+## ❓ How to Use
 
-- **HTTP Adapters:** Native support for different HTTP servers (Node.js, Fastify, Express)
-- **Routing System:** Typed routing with support for dynamic parameters
-- **Middleware:** Flexible middleware system with typed context
-- **Type Safety:** Full TypeScript support with type inference
-- **High Performance:** Optimized routing system using prefix tree (trie)
-- **URL Analysis:** Integrated URL parser with support for dynamic parameters
+Build routes with `.method()`/`.router()` and start the server with `.listen()`. This route validates its body with a middleware-provided context before running:
 
-## 🚀 Usage
-
-### Basic Setup
-
-```typescript
+```ts
 import { AsterFlow } from 'asterflow'
-import { adapters } from '@asterflow/adapter'
-import fastify from 'fastify'
-
-const server = fastify()
-const aster = new AsterFlow({ 
-  driver: adapters.fastify 
-})
-
-aster.listen(server, { port: 3000 })
-```
-
-### Defining Routes
-
-```typescript
-import { Router } from '@asterflow/router'
-
-const router = new Router({
-  path: '/:id=number?query#fragment',
-  methods: {
-    get({ response, url }) {
-      const params = url.getParams() // params.id is typed as number
-      const query = url.getSearchParams()
-      return response.send('Hello World')
-    }
-  }
-})
-
-aster.controller(router)
-```
-
-### Using Middleware
-
-```typescript
-import { Middleware, Router } from '@asterflow/router'
+import { Middleware } from '@asterflow/router'
+import { z } from 'zod'
 
 const auth = new Middleware({
   name: 'auth',
-  onRun({ next }) {
-    return next({
-      auth: false
-    })
+  onRun({ request, response, next }) {
+    if (!request.getHeaders().authorization) return response.unauthorized({ message: 'Missing token' })
+    return next({ userId: 42 })
   }
 })
 
-const router = new Router({
-  path: '/protected',
+const app = new AsterFlow() // defaults to the Node adapter
+
+app.method('post', {
+  path: '/users',
   use: [auth],
-  methods: {
-    get({ response, middleware }) {
-      if (!middleware.auth) {
-        return response.unauthorized({ 
-          message: 'Unauthorized' 
-        })
-      }
-      return response.send('Protected area')
-    }
+  schema: z.object({ name: z.string() }),
+  handler({ schema, middleware, response }) {
+    return response.created({ id: middleware.userId, name: schema.name })
   }
 })
+
+app.listen({ port: 3000 })
 ```
 
-### Individual Routes
+Plugins register onto the same instance with `.use()` and can add their own instance methods:
 
-```typescript
-import { Method } from '@asterflow/router'
+```ts
+import { AsterFlow } from 'asterflow'
+import { fsRoutingPlugin } from '@asterflow/fs'
 
-const route = new Method({
-  path: '/users/:id=number',
-  method: 'get',
-  handler: ({ response, url }) => {
-    const { id } = url.getParams() // id is typed as number
-    return response.send({ id })
-  }
-})
+const app = new AsterFlow()
+  .use(fsRoutingPlugin, { routes: [] }) // routes: AnyRouter[]
 
-aster.controller(route)
+app.listen({ port: 3000 })
 ```
 
 ## 🔗 Related Packages
 
-- [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - HTTP adapters for different runtimes
-- [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - Type-safe routing system
-- [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - Unified HTTP request system
-- [@asterflow/response](https://www.npmjs.com/package/@asterflow/response) - Type-safe HTTP response system
-- [reminist](https://www.npmjs.com/package/reminist) - Blazing fast, zero-dependency, TypeScript-native router
-- [@asterflow/url-parser](https://www.npmjs.com/package/@asterflow/url-parser) - High-performance typed URL parser with automatic type casting
-- [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - A modular and typed plugin system
+- [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - supplies the `driver` (Bun, Node, Express, Fastify) that `.listen()` delegates to
+- [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - `Method`/`Router`/`Middleware` classes that back `.method()`, `.router()` and `.controller()`
+- [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - plugin instances and types consumed by `.use()`
+- [@asterflow/response](https://www.npmjs.com/package/@asterflow/response) - `AsterResponse` is what every request handler works with and returns
+- [@asterflow/request](https://www.npmjs.com/package/@asterflow/request) - supplies the `Request` type passed into every route and middleware handler
 
 ## 📄 License
 
-MIT - See [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.
+This project is licensed under the [MIT License](../LICENSE).

package/dist/cjs/index.cjs

@@ -1,46 +1,47 @@
 "use strict";
 var y = Object.defineProperty;
-var x = Object.getOwnPropertyDescriptor;
-var P = Object.getOwnPropertyNames;
-var w = Object.prototype.hasOwnProperty;
-var A = (u, e) => {
+var w = Object.getOwnPropertyDescriptor;
+var A = Object.getOwnPropertyNames;
+var P = Object.prototype.hasOwnProperty;
+var M = (l, e) => {
   for (var t in e)
-    y(u, t, { get: e[t], enumerable: !0 });
-}, M = (u, e, t, s) => {
+    y(l, t, { get: e[t], enumerable: !0 });
+}, C = (l, e, t, s) => {
   if (e && typeof e == "object" || typeof e == "function")
-    for (let n of P(e))
-      !w.call(u, n) && n !== t && y(u, n, { get: () => e[n], enumerable: !(s = x(e, n)) || s.enumerable });
-  return u;
+    for (let n of A(e))
+      !P.call(l, n) && n !== t && y(l, n, { get: () => e[n], enumerable: !(s = w(e, n)) || s.enumerable });
+  return l;
 };
-var I = (u) => M(y({}, "__esModule", { value: !0 }), u);
+var v = (l) => C(y({}, "__esModule", { value: !0 }), l);
 // core/src/index.ts
-var C = {};
-A(C, {
-  AsterFlow: () => v,
-  AsterFlowInstance: () => c
+var D = {};
+M(D, {
+  AsterFlow: () => I,
+  AsterFlowInstance: () => h
 });
-module.exports = I(C);
+module.exports = v(D);
 // core/src/controllers/Asterflow.ts
-var f = require("@asterflow/adapter"), m = require("@asterflow/response"), l = require("@asterflow/router"), R = require("@asterflow/url-parser"), g = require("reminist");
+var x = require("@asterflow/adapter"), g = require("@asterflow/response"), R = require("@asterflow/router"), u = require("@asterflow/url-parser"), f = require("reminist");
 // core/src/utils/parser.ts
-function p(u, e) {
-  return `${u}${e}`.replace(/\/{2,}/g, "/");
+function m(l, e) {
+  return `${l}${e}`.replace(/\/{2,}/g, "/");
 }
 // core/src/controllers/Asterflow.ts
-var c = class {
+var h = class {
   driver;
-  reminist = new g.Reminist({ keys: Object.keys(l.MethodType) });
+  reminist = new f.Reminist({ keys: Object.keys(R.MethodType) });
   middlewares = [];
   plugins = {};
   onRequestPlugins = [];
   onResponsePlugins = [];
   beforeInitializePlugins = [];
   afterInitializePlugins = [];
+  pluginContext = {};
   constructor(e) {
-    this.driver = e?.driver ?? f.adapters.node, this.driver.onRequest = this.handleRequest.bind(this);
+    this.driver = e?.driver ?? x.adapters.node, this.driver.onRequest = this.handleRequest.bind(this);
   }
   async handleRequest(e, t) {
-    t = t ?? new m.AsterResponse();
+    t = t ?? new g.AsterResponse();
     let s = () => t.notFound({
       statusCode: 404,
       code: "NOT_FOUND",
@@ -51,26 +52,26 @@ var c = class {
     if (!r?.node?.store) return s();
     let i = r.node.store, a = await this.runHooks("onRequest", this, i, e, t);
     if (a) return a;
-    (i.url.ast.expressions.has(R.InternalExpression.Variable) || i.url.ast.expressions.has(R.InternalExpression.Slug)) && (e.url = e.url.withParser(i.url));
+    (i.url.ast.expressions.has(u.InternalExpression.Variable) || i.url.ast.expressions.has(u.InternalExpression.Dynamic) || i.url.ast.expressions.has(u.InternalExpression.DynamicCatchAll) || i.url.ast.expressions.has(u.InternalExpression.DynamicOptionalCatchAll) || i.url.ast.expressions.has(u.InternalExpression.Wildcard)) && (e.url = e.url.setParser(i.url));
     try {
       return await this.runHandler(i, e, t), await this.runHooks("onResponse", this, i, e, t), t;
     } catch (o) {
       return console.log(o), t.badRequest({
         statusCode: 400,
-        message: o instanceof R.ErrorLog ? "AST_ERROR" : "ERROR",
-        error: o instanceof R.ErrorLog || o instanceof Error ? o.message : o
+        message: o instanceof u.ErrorLog ? "AST_ERROR" : "ERROR",
+        error: o instanceof u.ErrorLog || o instanceof Error ? o.message : o
       });
     }
   }
   middleware(e) {
     for (let t of e.controllers) {
-      let s = p(e.basePath, t.path);
+      let s = m(e.basePath, t.path);
       this.addEntry(t, s);
     }
     return this;
   }
   controller(e) {
-    let t = p("/", e.path);
+    let t = m("/", e.path);
     return this.addEntry(e, t), this;
   }
   use(e, t) {
@@ -82,10 +83,10 @@ var c = class {
     return this;
   }
   router(e) {
-    return this.controller(new l.Router(e)), this;
+    return this.controller(new R.Router(e)), this;
   }
-  method(e) {
-    return this.controller(new l.Method(e)), this;
+  method(e, t) {
+    return this.controller(new R.Method(e, t)), this;
   }
   async resolvePluginContexts() {
     for (let e in this.plugins) {
@@ -96,12 +97,13 @@ var c = class {
           Object.assign(t.context, n);
         }
     }
+    this.pluginContext = Object.values(this.plugins).reduce((e, t) => ({ ...e, ...t.context }), {});
   }
   async listen(...e) {
     await this.resolvePluginContexts(), await this.runHooks("beforeInitialize", this), await this.driver.listen(...e), await this.runHooks("afterInitialize", this);
   }
   addEntry(e, t) {
-    let s = e instanceof l.Method ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new R.Analyze(t) };
+    let s = e instanceof R.Method ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new u.Analyze(t) };
     for (let r of s)
       this.reminist.add(r, t, n);
   }
@@ -124,9 +126,9 @@ var c = class {
             if (!o) break;
             if (!n || !r || !s) return;
             for (let d of o) {
-              let h = await d({ instance: t, router: s, request: n, response: r, plugin: a });
-              if (h && h instanceof m.AsterResponse)
-                return h;
+              let c = await d({ instance: t, router: s, request: n, response: r, plugin: a });
+              if (c && typeof c == "object" && c.constructor?.name === "AsterResponse")
+                return c;
             }
           }
           break;
@@ -141,31 +143,44 @@ var c = class {
           break;
       }
   }
+  async runMiddlewares(e, t, s, n) {
+    let r = {};
+    if (!e || e.length === 0) return { context: r };
+    let a = { request: t, response: s, schema: n, next: (o) => o };
+    for (let o of e) {
+      let d = await o.onRun(a);
+      if (d instanceof g.AsterResponse) return { context: r, response: d };
+      d && typeof d == "object" && Object.assign(r, d);
+    }
+    return { context: r };
+  }
   async runHandler({ route: e }, t, s) {
-    let n = t.getMethod().toLowerCase(), r = e instanceof l.Method ? e.handler : e.methods[n], i = e instanceof l.Method ? e.schema : e.schema?.[n];
+    let n = t.getMethod().toLowerCase(), r = e instanceof R.Method ? e.handler : e.methods[n], i = e instanceof R.Method ? e.schema : e.schema?.[n];
     if (!r) return null;
+    let a = await t.getBody(), { context: o, response: d } = await this.runMiddlewares(e.use, t, s, a);
+    if (d) return d;
     if (i) {
-      let d = i.safeParse(await t.getBody());
-      if (!d.success)
+      let p = i.safeParse(a);
+      if (!p.success)
         return s.validationError({
           statusCode: 422,
           message: "VALIDATION_ERROR",
-          error: JSON.parse(d.error)
+          error: JSON.parse(p.error)
         });
-      s.send(d.data);
+      s.send(p.data);
     }
-    let a = Object.values(this.plugins).reduce((d, h) => ({ ...d, ...h.context }), {}), o = {
+    let c = {
       instance: this,
       request: t,
       response: s,
       url: t.url,
-      schema: await t.getBody(),
-      middleware: {},
-      plugins: a
+      schema: a,
+      middleware: o,
+      plugins: this.pluginContext
     };
-    return r(o);
+    return r(c);
   }
-}, v = c;
+}, I = h;
 0 && (module.exports = {
   AsterFlow,
   AsterFlowInstance

package/dist/mjs/index.js

@@ -1,32 +1,33 @@
 // core/src/controllers/Asterflow.ts
-import { adapters as f } from "@asterflow/adapter";
-import { AsterResponse as y } from "@asterflow/response";
+import { adapters as x } from "@asterflow/adapter";
+import { AsterResponse as m } from "@asterflow/response";
 import {
-  Method as l,
-  MethodType as g,
-  Router as x
+  Method as R,
+  MethodType as f,
+  Router as w
 } from "@asterflow/router";
-import { Analyze as P, ErrorLog as p, InternalExpression as m } from "@asterflow/url-parser";
-import { Reminist as w } from "reminist";
+import { Analyze as A, ErrorLog as g, InternalExpression as l } from "@asterflow/url-parser";
+import { Reminist as P } from "reminist";
 // core/src/utils/parser.ts
-function R(c, e) {
-  return `${c}${e}`.replace(/\/{2,}/g, "/");
+function h(y, e) {
+  return `${y}${e}`.replace(/\/{2,}/g, "/");
 }
 // core/src/controllers/Asterflow.ts
-var h = class {
+var p = class {
   driver;
-  reminist = new w({ keys: Object.keys(g) });
+  reminist = new P({ keys: Object.keys(f) });
   middlewares = [];
   plugins = {};
   onRequestPlugins = [];
   onResponsePlugins = [];
   beforeInitializePlugins = [];
   afterInitializePlugins = [];
+  pluginContext = {};
   constructor(e) {
-    this.driver = e?.driver ?? f.node, this.driver.onRequest = this.handleRequest.bind(this);
+    this.driver = e?.driver ?? x.node, this.driver.onRequest = this.handleRequest.bind(this);
   }
   async handleRequest(e, t) {
-    t = t ?? new y();
+    t = t ?? new m();
     let s = () => t.notFound({
       statusCode: 404,
       code: "NOT_FOUND",
@@ -37,26 +38,26 @@ var h = class {
     if (!r?.node?.store) return s();
     let i = r.node.store, a = await this.runHooks("onRequest", this, i, e, t);
     if (a) return a;
-    (i.url.ast.expressions.has(m.Variable) || i.url.ast.expressions.has(m.Slug)) && (e.url = e.url.withParser(i.url));
+    (i.url.ast.expressions.has(l.Variable) || i.url.ast.expressions.has(l.Dynamic) || i.url.ast.expressions.has(l.DynamicCatchAll) || i.url.ast.expressions.has(l.DynamicOptionalCatchAll) || i.url.ast.expressions.has(l.Wildcard)) && (e.url = e.url.setParser(i.url));
     try {
       return await this.runHandler(i, e, t), await this.runHooks("onResponse", this, i, e, t), t;
     } catch (o) {
       return console.log(o), t.badRequest({
         statusCode: 400,
-        message: o instanceof p ? "AST_ERROR" : "ERROR",
-        error: o instanceof p || o instanceof Error ? o.message : o
+        message: o instanceof g ? "AST_ERROR" : "ERROR",
+        error: o instanceof g || o instanceof Error ? o.message : o
       });
     }
   }
   middleware(e) {
     for (let t of e.controllers) {
-      let s = R(e.basePath, t.path);
+      let s = h(e.basePath, t.path);
       this.addEntry(t, s);
     }
     return this;
   }
   controller(e) {
-    let t = R("/", e.path);
+    let t = h("/", e.path);
     return this.addEntry(e, t), this;
   }
   use(e, t) {
@@ -68,10 +69,10 @@ var h = class {
     return this;
   }
   router(e) {
-    return this.controller(new x(e)), this;
+    return this.controller(new w(e)), this;
   }
-  method(e) {
-    return this.controller(new l(e)), this;
+  method(e, t) {
+    return this.controller(new R(e, t)), this;
   }
   async resolvePluginContexts() {
     for (let e in this.plugins) {
@@ -82,12 +83,13 @@ var h = class {
           Object.assign(t.context, n);
         }
     }
+    this.pluginContext = Object.values(this.plugins).reduce((e, t) => ({ ...e, ...t.context }), {});
   }
   async listen(...e) {
     await this.resolvePluginContexts(), await this.runHooks("beforeInitialize", this), await this.driver.listen(...e), await this.runHooks("afterInitialize", this);
   }
   addEntry(e, t) {
-    let s = e instanceof l ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new P(t) };
+    let s = e instanceof R ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new A(t) };
     for (let r of s)
       this.reminist.add(r, t, n);
   }
@@ -111,7 +113,7 @@ var h = class {
             if (!n || !r || !s) return;
             for (let d of o) {
               let u = await d({ instance: t, router: s, request: n, response: r, plugin: a });
-              if (u && u instanceof y)
+              if (u && typeof u == "object" && u.constructor?.name === "AsterResponse")
                 return u;
             }
           }
@@ -127,32 +129,45 @@ var h = class {
           break;
       }
   }
+  async runMiddlewares(e, t, s, n) {
+    let r = {};
+    if (!e || e.length === 0) return { context: r };
+    let a = { request: t, response: s, schema: n, next: (o) => o };
+    for (let o of e) {
+      let d = await o.onRun(a);
+      if (d instanceof m) return { context: r, response: d };
+      d && typeof d == "object" && Object.assign(r, d);
+    }
+    return { context: r };
+  }
   async runHandler({ route: e }, t, s) {
-    let n = t.getMethod().toLowerCase(), r = e instanceof l ? e.handler : e.methods[n], i = e instanceof l ? e.schema : e.schema?.[n];
+    let n = t.getMethod().toLowerCase(), r = e instanceof R ? e.handler : e.methods[n], i = e instanceof R ? e.schema : e.schema?.[n];
     if (!r) return null;
+    let a = await t.getBody(), { context: o, response: d } = await this.runMiddlewares(e.use, t, s, a);
+    if (d) return d;
     if (i) {
-      let d = i.safeParse(await t.getBody());
-      if (!d.success)
+      let c = i.safeParse(a);
+      if (!c.success)
         return s.validationError({
           statusCode: 422,
           message: "VALIDATION_ERROR",
-          error: JSON.parse(d.error)
+          error: JSON.parse(c.error)
         });
-      s.send(d.data);
+      s.send(c.data);
     }
-    let a = Object.values(this.plugins).reduce((d, u) => ({ ...d, ...u.context }), {}), o = {
+    let u = {
       instance: this,
       request: t,
       response: s,
       url: t.url,
-      schema: await t.getBody(),
-      middleware: {},
-      plugins: a
+      schema: a,
+      middleware: o,
+      plugins: this.pluginContext
     };
-    return r(o);
+    return r(u);
   }
-}, k = h;
+}, O = p;
 export {
-  k as AsterFlow,
-  h as AsterFlowInstance
+  O as AsterFlow,
+  p as AsterFlowInstance
 };

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

@@ -1,15 +1,13 @@
 import { Runtime, type Adapter, type AnyAdapter } from '@asterflow/adapter';
 import type { AnyPlugins, InferConfigArgument, InferPluginExtension, Plugin, ResolvedPlugin } from '@asterflow/plugin';
 import { type Responders } from '@asterflow/response';
-import { Method, Router, type AnyMiddleware, type AnyMiddlewares, type AnyRouter, type AnySchema, type MethodHandler, type MethodKeys, type MethodOptions, type Middleware, type MiddlewareOutput, type RouteHandler, type RouterOptions, type SchemaDynamic } from '@asterflow/router';
-import { type NormalizePath } from '@asterflow/url-parser';
+import { Method, Router, type AnyMiddleware, type AnyMiddlewares, type AnyRouter, type AnySchema, type MethodCallProps, type MethodConstructorOptions, type MethodHandler, type MethodKeys, type Middleware, type MiddlewareOutput, type RouteHandler, type RouterCallProps, type RouterOptions, type SchemaDynamic } from '@asterflow/router';
 import { Reminist } from 'reminist';
 import type { AsterFlowOptions } from '../types/asterflow';
-import type { ExtractPaths, InferPath } from '../types/paths';
-import type { AnyReminist, InferReministContext, InferReministPath } from '../types/reminist';
+import type { AnyReminist, DefaultReminist, InferReministContext } from '../types/reminist';
 import type { BuildRouteContext, BuildRoutesContext, RouteEntry } from '../types/routes';
 import type { AnyRecord } from '../types/utils';
-export declare class AsterFlowInstance<const Drive extends AnyAdapter = Adapter<Runtime.Node>, const Routers extends AnyReminist = AnyReminist, const Plugins extends AnyPlugins = {}, const Middlewares extends AnyMiddlewares = [], const Extension extends AnyRecord = {}> {
+export declare class AsterFlowInstance<const Drive extends AnyAdapter = Adapter<Runtime.Node>, const Routers extends AnyReminist = DefaultReminist, const Plugins extends AnyPlugins = {}, const Middlewares extends AnyMiddlewares = [], const Extension extends AnyRecord = {}> {
     readonly driver: Drive;
     readonly reminist: Routers;
     readonly middlewares: Middlewares;
@@ -18,6 +16,8 @@ export declare class AsterFlowInstance<const Drive extends AnyAdapter = Adapter<
     private readonly onResponsePlugins;
     private readonly beforeInitializePlugins;
     private readonly afterInitializePlugins;
+    /** Merged view of every plugin's context, cached by `resolvePluginContexts()` at `listen()` time - see `runHandler`. */
+    private pluginContext;
     constructor(options?: AsterFlowOptions<Drive>);
     /**
      * Handles incoming requests, executing `onRequest` and `onResponse` plugin hooks.
@@ -31,34 +31,40 @@ export declare class AsterFlowInstance<const Drive extends AnyAdapter = Adapter<
     middleware<BasePath extends string, const Routes extends readonly AnyRouter[]>(options: {
         basePath: BasePath;
         controllers: Routes;
-    }): AsterFlow<Drive, Reminist<InferReministPath<Routers> extends string[] ? [...InferReministPath<Routers>, ...ExtractPaths<BasePath, Routes>] : ExtractPaths<BasePath, Routes>, InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRoutesContext<BasePath, Routes> : BuildRoutesContext<BasePath, Routes>, MethodKeys[]>, Plugins, Middlewares, Extension>;
+    }): AsterFlow<Drive, Reminist<InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRoutesContext<BasePath, Routes> : BuildRoutesContext<BasePath, Routes>, MethodKeys[]>, Plugins, Middlewares, Extension>;
     /**
      * Adds a single controller to AsterFlow.
      * The controller's path is normalized to be relative to the root.
      */
-    controller<Route extends AnyRouter>(router: Route): AsterFlow<Drive, Reminist<InferReministPath<Routers> extends string[] ? [...InferReministPath<Routers>, NormalizePath<InferPath<Route>>] : [NormalizePath<InferPath<Route>>], InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
+    controller<Route extends AnyRouter>(router: Route): AsterFlow<Drive, Reminist<InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
     /**
      * Registers a plugin and its configuration with the AsterFlow instance.
      * Applies any instance extensions defined by the plugin.
      */
-    use<Plug extends Plugin<any, any, any, any, any, any>>(plugin: Plug, config?: InferConfigArgument<Plug>): AsterFlow<Drive, Routers, Plugins & { [K in Plug["name"]]: ResolvedPlugin<Plug>; }, Middlewares, Extension & InferPluginExtension<Plug>>;
+    use<Plug extends Plugin<any>>(plugin: Plug, config?: InferConfigArgument<Plug>): AsterFlow<Drive, Routers, Plugins & { [K in Plug["name"]]: ResolvedPlugin<Plug>; }, Middlewares, Extension & InferPluginExtension<Plug>>;
     /**
      * Creates and adds a new router to the AsterFlow instance.
      * A router can contain multiple method handlers for different HTTP verbs.
      */
-    router<Responder extends Responders, const Path extends string = string, const Schema extends SchemaDynamic<MethodKeys> = SchemaDynamic<MethodKeys>, const Middlewares extends readonly AnyMiddleware[] = [], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Routers extends {
-        [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
+    router<Responder extends Responders, const Path extends string = string, const Schema extends SchemaDynamic<MethodKeys> = SchemaDynamic<MethodKeys>, const RouteMiddlewares extends readonly AnyMiddleware[] = [], const Context extends MiddlewareOutput<RouteMiddlewares> = MiddlewareOutput<RouteMiddlewares>, const Routers extends {
+        [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, RouteMiddlewares, Context>;
     } = {
-        [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-    }, const Route extends Router<Responder, Path, Schema, Middlewares, Context, Routers> = Router<Responder, Path, Schema, Middlewares, Context, Routers>>(options: RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>): AsterFlow<Drive, Reminist<InferReministPath<Routers> extends string[] ? [...InferReministPath<Routers>, NormalizePath<InferPath<Route>>] : [NormalizePath<InferPath<Route>>], InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
+        [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, RouteMiddlewares, Context>;
+    }, const Route extends Router<RouterCallProps<Responder, Path, Schema, RouteMiddlewares, Context, Routers>> = Router<RouterCallProps<Responder, Path, Schema, RouteMiddlewares, Context, Routers>>>(options: RouterOptions<RouterCallProps<Responder, Path, Schema, RouteMiddlewares, Context, Routers>>): AsterFlow<Drive, Reminist<InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
     /**
      * Creates and adds a new method handler (route) to the AsterFlow instance.
      * Defines a specific route for an HTTP method (GET, POST, etc.).
      */
-    method<Responder extends Responders, const Path extends string, const Methoder extends MethodKeys, const Schema extends AnySchema, const Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[], const Context extends MiddlewareOutput<Middlewares>, const Instance extends AsterFlowInstance<Drive, Routers, Plugins, Middlewares, Extension>, const Handler extends MethodHandler<Path, Drive['runtime'], Responder, Schema, Middlewares, Context, Instance>, const Route extends Method<Responder, Path, Drive['runtime'], Methoder, Schema, Middlewares, Context, Instance, Handler>>(options: MethodOptions<Responder, Path, Drive['runtime'], Methoder, Schema, Middlewares, Context, Instance, Handler>): AsterFlow<Drive, Reminist<InferReministPath<Routers> extends string[] ? [...InferReministPath<Routers>, NormalizePath<InferPath<Route>>] : [NormalizePath<InferPath<Route>>], InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
+    method<Responder extends Responders, const Path extends string = string, const Methoder extends MethodKeys = MethodKeys, const Schema extends AnySchema = AnySchema, const RouteMiddlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [], const Context extends MiddlewareOutput<RouteMiddlewares> = MiddlewareOutput<RouteMiddlewares>, const Instance extends AsterFlowInstance<Drive, Routers, Plugins, Middlewares, Extension> & AnyAsterflow = AsterFlowInstance<Drive, Routers, Plugins, Middlewares, Extension> & AnyAsterflow, const Handler extends MethodHandler<Path, Drive['runtime'], Responder, Schema, RouteMiddlewares, Context, Instance> = MethodHandler<Path, Drive['runtime'], Responder, Schema, RouteMiddlewares, Context, Instance>, const Route extends Method<MethodCallProps<Responder, Path, Drive['runtime'], Methoder, Schema, RouteMiddlewares, Context, Instance, {}, Handler>> = Method<MethodCallProps<Responder, Path, Drive['runtime'], Methoder, Schema, RouteMiddlewares, Context, Instance, {}, Handler>>>(methodKey: Methoder, options: MethodConstructorOptions<MethodCallProps<Responder, Path, Drive['runtime'], Methoder, Schema, RouteMiddlewares, Context, Instance, {}, Handler>>): AsterFlow<Drive, Reminist<InferReministContext<Routers> extends Record<string, RouteEntry<string, AnyRouter>> ? InferReministContext<Routers> & BuildRouteContext<Route> : BuildRouteContext<Route>, MethodKeys[]>, Plugins, Middlewares, Extension>;
     /**
      * Itera sobre todos os plugins registrados e executa seus resolvers
      * de forma assíncrona, construindo o contexto de cada um.
+     *
+     * Also caches the merged view of every plugin's context into
+     * `this.pluginContext` here, once, instead of re-merging it (via
+     * `Object.values(...).reduce(...)`, an O(plugins) allocation) on every
+     * single request in `runHandler` - plugin contexts are static after this
+     * point.
      */
     private resolvePluginContexts;
     /**
@@ -76,14 +82,24 @@ export declare class AsterFlowInstance<const Drive extends AnyAdapter = Adapter<
      */
     private runHooks;
     /**
-     * Executes a route handler, processing the request and response.
-     * Performs schema validation, if present, and invokes the route handler.
+     * Runs a route's `use` middleware chain in order, merging each
+     * middleware's `next(params)` output into a single accumulated context
+     * object. If a middleware returns an `AsterResponse` instead of calling
+     * `next(...)` (e.g. `return response.unauthorized({...})`), the chain
+     * stops immediately and that response is propagated back as final.
+     */
+    private runMiddlewares;
+    /**
+     * Executes a route handler, processing the request and response. Runs
+     * `use` middlewares first (so an unauthorized/rejected request short-
+     * circuits before paying for body validation), then schema validation if
+     * present, then invokes the route handler.
      */
     private runHandler;
 }
-export type AsterFlow<Drive extends AnyAdapter = AnyAdapter, Routers extends AnyReminist = AnyReminist, Plugins extends AnyPlugins = AnyPlugins, Middlewares extends readonly AnyMiddleware[] = AnyMiddleware[], Extension extends Record<string, any> = Record<string, any>> = AsterFlowInstance<Drive, Routers, Plugins, Middlewares, Extension> & Extension;
+export type AsterFlow<Drive extends AnyAdapter = AnyAdapter, Routers extends AnyReminist = DefaultReminist, Plugins extends AnyPlugins = AnyPlugins, Middlewares extends readonly AnyMiddleware[] = AnyMiddleware[], Extension extends Record<string, any> = Record<string, any>> = AsterFlowInstance<Drive, Routers, Plugins, Middlewares, Extension> & Extension;
 export declare const AsterFlow: {
-    new <Drive extends AnyAdapter = Adapter<Runtime.Node>>(options?: AsterFlowOptions<Drive>): AsterFlow<Drive, AnyReminist, {}, [], {}>;
+    new <Drive extends AnyAdapter = Adapter<Runtime.Node>>(options?: AsterFlowOptions<Drive>): AsterFlow<Drive, DefaultReminist, {}, [], {}>;
 };
 /**
  * Represents a generic AsterFlow instance, with all its types defined as `any`.

package/dist/types/types/paths.d.ts

@@ -1,4 +1,4 @@
-import type { AnyRouter, Method, Router } from '@asterflow/router';
+import type { Method, MethodProps, Router, RouterProps } from '@asterflow/router';
 import type { NormalizePath } from '@asterflow/url-parser';
 /**
  * Combines a base path with a relative path and normalizes the result.
@@ -8,10 +8,4 @@ export type CombinePaths<Base extends string, Path extends string> = NormalizePa
  * Infers the path from a `Router` or `Method` type.
  * This normalizes the path and combines it with the root.
  */
-export type InferPath<T> = T extends Router<any, infer P, any, any, any, any> ? CombinePaths<'/', P> : T extends Method<any, infer P, any, any, any, any, any, any, any> ? CombinePaths<'/', P> : never;
-/**
- * Extracts and normalizes the paths from an array of routers (`AnyRouter[]`), combining them with a base path.
- */
-export type ExtractPaths<Base extends string, Routes extends readonly AnyRouter[]> = {
-    [K in keyof Routes]: Routes[K] extends infer R extends AnyRouter ? CombinePaths<Base, InferPath<R>> : never;
-};
+export type InferPath<T> = T extends Router<infer Props extends RouterProps> ? CombinePaths<'/', Props['path']> : T extends Method<infer Props extends MethodProps> ? CombinePaths<'/', Props['path']> : never;

package/dist/types/types/reminist.d.ts

@@ -1,23 +1,22 @@
-import type { AnyRouter, MethodKeys } from '@asterflow/router';
+import type { MethodKeys } from '@asterflow/router';
 import type { Reminist } from 'reminist';
-import type { RouteEntry } from './routes';
 /**
  * Represents a generic Reminist instance, used for managing routes.
- * Includes a string array for paths, a record of route entries, and an array of HTTP method keys.
+ * Includes a record of route entries and an array of HTTP method keys.
  */
-export type AnyReminist = Reminist<readonly string[], Record<string, RouteEntry<string, AnyRouter>>, MethodKeys[]>;
+export type AnyReminist = Reminist<any, any>;
 /**
- * Infers the paths from a Reminist instance.
+ * The `Routers` type param's actual starting value for a fresh `AsterFlow`
+ * instance (before any `.method()`/`.router()` call). Deliberately NOT
+ * `AnyReminist`: a bare `any` context here makes
+ * `InferReministContext<Routers> extends Record<...> ? A : B` (used by
+ * `.method()`/`.router()`/`.controller()`/`.middleware()`'s return type)
+ * collapse to `any` - TS special-cases a naked `any` in a conditional
+ * type's checked position to `A | B`, and `any & X` is `any`, so the whole
+ * union collapses back to `any`. An empty, concrete context sidesteps that.
  */
-export type InferReministPath<T> = T extends Reminist<infer P, any, any> ? P : never;
+export type DefaultReminist = Reminist<{}, MethodKeys[]>;
 /**
  * Infers the context from a Reminist instance.
  */
-export type InferReministContext<T> = T extends Reminist<any, infer C, any> ? C : never;
-/**
- * Reminist context that preserves specific route information.
- * Each path maps to its specific typed route.
- */
-export type ReministContext<PathsAndRoutes extends Record<string, AnyRouter>> = {
-    readonly [Path in keyof PathsAndRoutes]: RouteEntry<Path extends string ? Path : never, PathsAndRoutes[Path]>;
-};
+export type InferReministContext<T> = T extends Reminist<infer C, any> ? C : never;

package/dist/types/types/routes.d.ts

@@ -1,4 +1,4 @@
-import type { AnyRouter, MethodKeys } from '@asterflow/router';
+import type { AnyRouter, MethodKeys, Prettify } from '@asterflow/router';
 import type { CombinePaths, InferPath } from './paths';
 import type { UnionToIntersection } from './utils';
 import type { Analyze, NormalizePath } from '@asterflow/url-parser';
@@ -18,10 +18,12 @@ export type BuildRoutesContext<Base extends string, Routes extends readonly AnyR
 }[number] & {}> & Record<string, RouteEntry<string, AnyRouter>>;
 /**
  * Defines the specific typing preserved for each route entry in Reminist.
+ * Wrapped in `Prettify` so it shows as a labeled `{ path: ..., route: ..., ... }`
+ * object on hover instead of `RouteEntry<"...", Method<...>>` by name.
  */
-export type RouteEntry<Path extends string, Route extends AnyRouter> = {
+export type RouteEntry<Path extends string, Route extends AnyRouter> = Prettify<{
     readonly path: Path;
     readonly route: Route;
     readonly methods: readonly MethodKeys[];
     readonly url: Analyze<string>;
-};
+}>;

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "asterflow",
-  "version": "0.0.6",
+  "version": "2.0.0",
+  "description": "The core framework - ties together adapters, routing, plugins and responses into one typed AsterFlow app.",
+  "keywords": [
+    "asterflow",
+    "http",
+    "framework",
+    "server",
+    "router",
+    "typescript"
+  ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -34,11 +43,11 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@asterflow/adapter": "1.0.14",
-    "@asterflow/plugin": "1.0.10",
-    "@asterflow/response": "1.0.11",
-    "@asterflow/router": "1.0.14",
-    "@asterflow/url-parser": "^2.0.3",
-    "reminist": "^1.0.5"
+    "@asterflow/adapter": "^1.0.13",
+    "@asterflow/plugin": "^1.1.0",
+    "@asterflow/response": "^1.1.0",
+    "@asterflow/router": "^2.0.0",
+    "@asterflow/url-parser": "^4.1.1",
+    "reminist": "^1.0.8"
   }
 }