ts-packages 1.0.0 → 3.0.0

package/packages/response-utils/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/packages/response-utils/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/packages/response-utils/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/packages/response-utils/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/packages/response-utils/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;

package/packages/response-utils/dist/cjs/middleware/express/expressMiddleware.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responderMiddleware = void 0;
+const factory_1 = require("../../core/factory");
+const responderMiddleware = (cfg) => {
+    const factory = (0, factory_1.createResponderFactory)(cfg);
+    return (_req, res, next) => {
+        ;
+        res.responder = () => factory(res);
+        next();
+    };
+};
+exports.responderMiddleware = responderMiddleware;

package/packages/response-utils/dist/esm/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/esm/adapters/express/ExpressResponder.js

@@ -0,0 +1,42 @@
+import { BaseResponder } from '../../core/BaseResponder';
+export class ExpressResponder extends 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);
+    }
+}

package/packages/response-utils/dist/esm/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/esm/constants/httpStatus.js

@@ -0,0 +1,31 @@
+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,
+});
+export const HTTP_STATUS = Object.freeze({
+    SUCCESS,
+    REDIRECTION,
+    CLIENT_ERROR,
+    SERVER_ERROR,
+});

package/packages/response-utils/dist/esm/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/esm/core/BaseResponder.js

@@ -0,0 +1,112 @@
+import { HTTP_STATUS } from '../constants/httpStatus';
+import { defaultConfig } from './config';
+export class BaseResponder {
+    constructor(cfg, sender) {
+        this.cfg = { ...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(HTTP_STATUS.SUCCESS.OK, this.buildEnvelope(data, message));
+    }
+    created(data, message = 'Created successfully') {
+        return this.send(HTTP_STATUS.SUCCESS.CREATED, this.buildEnvelope(data, message));
+    }
+    noContent(message = 'No Content') {
+        return this.send(HTTP_STATUS.SUCCESS.NO_CONTENT, this.buildEnvelope(undefined, message));
+    }
+    badRequest(message = 'Bad request', error) {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, this.buildEnvelope(undefined, message, error));
+    }
+    unauthorized(message = 'Unauthorized') {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, this.buildEnvelope(undefined, message));
+    }
+    forbidden(message = 'Forbidden') {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, this.buildEnvelope(undefined, message));
+    }
+    notFound(message = 'Not found') {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, this.buildEnvelope(undefined, message));
+    }
+    conflict(message = 'Conflict') {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.CONFLICT, this.buildEnvelope(undefined, message));
+    }
+    unprocessableEntity(message = 'Unprocessable Entity', error) {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY, this.buildEnvelope(undefined, message, error));
+    }
+    tooManyRequests(message = 'Too Many Requests') {
+        return this.send(HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS, this.buildEnvelope(undefined, message));
+    }
+    serverError(message = 'Internal server error', error) {
+        return this.send(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(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);
+    }
+}

package/packages/response-utils/dist/esm/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/esm/core/config.js

@@ -0,0 +1,12 @@
+export const defaultConfig = {
+    envelopeKeys: {
+        success: 'success',
+        message: 'message',
+        data: 'data',
+        error: 'error',
+        meta: 'meta',
+    },
+    defaultStatus: 200,
+    timestamp: false,
+    extra: null,
+};

package/packages/response-utils/dist/esm/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/esm/core/factory.js

@@ -0,0 +1,6 @@
+import { ExpressResponder } from '../adapters/express/ExpressResponder';
+export const createResponderFactory = (cfg) => {
+    return (res) => {
+        return new ExpressResponder(cfg, res);
+    };
+};

package/packages/response-utils/dist/esm/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/packages/response-utils/dist/esm/core/types.js

@@ -0,0 +1 @@
+export {};

package/packages/response-utils/dist/esm/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/packages/response-utils/dist/esm/index.js

@@ -0,0 +1,10 @@
+// Core Responders
+export { BaseResponder } from './core/BaseResponder';
+export { createResponderFactory } from './core/factory';
+export * from './core/types';
+export * from './core/config';
+// Adapters (Express)
+export { ExpressResponder } from './adapters/express/ExpressResponder';
+export { responderMiddleware } from './middleware/express/expressMiddleware';
+// HTTP Status Constants
+export { HTTP_STATUS } from './constants/httpStatus';

package/packages/response-utils/dist/esm/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/packages/response-utils/dist/esm/legacy.js

@@ -0,0 +1,18 @@
+export 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 };
+};
+export 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 };
+};
+export default {
+    success,
+    error,
+};

package/packages/response-utils/dist/esm/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;

package/packages/response-utils/dist/esm/middleware/express/expressMiddleware.js

@@ -0,0 +1,9 @@
+import { createResponderFactory } from '../../core/factory';
+export const responderMiddleware = (cfg) => {
+    const factory = createResponderFactory(cfg);
+    return (_req, res, next) => {
+        ;
+        res.responder = () => factory(res);
+        next();
+    };
+};

package/packages/response-utils/dist/types/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/types/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/types/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;
+}