express-resforge 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import { responseMiddleware } from './middleware/responseMiddleware';
+import { errorHandler } from './middleware/errorHandler';
+import { requestIdMiddleware } from './middleware/requestId';
+import { requestTimerMiddleware } from './middleware/requestTimer';
+import { asyncWrapper } from './helpers/errors';
+import { formatZodError } from './formatter/zodFormatter';
+import { formatJoiError } from './formatter/joiFormatter';
+import { formatMongooseError } from './formatter/mongooseFormatter';
+import { formatPrismaError } from './formatter/prismaFormatter';
+import { formatAxiosError } from './formatter/axiosFormatter';
+import { formatFirebaseError } from './formatter/firebaseFormatter';
+import { StandardApiResponse, ApiResponsePagination, ApiResponseMeta, ValidationErrorItem, ResponseOptions, PaginationOptions } from './types/responses';
+import { ApiKitConfig } from './types/config';
+import { ResponseBuilder } from './core/responseBuilder';
+/**
+ * Enterprise core orchestration object for express-api-kit.
+ */
+export declare const apiKit: {
+    /**
+     * The current semantic version of the toolkit.
+     */
+    version: string;
+    /**
+     * Main Express middleware that initializes request contexts and injects standard semantic response methods.
+     * @example app.use(apiKit.middleware({ apiVersion: 'v1' }));
+     */
+    middleware: typeof responseMiddleware;
+    /**
+     * Global Express error handling middleware that captures and formats uncaught exceptions.
+     * @example app.use(apiKit.errorHandler());
+     */
+    errorHandler: typeof errorHandler;
+    /**
+     * Standalone middleware to assign or forward unique transaction tracking correlation tokens.
+     */
+    requestId: typeof requestIdMiddleware;
+    /**
+     * Standalone middleware providing low-overhead performance profiling response headers.
+     */
+    requestTimer: typeof requestTimerMiddleware;
+    /**
+     * Higher-order async wrapper that handles errors in route pipelines without requiring try/catch blocks.
+     * @example app.get('/users', apiKit.async(async (req, res) => { ... }));
+     */
+    async: typeof asyncWrapper;
+    /**
+     * Registers custom global response payload modification plugins or analytics interceptors.
+     * @example
+     * apiKit.use((payload, req, res) => {
+     *   payload.meta.server = "Dream Mythic";
+     *   return payload;
+     * });
+     */
+    use: (plugin: import("./core/pluginManager").ApiKitPlugin) => void;
+    /**
+     * Centralized parsing utilities to normalize diverse ecosystem exceptions into consistent envelopes.
+     */
+    formatters: {
+        zod: typeof formatZodError;
+        joi: typeof formatJoiError;
+        mongoose: typeof formatMongooseError;
+        prisma: typeof formatPrismaError;
+        axios: typeof formatAxiosError;
+        firebase: typeof formatFirebaseError;
+    };
+};
+declare global {
+    namespace Express {
+        interface Response {
+            success<T = any>(data?: T, options?: ResponseOptions): ResponseBuilder<T>;
+            created<T = any>(data?: T, options?: ResponseOptions): ResponseBuilder<T>;
+            accepted<T = any>(data?: T, options?: ResponseOptions): ResponseBuilder<T>;
+            deleted(options?: ResponseOptions): ResponseBuilder<null>;
+            noContent(): void;
+            badRequest(options?: ResponseOptions): ResponseBuilder<null>;
+            unauthorized(options?: ResponseOptions): ResponseBuilder<null>;
+            forbidden(options?: ResponseOptions): ResponseBuilder<null>;
+            notFound(options?: ResponseOptions): ResponseBuilder<null>;
+            conflict(options?: ResponseOptions): ResponseBuilder<null>;
+            unprocessable(options?: ResponseOptions): ResponseBuilder<null>;
+            tooManyRequests(options?: ResponseOptions): ResponseBuilder<null>;
+            serverError(options?: ResponseOptions): ResponseBuilder<null>;
+            notImplemented(options?: ResponseOptions): ResponseBuilder<null>;
+            serviceUnavailable(options?: ResponseOptions): ResponseBuilder<null>;
+            paginate<T = any>(data: T[], options: PaginationOptions): ResponseBuilder<T[]>;
+        }
+    }
+}
+export { StandardApiResponse, ApiResponsePagination, ApiResponseMeta, ValidationErrorItem, ResponseOptions, PaginationOptions, ApiKitConfig, ResponseBuilder };
+export default apiKit;

