asterflow 0.0.1

package/README.md

@@ -0,0 +1,131 @@
+<div align="center">
+
+# 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)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=core&style=for-the-badge&colorA=302D41&colorB=b4befe)
+
+![bundle-size](https://img.shields.io/bundlejs/size/asterflow?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> The heart of the AsterFlow framework, providing server initialization and configuration with strong typing.
+
+## 📦 Installation
+
+```bash
+npm install asterflow
+# or
+bun install asterflow
+```
+
+## 💡 About
+
+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.
+
+## ✨ Features
+
+- **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
+
+## 🚀 Usage
+
+### Basic Setup
+
+```typescript
+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'
+
+const auth = new Middleware({
+  name: 'auth',
+  onRun({ next }) {
+    return next({
+      auth: false
+    })
+  }
+})
+
+const router = new Router({
+  path: '/protected',
+  use: [auth],
+  methods: {
+    get({ response, middleware }) {
+      if (!middleware.auth) {
+        return response.unauthorized({ 
+          message: 'Unauthorized' 
+        })
+      }
+      return response.send('Protected area')
+    }
+  }
+})
+```
+
+### Individual Routes
+
+```typescript
+import { Method } from '@asterflow/router'
+
+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 })
+  }
+})
+
+aster.controller(route)
+```
+
+## 🔗 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
+
+## 📄 License
+
+MIT - See [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.

package/dist/cjs/index.cjs

@@ -0,0 +1,159 @@
+"use strict";
+var y = Object.defineProperty;
+var f = Object.getOwnPropertyDescriptor;
+var P = Object.getOwnPropertyNames;
+var w = Object.prototype.hasOwnProperty;
+var A = (r, e) => {
+  for (var t in e)
+    y(r, t, { get: e[t], enumerable: !0 });
+}, M = (r, e, t, s) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let n of P(e))
+      !w.call(r, n) && n !== t && y(r, n, { get: () => e[n], enumerable: !(s = f(e, n)) || s.enumerable });
+  return r;
+};
+var I = (r) => M(y({}, "__esModule", { value: !0 }), r);
+// core/src/index.ts
+var C = {};
+A(C, {
+  AsterFlow: () => v,
+  AsterFlowInstance: () => h,
+  joinPaths: () => R
+});
+module.exports = I(C);
+// core/src/controllers/Asterflow.ts
+var m = require("@asterflow/adapter"), p = require("@asterflow/response"), a = require("@asterflow/router"), l = require("@asterflow/url-parser"), x = require("reminist");
+// core/src/utils/parser.ts
+function R(r, e) {
+  return `${r}${e}`.replace(/\/{2,}/g, "/");
+}
+// core/src/controllers/Asterflow.ts
+var h = class {
+  driver;
+  reminist = new x.Reminist({ keys: Object.keys(a.MethodType) });
+  middlewares = [];
+  plugins = {};
+  onRequestPlugins = [];
+  onResponsePlugins = [];
+  beforeInitializePlugins = [];
+  afterInitializePlugins = [];
+  constructor(e) {
+    this.driver = e?.driver ?? m.adapters.node, this.driver.onRequest = this.handleRequest.bind(this);
+  }
+  async handleRequest(e, t) {
+    t = t ?? new p.AsterResponse(), await this.runHooks("onRequest", e, t);
+    let s = () => t.notFound({
+      statusCode: 404,
+      code: "NOT_FOUND",
+      message: `Unable to find route: ${e.getPathname()}`
+    }), n = e.getMethod().toLowerCase();
+    if (!n) return s();
+    let o = this.reminist.find(n, e.url.getPathname());
+    if (!o?.node?.store) return s();
+    let i = o.node.store;
+    e.url = e.url.withParser(i.url);
+    try {
+      return await this.runHandler(i, e, t), await this.runHooks("onResponse", e, t), t;
+    } catch (d) {
+      let c = {
+        statusCode: 400,
+        message: d instanceof l.ErrorLog ? "AST_ERROR" : "ERROR",
+        error: d instanceof l.ErrorLog ? d.message : d
+      };
+      return t.badRequest(c);
+    }
+  }
+  middleware(e) {
+    for (let t of e.controllers) {
+      let s = R(e.basePath, t.path);
+      this.addEntry(t, s);
+    }
+    return this;
+  }
+  controller(e) {
+    let t = R("/", e.path);
+    return this.addEntry(e, t), this;
+  }
+  use(e, t) {
+    let n = e.defineInstance(this)._build(t);
+    if (this.plugins[n.name] = n, n.hooks.onRequest && this.onRequestPlugins.push(n), n.hooks.onResponse && this.onResponsePlugins.push(n), n.hooks.beforeInitialize && this.beforeInitializePlugins.push(n), n.hooks.afterInitialize && this.afterInitializePlugins.push(n), n._extensionFn) {
+      let o = n._extensionFn(this, n.context);
+      Object.assign(this, o);
+    }
+    return this;
+  }
+  router(e) {
+    return this.controller(new a.Router(e)), this;
+  }
+  method(e) {
+    return this.controller(new a.Method(e)), this;
+  }
+  async resolvePluginContexts() {
+    for (let e in this.plugins) {
+      let t = this.plugins[e];
+      if (t && t.resolvers)
+        for (let s of t.resolvers) {
+          let n = await s(t.context, t.context);
+          Object.assign(t.context, n);
+        }
+    }
+  }
+  async listen(...e) {
+    await this.resolvePluginContexts(), await this.runHooks("beforeInitialize"), await this.driver.listen(...e), await this.runHooks("afterInitialize");
+  }
+  addEntry(e, t) {
+    let s = e instanceof a.Method ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new l.Analyze(t) };
+    for (let o of s)
+      this.reminist.add(o, t, n);
+  }
+  async runHooks(e, t, s) {
+    let n = this[`${e}Plugins`];
+    for (let o of n)
+      switch (e) {
+        case "beforeInitialize":
+        case "afterInitialize":
+          {
+            let i = o.hooks[e];
+            if (i)
+              for (let d of i)
+                await d(this, o.context);
+          }
+          break;
+        case "onRequest":
+        case "onResponse": {
+          if (!t || !s) return;
+          for (let i of o.hooks.onRequest)
+            await i({ request: t, response: s, context: o.context });
+        }
+      }
+  }
+  async runHandler({ route: e }, t, s) {
+    let n = t.getMethod().toLowerCase(), o = e instanceof a.Method ? e.handler : e.methods[n], i = e instanceof a.Method ? e.schema : e.schema?.[n];
+    if (!o) return null;
+    if (i) {
+      let u = i.safeParse(t.getBody());
+      if (!u.success)
+        return s.validationError({
+          statusCode: 422,
+          message: "VALIDATION_ERROR",
+          error: u.error
+        });
+      s.send(u.data);
+    }
+    let d = Object.values(this.plugins).reduce((u, g) => ({ ...u, ...g.context }), {}), c = {
+      instance: this,
+      request: t,
+      response: s,
+      url: t.url,
+      schema: t.getBody(),
+      middleware: {},
+      plugins: d
+    };
+    return o(c);
+  }
+}, v = h;
+0 && (module.exports = {
+  AsterFlow,
+  AsterFlowInstance,
+  joinPaths
+});

