@naman_deep_singh/http-response 3.0.0

package/README.md

@@ -0,0 +1,189 @@
+# @naman_deep_singh/http-response
+
+**Version:** 3.0.0
+
+A flexible, framework-agnostic **TypeScript response utility library** for building consistent, typed, and configurable API responses.
+
+Designed with a clean **core + adapter** architecture.  
+First-class support for **Express.js**, pagination, and standardized HTTP status handling.
+
+---
+
+## 🚀 Features
+
+| Feature                                      | Status |
+|---------------------------------------------|:------:|
+| Fully typesafe response envelopes            |   ✅   |
+| Framework-agnostic core                      |   ✅   |
+| Express.js responder adapter                 |   ✅   |
+| Express middleware injection                 |   ✅   |
+| Pagination helpers                           |   ✅   |
+| Centralized responder configuration          |   ✅   |
+| HTTP status constants                        |   ✅   |
+
+---
+
+## 📦 Installation
+
+```sh
+npm install @naman_deep_singh/http-response
+
+📄 Response Envelope (Default Shape)
+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
+}
+🛠️ Usage
+✔ Framework-Agnostic (No Express)
+import { BaseResponder } from '@naman_deep_singh/http-response'
+
+const responder = new BaseResponder()
+
+const result = responder.ok({ user: 'John' }, 'Loaded')
+
+// When no sender is attached, returns:
+// { status: 200, body: ResponseEnvelope }
+console.log(result)
+🌐 Express Integration
+1️⃣ Register Middleware
+import express from 'express'
+import { responderMiddleware } from '@naman_deep_singh/http-response'
+
+const app = express()
+
+app.use(responderMiddleware())
+This injects a res.responder() factory into every request.
+
+2️⃣ Controller Usage
+app.get('/user', (req, res) => {
+  const responder = res.responder<{ id: number; name: string }>()
+
+  responder.okAndSend(
+    { id: 1, name: 'John Doe' },
+    'User found'
+  )
+})
+✅ okAndSend() automatically:
+
+sets HTTP status
+
+sends JSON response
+
+returns void for clean controller ergonomics
+
+⚙️ Middleware Configuration
+app.use(
+  responderMiddleware({
+    timestamp: true,
+    extra: { service: 'user-service' },
+  })
+)
+Example response:
+
+{
+  "success": true,
+  "data": { ... },
+  "error": null,
+  "meta": {
+    "timestamp": "2025-11-22T12:00:00Z"
+  },
+  "service": "user-service"
+}
+🔢 Pagination Support
+responder.paginateAndSend(
+  [{ id: 1 }],
+  1,    // page
+  10,   // limit
+  42,   // total
+  'Loaded'
+)
+Pagination metadata is automatically calculated.
+
+📚 Available Methods
+✅ Success Responses
+Method	HTTP
+ok()	200
+created()	201
+noContent()	204
+paginate()	200
+Each method has an Express variant:
+
+okAndSend()
+
+createdAndSend()
+
+paginateAndSend()
+
+❌ Error Responses
+Method	HTTP
+badRequest()	400
+unauthorized()	401
+forbidden()	403
+notFound()	404
+conflict()	409
+unprocessableEntity()	422
+tooManyRequests()	429
+serverError()	500
+Each also has a *AndSend() variant.
+
+🧩 HTTP Status Constants
+import { HTTP_STATUS } from '@naman_deep_singh/http-response'
+
+HTTP_STATUS.SUCCESS.OK              // 200
+HTTP_STATUS.CLIENT_ERROR.NOT_FOUND  // 404
+HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR // 500
+Categories
+SUCCESS
+
+REDIRECTION
+
+CLIENT_ERROR
+
+SERVER_ERROR
+
+✔ Object.freeze() protected
+✔ Fully literal-typed (as const)
+✔ IDE autocomplete friendly
+
+🧩 TypeScript: Express Response Augmentation (Recommended)
+For full type safety, add this once in your project:
+
+import type { ExpressResponder } from '@naman_deep_singh/http-response'
+
+declare global {
+  namespace Express {
+    interface Response {
+      responder: <P = unknown>() => ExpressResponder<P>
+    }
+  }
+}
+
+⚠️ Do not use for new projects.
+
+🔗 Integration with Other Packages
+With @naman_deep_singh/server-utils
+import { responderMiddleware } from '@naman_deep_singh/http-response'
+
+server.app.use(responderMiddleware())
+With @naman_deep_singh/errors-utils
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
+
+server.app.use(expressErrorHandler)
+Provides consistent error responses across services.
+
+🔜 Roadmap
+Fastify adapter
+
+Hono adapter
+
+Configurable envelope key mapping
+
+📄 License
+MIT © Naman Deep Singh

package/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/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/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/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/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/dist/cjs/core/BaseResponder.js

@@ -0,0 +1,116 @@
+"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) {
+        // errors-utils AppError compatibility
+        if (typeof err === 'object' && err !== null) {
+            const e = err;
+            if (typeof e.message === 'string') {
+                return {
+                    message: e.message,
+                    code: typeof e.code === 'string' ? e.code : undefined,
+                    details: e.details,
+                };
+            }
+        }
+        if (err instanceof Error) {
+            return { message: err.message };
+        }
+        if (typeof err === 'string') {
+            return { message: err };
+        }
+        return {
+            message: 'Internal server 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/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/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/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/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;

package/dist/cjs/core/types.d.ts

@@ -0,0 +1,32 @@
+export type PlainObject = Record<string, unknown>;
+export type ErrorShape = {
+    code?: string;
+    message: string;
+    details?: unknown;
+};
+export type ResponseEnvelope<T = unknown, M = PlainObject> = {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: ErrorShape | null;
+    meta?: M | null;
+};
+export type TransportResult = {
+    status: number;
+    body: unknown;
+};
+export type Sender = (status: number, body: unknown) => Promise<any> | any;
+export interface PaginationMeta {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNext?: boolean;
+    hasPrev?: boolean;
+    offset?: number;
+    links?: {
+        next?: string;
+        prev?: string;
+        self: string;
+    };
+}

package/dist/cjs/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+export { BaseResponder } from './core/BaseResponder';
+export { createResponderFactory } from './core/factory';
+export * from './core/types';
+export * from './core/config';
+export { ExpressResponder } from './adapters/express/ExpressResponder';
+export { responderMiddleware } from './middleware/express/expressMiddleware';
+export { HTTP_STATUS } from './constants/httpStatus';
+export type { HttpStatusCode } from './constants/httpStatus';

package/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_STATUS = exports.responderMiddleware = exports.ExpressResponder = exports.createResponderFactory = exports.BaseResponder = void 0;
+// Core Responders
+var BaseResponder_1 = require("./core/BaseResponder");
+Object.defineProperty(exports, "BaseResponder", { enumerable: true, get: function () { return BaseResponder_1.BaseResponder; } });
+var factory_1 = require("./core/factory");
+Object.defineProperty(exports, "createResponderFactory", { enumerable: true, get: function () { return factory_1.createResponderFactory; } });
+__exportStar(require("./core/types"), exports);
+__exportStar(require("./core/config"), exports);
+// Adapters (Express)
+var ExpressResponder_1 = require("./adapters/express/ExpressResponder");
+Object.defineProperty(exports, "ExpressResponder", { enumerable: true, get: function () { return ExpressResponder_1.ExpressResponder; } });
+var expressMiddleware_1 = require("./middleware/express/expressMiddleware");
+Object.defineProperty(exports, "responderMiddleware", { enumerable: true, get: function () { return expressMiddleware_1.responderMiddleware; } });
+// HTTP Status Constants
+var httpStatus_1 = require("./constants/httpStatus");
+Object.defineProperty(exports, "HTTP_STATUS", { enumerable: true, get: function () { return httpStatus_1.HTTP_STATUS; } });

package/dist/cjs/legacy.d.ts

@@ -0,0 +1,19 @@
+export declare const success: <T>(data: T, message?: string, status?: number, res?: {
+    status: (code: number) => any;
+    json: (body: unknown) => any;
+}) => any;
+export declare const error: (message: string, status?: number, err?: string, res?: {
+    status: (code: number) => any;
+    json: (body: unknown) => any;
+}) => any;
+declare const _default: {
+    success: <T>(data: T, message?: string, status?: number, res?: {
+        status: (code: number) => any;
+        json: (body: unknown) => any;
+    }) => any;
+    error: (message: string, status?: number, err?: string, res?: {
+        status: (code: number) => any;
+        json: (body: unknown) => any;
+    }) => any;
+};
+export default _default;

package/dist/cjs/legacy.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.success = void 0;
+const success = (data, message = 'Success', status = 200, res) => {
+    if (res)
+        return res
+            .status(status)
+            .json({ success: true, message, data, statusCode: status });
+    return { success: true, message, data, statusCode: status };
+};
+exports.success = success;
+const error = (message, status = 500, err, res) => {
+    if (res)
+        return res
+            .status(status)
+            .json({ success: false, message, error: err, statusCode: status });
+    return { success: false, message, error: err, statusCode: status };
+};
+exports.error = error;
+exports.default = {
+    success: exports.success,
+    error: exports.error,
+};

package/dist/cjs/middleware/express/expressMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { RequestHandler } from 'express';
+import type { ResponderConfig } from '../../core/config';
+export declare const responderMiddleware: (cfg?: Partial<ResponderConfig>) => RequestHandler;