package/dist/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseBuilder = exports.apiKit = void 0;
+// Core Architectural Components
+const responseMiddleware_1 = require("./middleware/responseMiddleware");
+const errorHandler_1 = require("./middleware/errorHandler");
+const requestId_1 = require("./middleware/requestId");
+const requestTimer_1 = require("./middleware/requestTimer");
+const errors_1 = require("./helpers/errors");
+const pluginManager_1 = require("./core/pluginManager");
+const version_1 = require("./version");
+// Ecosystem Error Formatters
+const zodFormatter_1 = require("./formatter/zodFormatter");
+const joiFormatter_1 = require("./formatter/joiFormatter");
+const mongooseFormatter_1 = require("./formatter/mongooseFormatter");
+const prismaFormatter_1 = require("./formatter/prismaFormatter");
+const axiosFormatter_1 = require("./formatter/axiosFormatter");
+const firebaseFormatter_1 = require("./formatter/firebaseFormatter");
+const responseBuilder_1 = require("./core/responseBuilder");
+Object.defineProperty(exports, "ResponseBuilder", { enumerable: true, get: function () { return responseBuilder_1.ResponseBuilder; } });
+/**
+ * Enterprise core orchestration object for express-api-kit.
+ */
+exports.apiKit = {
+    /**
+     * The current semantic version of the toolkit.
+     */
+    version: version_1.VERSION,
+    /**
+     * Main Express middleware that initializes request contexts and injects standard semantic response methods.
+     * @example app.use(apiKit.middleware({ apiVersion: 'v1' }));
+     */
+    middleware: responseMiddleware_1.responseMiddleware,
+    /**
+     * Global Express error handling middleware that captures and formats uncaught exceptions.
+     * @example app.use(apiKit.errorHandler());
+     */
+    errorHandler: errorHandler_1.errorHandler,
+    /**
+     * Standalone middleware to assign or forward unique transaction tracking correlation tokens.
+     */
+    requestId: requestId_1.requestIdMiddleware,
+    /**
+     * Standalone middleware providing low-overhead performance profiling response headers.
+     */
+    requestTimer: requestTimer_1.requestTimerMiddleware,
+    /**
+     * Higher-order async wrapper that handles errors in route pipelines without requiring try/catch blocks.
+     * @example app.get('/users', apiKit.async(async (req, res) => { ... }));
+     */
+    async: errors_1.asyncWrapper,
+    /**
+     * Registers custom global response payload modification plugins or analytics interceptors.
+     * @example
+     * apiKit.use((payload, req, res) => {
+     *   payload.meta.server = "Dream Mythic";
+     *   return payload;
+     * });
+     */
+    use: pluginManager_1.globalPluginManager.use.bind(pluginManager_1.globalPluginManager),
+    /**
+     * Centralized parsing utilities to normalize diverse ecosystem exceptions into consistent envelopes.
+     */
+    formatters: {
+        zod: zodFormatter_1.formatZodError,
+        joi: joiFormatter_1.formatJoiError,
+        mongoose: mongooseFormatter_1.formatMongooseError,
+        prisma: prismaFormatter_1.formatPrismaError,
+        axios: axiosFormatter_1.formatAxiosError,
+        firebase: firebaseFormatter_1.formatFirebaseError,
+    }
+};
+// Default export compatibility support mapping for CommonJS / ESM workflows
+exports.default = exports.apiKit;

package/dist/middleware/errorHandler.d.ts

@@ -0,0 +1,9 @@
+import { ErrorRequestHandler } from 'express';
+import { ApiKitConfig } from '../types/config';
+/**
+ * Enterprise-grade global Express error handling middleware factory.
+ * Intercepts thrown application exceptions and normalizes them into standard envelopes.
+ *
+ * @param config Optional configuration overrides block.
+ */
+export declare function errorHandler(config?: ApiKitConfig): ErrorRequestHandler;

