ts-packages 1.0.0 → 2.0.0

package/packages/js-extensions/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    },
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/response-utils/README.md

@@ -1,110 +1,246 @@
 # @naman_deep_singh/response-utils
 
-TypeScript utilities for standardized HTTP API responses with common status codes and error handling. Supports both standalone usage and Express.js integration.
+**Version:** 2.1.2
 
-## Installation
+A flexible, framework-agnostic **TypeScript** response utility library for building consistent and configurable API responses.  
+Supports **Express.js**, pagination, typed payloads, and expandable response adapters.
 
-```bash
+---
+
+## 🚀 Features
+
+| Feature                                        | Status |
+| ---------------------------------------------- | :----: |
+| Fully Typesafe Response Envelopes              |   ✅   |
+| Framework-Agnostic Core                        |   ✅   |
+| Express.js Adapter + Middleware                |   ✅   |
+| Automatic HTTP Status Handling                 |   ✅   |
+| Pagination Responses                           |   ✅   |
+| Centralized Response Config                    |   ✅   |
+| Status Code Constants                          |   ✅   |
+| Legacy API (`success`, `error`, etc.)          |   ⚠️ Deprecated   |
+
+---
+
+## 📦 Installation
+
+```sh
 npm install @naman_deep_singh/response-utils
 ```
 
-## Features
+## 🧠 Architecture Overview
 
-- ✅ **Standardized API responses** with consistent format
-- ✅ **Express.js integration** - automatically sets HTTP status codes
-- ✅ **TypeScript support** with full type safety
-- ✅ **Hybrid exports** - use named imports or namespace imports
-- ✅ **Pagination support** with metadata
-- ✅ **Common HTTP status codes** (200, 201, 400, 401, 403, 404, 408, 409, 422, 429, 500)
+```
+response-utils
+├─ core/          → BaseResponder + config + factory (framework-independent)
+├─ adapters/
+│   └─ express/   → ExpressResponder + middleware
+├─ constants/     → HTTP status constants
+└─ legacy/        → success(), error(), etc. (optional migration layer)
+```
 
-## Usage
+## 📄 Response Format (Default Envelope)
 
-### Named Imports (Tree-shakable)
 ```typescript
-import { success, error, created, notFound, paginated } from '@naman_deep_singh/response-utils';
+interface ResponseEnvelope<P = unknown, M = Record<string, unknown>> {
+  success: boolean;
+  message?: string;
+  data?: P;
+  error: { message: string; code?: string; details?: unknown } | null;
+  meta: M | null;
+}
+```
 
-// Success responses
-const userResponse = success({ id: 1, name: 'John' }, 'User found');
-const createdResponse = created({ id: 2, name: 'Jane' });
+## 🛠️ Usage Examples
 
-// Error responses
-const errorResponse = notFound('User not found');
-const validationResponse = validationError('Invalid input', ['Name is required']);
+### ✔ Framework-Agnostic (no Express)
+```typescript
+import { BaseResponder } from '@naman_deep_singh/response-utils';
 
-// Paginated responses
-const paginatedUsers = paginated([{id: 1}, {id: 2}], 1, 10, 25);
+const r = new BaseResponder();
+const result = r.ok({ user: "John" }, "Loaded");
+console.log(result);
 ```
 
-### Namespace Import
+### 🌐 Express Integration
+
+#### 1️⃣ Add Middleware
+
 ```typescript
-import ResponseUtils from '@naman_deep_singh/response-utils';
+import express from 'express';
+import { responderMiddleware } from '@naman_deep_singh/response-utils';
 
-const response = ResponseUtils.success({ id: 1 }, 'Success');
+const app = express();
+app.use(responderMiddleware());
 ```
 
-### Express.js Integration
+#### 2️⃣ Controller Usage
+
 ```typescript
