@abejarano/ts-express-server 1.5.2 → 1.6.0

package/README.md

@@ -1,6 +1,6 @@
-# TypeScript Express Server Framework
+# TypeScript Server Framework (Express + Bun)
 
-A modular and extensible TypeScript framework for building Express.js servers with a clean architecture pattern that separates concerns between server modules and services.
+A modular and extensible TypeScript framework for building Express or Bun servers with a clean architecture pattern that separates concerns between server modules and services.
 
 ## Features
 
@@ -12,6 +12,7 @@ A modular and extensible TypeScript framework for building Express.js servers wi
 - 🛡️ **Type Safety**: Full TypeScript support with strong typing
 - 🔧 **Configurable**: Highly customizable modules and services
 - 🎨 **Decorators**: Clean and declarative controller definition
+- ⚙️ **Runtime Choice**: Run on Express (Node) or Bun via `ServerRuntime`
 
 ## Installation
 
@@ -32,6 +33,17 @@ yarn add @abejarano/ts-express-server
 - [API Reference](docs/api-reference.md)
 - [Examples](docs/examples.md)
 
+## Runtime Selection
+
+```typescript
+import { BootstrapServer } from "@abejarano/ts-express-server";
+
+const server = new BootstrapServer(3000, { runtime: "bun" });
+server.start();
+```
+
+You can also use `ServerRuntime.Bun` and `ServerRuntime.Express` if you prefer the enum.
+
 ## Contributing
 
 1. Fork the repository

package/dist/BootstrapServer.d.ts

@@ -1,20 +1,26 @@
-import { Express } from "express";
-import { Server as HttpServer } from "http";
 import { BaseServerModule, BaseServerService } from "./abstract";