package/dist/middleware/errorHandler.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = errorHandler;
+const config_1 = require("../types/config");
+const httpStatus_1 = require("../constants/httpStatus");
+const responseCodes_1 = require("../constants/responseCodes");
+/**
+ * Enterprise-grade global Express error handling middleware factory.
+ * Intercepts thrown application exceptions and normalizes them into standard envelopes.
+ *
+ * @param config Optional configuration overrides block.
+ */
+function errorHandler(config) {
+    return (err, req, res, next) => {
+        // Dynamically look up active framework configurations attached to the response context
+        const activeConfig = res.__apiKitConfig || {
+            ...config_1.DefaultApiKitConfig,
+            ...config,
+            errors: { ...config_1.DefaultApiKitConfig.errors, ...config?.errors },
+        };
+        let statusCode = err.status || err.statusCode || httpStatus_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        let responseCode = err.code || responseCodes_1.ResponseCodes.SERVER_ERROR;
+        let message = err.message || 'An unexpected error occurred.';
+        let errors = err.errors || undefined;
+        // Detect if this is a standard operational or semantic exception
+        const isClientError = statusCode >= 400 && statusCode < 500;
+        // Sanitize unhandled 5xx internal crashes in production environments to safeguard system security
+        if (!isClientError && activeConfig.errors.sanitizeServerErrors) {
+            message = activeConfig.customMessages?.[httpStatus_1.HttpStatus.INTERNAL_SERVER_ERROR] || 'An unexpected internal server error occurred.';
+            responseCode = responseCodes_1.ResponseCodes.SERVER_ERROR;
+        }
+        // Capture standard validation error footprints exposed across third-party engines
+        if (err.name === 'ValidationError' || err.isJoi || err.name === 'ZodError') {
+            statusCode = httpStatus_1.HttpStatus.UNPROCESSABLE_ENTITY;
+            responseCode = responseCodes_1.ResponseCodes.UNPROCESSABLE;
+        }
+        // Build the finalized JSON payload while checking stack trace configurations
+        const errorPayload = {
+            message,
+        };
+        if (errors) {
+            errorPayload.errors = errors;
+        }
+        if (activeConfig.errors.exposeStack && err.stack) {
+            errorPayload.meta = {
+                ...errorPayload.meta,
+                stack: err.stack,
+            };
+        }
+        // Dispatch the payload through the appropriate contextual res channel safely
+        if (typeof res.unprocessable === 'function' && statusCode === httpStatus_1.HttpStatus.UNPROCESSABLE_ENTITY) {
+            res.unprocessable(errorPayload).send();
+            return;
+        }
+        if (typeof res.badRequest === 'function' && statusCode === httpStatus_1.HttpStatus.BAD_REQUEST) {
+            res.badRequest(errorPayload).send();
+            return;
+        }
+        if (typeof res.unauthorized === 'function' && statusCode === httpStatus_1.HttpStatus.UNAUTHORIZED) {
+            res.unauthorized(errorPayload).send();
+            return;
+        }
+        if (typeof res.forbidden === 'function' && statusCode === httpStatus_1.HttpStatus.FORBIDDEN) {
+            res.forbidden(errorPayload).send();
+            return;
+        }
+        if (typeof res.notFound === 'function' && statusCode === httpStatus_1.HttpStatus.NOT_FOUND) {
+            res.notFound(errorPayload).send();
+            return;
+        }
+        // Default fallback structural dispatch for standard unhandled server executions
+        if (typeof res.serverError === 'function') {
+            res.serverError(errorPayload).send();
+            return;
+        }
+        // Extreme fallback if invoked prior to response middleware decoration
+        res.status(statusCode).json({
+            success: false,
+            statusCode,
+            responseCode,
+            message,
+            data: null,
+            meta: {
+                timestamp: new Date().toISOString(),
+            },
+            ...(errors ? { errors } : {}),
+            ...(activeConfig.errors.exposeStack && err.stack ? { stack: err.stack } : {}),
+        });
+    };
+}

package/dist/middleware/requestId.d.ts

@@ -0,0 +1,16 @@
+import { RequestHandler } from 'express';
+declare global {
+    namespace Express {
+        interface Request {
+            /**
+             * Unique enterprise transaction correlation identifier.
+             */
+            id?: string;
+        }
+    }
+}
+/**
+ * Middleware that assigns or forwards a unique transaction identifier to every incoming request.
+ * Automatically injects the tracking token into the outbound 'X-Request-ID' header.
+ */
+export declare function requestIdMiddleware(): RequestHandler;