-import { success, notFound } from '@naman_deep_singh/response-utils';
-import { Request, Response } from 'express';
-
-app.get('/users/:id', (req: Request, res: Response) => {
-  const user = findUser(req.params.id);
-  
-  if (!user) {
-    return notFound('User not found', res); // Sets status 404 and sends response
-  }
-  
-  return success(user, 'User found', 200, res); // Sets status 200 and sends response
+app.get('/user', (req, res) => {
+  const responder = (res as any).responder();
+  return responder.okAndSend({ id: 1, name: "John Doe" }, "User found");
 });
 ```
 
-## API Reference
+`okAndSend()` automatically applies HTTP status + JSON response.
 
-### Success Responses
-- `success<T>(data: T, message?, statusCode?, res?)` - Generic success response (200)
-- `created<T>(data: T, message?, res?)` - 201 Created response
-- `noContent(message?, res?)` - 204 No Content response
-- `paginated<T>(data: T[], page, limit, total, message?, res?)` - Paginated response with metadata
+#### ⚙️ Config Options
 
-### Error Responses
-- `error(message, statusCode?, error?, res?)` - Generic error response
-- `badRequest(message?, validationError?, res?)` - 400 Bad Request
-- `unauthorized(message?, res?)` - 401 Unauthorized
-- `forbidden(message?, res?)` - 403 Forbidden
-- `notFound(message?, res?)` - 404 Not Found
-- `timeout(message?, res?)` - 408 Request Timeout
-- `conflict(message?, res?)` - 409 Conflict
-- `validationError(message?, errors[], res?)` - 422 Validation Error
-- `tooManyRequests(message?, res?)` - 429 Too Many Requests
-- `serverError(message?, res?)` - 500 Internal Server Error
+```typescript
+app.use(responderMiddleware({
+  timestamp: true,
+  extra: { service: "user-service" }
+}));
+```
 
-### Utility Functions
-- `logError(context: string, error: unknown)` - Structured error logging
-- `getErrorMessage(error: unknown)` - Extract error message safely
+Example output:
 
-## Response Format
+```json
+{
+  "success": true,
+  "data": { ... },
+  "error": null,
+  "meta": {
+    "timestamp": "2025-11-22T12:00:00Z",
+    "service": "user-service"
+  }
+}
+```
 
-All responses follow the `ApiResponse<T>` interface:
+### 🔢 Pagination Support
 
 ```typescript
-interface ApiResponse<T = any> {
-  success: boolean;
-  message: string;
-  data?: T;
-  error?: string;
-  statusCode: number;
-}
+responder.paginateAndSend(
+  [{ id: 1 }],
+  1, // page
+  10, // limit
+  42, // total
+  "Loaded"
+);
 ```
 
-## Paginated Response Format
+## 📚 Supported Methods
+
+### Success Methods
+| Method | Status |
+|--------|--------|
+| `ok()` | 200 |
+| `created()` | 201 |
+| `noContent()` | 204 |
+| `paginated()` | 200 |
+
+### Error Methods
+| Method | Status |
+|--------|--------|
+| `badRequest()` | 400 |
+| `unauthorized()` | 401 |
+| `forbidden()` | 403 |
+| `notFound()` | 404 |
+| `conflict()` | 409 |
+| `unprocessableEntity()` | 422 |
+| `tooManyRequests()` | 429 |
+| `serverError()` | 500 |
+
+**Each has an Express `*AndSend()` variant**  
+Example → `notFoundAndSend()`, `createdAndSend()`
+
+### 🧩 Status Constants
 
 ```typescript
-interface PaginatedResponse<T> extends ApiResponse<T[]> {
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-  };
-}
-```
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+
+console.log(HTTP_STATUS.CLIENT_ERROR.NOT_FOUND); // 404
+console.log(HTTP_STATUS.SUCCESS.CREATED); // 201
+```
+
+**Categories:**
+- `SUCCESS`
+- `REDIRECTION`
+- `CLIENT_ERROR`
+- `SERVER_ERROR`
+
+**All fully readonly + literal typed** ✔
+
+
+### 🧩 Status Constants
+
+```typescript
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils';
+
+console.log(HTTP_STATUS.CLIENT_ERROR.NOT_FOUND); // 404
+console.log(HTTP_STATUS.SUCCESS.CREATED); // 201
+```
+
+**Categories available:**
+
+- `SUCCESS`
+- `REDIRECTION`
+- `CLIENT_ERROR`
+- `SERVER_ERROR`
+
+All values are:
+
+✔ Object.freeze() protected  
+✔ Strongly typed using as const  
+✔ Auto-complete supported in IDEs  
+✔ Works with any HTTP framework
+
+### 🕘 Legacy API (Migration-friendly)
+
+```typescript
+import { success, error } from '@naman_deep_singh/response-utils/legacy';
+
+// Success response
+const result = success({ id: 1, name: 'John' }, 'User found', 200);
+// Returns: { success: true, message: 'User found', data: {...}, statusCode: 200 }
+
+// Error response  
+const errorResult = error('User not found', 404, 'NOT_FOUND');
+// Returns: { success: false, message: 'User not found', error: 'NOT_FOUND', statusCode: 404 }
+
+// With Express response object
+success({ users: [] }, 'Success', 200, res); // Automatically sends response
+error('Server error', 500, undefined, res); // Automatically sends error
+```
+
+**Legacy Functions:**
+- `success(data, message?, status?, res?)` - Create success response
+- `error(message, status?, error?, res?)` - Create error response
+
+⚠ **Recommended only for old codebases.** Use BaseResponder/ExpressResponder for new projects.
+
+## 🔜 Roadmap
+
+| Feature | Status |
+|---------|--------|
+| Fastify Adapter | Planned |
+| Hono Adapter | Planned |
+| Custom Error Classes | Planned |
+
+## Integration with Other Packages
+
+### With @naman_deep_singh/server-utils
+
+```typescript
+import { createServer } from '@naman_deep_singh/server-utils';
+import { responderMiddleware } from '@naman_deep_singh/response-utils';
+
+const server = createServer('My API', '1.0.0');
+server.app.use(responderMiddleware());
+
+// All server-utils middleware now uses consistent response format
+```
+
+### With @naman_deep_singh/errors-utils
+
+```typescript
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils';
+
+// Advanced error handling with consistent responses
+server.app.use(expressErrorHandler);
+```
+
+## 📄 License
+
+MIT © Naman Deep Singh

package/packages/response-utils/dist/cjs/adapters/express/ExpressResponder.d.ts

@@ -0,0 +1,18 @@
+import type { Response } from 'express';
+import { BaseResponder } from '../../core/BaseResponder';
+import type { ResponderConfig } from '../../core/config';
+export declare class ExpressResponder<P = unknown> extends BaseResponder<P> {
+    private readonly res;
+    constructor(cfg: Partial<ResponderConfig> | undefined, res: Response);
+    okAndSend(data?: P, message?: string): void;
+    createdAndSend(data?: P, message?: string): void;
+    badRequestAndSend(message?: string, error?: unknown): void;
+    unauthorizedAndSend(message?: string): void;
+    forbiddenAndSend(message?: string): void;
+    notFoundAndSend(message?: string): void;
+    conflictAndSend(message?: string): void;
+    unprocessableEntityAndSend(message?: string, error?: unknown): void;
+    tooManyRequestsAndSend(message?: string): void;
+    serverErrorAndSend(message?: string, error?: unknown): void;
+    paginateAndSend(data: P[], page: number, limit: number, total: number, message?: string): void;
+}

package/packages/response-utils/dist/cjs/adapters/express/ExpressResponder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressResponder = void 0;
+const BaseResponder_1 = require("../../core/BaseResponder");
+class ExpressResponder extends BaseResponder_1.BaseResponder {
+    constructor(cfg, res) {
+        // attach sender which calls res.status().json()
+        super(cfg, (status, body) => res.status(status).json(body));
+        this.res = res;
+    }
+    // convenience methods that return void for middleware/controller ergonomics
+    okAndSend(data, message) {
+        void this.ok(data, message);
+    }
+    createdAndSend(data, message) {
+        void this.created(data, message);
+    }
+    badRequestAndSend(message, error) {
+        void this.badRequest(message, error);
+    }
+    unauthorizedAndSend(message) {
+        void this.unauthorized(message);
+    }
+    forbiddenAndSend(message) {
+        void this.forbidden(message);
+    }
+    notFoundAndSend(message) {
+        void this.notFound(message);
+    }
+    conflictAndSend(message) {
+        void this.conflict(message);
+    }
+    unprocessableEntityAndSend(message, error) {
+        void this.unprocessableEntity(message, error);
+    }
+    tooManyRequestsAndSend(message) {
+        void this.tooManyRequests(message);
+    }
+    serverErrorAndSend(message, error) {
+        void this.serverError(message, error);
+    }
+    paginateAndSend(data, page, limit, total, message) {
+        void this.paginate(data, page, limit, total, message);
+    }
+}
+exports.ExpressResponder = ExpressResponder;

package/packages/response-utils/dist/cjs/constants/httpStatus.d.ts

@@ -0,0 +1,54 @@
+declare const SUCCESS: Readonly<{
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NO_CONTENT: 204;
+}>;
+declare const REDIRECTION: Readonly<{
+    readonly NOT_MODIFIED: 304;
+}>;
+declare const CLIENT_ERROR: Readonly<{
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly CONFLICT: 409;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly TOO_MANY_REQUESTS: 429;
+}>;
+declare const SERVER_ERROR: Readonly<{
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+}>;
+export declare const HTTP_STATUS: Readonly<{
+    readonly SUCCESS: Readonly<{
+        readonly OK: 200;
+        readonly CREATED: 201;
+        readonly ACCEPTED: 202;
+        readonly NO_CONTENT: 204;
+    }>;
+    readonly REDIRECTION: Readonly<{
+        readonly NOT_MODIFIED: 304;
+    }>;
+    readonly CLIENT_ERROR: Readonly<{
+        readonly BAD_REQUEST: 400;
+        readonly UNAUTHORIZED: 401;
+        readonly FORBIDDEN: 403;
+        readonly NOT_FOUND: 404;
+        readonly METHOD_NOT_ALLOWED: 405;
+        readonly CONFLICT: 409;
+        readonly UNPROCESSABLE_ENTITY: 422;
+        readonly TOO_MANY_REQUESTS: 429;
+    }>;
+    readonly SERVER_ERROR: Readonly<{
+        readonly INTERNAL_SERVER_ERROR: 500;
+        readonly NOT_IMPLEMENTED: 501;
+        readonly BAD_GATEWAY: 502;
+        readonly SERVICE_UNAVAILABLE: 503;
+    }>;
+}>;
+export type HttpStatusCode = (typeof SUCCESS)[keyof typeof SUCCESS] | (typeof REDIRECTION)[keyof typeof REDIRECTION] | (typeof CLIENT_ERROR)[keyof typeof CLIENT_ERROR] | (typeof SERVER_ERROR)[keyof typeof SERVER_ERROR];
+export {};

package/packages/response-utils/dist/cjs/constants/httpStatus.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_STATUS = void 0;
+const SUCCESS = Object.freeze({
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NO_CONTENT: 204,
+});
+const REDIRECTION = Object.freeze({
+    NOT_MODIFIED: 304,
+});
+const CLIENT_ERROR = Object.freeze({
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
+    CONFLICT: 409,
+    UNPROCESSABLE_ENTITY: 422,
+    TOO_MANY_REQUESTS: 429,
+});
+const SERVER_ERROR = Object.freeze({
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+});
+exports.HTTP_STATUS = Object.freeze({
+    SUCCESS,
+    REDIRECTION,
+    CLIENT_ERROR,
+    SERVER_ERROR,
+});

package/packages/response-utils/dist/cjs/core/BaseResponder.d.ts

@@ -0,0 +1,31 @@
+import { type ResponderConfig } from './config';
+import type { PaginationMeta, ResponseEnvelope, Sender } from './types';
+export declare class BaseResponder<P = unknown, M = PaginationMeta> {
+    protected readonly cfg: ResponderConfig;
+    protected sender?: Sender;
+    constructor(cfg?: Partial<ResponderConfig>, sender?: Sender);
+    attachSender(sender: Sender): void;
+    protected normalizeError(err: unknown): {
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+    protected buildEnvelope(data?: P, message?: string, error?: unknown, meta?: M): ResponseEnvelope<P, M>;
+    protected send(status: number, envelope: ResponseEnvelope<P, M>): any;
+    /** -----------------------------
+     *  Standard REST Response Helpers
+     * ----------------------------- */
+    ok(data?: P, message?: string): any;
+    created(data?: P, message?: string): any;
+    noContent(message?: string): any;
+    badRequest(message?: string, error?: unknown): any;
+    unauthorized(message?: string): any;
+    forbidden(message?: string): any;
+    notFound(message?: string): any;
+    conflict(message?: string): any;
+    unprocessableEntity(message?: string, error?: unknown): any;
+    tooManyRequests(message?: string): any;
+    serverError(message?: string, error?: unknown): any;
+    paginate(data: P[], page: number, limit: number, total: number, message?: string): any;
+    paginateOffset(data: P[], offset: number, limit: number, total: number, message?: string): any;
+}

package/packages/response-utils/dist/cjs/core/BaseResponder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResponder = void 0;
+const httpStatus_1 = require("../constants/httpStatus");
+const config_1 = require("./config");
+class BaseResponder {
+    constructor(cfg, sender) {
+        this.cfg = { ...config_1.defaultConfig, ...(cfg ?? {}) };
+        this.sender = sender;
+    }
+    attachSender(sender) {
+        this.sender = sender;
+    }
+    normalizeError(err) {
+        if (err instanceof Error)
+            return { message: err.message, code: err.code };
+        if (typeof err === 'string')
+            return { message: err };
+        return { message: 'Unknown error', details: err };
+    }
+    buildEnvelope(data, message, error, meta) {
+        const env = {
+            success: !error,
+            message: message ?? (error ? 'Error' : undefined),
+            data: error ? undefined : data,
+            error: error ? this.normalizeError(error) : null,
+            meta: meta ?? null,
+        };
+        if (this.cfg.timestamp) {
+            env.meta = {
+                ...(env.meta ?? {}),
+                timestamp: new Date().toISOString(),
+            };
+        }
+        if (this.cfg.extra) {
+            Object.assign(env, this.cfg.extra);
+        }
+        return env;
+    }
+    send(status, envelope) {
+        if (!this.sender)
+            return { status, body: envelope };
+        return this.sender(status, envelope);
+    }
+    /** -----------------------------
+     *  Standard REST Response Helpers
+     * ----------------------------- */
+    ok(data, message = 'Success') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.OK, this.buildEnvelope(data, message));
+    }
+    created(data, message = 'Created successfully') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.CREATED, this.buildEnvelope(data, message));
+    }
+    noContent(message = 'No Content') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.NO_CONTENT, this.buildEnvelope(undefined, message));
+    }
+    badRequest(message = 'Bad request', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, this.buildEnvelope(undefined, message, error));
+    }
+    unauthorized(message = 'Unauthorized') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, this.buildEnvelope(undefined, message));
+    }
+    forbidden(message = 'Forbidden') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, this.buildEnvelope(undefined, message));
+    }
+    notFound(message = 'Not found') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, this.buildEnvelope(undefined, message));
+    }
+    conflict(message = 'Conflict') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT, this.buildEnvelope(undefined, message));
+    }
+    unprocessableEntity(message = 'Unprocessable Entity', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY, this.buildEnvelope(undefined, message, error));
+    }
+    tooManyRequests(message = 'Too Many Requests') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS, this.buildEnvelope(undefined, message));
+    }
+    serverError(message = 'Internal server error', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, this.buildEnvelope(undefined, message, error));
+    }
+    paginate(data, page, limit, total, message = 'Success') {
+        const totalPages = Math.max(1, Math.ceil(total / limit));
+        const offset = (page - 1) * limit;
+        const pagination = {
+            page,
+            limit,
+            total,
+            totalPages,
+            offset,
+            hasNext: page < totalPages,
+            hasPrev: page > 1,
+        };
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.OK, this.buildEnvelope(data, message, undefined, pagination));
+    }
+    paginateOffset(data, offset, limit, total, message = 'Success') {
+        const page = Math.floor(offset / limit) + 1;
+        return this.paginate(data, page, limit, total, message);
+    }
+}
+exports.BaseResponder = BaseResponder;