package/dist/cjs/package.json

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

package/dist/mjs/index.js

@@ -0,0 +1,144 @@
+// core/src/controllers/Asterflow.ts
+import { adapters as m } from "@asterflow/adapter";
+import { AsterResponse as p } from "@asterflow/response";
+import {
+  Method as d,
+  MethodType as x,
+  Router as g
+} from "@asterflow/router";
+import { Analyze as f, ErrorLog as c } from "@asterflow/url-parser";
+import { Reminist as P } from "reminist";
+// core/src/utils/parser.ts
+function l(h, e) {
+  return `${h}${e}`.replace(/\/{2,}/g, "/");
+}
+// core/src/controllers/Asterflow.ts
+var R = class {
+  driver;
+  reminist = new P({ keys: Object.keys(x) });
+  middlewares = [];
+  plugins = {};
+  onRequestPlugins = [];
+  onResponsePlugins = [];
+  beforeInitializePlugins = [];
+  afterInitializePlugins = [];
+  constructor(e) {
+    this.driver = e?.driver ?? m.node, this.driver.onRequest = this.handleRequest.bind(this);
+  }
+  async handleRequest(e, t) {
+    t = t ?? new p(), await this.runHooks("onRequest", e, t);
+    let s = () => t.notFound({
+      statusCode: 404,
+      code: "NOT_FOUND",
+      message: `Unable to find route: ${e.getPathname()}`
+    }), n = e.getMethod().toLowerCase();
+    if (!n) return s();
+    let o = this.reminist.find(n, e.url.getPathname());
+    if (!o?.node?.store) return s();
+    let r = o.node.store;
+    e.url = e.url.withParser(r.url);
+    try {
+      return await this.runHandler(r, e, t), await this.runHooks("onResponse", e, t), t;
+    } catch (i) {
+      let u = {
+        statusCode: 400,
+        message: i instanceof c ? "AST_ERROR" : "ERROR",
+        error: i instanceof c ? i.message : i
+      };
+      return t.badRequest(u);
+    }
+  }
+  middleware(e) {
+    for (let t of e.controllers) {
+      let s = l(e.basePath, t.path);
+      this.addEntry(t, s);
+    }
+    return this;
+  }
+  controller(e) {
+    let t = l("/", e.path);
+    return this.addEntry(e, t), this;
+  }
+  use(e, t) {
+    let n = e.defineInstance(this)._build(t);
+    if (this.plugins[n.name] = n, n.hooks.onRequest && this.onRequestPlugins.push(n), n.hooks.onResponse && this.onResponsePlugins.push(n), n.hooks.beforeInitialize && this.beforeInitializePlugins.push(n), n.hooks.afterInitialize && this.afterInitializePlugins.push(n), n._extensionFn) {
+      let o = n._extensionFn(this, n.context);
+      Object.assign(this, o);
+    }
+    return this;
+  }
+  router(e) {
+    return this.controller(new g(e)), this;
+  }
+  method(e) {
+    return this.controller(new d(e)), this;
+  }
+  async resolvePluginContexts() {
+    for (let e in this.plugins) {
+      let t = this.plugins[e];
+      if (t && t.resolvers)
+        for (let s of t.resolvers) {
+          let n = await s(t.context, t.context);
+          Object.assign(t.context, n);
+        }
+    }
+  }
+  async listen(...e) {
+    await this.resolvePluginContexts(), await this.runHooks("beforeInitialize"), await this.driver.listen(...e), await this.runHooks("afterInitialize");
+  }
+  addEntry(e, t) {
+    let s = e instanceof d ? [e.method] : Object.keys(e.methods), n = { path: t, route: e, methods: s, url: new f(t) };
+    for (let o of s)
+      this.reminist.add(o, t, n);
+  }
+  async runHooks(e, t, s) {
+    let n = this[`${e}Plugins`];
+    for (let o of n)
+      switch (e) {
+        case "beforeInitialize":
+        case "afterInitialize":
+          {
+            let r = o.hooks[e];
+            if (r)
+              for (let i of r)
+                await i(this, o.context);
+          }
+          break;
+        case "onRequest":
+        case "onResponse": {
+          if (!t || !s) return;
+          for (let r of o.hooks.onRequest)
+            await r({ request: t, response: s, context: o.context });
+        }
+      }
+  }
+  async runHandler({ route: e }, t, s) {
+    let n = t.getMethod().toLowerCase(), o = e instanceof d ? e.handler : e.methods[n], r = e instanceof d ? e.schema : e.schema?.[n];
+    if (!o) return null;
+    if (r) {
+      let a = r.safeParse(t.getBody());
+      if (!a.success)
+        return s.validationError({
+          statusCode: 422,
+          message: "VALIDATION_ERROR",
+          error: a.error
+        });
+      s.send(a.data);
+    }
+    let i = Object.values(this.plugins).reduce((a, y) => ({ ...a, ...y.context }), {}), u = {
+      instance: this,
+      request: t,
+      response: s,
+      url: t.url,
+      schema: t.getBody(),
+      middleware: {},
+      plugins: i
+    };
+    return o(u);
+  }
+}, O = R;
+export {
+  O as AsterFlow,
+  R as AsterFlowInstance,
+  l as joinPaths
+};