package/dist/middleware/requestId.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestIdMiddleware = requestIdMiddleware;
+const uuid_1 = require("../utils/uuid");
+/**
+ * Middleware that assigns or forwards a unique transaction identifier to every incoming request.
+ * Automatically injects the tracking token into the outbound 'X-Request-ID' header.
+ */
+function requestIdMiddleware() {
+    return (req, res, next) => {
+        const headerName = 'X-Request-ID';
+        const activeId = req.headers['x-request-id'] || req.headers['x-correlation-id'] || (0, uuid_1.generateUuid)();
+        // Safely assign the tracking token using our extended interface type definition
+        req.id = Array.isArray(activeId) ? activeId[0] : activeId;
+        res.setHeader(headerName, req.id);
+        next();
+    };
+}

package/dist/middleware/requestTimer.d.ts

@@ -0,0 +1,6 @@
+import { RequestHandler } from 'express';
+/**
+ * High-precision performance profiling middleware.
+ * Intercepts the response stream write step to safely inject execution time markers.
+ */
+export declare function requestTimerMiddleware(): RequestHandler;

package/dist/middleware/requestTimer.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestTimerMiddleware = requestTimerMiddleware;
+/**
+ * High-precision performance profiling middleware.
+ * Intercepts the response stream write step to safely inject execution time markers.
+ */
+function requestTimerMiddleware() {
+    return (req, res, next) => {
+        const start = process.hrtime();
+        // Capture the original baseline terminal method reference
+        const originalEnd = res.end;
+        // Intercept the final payload flushing step
+        res.end = function (chunk, encoding, cb) {
+            // Calculate delta milliseconds precisely before headers freeze
+            const diff = process.hrtime(start);
+            const ms = (diff[0] * 1000) + (diff[1] / 1000000);
+            if (!res.headersSent) {
+                res.setHeader('X-Response-Time', `${ms.toFixed(2)}ms`);
+            }
+            // Restore application execution context back to the original engine channel
+            return originalEnd.call(this, chunk, encoding, cb);
+        };
+        next();
+    };
+}

package/dist/middleware/responseMiddleware.d.ts

@@ -0,0 +1,7 @@
+import { RequestHandler } from 'express';
+import { ApiKitConfig } from '../types/config';
+/**
+ * Express Middleware factory providing standardized API orchestration across endpoints.
+ * @param config Optional user customization options object.
+ */
+export declare function responseMiddleware(config?: ApiKitConfig): RequestHandler;