package/packages/response-utils/dist/cjs/core/config.d.ts

@@ -0,0 +1,15 @@
+import type { PlainObject } from './types';
+export type EnvelopeKeys = {
+    success?: string;
+    message?: string;
+    data?: string;
+    error?: string;
+    meta?: string;
+};
+export type ResponderConfig = {
+    envelopeKeys?: EnvelopeKeys;
+    defaultStatus?: number;
+    timestamp?: boolean;
+    extra?: PlainObject | null;
+};
+export declare const defaultConfig: ResponderConfig;

package/packages/response-utils/dist/cjs/core/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = void 0;
+exports.defaultConfig = {
+    envelopeKeys: {
+        success: 'success',
+        message: 'message',
+        data: 'data',
+        error: 'error',
+        meta: 'meta',
+    },
+    defaultStatus: 200,
+    timestamp: false,
+    extra: null,
+};

package/packages/response-utils/dist/cjs/core/factory.d.ts

@@ -0,0 +1,3 @@
+import { ExpressResponder } from '../adapters/express/ExpressResponder';
+import type { ResponderConfig } from './config';
+export declare const createResponderFactory: (cfg?: Partial<ResponderConfig>) => <P = unknown, _M = Record<string, unknown>>(res: import("express").Response) => ExpressResponder<P>;

package/packages/response-utils/dist/cjs/core/factory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResponderFactory = void 0;
+const ExpressResponder_1 = require("../adapters/express/ExpressResponder");
+const createResponderFactory = (cfg) => {
+    return (res) => {
+        return new ExpressResponder_1.ExpressResponder(cfg, res);
+    };
+};
+exports.createResponderFactory = createResponderFactory;