+import { ServerAdapter, ServerApp, ServerInstance, ServerRuntime } from "./abstract";
+export interface BootstrapServerOptions {
+    runtime?: ServerRuntime;
+    adapter?: ServerAdapter;
+}
 export declare class BootstrapServer {
     private readonly app;
     private readonly port;
-    private httpServer?;
+    private server?;
     private modules;
     private services;
-    constructor(port: number);
+    private readonly adapter;
+    private readonly runtime;
+    constructor(port: number, options?: BootstrapServerOptions);
     removeModule(moduleName: string): BootstrapServer;
     addModule(module: BaseServerModule): BootstrapServer;
     addModules(modules: BaseServerModule[]): BootstrapServer;
     addService(service: BaseServerService): BootstrapServer;
     addServices(services: BaseServerService[]): BootstrapServer;
-    getApp(): Express;
-    getHttpServer(): HttpServer | undefined;
+    getApp(): ServerApp;
+    getServer(): ServerInstance | undefined;
+    getHttpServer(): ServerInstance | undefined;
     initialize(): Promise<void>;
     start(): Promise<void>;
     gracefulShutdown(): Promise<void>;
@@ -23,4 +29,5 @@ export declare class BootstrapServer {
     private initializeServices;
     private initializeServerModules;
     private setupGracefulShutdown;
+    private createAdapter;
 }

package/dist/BootstrapServer.js

@@ -1,23 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BootstrapServer = void 0;
-const express_1 = __importDefault(require("express"));
-const body_parser_1 = __importDefault(require("body-parser"));
-const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const abstract_1 = require("./abstract");
+const adapters_1 = require("./adapters");
 class BootstrapServer {
-    constructor(port) {
+    constructor(port, options) {
         this.modules = [];
         this.services = [];
         this.port = port;
-        this.app = (0, express_1.default)();
-        this.app.use(express_1.default.json());
-        this.app.use(body_parser_1.default.urlencoded({ extended: true }));
-        this.app.use((0, cookie_parser_1.default)());
-        this.app.set("port", port);
-        this.app.set("trust proxy", 1);
+        this.adapter = options?.adapter ?? this.createAdapter(options?.runtime);
+        this.runtime = this.adapter.runtime;
+        this.app = this.adapter.createApp();
+        this.adapter.configure(this.app, port);
     }
     removeModule(moduleName) {
         this.modules = this.modules.filter((m) => m.getModuleName() !== moduleName);
@@ -60,8 +54,11 @@ class BootstrapServer {
     getApp() {
         return this.app;
     }
+    getServer() {
+        return this.server;
+    }
     getHttpServer() {
-        return this.httpServer;
+        return this.server;
     }
     async initialize() {
         await this.initializeServerModules();
@@ -69,12 +66,12 @@ class BootstrapServer {
     async start() {
         await this.initializeServerModules();
         return new Promise((resolve) => {
-            this.httpServer = this.app.listen(this.port, () => {
+            this.server = this.adapter.listen(this.app, this.port, () => {
                 console.log(`Server running on port ${this.port}`);
                 this.setupGracefulShutdown();
                 resolve();
             });
-            this.initializeServices(this.httpServer);
+            this.initializeServices(this.server);
         });
     }
     async gracefulShutdown() {
@@ -109,12 +106,12 @@ class BootstrapServer {
                 }
             }
             // Close HTTP server
-            if (this.httpServer) {
-                console.log("Closing HTTP server...");
+            if (this.server) {
+                console.log("Closing server...");
                 await new Promise((resolve) => {
-                    this.httpServer.close(() => resolve());
+                    this.server.close(() => resolve());
                 });
-                console.log("HTTP server closed");
+                console.log("Server closed");
             }
             console.log("Graceful shutdown completed. Exiting...");
             process.exit(0);
@@ -131,11 +128,11 @@ class BootstrapServer {
     hasModule(moduleClass) {
         return this.modules.some((m) => m instanceof moduleClass);
     }
-    async initializeServices(http) {
+    async initializeServices(server) {
         console.log("Starting services...");
         for (const service of this.services) {
             try {
-                await service.start(http);
+                await service.start(server);
                 console.log(`Service started: ${service.name}`);
             }
             catch (error) {
@@ -149,9 +146,13 @@ class BootstrapServer {
         // Sort modules by priority (lower number = higher priority)
         this.modules.sort((a, b) => (a.priority || 0) - (b.priority || 0));
         console.log("Initializing server modules in priority order:");
+        const context = {
+            runtime: this.runtime,
+            adapter: this.adapter,
+        };
         for (const module of this.modules) {
             try {
-                await module.init(this.app);
+                await module.init(this.app, context);
                 console.log(`Module initialized: ${module.getModuleName()}`);
             }
             catch (error) {
@@ -169,5 +170,11 @@ class BootstrapServer {
         process.on("SIGINT", () => shutdown("SIGINT"));
         process.on("SIGTERM", () => shutdown("SIGTERM"));
     }
+    createAdapter(runtime) {
+        if (runtime === abstract_1.ServerRuntime.Bun) {
+            return new adapters_1.BunAdapter();
+        }
+        return new adapters_1.ExpressAdapter();
+    }
 }
 exports.BootstrapServer = BootstrapServer;

package/dist/BootstrapStandardServer.d.ts

@@ -1,7 +1,8 @@
 import { BootstrapServer } from "./BootstrapServer";
 import { ControllersModule, RoutesModule } from "./modules";
-import { BaseServerModule, BaseServerService } from "./abstract";
+import { BaseServerModule, BaseServerService, ServerRuntime } from "./abstract";
 export interface BootstrapStandardServerOptions {
+    runtime?: ServerRuntime;
     modules?: {
         cors?: BaseServerModule | false;
         security?: BaseServerModule | false;

package/dist/BootstrapStandardServer.js

@@ -64,12 +64,14 @@ function BootstrapStandardServer(port, arg2, arg3, arg4, arg5) {
     if (preset?.extra?.length) {
         modulesToRegister.push(...preset.extra);
     }
-    const expressServer = new BootstrapServer_1.BootstrapServer(port).addModules(modulesToRegister);
+    const server = new BootstrapServer_1.BootstrapServer(port, {
+        runtime: options?.runtime,
+    }).addModules(modulesToRegister);
     if (controllersModule) {
-        expressServer.addModule(controllersModule);
+        server.addModule(controllersModule);
     }
     if (services) {
-        expressServer.addServices(services);
+        server.addServices(services);
     }
-    return expressServer;
+    return server;
 }

package/dist/abstract/ServerModule.d.ts

@@ -1,7 +1,7 @@
-import { Express } from "express";
+import { ServerApp, ServerContext } from "./ServerTypes";
 export declare abstract class BaseServerModule {
     priority: number;
     abstract getModuleName(): string;
-    abstract init(app: Express): Promise<void> | void;
+    abstract init(app: ServerApp, context?: ServerContext): Promise<void> | void;
     shutdown(): Promise<void>;
 }

package/dist/abstract/ServerService.d.ts

@@ -1,6 +1,6 @@
-import { Server as HttpServer } from "http";
+import { ServerInstance } from "./ServerTypes";
 export declare abstract class BaseServerService {
     abstract name: string;
-    abstract start(http: HttpServer): Promise<void> | void;
+    abstract start(server: ServerInstance): Promise<void> | void;
     stop(): Promise<void>;
 }

package/dist/abstract/ServerTypes.d.ts

@@ -0,0 +1,55 @@
+export declare enum ServerRuntime {
+    Express = "express",
+    Bun = "bun"
+}
+export type NextFunction = (err?: unknown) => void;
+export type ServerHandler = (req: any, res: any, next: NextFunction) => any;
+export interface ServerRequest {
+    method: string;
+    path: string;
+    originalUrl?: string;
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    headers: Record<string, string | string[] | undefined>;
+    body?: unknown;
+    files?: unknown;
+    cookies?: Record<string, string>;
+    ip?: string;
+    requestId?: string;
+    raw?: unknown;
+}
+export interface ServerResponse {
+    status(code: number): this;
+    json(body: unknown): void | Promise<void>;
+    send(body: unknown): void | Promise<void>;
+    set(name: string, value: string): this;
+    header(name: string, value: string): this;
+    end(body?: unknown): void | Promise<void>;
+}
+export type ServerHandlerInput = ServerHandler | ServerHandler[] | ServerRouter;
+export interface ServerRouter {
+    use(pathOrHandler: string | ServerHandlerInput, ...handlers: ServerHandlerInput[]): void;
+    get(path: string, ...handlers: ServerHandler[]): void;
+    post(path: string, ...handlers: ServerHandler[]): void;
+    put(path: string, ...handlers: ServerHandler[]): void;
+    delete(path: string, ...handlers: ServerHandler[]): void;
+    patch(path: string, ...handlers: ServerHandler[]): void;
+}
+export interface ServerApp extends ServerRouter {
+    set?(key: string, value: unknown): void;
+    listen?(port: number, callback?: () => void): unknown;
+}
+export type ServerInstance = {
+    close(callback?: () => void): void;
+};
+export interface ServerAdapter {
+    runtime: ServerRuntime;
+    createApp(): ServerApp;
+    createRouter(): ServerRouter;
+    configure(app: ServerApp, port: number): void;
+    listen(app: ServerApp, port: number, onListen: () => void): ServerInstance;
+}
+export interface ServerContext {
+    runtime: ServerRuntime;
+    adapter: ServerAdapter;
+}

package/dist/abstract/ServerTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerRuntime = void 0;
+var ServerRuntime;
+(function (ServerRuntime) {
+    ServerRuntime["Express"] = "express";
+    ServerRuntime["Bun"] = "bun";
+})(ServerRuntime || (exports.ServerRuntime = ServerRuntime = {}));

package/dist/abstract/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./ServerService";
 export * from "./ServerModule";
+export * from "./ServerTypes";

package/dist/abstract/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ServerService"), exports);
 __exportStar(require("./ServerModule"), exports);
+__exportStar(require("./ServerTypes"), exports);

package/dist/adapters/BunAdapter.d.ts

@@ -0,0 +1,8 @@
+import { ServerAdapter, ServerApp, ServerInstance, ServerRouter, ServerRuntime } from "../abstract/ServerTypes";
+export declare class BunAdapter implements ServerAdapter {
+    runtime: ServerRuntime;
+    createApp(): ServerApp;
+    createRouter(): ServerRouter;
+    configure(app: ServerApp, _port: number): void;
+    listen(app: ServerApp, port: number, onListen: () => void): ServerInstance;
+}