package/dist/middleware/responseMiddleware.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseMiddleware = responseMiddleware;
+const config_1 = require("../types/config");
+const httpStatus_1 = require("../constants/httpStatus");
+const responseCodes_1 = require("../constants/responseCodes");
+const responseFactory_1 = require("../core/responseFactory");
+const uuid_1 = require("../utils/uuid");
+const context_1 = require("../core/context");
+/**
+ * Express Middleware factory providing standardized API orchestration across endpoints.
+ * @param config Optional user customization options object.
+ */
+function responseMiddleware(config) {
+    const activeConfig = {
+        ...config_1.DefaultApiKitConfig,
+        ...config,
+        errors: { ...config_1.DefaultApiKitConfig.errors, ...config?.errors },
+    };
+    return (req, res, next) => {
+        // Attach current configurations to response object internally for access down the line
+        res.__apiKitConfig = activeConfig;
+        // Resolve or generate incoming transaction tracking identifier tokens
+        let requestId = '';
+        if (activeConfig.enableRequestId) {
+            const incomingId = req.headers['x-request-id'] || req.headers['x-correlation-id'];
+            requestId = Array.isArray(incomingId) ? incomingId[0] : incomingId || (0, uuid_1.generateUuid)();
+            res.setHeader('X-Request-ID', requestId);
+        }
+        // 1. Inject semantic shortcut helpers directly into the response instance
+        res.success = function (data, options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.OK, true, responseCodes_1.ResponseCodes.SUCCESS, data, options);
+        };
+        res.created = function (data, options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.CREATED, true, responseCodes_1.ResponseCodes.CREATED, data, options);
+        };
+        res.accepted = function (data, options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.ACCEPTED, true, responseCodes_1.ResponseCodes.ACCEPTED, data, options);
+        };
+        res.deleted = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.OK, false, responseCodes_1.ResponseCodes.DELETED, null, options);
+        };
+        res.noContent = function () {
+            return res.status(httpStatus_1.HttpStatus.NO_CONTENT).send();
+        };
+        res.badRequest = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.BAD_REQUEST, false, responseCodes_1.ResponseCodes.BAD_REQUEST, null, options);
+        };
+        res.unauthorized = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.UNAUTHORIZED, false, responseCodes_1.ResponseCodes.UNAUTHORIZED, null, options);
+        };
+        res.forbidden = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.FORBIDDEN, false, responseCodes_1.ResponseCodes.FORBIDDEN, null, options);
+        };
+        res.notFound = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.NOT_FOUND, false, responseCodes_1.ResponseCodes.NOT_FOUND, null, options);
+        };
+        res.conflict = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.CONFLICT, false, responseCodes_1.ResponseCodes.CONFLICT, null, options);
+        };
+        res.unprocessable = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.UNPROCESSABLE_ENTITY, false, responseCodes_1.ResponseCodes.UNPROCESSABLE, null, options);
+        };
+        res.tooManyRequests = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.TOO_MANY_REQUESTS, false, responseCodes_1.ResponseCodes.TOO_MANY_REQUESTS, null, options);
+        };
+        res.serverError = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.INTERNAL_SERVER_ERROR, false, responseCodes_1.ResponseCodes.SERVER_ERROR, null, options);
+        };
+        res.notImplemented = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.NOT_IMPLEMENTED, false, responseCodes_1.ResponseCodes.NOT_IMPLEMENTED, null, options);
+        };
+        res.serviceUnavailable = function (options) {
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.SERVICE_UNAVAILABLE, false, responseCodes_1.ResponseCodes.SERVICE_UNAVAILABLE, null, options);
+        };
+        // 2. Automate pagination schema formatting logic
+        res.paginate = function (data, options) {
+            const { page, limit, total, message, responseCode, meta } = options;
+            return responseFactory_1.ResponseFactory.create(res, httpStatus_1.HttpStatus.OK, true, responseCodes_1.ResponseCodes.SUCCESS, data, {
+                message,
+                responseCode,
+                meta,
+                pagination: { page, limit, total },
+            });
+        };
+        // 3. Wrap request inside isolation store container to track performance metrics flawlessly
+        context_1.requestContext.run({
+            requestId,
+            startTime: process.hrtime(),
+            timestamp: new Date().toISOString(),
+        }, () => next());
+    };
+}

package/dist/plugins/pluginAPI.d.ts

@@ -0,0 +1,7 @@
+import { ApiKitPlugin } from '../core/pluginManager';
+export declare const pluginAPI: {
+    /**
+     * Registers a global payload modification plugin hook.
+     */
+    register(plugin: ApiKitPlugin): void;
+};

package/dist/plugins/pluginAPI.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginAPI = void 0;
+const pluginManager_1 = require("../core/pluginManager");
+exports.pluginAPI = {
+    /**
+     * Registers a global payload modification plugin hook.
+     */
+    register(plugin) {
+        pluginManager_1.globalPluginManager.use(plugin);
+    }
+};

