@asterflow/response 1.0.1

package/README.md

@@ -0,0 +1,214 @@
+<div align="center">
+
+# @asterflow/response
+
+![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/response?style=for-the-badge&colorA=302D41&colorB=3ac97b)
+
+</div>
+
+> Unified HTTP response adapter system for AsterFlow applications.
+
+## 📦 Installation
+
+```bash
+npm install @asterflow/response
+# or
+bun install @asterflow/response
+```
+
+## 💡 About
+
+@asterflow/response provides a type-safe, unified response system for AsterFlow applications. It standardizes HTTP response handling across different runtimes while maintaining full type safety and providing convenient helper methods for common HTTP status codes.
+
+## ✨ Features
+
+- **Complete Type Safety:** Full TypeScript support with type inference for responses, status codes, and body types
+- **Status Code Helpers:** Built-in methods for common HTTP status codes (200, 201, 400, 404, etc.)
+- **Header Management:** Type-safe header manipulation with method chaining
+- **Cookie Support:** Integrated cookie management system
+- **Content Type Detection:** Automatic content type detection and JSON serialization
+- **Multi-Runtime Support:** Compatible with standard Response and Node.js ServerResponse
+- **Immutable Design:** Response objects are immutable, promoting safer code patterns
+- **Method Chaining:** Fluent API for building complex responses
+
+## 🚀 Usage
+
+### Basic Response
+
+```typescript
+import { Response } from '@asterflow/response'
+
+// Simple text response
+const response = new Response()
+  .success({ message: 'Hello World!' })
+
+// With status code
+const response = new Response()
+  .status(201)
+  .send({ id: 1, name: 'User' })
+```
+
+### Status Code Helpers
+
+```typescript
+import { Response } from '@asterflow/response'
+
+// Success responses
+const success = new Response().success({ data: 'Success!' })
+const created = new Response().created({ id: 1 })
+const noContent = new Response().noContent()
+
+// Error responses
+const badRequest = new Response().badRequest({ error: 'Invalid input' })
+const unauthorized = new Response().unauthorized({ error: 'Not authenticated' })
+const forbidden = new Response().forbidden({ error: 'Access denied' })
+const notFound = new Response().notFound({ error: 'Resource not found' })
+const zodError = new Response().zodError({ errors: ['Validation failed'] })
+```
+
+### Headers and Cookies
+
+```typescript
+import { Response } from '@asterflow/response'
+
+const response = new Response()
+  .success({ message: 'Hello!' })
+  .setHeader('X-Custom-Header', 'custom-value')
+  .setHeader('Cache-Control', 'no-cache')
+  .setCookie('session', 'abc123')
+  .setCookie('theme', 'dark')
+
+// Headers and cookies are fully typed
+console.log(response.header) // Map with typed entries
+console.log(response.cookies) // Map with typed entries
+```
+
+### JSON Responses
+
+```typescript
+import { Response } from '@asterflow/response'
+
+// Automatic JSON serialization
+const jsonResponse = new Response()
+  .json({ 
+    users: [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Jane' }
+    ]
+  })
+
+// Content-Type automatically set to application/json
+```
+
+### Integration with Different Runtimes
+
+#### Standard Web API
+
+```typescript
+import { Response } from '@asterflow/response'
+
+const response = new Response()
+  .success({ message: 'Hello World!' })
+
+// Convert to standard Response
+const webResponse = response.toResponse()
+```
+
+#### Node.js HTTP Server
+
+```typescript
+import { Response } from '@asterflow/response'
+import { createServer } from 'http'
+
+createServer((req, res) => {
+  const response = new Response()
+    .success({ message: 'Hello from Node.js!' })
+  
+  // Convert to ServerResponse
+  response.toServerResponse(res)
+})
+```
+
+### Advanced Type Safety
+
+```typescript
+import { Response } from '@asterflow/response'
+
+// Define custom response types
+type MyResponders = {
+  200: { message: string; data: unknown }
+  201: { id: number; message: string }
+  400: { error: string; details?: string[] }
+  404: { error: string }
+}
+
+const response = new Response<MyResponders>()
+  .success({ message: 'Success!', data: { id: 1 } }) // Fully typed
+  
+// TypeScript will enforce the correct shape for each status code
+```
+
+### Method Chaining
+
+```typescript
+import { Response } from '@asterflow/response'
+
+const response = new Response()
+  .status(201)
+  .setHeader('Location', '/users/123')
+  .setHeader('X-Request-ID', 'req-123')
+  .setCookie('last-action', 'create-user')
+  .json({ 
+    id: 123, 
+    message: 'User created successfully' 
+  })
+```
+
+## 🔧 API Reference
+
+### Core Methods
+
+- `status(code)` - Set HTTP status code
+- `getStatus()` - Get current status code
+- `send(data)` - Send response with data
+- `json(data)` - Send JSON response with proper Content-Type
+
+### Status Code Helpers
+
+- `success(data)` - 200 OK
+- `created(data)` - 201 Created
+- `noContent(data)` - 204 No Content
+- `badRequest(data)` - 400 Bad Request
+- `unauthorized(data)` - 401 Unauthorized
+- `forbidden(data)` - 403 Forbidden
+- `notFound(data)` - 404 Not Found
+- `zodError(data)` - 422 Unprocessable Entity
+
+### Header and Cookie Management
+
+- `setHeader(name, value)` - Add/update header
+- `setCookie(name, value)` - Add/update cookie
+
+### Runtime Conversion
+
+- `toResponse()` - Convert to standard Web API Response
+- `toServerResponse(serverRes)` - Write to Node.js ServerResponse
+
+## 🔗 Related Packages
+
+- [@asterflow/core](https://www.npmjs.com/package/@asterflow/core) - Core framework
+- [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - Type-safe routing system
+- [@asterflow/adapter](https://www.npmjs.com/package/@asterflow/adapter) - HTTP adapters for different runtimes
+- [@asterflow/request](https://www.npmjs.com/package/@asterflow/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,116 @@
+"use strict";
+var r = Object.defineProperty;
+var d = Object.getOwnPropertyDescriptor;
+var p = Object.getOwnPropertyNames;
+var c = Object.prototype.hasOwnProperty;
+var h = (n, e) => {
+  for (var t in e)
+    r(n, t, { get: e[t], enumerable: !0 });
+}, u = (n, e, t, s) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let o of p(e))
+      !c.call(n, o) && o !== t && r(n, o, { get: () => e[o], enumerable: !(s = d(e, o)) || s.enumerable });
+  return n;
+};
+var M = (n) => u(r({}, "__esModule", { value: !0 }), n);
+
+// packages/response/src/index.ts
+var y = {};
+h(y, {
+  Response: () => i
+});
+module.exports = M(y);
+
+// packages/response/src/controllers/Response.ts
+var i = class n {
+  _status;
+  body;
+  header;
+  cookies;
+  constructor(e) {
+    this._status = e?.code ?? 200, this.body = e?.data, this.header = e?.header ?? /* @__PURE__ */ new Map(), this.cookies = e?.cookies ?? /* @__PURE__ */ new Map();
+  }
+  clone(e) {
+    return new n({
+      code: e.code !== void 0 ? e.code : this._status,
+      data: e.data !== void 0 ? e.data : this.body,
+      header: e.header !== void 0 ? e.header : this.header,
+      cookies: e.cookies !== void 0 ? e.cookies : this.cookies
+    });
+  }
+  // --- Core Methods ---
+  status(e) {
+    return this.clone({ code: e });
+  }
+  getStatus() {
+    return this._status;
+  }
+  code(e) {
+    return this.status(e);
+  }
+  send(e) {
+    return this.clone({ data: e });
+  }
+  json(e) {
+    let t = new Map(this.header);
+    return t.set("Content-Type", "application/json"), this.clone({ data: e, header: t });
+  }
+  // --- Response Helpers ---
+  success(e) {
+    return this.clone({ code: 200, data: e });
+  }
+  created(e) {
+    return this.clone({ code: 201, data: e });
+  }
+  noContent(e) {
+    return this.clone({ code: 204, data: e });
+  }
+  badRequest(e) {
+    return this.clone({ code: 400, data: e });
+  }
+  zodError(e) {
+    return this.clone({ code: 422, data: e });
+  }
+  unauthorized(e) {
+    return this.clone({ code: 401, data: e });
+  }
+  forbidden(e) {
+    return this.clone({ code: 403, data: e });
+  }
+  notFound(e) {
+    return this.clone({ code: 404, data: e });
+  }
+  setHeader(e, t) {
+    let s = new Map(this.header);
+    return s.set(e, t), this.clone({ header: s });
+  }
+  setCookie(e, t) {
+    let s = new Map(this.cookies);
+    return s.set(e, t), this.clone({ cookies: s });
+  }
+  toResponse() {
+    let e = new Headers();
+    e.set("Content-Type", "text/plain");
+    for (let [s, o] of this.header) e.set(s, o);
+    (typeof this.body == "object" || Array.isArray(this.body)) && e.set("Content-Type", "application/json");
+    for (let [s, o] of this.cookies) e.append("Set-Cookie", `${s}=${o}`);
+    let t = e.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    return new globalThis.Response(t, {
+      status: this._status,
+      headers: e
+    });
+  }
+  toServerResponse(e) {
+    let t = new Headers();
+    t.set("Content-Type", "text/plain");
+    for (let [o, a] of this.header) t.set(o, a);
+    (typeof this.body == "object" || Array.isArray(this.body)) && t.set("Content-Type", "application/json");
+    for (let [o, a] of this.cookies) t.append("Set-Cookie", `${o}=${a}`);
+    let s = t.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    e.writeHead(this._status, Object.fromEntries(t)), e.end(s);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Response
+});

package/dist/cjs/package.json

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

package/dist/mjs/index.js

@@ -0,0 +1,92 @@
+// packages/response/src/controllers/Response.ts
+var a = class r {
+  _status;
+  body;
+  header;
+  cookies;
+  constructor(e) {
+    this._status = e?.code ?? 200, this.body = e?.data, this.header = e?.header ?? /* @__PURE__ */ new Map(), this.cookies = e?.cookies ?? /* @__PURE__ */ new Map();
+  }
+  clone(e) {
+    return new r({
+      code: e.code !== void 0 ? e.code : this._status,
+      data: e.data !== void 0 ? e.data : this.body,
+      header: e.header !== void 0 ? e.header : this.header,
+      cookies: e.cookies !== void 0 ? e.cookies : this.cookies
+    });
+  }
+  // --- Core Methods ---
+  status(e) {
+    return this.clone({ code: e });
+  }
+  getStatus() {
+    return this._status;
+  }
+  code(e) {
+    return this.status(e);
+  }
+  send(e) {
+    return this.clone({ data: e });
+  }
+  json(e) {
+    let t = new Map(this.header);
+    return t.set("Content-Type", "application/json"), this.clone({ data: e, header: t });
+  }
+  // --- Response Helpers ---
+  success(e) {
+    return this.clone({ code: 200, data: e });
+  }
+  created(e) {
+    return this.clone({ code: 201, data: e });
+  }
+  noContent(e) {
+    return this.clone({ code: 204, data: e });
+  }
+  badRequest(e) {
+    return this.clone({ code: 400, data: e });
+  }
+  zodError(e) {
+    return this.clone({ code: 422, data: e });
+  }
+  unauthorized(e) {
+    return this.clone({ code: 401, data: e });
+  }
+  forbidden(e) {
+    return this.clone({ code: 403, data: e });
+  }
+  notFound(e) {
+    return this.clone({ code: 404, data: e });
+  }
+  setHeader(e, t) {
+    let s = new Map(this.header);
+    return s.set(e, t), this.clone({ header: s });
+  }
+  setCookie(e, t) {
+    let s = new Map(this.cookies);
+    return s.set(e, t), this.clone({ cookies: s });
+  }
+  toResponse() {
+    let e = new Headers();
+    e.set("Content-Type", "text/plain");
+    for (let [s, o] of this.header) e.set(s, o);
+    (typeof this.body == "object" || Array.isArray(this.body)) && e.set("Content-Type", "application/json");
+    for (let [s, o] of this.cookies) e.append("Set-Cookie", `${s}=${o}`);
+    let t = e.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    return new globalThis.Response(t, {
+      status: this._status,
+      headers: e
+    });
+  }
+  toServerResponse(e) {
+    let t = new Headers();
+    t.set("Content-Type", "text/plain");
+    for (let [o, n] of this.header) t.set(o, n);
+    (typeof this.body == "object" || Array.isArray(this.body)) && t.set("Content-Type", "application/json");
+    for (let [o, n] of this.cookies) t.append("Set-Cookie", `${o}=${n}`);
+    let s = t.get("Content-Type") === "application/json" ? JSON.stringify(this.body) : String(this.body);
+    e.writeHead(this._status, Object.fromEntries(t)), e.end(s);
+  }
+};
+export {
+  a as Response
+};

package/dist/mjs/package.json

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

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

@@ -0,0 +1,37 @@
+import type { BodyMap, Responders, ResponseOptions } from '../types/response';
+import { ServerResponse } from 'http';
+export declare class Response<Responder extends Responders = Responders, BM extends BodyMap<Responder> = BodyMap<Responder>, Status extends keyof BM = keyof BM, Header extends Map<string, string> = Map<string, string>, Cookies extends Map<string, string> = Map<string, string>> {
+    protected readonly _status: Status;
+    readonly body?: BM[Status];
+    readonly header: Header;
+    readonly cookies: Cookies;
+    constructor(options?: ResponseOptions<Responder, BM, Status, Header, Cookies>);
+    protected clone<NewHeader extends Map<string, string> = Header, NewCookies extends Map<string, string> = Cookies>(overrides: {
+        data?: BM[Status];
+        header?: NewHeader;
+        cookies?: NewCookies;
+    }): Response<Responder, BM, Status, NewHeader, NewCookies>;
+    protected clone<NewStatus extends keyof BM, NewCookies extends Map<string, string> = Cookies>(overrides: {
+        code: NewStatus;
+        data?: BM[NewStatus];
+        header?: Header;
+        cookies?: NewCookies;
+    }): Response<Responder, BM, NewStatus, Header, NewCookies>;
+    status<NS extends keyof BM>(code: NS): Response<Responder, BM, NS, Header, Cookies>;
+    getStatus(): Status;
+    code<NS extends keyof BM>(code: NS): Response<Responder, BM, NS, Header, Cookies>;
+    send(data: BM[Status]): Response<Responder, BM, Status, Header, Cookies>;
+    json(data: BM[Status]): Response<Responder, BM, Status, Header & Map<"Content-Type", "application/json">, Cookies>;
+    success(data: BM[200]): Response<Responder, BM, 200, Header, Cookies>;
+    created(data: BM[201]): Response<Responder, BM, 201, Header, Cookies>;
+    noContent(data: BM[204]): Response<Responder, BM, 204, Header, Cookies>;
+    badRequest(data: BM[400]): Response<Responder, BM, 400, Header, Cookies>;
+    zodError(data: BM[422]): Response<Responder, BM, 422, Header, Cookies>;
+    unauthorized(data: BM[401]): Response<Responder, BM, 401, Header, Cookies>;
+    forbidden(data: BM[403]): Response<Responder, BM, 403, Header, Cookies>;
+    notFound(data: BM[404]): Response<Responder, BM, 404, Header, Cookies>;
+    setHeader<Name extends string, Value extends string>(name: Name, value: Value): Response<Responder, BM, Status, Header & Map<Name, Value>, Cookies>;
+    setCookie<Name extends string, Value extends string>(name: Name, value: Value): Response<Responder, BM, Status, Header, Cookies & Map<Name, Value>>;
+    toResponse(): globalThis.Response;
+    toServerResponse(output: ServerResponse): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types/response';
+export * from './controllers/Response';

package/dist/types/types/response.d.ts

@@ -0,0 +1,12 @@
+export type Responders = {
+    [x in number]: unknown;
+};
+export type BodyMap<Responder extends Responders> = {
+    [S in keyof Responder]: Responder[S];
+};
+export type ResponseOptions<Responder extends Responders, BM extends BodyMap<Responder>, Status extends keyof BM, Header extends Map<string, string>, Cookies extends Map<string, string>> = {
+    data?: BM[Status];
+    code?: Status;
+    header?: Header;
+    cookies?: Cookies;
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@asterflow/response",
+  "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",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "typescript": "^5.8.3"
+  }
+}

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