@asterflow/adapter 1.0.1

package/README.md

@@ -0,0 +1,228 @@
+<div align="center">
+
+# @asterflow/adapter
+
+![license-info](https://img.shields.io/github/license/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
+![stars-info](https://img.shields.io/github/stars/Ashu11-A/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+
+![last-commit](https://img.shields.io/github/last-commit/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=b4befe)
+![commit-activity](https://img.shields.io/github/commit-activity/y/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af)
+![code-size](https://img.shields.io/github/languages/code-size/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=90dceb)
+
+![top-language](https://img.shields.io/github/languages/top/Ashu11-A/AsterFlow?style=for-the-badge&colorA=302D41&colorB=90dceb)
+![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/adapter?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> HTTP adapters for the AsterFlow framework, providing a unified interface for different runtimes.
+
+## 📦 Installation
+
+```bash
+npm install @asterflow/adapter
+# or
+bun install @asterflow/adapter
+```
+
+## 💡 About
+
+@asterflow/adapter is an HTTP adapter system that allows AsterFlow applications to run on different execution environments. The package provides an abstraction layer that unifies the interface of different HTTP servers, allowing you to write your code once and run it on any supported runtime.
+
+## ✨ Features
+
+- **Multiple Runtimes:** Native support for:
+  - Node.js HTTP Server
+  - Bun
+  - Express
+  - Fastify
+- **Unified Interface:** Consistent API regardless of runtime
+- **Error Handling:** Robust error handling system with standardized responses
+- **Strong Typing:** Full TypeScript support with type inference
+- **Router Integration:** Works seamlessly with AsterFlow's routing system
+- **Zero Configuration:** Works immediately after installation
+- **Middleware Support:** Compatible with runtime-specific middleware
+
+## 🚀 Usage
+
+### Basic Example
+
+```typescript
+import { AsterFlow } from '@asterflow/core'
+import { adapters } from '@asterflow/adapter'
+import { Router } from '@asterflow/router'
+
+// Create an AsterFlow instance with the desired adapter
+const app = new AsterFlow({ 
+  driver: adapters.node // or adapters.bun, adapters.express, adapters.fastify
+})
+
+// Define your routes
+const router = new Router({
+  path: '/hello',
+  methods: {
+    get({ response }) {
+      return response.send('Hello World!')
+    }
+  }
+})
+
+// Register routes
+app.controller(router)
+
+// Start the server
+app.listen({ port: 3000 })
+```
+
+### Available Adapters
+
+#### Node.js HTTP Server
+
+```typescript
+import { AsterFlow } from '@asterflow/core'
+import { adapters } from '@asterflow/adapter'
+
+const app = new AsterFlow({
+  driver: adapters.node
+})
+
+app.listen({ port: 3000 })
+```
+
+#### Bun
+
+```typescript
+import { AsterFlow } from '@asterflow/core'
+import { adapters } from '@asterflow/adapter'
+
+const app = new AsterFlow({
+  driver: adapters.bun
+})
+
+app.listen({ port: 3000 })
+```
+
+#### Express
+
+```typescript
+import { AsterFlow } from '@asterflow/core'
+import { adapters } from '@asterflow/adapter'
+import express from 'express'
+
+const expressApp = express()
+const app = new AsterFlow({
+  driver: adapters.express
+})
+
+// Use Express middleware
+expressApp.use(express.json())
+
+app.listen(expressApp, 3000)
+```
+
+#### Fastify
+
+```typescript
+import { AsterFlow } from '@asterflow/core'
+import { adapters } from '@asterflow/adapter'
+import fastify from 'fastify'
+
+const server = fastify()
+const app = new AsterFlow({
+  driver: adapters.fastify
+})
+
+app.listen(server, { port: 3000 }, (err) => {
+  if (err) {
+    console.error(err)
+    process.exit(1)
+  }
+  console.log('Server listening!')
+})
+```
+
+## 🔧 Architecture
+
+### Adapter System
+
+The package uses an adapter system that implements the `Adapter` interface:
+
+```typescript
+class Adapter<Type extends Runtime> {
+  readonly runtime: Type
+  readonly listen: OptionsDriver<Type>['listen']
+  onRequest?: (request: Request, response: Response) => Promise<Response> | Response
+}
+```
+
+Each adapter implements:
+- Runtime-specific server initialization
+- Request conversion to AsterFlow format
+- Standardized error handling
+- Integration with the routing system
+
+### Error Handling
+
+The system includes robust error handling that:
+- Standardizes error responses
+- Provides stack traces in development environment
+- Logs errors for diagnostics
+- Maintains security by not exposing sensitive details in production
+
+```typescript
+interface ErrorPayload {
+  statusCode: number
+  error: string
+  message: string
+  details?: unknown
+}
+```
+
+## 📚 API Reference
+
+### Main Types
+
+```typescript
+enum Runtime {
+  Bun = 'bun',
+  Express = 'express',
+  Node = 'node',
+  Fastify = 'fastify'
+}
+
+interface OptionsDriver<Type extends Runtime> {
+  runtime: Type
+  listen: (...params: ListenParams<Type>) => void
+  onRequest?: (request: Request, response?: Response) => Response | Promise<Response>
+}
+```
+
+### Configuration Options
+
+Each adapter accepts runtime-specific options while maintaining proper typing:
+
+```typescript
+// Node/Bun
+interface ListenOptions {
+  port: number
+  host?: string
+  backlog?: number
+}
+
+// Fastify
+interface FastifyOptions extends FastifyListenOptions {
+  // Fastify-specific options
+}
+
+// Express
+type ExpressOptions = Express.Application
+```
+
+## 🔗 Related Packages
+
+- [@asterflow/core](https://github.com/Ashu11-A/AsterFlow/tree/main/core) - Core framework
+- [@asterflow/router](https://github.com/Ashu11-A/AsterFlow/tree/main/packages/router) - Routing system
+- [@asterflow/request](https://github.com/Ashu11-A/AsterFlow/tree/main/packages/request) - Unified HTTP request system
+
+## 📄 License
+
+MIT - See [LICENSE](https://github.com/Ashu11-A/AsterFlow/blob/main/LICENSE) for more details.

package/dist/cjs/index.cjs

@@ -0,0 +1,149 @@
+"use strict";
+var a = Object.defineProperty;
+var w = Object.getOwnPropertyDescriptor;
+var T = Object.getOwnPropertyNames;
+var F = Object.prototype.hasOwnProperty;
+var O = (e, t) => {
+  for (var r in t)
+    a(e, r, { get: t[r], enumerable: !0 });
+}, C = (e, t, r, n) => {
+  if (t && typeof t == "object" || typeof t == "function")
+    for (let s of T(t))
+      !F.call(e, s) && s !== r && a(e, s, { get: () => t[s], enumerable: !(n = w(t, s)) || n.enumerable });
+  return e;
+};
+var L = (e) => C(a({}, "__esModule", { value: !0 }), e);
+
+// packages/adapter/src/index.ts
+var S = {};
+O(S, {
+  Adapter: () => o,
+  Runtime: () => i,
+  adapters: () => A
+});
+module.exports = L(S);
+
+// packages/adapter/src/types/adapter.ts
+var B = require("@asterflow/router"), N = require("express"), i = /* @__PURE__ */ ((s) => (s.Bun = "bun", s.Express = "express", s.Node = "node", s.Fastify = "fastify", s))(i || {});
+
+// packages/adapter/src/controllers/Adapter.ts
+var U = require("@asterflow/router"), o = class {
+  runtime;
+  listen;
+  onRequest = void 0;
+  constructor({ runtime: t, listen: r }) {
+    this.runtime = t, this.listen = r;
+  }
+};
+
+// packages/adapter/src/adapters/bun.ts
+var m = require("@asterflow/request");
+var f = require("@asterflow/router"), d = new o({
+  runtime: "bun",
+  listen(e, t) {
+    try {
+      Bun.serve({
+        ...e,
+        fetch: async (r) => this.onRequest ? (await this.onRequest(new m.BunRequest(r))).toResponse() : new f.Response().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        }).toResponse()
+      }), t?.(null);
+    } catch (r) {
+      t?.(r);
+    }
+  }
+});
+
+// packages/adapter/src/adapters/fastify.ts
+var l = require("@asterflow/router");
+var R = require("@asterflow/request"), y = new o({
+  runtime: "fastify",
+  listen(e, t, r) {
+    e.all("*", async (n) => this.onRequest ? (await this.onRequest(new R.FastifyRequest(n))).toResponse() : new l.Response().notFound({
+      statusCode: 500,
+      error: "Internal Server Error",
+      message: "The onRequest() function must be defined before the listen() function."
+    })), e.listen(t, r);
+  }
+});
+
+// packages/adapter/src/adapters/node.ts
+var x = require("http"), E = require("@asterflow/router");
+var q = require("@asterflow/request");
+
+// packages/adapter/src/utils/errorHandler.ts
+var u = require("@asterflow/router");
+function c(e) {
+  let t;
+  return e instanceof u.Response ? e : (e instanceof Error ? t = {
+    statusCode: 500,
+    error: e.name,
+    message: e.message,
+    // Optionally attach stack in non-prod
+    details: process.env.NODE_ENV !== "production" ? e.stack : void 0
+  } : t = {
+    statusCode: 500,
+    error: "InternalServerError",
+    message: typeof e == "string" ? e : "An unexpected error occurred.",
+    details: e
+  }, console.error("Unhandled exception in adapter:", e), new u.Response().status(t.statusCode).json({
+    error: t.error,
+    message: t.message,
+    ...t.details ? { details: t.details } : {}
+  }));
+}
+
+// packages/adapter/src/adapters/node.ts
+var h = new o({
+  runtime: "node",
+  listen(e, t) {
+    try {
+      (0, x.createServer)(async (r, n) => {
+        if (!this.onRequest) return new E.Response().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        });
+        try {
+          return (await this.onRequest(new q.NodeRequest(r))).toServerResponse(n);
+        } catch (s) {
+          return c(s).toServerResponse(n);
+        }
+      }).listen(e), t?.(null);
+    } catch (r) {
+      t?.(r);
+    }
+  }
+});
+
+// packages/adapter/src/adapters/express.ts
+var $ = require("express"), g = require("@asterflow/router");
+var v = require("@asterflow/request"), b = new o({
+  runtime: "express",
+  listen(e, ...t) {
+    return e.all("/{*path}", async (r, n) => {
+      if (!this.onRequest) {
+        let p = new g.Response().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        }).toResponse();
+        n.status(p.status).set(Object.fromEntries(p.headers)).send(await p.text());
+        return;
+      }
+      let s = (await this.onRequest(new v.ExpressRequest(r))).toResponse();
+      n.status(s.status).set(Object.fromEntries(s.headers)).send(await s.text());
+    }), e.listen(...t), e;
+  }
+});
+
+// packages/adapter/src/index.ts
+var A = { bun: d, fastify: y, node: h, express: b };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Adapter,
+  Runtime,
+  adapters
+});

package/dist/cjs/package.json

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

package/dist/mjs/index.js

@@ -0,0 +1,131 @@
+// packages/adapter/src/types/adapter.ts
+import "@asterflow/router";
+import "express";
+var i = /* @__PURE__ */ ((s) => (s.Bun = "bun", s.Express = "express", s.Node = "node", s.Fastify = "fastify", s))(i || {});
+
+// packages/adapter/src/controllers/Adapter.ts
+import "@asterflow/router";
+var o = class {
+  runtime;
+  listen;
+  onRequest = void 0;
+  constructor({ runtime: t, listen: r }) {
+    this.runtime = t, this.listen = r;
+  }
+};
+
+// packages/adapter/src/adapters/bun.ts
+import { BunRequest as R } from "@asterflow/request";
+import { Response as y } from "@asterflow/router";
+var a = new o({
+  runtime: "bun",
+  listen(e, t) {
+    try {
+      Bun.serve({
+        ...e,
+        fetch: async (r) => this.onRequest ? (await this.onRequest(new R(r))).toResponse() : new y().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        }).toResponse()
+      }), t?.(null);
+    } catch (r) {
+      t?.(r);
+    }
+  }
+});
+
+// packages/adapter/src/adapters/fastify.ts
+import { Response as c } from "@asterflow/router";
+import { FastifyRequest as x } from "@asterflow/request";
+var u = new o({
+  runtime: "fastify",
+  listen(e, t, r) {
+    e.all("*", async (n) => this.onRequest ? (await this.onRequest(new x(n))).toResponse() : new c().notFound({
+      statusCode: 500,
+      error: "Internal Server Error",
+      message: "The onRequest() function must be defined before the listen() function."
+    })), e.listen(t, r);
+  }
+});
+
+// packages/adapter/src/adapters/node.ts
+import { createServer as E } from "http";
+import { Response as q } from "@asterflow/router";
+import { NodeRequest as h } from "@asterflow/request";
+
+// packages/adapter/src/utils/errorHandler.ts
+import { Response as m } from "@asterflow/router";
+function f(e) {
+  let t;
+  return e instanceof m ? e : (e instanceof Error ? t = {
+    statusCode: 500,
+    error: e.name,
+    message: e.message,
+    // Optionally attach stack in non-prod
+    details: process.env.NODE_ENV !== "production" ? e.stack : void 0
+  } : t = {
+    statusCode: 500,
+    error: "InternalServerError",
+    message: typeof e == "string" ? e : "An unexpected error occurred.",
+    details: e
+  }, console.error("Unhandled exception in adapter:", e), new m().status(t.statusCode).json({
+    error: t.error,
+    message: t.message,
+    ...t.details ? { details: t.details } : {}
+  }));
+}
+
+// packages/adapter/src/adapters/node.ts
+var d = new o({
+  runtime: "node",
+  listen(e, t) {
+    try {
+      E(async (r, n) => {
+        if (!this.onRequest) return new q().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        });
+        try {
+          return (await this.onRequest(new h(r))).toServerResponse(n);
+        } catch (s) {
+          return f(s).toServerResponse(n);
+        }
+      }).listen(e), t?.(null);
+    } catch (r) {
+      t?.(r);
+    }
+  }
+});
+
+// packages/adapter/src/adapters/express.ts
+import "express";
+import { Response as g } from "@asterflow/router";
+import { ExpressRequest as v } from "@asterflow/request";
+var l = new o({
+  runtime: "express",
+  listen(e, ...t) {
+    return e.all("/{*path}", async (r, n) => {
+      if (!this.onRequest) {
+        let p = new g().notFound({
+          statusCode: 500,
+          error: "Internal Server Error",
+          message: "The onRequest() function must be defined before the listen() function."
+        }).toResponse();
+        n.status(p.status).set(Object.fromEntries(p.headers)).send(await p.text());
+        return;
+      }
+      let s = (await this.onRequest(new v(r))).toResponse();
+      n.status(s.status).set(Object.fromEntries(s.headers)).send(await s.text());
+    }), e.listen(...t), e;
+  }
+});
+
+// packages/adapter/src/index.ts
+var pe = { bun: a, fastify: u, node: d, express: l };
+export {
+  o as Adapter,
+  i as Runtime,
+  pe as adapters
+};