package/dist/mjs/package.json

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

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

@@ -0,0 +1,90 @@
+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 { Reminist } from 'reminist';
+import type { AsterFlowOptions } from '../types/asterflow';
+import type { ExtractPaths, InferPath, NormalizePath } from '../types/paths';
+import type { AnyReminist, InferReministContext, InferReministPath } 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 = {}> {
+    readonly driver: Drive;
+    readonly reminist: Routers;
+    readonly middlewares: Middlewares;
+    plugins: Plugins;
+    private readonly onRequestPlugins;
+    private readonly onResponsePlugins;
+    private readonly beforeInitializePlugins;
+    private readonly afterInitializePlugins;
+    constructor(options?: AsterFlowOptions<Drive>);
+    /**
+     * Handles incoming requests, executing `onRequest` and `onResponse` plugin hooks.
+     * Finds the matching route and executes its handler. Manages errors and "not found" responses.
+     */
+    private handleRequest;
+    /**
+     * Adds a group of controllers with a common `basePath`.
+     * Each route within the provided controllers will be prefixed with the `basePath`.
+     */
+    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>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * 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>;
+    } = {
+        [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>;
+    /**
+     * 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>;
+    /**
+     * Itera sobre todos os plugins registrados e executa seus resolvers
+     * de forma assíncrona, construindo o contexto de cada um.
+     */
+    private resolvePluginContexts;
+    /**
+     * Starts the application server, triggering `beforeInitialize` and `afterInitialize` lifecycle hooks.
+     */
+    listen(...args: Parameters<Drive['listen']>): Promise<void>;
+    /**
+     * Adds a route entry to Reminist, associating it with specific HTTP methods.
+     * Normalizes the route path and registers it for each supported method.
+     */
+    private addEntry;
+    /**
+     * Executes the hook handlers for a specific hook name.
+     */
+    private runHooks;
+    /**
+     * Executes a route handler, processing the request and response.
+     * Performs schema validation, if present, and 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 declare const AsterFlow: {
+    new <Drive extends AnyAdapter = Adapter<Runtime.Node>>(options?: AsterFlowOptions<Drive>): AsterFlow<Drive, AnyReminist, {}, [], {}>;
+};
+/**
+ * Represents a generic AsterFlow instance, with all its types defined as `any`.
+ * This allows flexibility when referencing AsterFlow without specifying all its type parameters.
+ */
+export type AnyAsterflow = AsterFlowInstance<AnyAdapter, AnyReminist, AnyPlugins, AnyMiddlewares, AnyRecord>;

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './controllers/Asterflow';
+export * from './types/asterflow';
+export * from './types/paths';
+export * from './types/plugin';
+export * from './types/reminist';
+export * from './types/routes';
+export * from './types/utils';
+export * from './utils/parser';

package/dist/types/types/asterflow.d.ts

@@ -0,0 +1,9 @@
+import type { AnyAdapter } from '@asterflow/adapter';
+import type { AnyAsterflow, AsterFlow } from '../controllers/Asterflow';
+export type ExtendedAsterflow<AF extends AnyAsterflow> = AF extends AsterFlow<any, any, any, any, infer E> ? AF & E : AF;
+/**
+ * Defines the options for initializing an AsterFlow instance.
+ */
+export type AsterFlowOptions<Drive extends AnyAdapter> = {
+    driver?: Drive;
+};

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

@@ -0,0 +1,46 @@
+import type { AnyRouter, Method, Router } from '@asterflow/router';
+/**
+ * Removes the fragment identifier from a URL path.
+ * @example
+ * // '/page#about' -> '/page'
+ */
+type RemoveFragment<Path extends string> = Path extends `${infer CleanPath}#${string}` ? CleanPath : Path;
+/**
+ * Removes the query string from a URL path.
+ * @example
+ * // '/users?data=1' -> '/users'
+ */
+type RemoveQueryString<Path extends string> = Path extends `${infer CleanPath}?${string}` ? CleanPath : Path;
+/**
+ * Removes type definitions from path segments.
+ * Recursively processes the path to clean parts like '=number'.
+ * @example
+ * // '/users/:id=number' -> '/users/:id'
+ */
+type SanitizeSegments<Path extends string> = Path extends `/${infer Rest}` ? `/${SanitizeSegments<Rest>}` : Path extends `${infer Segment}/${infer Rest}` ? `${(Segment extends `${infer Name}=${string}` ? Name : Segment)}/${SanitizeSegments<Rest>}` : Path extends `${infer Name}=${string}` ? Name : Path;
+/**
+ * Normalizes a URL path by performing several cleaning operations:
+ * 1. Replaces double slashes ('//') with a single slash.
+ * 2. Removes the URL fragment (e.g., '#about').
+ * 3. Removes the query string (e.g., '?data=1').
+ * 4. Removes type definitions from path segments (e.g., ':id=number' -> ':id').
+ * @example
+ * // '/users//:id=number?data=1#profile' -> '/users/:id'
+ */
+export type NormalizePath<Path extends string> = Path extends `${infer Head}//${infer Tail}` ? NormalizePath<`${Head}/${Tail}`> : SanitizeSegments<RemoveQueryString<RemoveFragment<Path>>>;
+/**
+ * Combines a base path with a relative path and normalizes the result.
+ */
+export type CombinePaths<Base extends string, Path extends string> = NormalizePath<`${Base}${Path}`>;
+/**
+ * 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 {};

package/dist/types/types/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { UnionToIntersection } from './utils';
+/**
+ * Combines the contexts of multiple plugins into a single intersection type.
+ * This allows safe access to all properties of the merged plugin contexts.
+ */
+export type MergedPluginContexts<Plugins extends Record<string, {
+    context: any;
+}>> = UnionToIntersection<Plugins[keyof Plugins]['context']>;

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

@@ -0,0 +1,23 @@
+import type { AnyRouter, 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.
+ */
+export type AnyReminist = Reminist<readonly string[], Record<string, RouteEntry<string, AnyRouter>>, MethodKeys[]>;
+/**
+ * Infers the paths from a Reminist instance.
+ */
+export type InferReministPath<T> = T extends Reminist<infer P, any, any> ? P : never;
+/**
+ * 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]>;
+};

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

@@ -0,0 +1,27 @@
+import type { AnyRouter, MethodKeys } from '@asterflow/router';
+import type { CombinePaths, InferPath, NormalizePath } from './paths';
+import type { UnionToIntersection } from './utils';
+import type { Analyze } from '@asterflow/url-parser';
+/**
+ * Builds the context for a single route, inferring the path and associating the route entry.
+ */
+export type BuildRouteContext<Route extends AnyRouter, Path extends string = NormalizePath<InferPath<Route>>> = {
+    readonly [K in Path]: RouteEntry<Path, Route>;
+} & Record<string, RouteEntry<string, AnyRouter>>;
+/**
+ * Builds the context for multiple routes, combining base paths and inferring route entries.
+ */
+export type BuildRoutesContext<Base extends string, Routes extends readonly AnyRouter[]> = UnionToIntersection<{
+    [K in keyof Routes]: Routes[K] extends AnyRouter ? {
+        readonly [P in CombinePaths<Base, InferPath<Routes[K]>>]: RouteEntry<CombinePaths<Base, InferPath<Routes[K]>>, Routes[K]>;
+    } : never;
+}[number] & {}> & Record<string, RouteEntry<string, AnyRouter>>;
+/**
+ * Defines the specific typing preserved for each route entry in Reminist.
+ */
+export type RouteEntry<Path extends string, Route extends AnyRouter> = {
+    readonly path: Path;
+    readonly route: Route;
+    readonly methods: readonly MethodKeys[];
+    readonly url: Analyze<string>;
+};

package/dist/types/types/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a union of types into an intersection of types.
+ * Useful for combining properties from multiple types into a single coalesced type.
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+export type AnyRecord = Record<string, any>;

package/dist/types/utils/parser.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Joins two path segments, normalizing slashes to prevent double slashes.
+ */
+export declare function joinPaths(base: string, path: string): string;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "asterflow",
+  "version": "0.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",
+  "author": "Ashu11-A",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AsterFlow/AsterFlow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AsterFlow/AsterFlow/issues"
+  },
+  "homepage": "https://github.com/AsterFlow/AsterFlow",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "dev": "bun run --inspect=ws://localhost:6499 src/index.ts",
+    "exemple": "bun run --inspect-brk=ws://localhost:6499 src/exemple.ts"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.63",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@asterflow/adapter": "1.0.9",
+    "@asterflow/plugin": "1.0.5",
+    "@asterflow/response": "1.0.6",
+    "@asterflow/router": "1.0.9",
+    "@asterflow/url-parser": "^2.0.1",
+    "reminist": "^1.0.5"
+  }
+}

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"
+  ]
+}