ts-packages 1.0.0 → 3.0.0

package/packages/server-utils/dist/esm/middleware/errorHandler.middleware.js

@@ -0,0 +1,44 @@
+import { AppError } from '@naman_deep_singh/errors-utils';
+export function createErrorHandler() {
+    return (error, _req, res, next) => {
+        if (res.headersSent) {
+            return next(error);
+        }
+        // Use responder if available
+        const responder = res.responder?.() ?? null;
+        // Known application error
+        if (error instanceof AppError) {
+            if (responder) {
+                return responder
+                    .status(error.statusCode)
+                    .error(error.code, error.details);
+            }
+            // Fallback (if responder middleware is not mounted)
+            return res.status(error.statusCode).json({
+                success: false,
+                message: error.code,
+                error: {
+                    message: error.code,
+                    details: error.details,
+                },
+                data: undefined,
+                meta: null,
+            });
+        }
+        // Unknown / unhandled error
+        console.error('Unhandled error:', error);
+        const status = 500;
+        const message = 'Internal Server Error';
+        if (responder) {
+            return responder.status(status).error(message);
+        }
+        // Final fallback
+        return res.status(status).json({
+            success: false,
+            message,
+            error: { message },
+            data: undefined,
+            meta: null,
+        });
+    };
+}

package/packages/server-utils/dist/esm/middleware/index.d.ts

@@ -0,0 +1,10 @@
+export { AuthConfig, createAuthMiddleware } from './auth.middleware';
+export { cacheResponse } from './cache.middleware';
+export { createErrorHandler } from './errorHandler.middleware';
+export { createLoggingMiddleware } from './logging.middleware';
+export { RateLimitConfig, createRateLimitMiddleware, } from './rateLimiter.middleware';
+export { createRequestIdMiddleware } from './requestId.middleware';
+export { useSession } from './session.middleware';
+export { ValidationRule, createValidationMiddleware, } from './validation.middleware';
+export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, } from './plugins.middleware';
+export { validateFields, rateLimit, requireAuth, } from './plugins.middleware';

package/packages/server-utils/dist/esm/middleware/index.js

@@ -0,0 +1,20 @@
+// Authentication Middleware
+export { createAuthMiddleware } from './auth.middleware';
+// Cache Middleware
+export { cacheResponse } from './cache.middleware';
+// Error Handler Middleware
+export { createErrorHandler } from './errorHandler.middleware';
+// Logging Middleware
+export { createLoggingMiddleware } from './logging.middleware';
+// Rate Limiter Middleware
+export { createRateLimitMiddleware, } from './rateLimiter.middleware';
+// Request ID Middleware
+export { createRequestIdMiddleware } from './requestId.middleware';
+// Session Middleware
+export { useSession } from './session.middleware';
+// Validation Middleware
+export { createValidationMiddleware, } from './validation.middleware';
+// Plugin middleware functions (for application-level middleware)
+export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, } from './plugins.middleware';
+// Convenience middleware functions (for route-level middleware)
+export { validateFields, rateLimit, requireAuth, } from './plugins.middleware';

package/packages/server-utils/dist/esm/middleware/logging.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export declare function createLoggingMiddleware(format?: 'simple' | 'detailed'): RequestHandler;

package/packages/server-utils/dist/esm/middleware/logging.middleware.js

@@ -0,0 +1,16 @@
+// Logging middleware
+export function createLoggingMiddleware(format = 'simple') {
+    return (req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+            const duration = Date.now() - start;
+            if (format === 'detailed') {
+                console.log(`${req.method} ${req.url} - ${res.statusCode} - ${duration}ms - ${req.ip}`);
+            }
+            else {
+                console.log(`${req.method} ${req.url} - ${res.statusCode}`);
+            }
+        });
+        next();
+    };
+}

package/packages/server-utils/dist/esm/middleware/plugins.middleware.d.ts

@@ -0,0 +1,14 @@
+import type { RequestHandler } from 'express';
+import type { ServerPlugin } from '../types';
+import type { AuthConfig } from './auth.middleware';
+import type { RateLimitConfig } from './rateLimiter.middleware';
+import type { ValidationRule } from './validation.middleware';
+export declare function withLogging(format?: 'simple' | 'detailed'): ServerPlugin;
+export declare function withErrorHandler(): ServerPlugin;
+export declare function withRequestId(): ServerPlugin;
+export declare function withValidation(rules: ValidationRule[]): ServerPlugin;
+export declare function withRateLimit(config?: RateLimitConfig): ServerPlugin;
+export declare function withAuth(config: AuthConfig): ServerPlugin;
+export declare function validateFields(rules: ValidationRule[]): RequestHandler;
+export declare function rateLimit(config?: RateLimitConfig): RequestHandler;
+export declare function requireAuth(config: AuthConfig): RequestHandler;

package/packages/server-utils/dist/esm/middleware/plugins.middleware.js

@@ -0,0 +1,47 @@
+import { createAuthMiddleware } from './auth.middleware';
+import { createErrorHandler } from './errorHandler.middleware';
+import { createLoggingMiddleware } from './logging.middleware';
+import { createRateLimitMiddleware } from './rateLimiter.middleware';
+import { createRequestIdMiddleware } from './requestId.middleware';
+import { createValidationMiddleware } from './validation.middleware';
+// Plugin versions
+export function withLogging(format = 'simple') {
+    return (app) => {
+        app.use(createLoggingMiddleware(format));
+    };
+}
+export function withErrorHandler() {
+    return (app) => {
+        app.use(createErrorHandler());
+    };
+}
+export function withRequestId() {
+    return (app) => {
+        app.use(createRequestIdMiddleware());
+    };
+}
+export function withValidation(rules) {
+    return (app) => {
+        app.use(createValidationMiddleware(rules));
+    };
+}
+export function withRateLimit(config = {}) {
+    return (app) => {
+        app.use(createRateLimitMiddleware(config));
+    };
+}
+export function withAuth(config) {
+    return (app) => {
+        app.use(createAuthMiddleware(config));
+    };
+}
+// Convenience functions for route-specific middleware
+export function validateFields(rules) {
+    return createValidationMiddleware(rules);
+}
+export function rateLimit(config = {}) {
+    return createRateLimitMiddleware(config);
+}
+export function requireAuth(config) {
+    return createAuthMiddleware(config);
+}

package/packages/server-utils/dist/esm/middleware/rateLimiter.middleware.d.ts

@@ -0,0 +1,8 @@
+import type { Request, RequestHandler } from 'node_modules/@types/express';
+export interface RateLimitConfig {
+    windowMs?: number;
+    maxRequests?: number;
+    message?: string;
+    keyGenerator?: (req: Request) => string;
+}
+export declare function createRateLimitMiddleware(config?: RateLimitConfig): RequestHandler;

package/packages/server-utils/dist/esm/middleware/rateLimiter.middleware.js

@@ -0,0 +1,32 @@
+const rateLimitStore = new Map();
+export function createRateLimitMiddleware(config = {}) {
+    const { windowMs = 15 * 60 * 1000, maxRequests = 100, message = 'Too many requests, please try again later', keyGenerator = (req) => req.ip || 'unknown', } = config;
+    return (req, res, next) => {
+        const key = keyGenerator(req);
+        const now = Date.now();
+        const record = rateLimitStore.get(key);
+        if (!record || now > record.resetTime) {
+            rateLimitStore.set(key, {
+                count: 1,
+                resetTime: now + windowMs,
+            });
+            return next();
+        }
+        if (record.count >= maxRequests) {
+            return res.status(429).json({
+                success: false,
+                message,
+                data: undefined,
+                error: {
+                    message,
+                    details: {
+                        retryAfter: Math.ceil((record.resetTime - now) / 1000),
+                    },
+                },
+                meta: null,
+            });
+        }
+        record.count++;
+        next();
+    };
+}

package/packages/server-utils/dist/esm/middleware/requestId.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export declare function createRequestIdMiddleware(): RequestHandler;

package/packages/server-utils/dist/esm/middleware/requestId.middleware.js

@@ -0,0 +1,9 @@
+// Request ID middleware
+export function createRequestIdMiddleware() {
+    return (req, res, next) => {
+        const requestId = Math.random().toString(36).substring(2, 15);
+        req.requestId = requestId;
+        res.setHeader('X-Request-ID', requestId);
+        next();
+    };
+}

package/packages/server-utils/dist/esm/middleware/session.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export declare function useSession(cookieName?: string): RequestHandler;

package/packages/server-utils/dist/esm/middleware/session.middleware.js

@@ -0,0 +1,50 @@
+// Session middleware helper (attaches sessionStore and helpers to req)
+export function useSession(cookieName) {
+    return async (req, _res, next) => {
+        try {
+            const store = req.app.locals.sessionStore;
+            if (!store)
+                return next();
+            const name = cookieName || req.app.locals.sessionCookieName || 'sid';
+            let sid = req.cookies?.[name];
+            if (!sid) {
+                const cookieHeader = req.headers.cookie;
+                if (cookieHeader) {
+                    const match = cookieHeader
+                        .split(';')
+                        .map((s) => s.trim())
+                        .find((s) => s.startsWith(`${name}=`));
+                    if (match)
+                        sid = match.split('=')[1];
+                }
+            }
+            req.sessionId = sid;
+            req.sessionStore = store;
+            req.getSession = async () => {
+                if (!sid)
+                    return null;
+                try {
+                    return await store.get(sid);
+                }
+                catch (error) {
+                    console.error(`[Session] Failed to get session "${sid}":`, error);
+                    throw error;
+                }
+            };
+            req.createSession = async (id, data, ttl) => {
+                try {
+                    return await store.create(id, data, ttl);
+                }
+                catch (error) {
+                    console.error(`[Session] Failed to create session "${id}":`, error);
+                    throw error;
+                }
+            };
+            next();
+        }
+        catch (error) {
+            console.error('[Session] Unexpected error in useSession middleware:', error);
+            next();
+        }
+    };
+}

package/packages/server-utils/dist/esm/middleware/validation.middleware.d.ts

@@ -0,0 +1,11 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export interface ValidationRule {
+    field: string;
+    required?: boolean;
+    type?: 'string' | 'number' | 'email' | 'boolean';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    custom?: (value: unknown) => boolean | string;
+}
+export declare function createValidationMiddleware(rules: ValidationRule[]): RequestHandler;

package/packages/server-utils/dist/esm/middleware/validation.middleware.js

@@ -0,0 +1,64 @@
+import { ValidationError } from '@naman_deep_singh/errors-utils';
+export function createValidationMiddleware(rules) {
+    return (req, _res, next) => {
+        const errors = [];
+        for (const rule of rules) {
+            const value = req.body[rule.field];
+            if (rule.required &&
+                (value === undefined || value === null || value === '')) {
+                errors.push(`${rule.field} is required`);
+                continue;
+            }
+            if (value === undefined || value === null)
+                continue;
+            if (rule.type) {
+                switch (rule.type) {
+                    case 'email':
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        if (!emailRegex.test(value)) {
+                            errors.push(`${rule.field} must be a valid email`);
+                        }
+                        break;
+                    case 'string':
+                        if (typeof value !== 'string') {
+                            errors.push(`${rule.field} must be a string`);
+                        }
+                        break;
+                    case 'number':
+                        if (typeof value !== 'number' && isNaN(Number(value))) {
+                            errors.push(`${rule.field} must be a number`);
+                        }
+                        break;
+                    case 'boolean':
+                        if (typeof value !== 'boolean') {
+                            errors.push(`${rule.field} must be a boolean`);
+                        }
+                        break;
+                }
+            }
+            if (rule.minLength && value.length < rule.minLength) {
+                errors.push(`${rule.field} must be at least ${rule.minLength} characters`);
+            }
+            if (rule.maxLength && value.length > rule.maxLength) {
+                errors.push(`${rule.field} must be no more than ${rule.maxLength} characters`);
+            }
+            if (rule.pattern && !rule.pattern.test(value)) {
+                errors.push(`${rule.field} format is invalid`);
+            }
+            if (rule.custom) {
+                const result = rule.custom(value);
+                if (result !== true) {
+                    errors.push(typeof result === 'string' ? result : `${rule.field} is invalid`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            // Use ValidationError from errors-utils and let error middleware handle response
+            const validationError = new ValidationError({
+                fieldErrors: errors,
+            });
+            return next(validationError);
+        }
+        next();
+    };
+}

package/packages/server-utils/dist/esm/types/index.d.ts

@@ -0,0 +1,87 @@
+import type express from 'express';
+export interface CorsOptions {
+    origin?: string | string[] | boolean | RegExp | ((origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) => void);
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}
+export interface ServerConfig {
+    port?: number;
+    cors?: boolean | CorsOptions;
+    helmet?: boolean;
+    json?: boolean;
+    cookieParser?: boolean;
+    customMiddleware?: express.RequestHandler[];
+    healthCheck?: boolean | string;
+    gracefulShutdown?: boolean;
+    socketIO?: SocketIOConfig;
+    periodicHealthCheck?: PeriodicHealthCheckConfig;
+    name?: string;
+    version?: string;
+    cache?: {
+        enabled?: boolean;
+        adapter?: 'redis' | 'memcache' | 'memory';
+        options?: unknown;
+        defaultTTL?: number;
+    };
+    session?: {
+        enabled?: boolean;
+        cookieName?: string;
+        ttl?: number;
+        cookieOptions?: {
+            path?: string;
+            httpOnly?: boolean;
+            secure?: boolean;
+            sameSite?: 'lax' | 'strict' | 'none';
+        };
+    };
+}
+export interface PeriodicHealthCheckConfig {
+    enabled?: boolean;
+    interval?: number;
+    services?: HealthCheckService[];
+}
+export interface HealthCheckService {
+    name: string;
+    url: string;
+    timeout?: number;
+}
+export interface SocketIOConfig {
+    enabled?: boolean;
+    cors?: boolean | {
+        origin?: string | string[] | boolean;
+        methods?: string[];
+        credentials?: boolean;
+    };
+    onConnection?: (socket: unknown) => void;
+    onDisconnection?: (socket: unknown, reason: string) => void;
+    path?: string;
+}
+export interface HealthCheckConfig {
+    path?: string;
+    customChecks?: HealthCheck[];
+}
+export interface HealthCheck {
+    name: string;
+    check: () => Promise<boolean>;
+}
+export interface GracefulShutdownConfig {
+    timeout?: number;
+    onShutdown?: () => Promise<void>;
+    serverName?: string;
+    serverVersion?: string;
+}
+export interface SocketInstance {
+    id: string;
+    emit: (event: string, data?: unknown) => void;
+    on: (event: string, handler: (...args: unknown[]) => void) => void;
+    broadcast: {
+        emit: (event: string, data?: unknown) => void;
+    };
+    disconnect: () => void;
+}
+export type ServerPlugin = (app: express.Application, config: ServerConfig) => void;

package/packages/server-utils/dist/esm/types/index.js

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

package/packages/server-utils/dist/esm/utils/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getEnv(key: string, defaultValue?: string): string;
+export declare function getEnvNumber(key: string, defaultValue?: number): number;
+export declare function getEnvBoolean(key: string, defaultValue?: boolean): boolean;

package/packages/server-utils/dist/esm/utils/utils.js

@@ -0,0 +1,38 @@
+export function getEnv(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    return value; // empty string allowed
+}
+export function getEnvNumber(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Environment variable ${key} must be a valid number`);
+    }
+    return parsed;
+}
+export function getEnvBoolean(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized !== 'true' && normalized !== 'false') {
+        throw new Error(`Environment variable ${key} must be 'true' or 'false'`);
+    }
+    return normalized === 'true';
+}

package/packages/server-utils/dist/types/core/health.d.ts

@@ -0,0 +1,5 @@
+import type { Application, RequestHandler } from 'express';
+import type { HealthCheckConfig, ServerPlugin } from '../types';
+export declare function createHealthCheck(config?: HealthCheckConfig): RequestHandler;
+export declare function withHealthCheck(path?: string, config?: HealthCheckConfig): ServerPlugin;
+export declare function addHealthCheck(app: Application, path?: string, config?: HealthCheckConfig): void;

package/packages/server-utils/dist/types/core/periodic-health.d.ts

@@ -0,0 +1,11 @@
+import type { PeriodicHealthCheckConfig } from '../types';
+export declare class PeriodicHealthMonitor {
+    private intervals;
+    private config;
+    private serviceName;
+    constructor(config: PeriodicHealthCheckConfig, serviceName: string);
+    start(): void;
+    stop(): void;
+    private checkServiceHealth;
+    getHealthStatus(): Promise<Record<string, boolean>>;
+}

package/packages/server-utils/dist/types/core/server.d.ts

@@ -0,0 +1,73 @@
+import { type ICache, SessionStore } from '@naman_deep_singh/cache';
+import type { Server } from 'http';
+import type { Application } from 'express';
+import type { ServerConfig, SocketIOConfig } from '../types';
+export interface GrpcService {
+    service: Record<string, unknown>;
+    implementation: Record<string, (...args: unknown[]) => unknown>;
+}
+export interface RpcMethod {
+    [key: string]: (params: unknown[], callback: (error: Error | null, result?: unknown) => void) => void;
+}
+export interface WebhookConfig {
+    path: string;
+    secret?: string;
+    handler: (payload: Record<string, unknown>, headers: Record<string, string | string[]>) => void | Promise<void>;
+}
+export interface GrpcServerInstance {
+    start(): void;
+    forceShutdown(): void;
+    addService(service: unknown, implementation: unknown): void;
+    bindAsync(address: string, credentials: unknown, callback: () => void): void;
+}
+export interface ServerInstanceConfig extends Required<Omit<ServerConfig, 'socketIO' | 'name' | 'version'>> {
+    name: string;
+    version: string;
+    startTime: Date;
+    socketIO?: SocketIOConfig;
+}
+export interface ServerInstance {
+    app: Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+    port: number;
+    uptime: number;
+    status: 'starting' | 'running' | 'stopping' | 'stopped';
+    startTime: Date;
+}
+export declare class ExpressServer implements ServerInstance {
+    app: Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    cache?: ICache<unknown>;
+    sessionStore?: SessionStore | undefined;
+    private status;
+    private grpcServices;
+    private grpcServer?;
+    private rpcMethods;
+    private socketIO?;
+    private healthMonitor?;
+    constructor(name?: string, version?: string, config?: ServerConfig);
+    private setupMiddleware;
+    private setupCacheAndSession;
+    private setupPeriodicHealthMonitoring;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export declare function createServer(name?: string, version?: string, config?: ServerConfig): ServerInstance;

package/packages/server-utils/dist/types/core/shutdown.d.ts

@@ -0,0 +1,5 @@
+import type { Server } from 'http';
+import type { GracefulShutdownConfig, ServerPlugin } from '../types';
+export declare function createGracefulShutdown(server: Server, config?: GracefulShutdownConfig): void;
+export declare function withGracefulShutdown(config?: GracefulShutdownConfig): ServerPlugin;
+export declare function startServerWithShutdown(app: import('express').Application, port: number, shutdownConfig?: GracefulShutdownConfig, serverName?: string, serverVersion?: string): Server;

package/packages/server-utils/dist/types/index.d.ts

@@ -0,0 +1,46 @@
+export { ExpressServer, createServer } from './core/server';
+export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig, } from './core/server';
+export { Request, Response, NextFunction, Router, Application } from 'express';
+export type { RequestHandler, ErrorRequestHandler } from 'express';
+export { createHealthCheck, withHealthCheck, addHealthCheck, } from './core/health';
+export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown, } from './core/shutdown';
+export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, cacheResponse, useSession, type ValidationRule, type RateLimitConfig, type AuthConfig, } from './middleware';
+export { getEnv, getEnvNumber, getEnvBoolean, } from './utils/utils';
+export { PeriodicHealthMonitor } from './core/periodic-health';
+export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin, SocketIOConfig, SocketInstance, PeriodicHealthCheckConfig, HealthCheckService, } from './types';
+import { addHealthCheck, createHealthCheck, withHealthCheck } from './core/health';
+import { PeriodicHealthMonitor } from './core/periodic-health';
+import { ExpressServer, createServer } from './core/server';
+import { createGracefulShutdown, startServerWithShutdown, withGracefulShutdown } from './core/shutdown';
+import { createAuthMiddleware, createErrorHandler, createLoggingMiddleware, createRateLimitMiddleware, createRequestIdMiddleware, createValidationMiddleware, rateLimit, requireAuth, validateFields, withAuth, withErrorHandler, withLogging, withRateLimit, withRequestId, withValidation } from './middleware';
+import { getEnv, getEnvBoolean, getEnvNumber } from './utils/utils';
+declare const ServerUtils: {
+    createServer: typeof createServer;
+    ExpressServer: typeof ExpressServer;
+    createHealthCheck: typeof createHealthCheck;
+    withHealthCheck: typeof withHealthCheck;
+    addHealthCheck: typeof addHealthCheck;
+    createGracefulShutdown: typeof createGracefulShutdown;
+    withGracefulShutdown: typeof withGracefulShutdown;
+    startServerWithShutdown: typeof startServerWithShutdown;
+    createLoggingMiddleware: typeof createLoggingMiddleware;
+    createErrorHandler: typeof createErrorHandler;
+    createRequestIdMiddleware: typeof createRequestIdMiddleware;
+    createValidationMiddleware: typeof createValidationMiddleware;
+    createRateLimitMiddleware: typeof createRateLimitMiddleware;
+    createAuthMiddleware: typeof createAuthMiddleware;
+    withLogging: typeof withLogging;
+    withErrorHandler: typeof withErrorHandler;
+    withRequestId: typeof withRequestId;
+    withValidation: typeof withValidation;
+    withRateLimit: typeof withRateLimit;
+    withAuth: typeof withAuth;
+    validateFields: typeof validateFields;
+    rateLimit: typeof rateLimit;
+    requireAuth: typeof requireAuth;
+    getEnv: typeof getEnv;
+    getEnvNumber: typeof getEnvNumber;
+    getEnvBoolean: typeof getEnvBoolean;
+    PeriodicHealthMonitor: typeof PeriodicHealthMonitor;
+};
+export default ServerUtils;

package/packages/server-utils/dist/types/middleware/auth.middleware.d.ts

@@ -0,0 +1,6 @@
+import type { Request, RequestHandler } from 'express';
+export interface AuthConfig {
+    secret: string;
+    tokenExtractor?: (req: Request) => string | null;
+}
+export declare function createAuthMiddleware(config: AuthConfig): RequestHandler;

package/packages/server-utils/dist/types/middleware/cache.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export declare function cacheResponse(ttl?: number): RequestHandler;

package/packages/server-utils/dist/types/middleware/errorHandler.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorRequestHandler } from 'express';
+export declare function createErrorHandler(): ErrorRequestHandler;