package/dist/mjs/package.json

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

package/dist/types/adapters/bun.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from '../controllers/Adapter';
+import { Runtime } from '../types/adapter';
+declare const _default: Adapter<Runtime.Bun>;
+export default _default;

package/dist/types/adapters/express.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from '../controllers/Adapter';
+import { Runtime } from '../types/adapter';
+declare const _default: Adapter<Runtime.Express>;
+export default _default;

package/dist/types/adapters/fastify.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from '../controllers/Adapter';
+import { Runtime } from '../types/adapter';
+declare const _default: Adapter<Runtime.Fastify>;
+export default _default;

package/dist/types/adapters/node.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from '../controllers/Adapter';
+import { Runtime } from '../types/adapter';
+declare const _default: Adapter<Runtime.Node>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import type { Request } from '@asterflow/request';
+import { Runtime, type OptionsDriver } from '../types/adapter';
+import { Response as ResponseCustom } from '@asterflow/router';
+export declare class Adapter<Type extends Runtime> {
+    readonly runtime: Type;
+    readonly listen: OptionsDriver<Type>['listen'];
+    onRequest: (<RequestType>(request: Request<RequestType>, response: ResponseCustom) => Promise<Response> | Response) | undefined;
+    constructor({ runtime, listen }: OptionsDriver<Type>);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './controllers/Adapter';
+export * from './types/adapter';
+declare const adapters: {
+    bun: import(".").Adapter<import(".").Runtime.Bun>;
+    fastify: import(".").Adapter<import(".").Runtime.Fastify>;
+    node: import(".").Adapter<import(".").Runtime.Node>;
+    express: import(".").Adapter<import(".").Runtime.Express>;
+};
+export { adapters };

package/dist/types/types/adapter.d.ts

@@ -0,0 +1,22 @@
+import type { Request } from '@asterflow/request';
+import { Response as ResponseCustom } from '@asterflow/router';
+import type { ServeOptions as BunServeOptions } from 'bun';
+import { type Express } from 'express';
+import type { FastifyInstance, FastifyListenOptions } from 'fastify';
+import type { ListenOptions } from 'net';
+export declare enum Runtime {
+    Bun = "bun",
+    Express = "express",
+    Node = "node",
+    Fastify = "fastify"
+}
+export type ExpressListenArgs = [port: number, hostname: string, backlog: number, callback?: (err?: Error) => void] | [port: number, hostname: string, callback?: (err?: Error) => void] | [port: number, callback?: (err?: Error) => void] | [path: string, callback?: (err?: Error) => void];
+export type FastifyListenArgs = [fastify: FastifyInstance, params: FastifyListenOptions, callback: (err: Error | null, address: string) => void];
+export type BunListenArgs = [options: Omit<BunServeOptions, 'fetch'>, callback?: (err: Error | null) => void];
+export type NodeListenArgs = [options: ListenOptions, callback?: (err: Error | null) => void];
+export type ListenParams<Type extends Runtime> = Type extends Runtime.Bun ? BunListenArgs : Type extends Runtime.Fastify ? FastifyListenArgs : Type extends Runtime.Express ? [app: Express, ExpressListenArgs] : NodeListenArgs;
+export type OptionsDriver<Type extends Runtime> = {
+    runtime: Type;
+    listen: (...params: ListenParams<Type>) => void;
+    onRequest?: <RequestType>(request: Request<RequestType>, response?: ResponseCustom) => ResponseCustom | Promise<ResponseCustom>;
+};

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

@@ -0,0 +1,5 @@
+import { Response } from '@asterflow/router';
+/**
+ * Turn any thrown value into a Response.
+ */
+export declare function toErrorResponse(err: unknown): Response;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@asterflow/adapter",
+  "version": "1.0.1",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/mjs/index.js",
+  "types": "dist/types/index.d.ts",
+  "typings": "dist/types/index.d.ts",
+  "type": "module",
+  "license": "MIT",
+  "author": "Ashu11-A",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ashu11-A/AsterFlow.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Ashu11-A/AsterFlow/issues"
+  },
+  "homepage": "https://github.com/Ashu11-A/AsterFlow",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.15",
+    "fastify": "^5.3.3",
+    "@asterflow/router": "workspace:^1.0.1",
+    "@asterflow/request": "workspace:^1.0.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@types/express": "^5.0.3",
+    "express": "^5.1.0"
+  }
+}

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