package/dist/types/config.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Toolkit configuration signatures and defaults validation typing.
+ */
+export interface ApiKitConfig {
+    /**
+     * The global active version of your API (e.g., 'v1', '1.0.0').
+     * If provided, automatically injected into every output meta object.
+     */
+    apiVersion?: string;
+    /**
+     * Toggle to enable or disable automatic X-Request-ID middleware parsing/generation.
+     * @default true
+     */
+    enableRequestId?: boolean;
+    /**
+     * Toggle to enable or disable high-precision performance monitoring (execution time).
+     * @default true
+     */
+    enablePerformanceTiming?: boolean;
+    /**
+     * Custom plugin/interceptors applied globally to all responses.
+     */
+    plugins?: Array<(payload: any, req: any, res: any) => any>;
+    /**
+     * Enterprise deep-override fallback message dictionary for mapping raw status numbers to custom text.
+     */
+    customMessages?: Record<number, string>;
+    /**
+     * Standard error options covering environmental handling constraints.
+     */
+    errors?: {
+        /**
+         * Expose full debug stacks directly in the json errors array.
+         * Generally set to false or conditionally tied to `process.env.NODE_ENV === 'development'`.
+         * @default false
+         */
+        exposeStack?: boolean;
+        /**
+         * Obfuscate default unhandled runtime exceptions with a sanitized fallback message.
+         * @default true
+         */
+        sanitizeServerErrors?: boolean;
+    };
+}
+/**
+ * Frozen defaults structure used internally when configuration properties are omitted.
+ */
+export declare const DefaultApiKitConfig: Required<Omit<ApiKitConfig, 'apiVersion' | 'plugins' | 'customMessages'>> & {
+    apiVersion: string | undefined;
+    plugins: NonNullable<ApiKitConfig['plugins']>;
+    customMessages: Record<number, string>;
+};

package/dist/types/config.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @fileoverview Toolkit configuration signatures and defaults validation typing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultApiKitConfig = void 0;
+/**
+ * Frozen defaults structure used internally when configuration properties are omitted.
+ */
+exports.DefaultApiKitConfig = {
+    apiVersion: undefined,
+    enableRequestId: true,
+    enablePerformanceTiming: true,
+    plugins: [],
+    customMessages: {},
+    errors: {
+        exposeStack: false,
+        sanitizeServerErrors: true,
+    },
+};
+Object.freeze(exports.DefaultApiKitConfig);
+Object.freeze(exports.DefaultApiKitConfig.errors);

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './responses';
+export * from './config';
+export * from './plugin';

package/dist/types/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./responses"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./plugin"), exports);

package/dist/types/plugin.d.ts

@@ -0,0 +1,11 @@
+import { StandardApiResponse } from './responses';
+import { Request, Response } from 'express';
+/**
+ * Signature function blueprint for all custom response interceptor plugins.
+ */
+export type ApiKitPlugin = (payload: StandardApiResponse<any>, req: Request, res: Response) => StandardApiResponse<any> | Promise<StandardApiResponse<any>>;
+export interface PluginMetadata {
+    name: string;
+    version: string;
+    description?: string;
+}

package/dist/types/plugin.js

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

package/dist/types/responses.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @fileoveriew Core response type definitions for express-api-kit.
+ * Establishes strict contract types for standardized API structural states.
+ */
+/**
+ * Standard pagination metadata structure generated automatically by the toolkit.
+ */
+export interface ApiResponsePagination {
+    page: number;
+    limit: number;
+    totalElements: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+}
+/**
+ * Structural metadata automatically appended to API payloads by internal middleware.
+ */
+export interface ApiResponseMeta {
+    requestId: string;
+    timestamp: string;
+    executionTimeMs: number;
+    apiVersion?: string;
+    [key: string]: unknown;
+}
+/**
+ * Structural shape of standard validation error items.
+ */
+export interface ValidationErrorItem {
+    field: string;
+    message: string;
+    rule?: string;
+}
+/**
+ * Base standardized envelope for all API responses across the enterprise kit.
+ * @template T The type of the main data payload.
+ */
+export interface StandardApiResponse<T = unknown> {
+    success: boolean;
+    statusCode: number;
+    responseCode: string;
+    message: string;
+    data: T | null;
+    meta: ApiResponseMeta;
+    pagination?: ApiResponsePagination;
+    errors?: ValidationErrorItem[] | unknown;
+}
+/**
+ * Flexible input signature for modifying standard response options dynamically.
+ */
+export interface ResponseOptions {
+    message?: string;
+    responseCode?: string;
+    meta?: Record<string, unknown>;
+    errors?: ValidationErrorItem[] | unknown;
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+    };
+}
+/**
+ * Custom extended options specifically mapped for paginated execution.
+ */
+export interface PaginationOptions {
+    page: number;
+    limit: number;
+    total: number;
+    message?: string;
+    responseCode?: string;
+    meta?: Record<string, unknown>;
+}

package/dist/types/responses.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @fileoveriew Core response type definitions for express-api-kit.
+ * Establishes strict contract types for standardized API structural states.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });