@naman_deep_singh/server-utils 1.0.8 → 1.1.0

package/dist/esm/shutdown.js

@@ -0,0 +1,52 @@
+export function createGracefulShutdown(server, config = {}) {
+    const { timeout = 10000, onShutdown, serverName, serverVersion } = config;
+    const nameVersion = serverName && serverVersion ? `${serverName} v${serverVersion}` : 'Server';
+    const shutdown = async (signal) => {
+        console.log(`🛑 ${nameVersion} received ${signal}, shutting down gracefully...`);
+        const shutdownTimer = setTimeout(() => {
+            console.log(`⏰ ${nameVersion} shutdown timeout reached, forcing exit`);
+            process.exit(1);
+        }, timeout);
+        try {
+            // Run custom shutdown logic
+            if (onShutdown) {
+                await onShutdown();
+            }
+            // Close server
+            server.close(() => {
+                clearTimeout(shutdownTimer);
+                console.log(`👋 ${nameVersion} closed. Exiting now.`);
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            clearTimeout(shutdownTimer);
+            console.error(`❌ ${nameVersion} error during shutdown:`, error);
+            process.exit(1);
+        }
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+export function withGracefulShutdown(config = {}) {
+    return (app, serverConfig) => {
+        // This plugin needs to be applied after server.listen()
+        // Store config for later use
+        app.__gracefulShutdownConfig = config;
+    };
+}
+export function startServerWithShutdown(app, port, shutdownConfig = {}, serverName, serverVersion) {
+    const server = app.listen(port, () => {
+        const nameVersion = serverName && serverVersion ? `${serverName} v${serverVersion}` : 'Server';
+        console.log(`🚀 ${nameVersion} running on http://localhost:${port}`);
+    });
+    // Apply graceful shutdown from stored config or provided config
+    const config = app.__gracefulShutdownConfig || shutdownConfig;
+    const enhancedConfig = {
+        ...config,
+        serverName,
+        serverVersion
+    };
+    createGracefulShutdown(server, enhancedConfig);
+    return server;
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,70 @@
+import 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;
+}
+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/dist/esm/types.js

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

package/dist/esm/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/dist/esm/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/dist/types/health.d.ts

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

package/dist/types/index.d.ts

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

@@ -0,0 +1,37 @@
+import express from 'express';
+import { ServerPlugin } from './types';
+export declare function createLoggingMiddleware(format?: 'simple' | 'detailed'): express.RequestHandler;
+export declare function createErrorHandler(): express.ErrorRequestHandler;
+export declare function createRequestIdMiddleware(): express.RequestHandler;
+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[]): express.RequestHandler;
+export interface RateLimitConfig {
+    windowMs?: number;
+    maxRequests?: number;
+    message?: string;
+    keyGenerator?: (req: express.Request) => string;
+}
+export declare function createRateLimitMiddleware(config?: RateLimitConfig): express.RequestHandler;
+export interface AuthConfig {
+    tokenExtractor?: (req: express.Request) => string | null;
+    tokenValidator?: (token: string) => Promise<unknown> | unknown;
+    unauthorizedMessage?: string;
+}
+export declare function createAuthMiddleware(config: AuthConfig): express.RequestHandler;
+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[]): express.RequestHandler;
+export declare function rateLimit(config?: RateLimitConfig): express.RequestHandler;
+export declare function requireAuth(config: AuthConfig): express.RequestHandler;

package/dist/types/periodic-health.d.ts

@@ -0,0 +1,11 @@
+import { 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/dist/types/server.d.ts

@@ -0,0 +1,69 @@
+import express from 'express';
+import { Server } from 'http';
+import { 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: express.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: express.Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    private status;
+    private grpcServices;
+    private grpcServer?;
+    private rpcMethods;
+    private socketIO?;
+    private healthMonitor?;
+    constructor(name?: string, version?: string, config?: ServerConfig);
+    private setupMiddleware;
+    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/dist/types/shutdown.d.ts

@@ -0,0 +1,5 @@
+import { Server } from 'http';
+import { 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: any, port: number, shutdownConfig?: GracefulShutdownConfig, serverName?: string, serverVersion?: string): Server;

package/dist/types/types.d.ts

@@ -0,0 +1,70 @@
+import 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;
+}
+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/dist/types/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/package.json

@@ -1,12 +1,22 @@
 {
   "name": "@naman_deep_singh/server-utils",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Extensible server utilities for Express.js microservices with TypeScript",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc"
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
   },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "keywords": [
     "server",
     "express",
@@ -16,7 +26,6 @@
   ],
   "author": "Naman Deep Singh",
   "license": "ISC",
-  "packageManager": "pnpm@10.20.0",
   "dependencies": {
     "express": "^5.1.0",
     "cors": "^2.8.5",
@@ -26,6 +35,12 @@
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "rimraf": "^5.0.5"
+  },
+  "scripts": {
+    "build": "pnpm run build:types && tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.base.json --emitDeclarationOnly --outDir dist/types",
+    "clean": "rimraf dist"
   }
 }

package/src/health.ts

@@ -1,47 +0,0 @@
-import express from 'express';
-import { HealthCheckConfig, HealthCheck, ServerPlugin } from './types';
-
-export function createHealthCheck(config: HealthCheckConfig = {}): express.RequestHandler {
-  const { customChecks = [] } = config;
-
-  return async (req: express.Request, res: express.Response) => {
-    try {
-      const checks: Record<string, boolean> = {
-        server: true,
-        timestamp: Date.now() as any
-      };
-
-      // Run custom health checks
-      for (const check of customChecks) {
-        try {
-          checks[check.name] = await check.check();
-        } catch (error) {
-          checks[check.name] = false;
-        }
-      }
-
-      const isHealthy = Object.values(checks).every(status => status === true || typeof status === 'number');
-      
-      res.status(isHealthy ? 200 : 503).json({
-        status: isHealthy ? 'healthy' : 'unhealthy',
-        checks
-      });
-    } catch (error) {
-      res.status(503).json({
-        status: 'unhealthy',
-        error: 'Health check failed'
-      });
-    }
-  };
-}
-
-export function withHealthCheck(path: string = '/health', config: HealthCheckConfig = {}): ServerPlugin {
-  return (app: express.Application) => {
-    app.get(path, createHealthCheck(config));
-  };
-}
-
-// Convenience function for direct use
-export function addHealthCheck(app: express.Application, path: string = '/health', config: HealthCheckConfig = {}): void {
-  app.get(path, createHealthCheck(config));
-}

package/src/index.ts

@@ -1,126 +0,0 @@
-// Core server utilities
-export { ExpressServer, createServer } from './server';
-export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig } from './server';
-
-// Express re-exports (to avoid direct Express dependency in services)
-export { Request, Response, NextFunction, Router, Application } from 'express';
-export type { RequestHandler, ErrorRequestHandler } from 'express';
-
-// Health check utilities
-export { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
-
-// Graceful shutdown utilities
-export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
-
-// Middleware utilities
-export {
-  createLoggingMiddleware,
-  createErrorHandler,
-  createRequestIdMiddleware,
-  createValidationMiddleware,
-  createRateLimitMiddleware,
-  createAuthMiddleware,
-  withLogging,
-  withErrorHandler,
-  withRequestId,
-  withValidation,
-  withRateLimit,
-  withAuth,
-  validateFields,
-  rateLimit,
-  requireAuth,
-  type ValidationRule,
-  type RateLimitConfig,
-  type AuthConfig
-} from './middleware';
-
-// Utility functions
-export {
-  getEnv,
-  getEnvNumber,
-  getEnvBoolean
-} from './utils';
-
-// Periodic health monitoring
-export { PeriodicHealthMonitor } from './periodic-health';
-
-// Types
-export type {
-  ServerConfig,
-  HealthCheckConfig,
-  HealthCheck,
-  GracefulShutdownConfig,
-  ServerPlugin,
-  SocketIOConfig,
-  SocketInstance,
-  PeriodicHealthCheckConfig,
-  HealthCheckService
-} from './types';
-
-// Import all exports for default export
-import { ExpressServer, createServer } from './server';
-import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
-import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
-import {
-  createLoggingMiddleware,
-  createErrorHandler,
-  createRequestIdMiddleware,
-  createValidationMiddleware,
-  createRateLimitMiddleware,
-  createAuthMiddleware,
-  withLogging,
-  withErrorHandler,
-  withRequestId,
-  withValidation,
-  withRateLimit,
-  withAuth,
-  validateFields,
-  rateLimit,
-  requireAuth
-} from './middleware';
-import { getEnv, getEnvNumber, getEnvBoolean } from './utils';
-import { PeriodicHealthMonitor } from './periodic-health';
-
-// Default export for namespace usage
-const ServerUtils = {
-  // Server creation
-  createServer,
-  ExpressServer,
-
-  // Health checks
-  createHealthCheck,
-  withHealthCheck,
-  addHealthCheck,
-
-  // Graceful shutdown
-  createGracefulShutdown,
-  withGracefulShutdown,
-  startServerWithShutdown,
-
-  // Middleware
-  createLoggingMiddleware,
-  createErrorHandler,
-  createRequestIdMiddleware,
-  createValidationMiddleware,
-  createRateLimitMiddleware,
-  createAuthMiddleware,
-  withLogging,
-  withErrorHandler,
-  withRequestId,
-  withValidation,
-  withRateLimit,
-  withAuth,
-  validateFields,
-  rateLimit,
-  requireAuth,
-
-  // Utils
-  getEnv,
-  getEnvNumber,
-  getEnvBoolean,
-
-  // Periodic Health Monitoring
-  PeriodicHealthMonitor,
-};
-
-export default ServerUtils;