elit 3.1.6 → 3.1.8

package/src/server.ts

@@ -16,23 +16,30 @@ import { lookup } from './mime-types';
 import { isBun, isDeno } from './runtime';
 import type { DevServerOptions, DevServer, HMRMessage, Child, VNode, ProxyConfig } from './types';
 import { dom } from './dom';
+import { Database, DatabaseConfig } from './database';
 
 // ===== Router =====
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD' | 'ALL';
 
+export interface ElitRequest extends IncomingMessage {
+  body?: any;
+}
+
+export interface ElitResponse extends ServerResponse {
+  json(data: any, statusCode?: number): this;
+  send(data: any): this;
+  status(code: number): this;
+}
+
 export interface ServerRouteContext {
-  req: IncomingMessage;
-  res: ServerResponse;
+  req: ElitRequest;
+  res: ElitResponse;
   params: Record<string, string>;
   query: Record<string, string>;
   body: any;
   headers: Record<string, string | string[] | undefined>;
   user?: any;
-  // Express-compatible response helpers
-  send?(data: any): ServerResponse;
-  json?(data: any): ServerResponse;
-  status?(code: number): ServerResponse;
 }
 
 export type ServerRouteHandler = (ctx: ServerRouteContext, next?: () => Promise<void>) => void | Promise<void>;
@@ -46,6 +53,25 @@ interface ServerRoute {
   middlewares: Middleware[];
 }
 
+class ServerDatabase {
+  private _db: Database | null = null;
+
+  constructor() {
+
+  }
+
+  async initialize(config: DatabaseConfig) {
+    this._db = new Database(config);
+  }
+
+  database() {
+    return this._db;
+  }
+}
+
+export const serverDatabase = new ServerDatabase();
+
+export const database = serverDatabase.database;
 export class ServerRouter {
   private routes: ServerRoute[] = [];
   private middlewares: Middleware[] = [];
@@ -66,19 +92,19 @@ export class ServerRouter {
   }
 
   // Express-like .all() method - matches all HTTP methods
-  all = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('ALL', path, handlers as any);
+  all = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('ALL', path, handlers as any);
 
   // Support per-route middleware: accept middleware(s) before the final handler
-  get = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('GET', path, handlers as any);
-  post = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('POST', path, handlers as any);
-  put = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('PUT', path, handlers as any);
-  delete = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('DELETE', path, handlers as any);
-  patch = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('PATCH', path, handlers as any);
-  options = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('OPTIONS', path, handlers as any);
-  head = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('HEAD', path, handlers as any);
+  get = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('GET', path, handlers as any);
+  post = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('POST', path, handlers as any);
+  put = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('PUT', path, handlers as any);
+  delete = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('DELETE', path, handlers as any);
+  patch = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('PATCH', path, handlers as any);
+  options = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('OPTIONS', path, handlers as any);
+  head = (path: string, ...handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this => this.addRoute('HEAD', path, handlers as any);
 
   // Convert Express-like handler/middleware to internal Middleware
-  private toMiddleware(fn: Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)): Middleware {
+  private toMiddleware(fn: Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)): Middleware {
     // If it's already our Middleware, return as-is
     if ((fn as Middleware).length === 2 && (fn as any).name !== 'bound ') {
       // Cannot reliably detect, so always wrap to normalize behavior
@@ -116,7 +142,7 @@ export class ServerRouter {
     };
   }
 
-  private addRoute(method: HttpMethod, path: string, handlers: Array<Middleware | ServerRouteHandler | ((req: IncomingMessage, res: ServerResponse, next?: () => void) => any)>): this {
+  private addRoute(method: HttpMethod, path: string, handlers: Array<Middleware | ServerRouteHandler | ((req: ElitRequest, res: ServerResponse, next?: () => void) => any)>): this {
     const { pattern, paramNames } = this.pathToRegex(path);
     // Last item is the actual route handler, preceding items are middlewares
     if (!handlers || handlers.length === 0) throw new Error('Route must include a handler');
@@ -173,10 +199,10 @@ export class ServerRouter {
       try {
         const text = await (req as any).text();
         if (!text) return {};
-        
+
         const contentType = req.headers['content-type'];
         const ct = (Array.isArray(contentType) ? contentType[0] : (contentType || '')).toLowerCase();
-        
+
         // Parse JSON (either by content-type or if it looks like JSON)
         if (ct.includes('application/json') || ct.includes('json') || text.trim().startsWith('{') || text.trim().startsWith('[')) {
           try {
@@ -185,12 +211,12 @@ export class ServerRouter {
             return text;
           }
         }
-        
+
         // Parse URL-encoded
         if (ct.includes('application/x-www-form-urlencoded') || ct.includes('urlencoded')) {
           return Object.fromEntries(new URLSearchParams(text));
         }
-        
+
         // Return raw text
         return text;
       } catch (e) {
@@ -203,28 +229,28 @@ export class ServerRouter {
     return new Promise((resolve, reject) => {
       const contentLengthHeader = req.headers['content-length'];
       const contentLength = parseInt(Array.isArray(contentLengthHeader) ? contentLengthHeader[0] : (contentLengthHeader || '0'), 10);
-      
+
       if (contentLength === 0) {
         resolve({});
         return;
       }
 
       const chunks: Buffer[] = [];
-      
+
       req.on('data', chunk => {
         chunks.push(Buffer.from(chunk));
       });
-      
+
       req.on('end', () => {
         const body = Buffer.concat(chunks).toString();
         try {
           const ct = req.headers['content-type'] || '';
           resolve(ct.includes('json') ? (body ? JSON.parse(body) : {}) : ct.includes('urlencoded') ? Object.fromEntries(new URLSearchParams(body)) : body);
-        } catch (e) { 
-          reject(e); 
+        } catch (e) {
+          reject(e);
         }
       });
-      
+
       req.on('error', reject);
     });
   }
@@ -240,48 +266,26 @@ export class ServerRouter {
 
       let body: any = {};
       if (['POST', 'PUT', 'PATCH'].includes(method)) {
-        try { 
+        try {
           body = await this.parseBody(req);
+          // Attach body to req for Express-like compatibility
+          (req as ElitRequest).body = body;
         }
-        catch (e) { 
-          res.writeHead(400, { 'Content-Type': 'application/json' }); 
-          res.end('{"error":"Invalid request body"}'); 
-          return true; 
+        catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end('{"error":"Invalid request body"}');
+          return true;
         }
       }
 
       // Add Express-like response helpers to context
-      const ctx: ServerRouteContext = { 
-        req, 
-        res, 
-        params, 
-        query: this.parseQuery(url), 
-        body, 
-        headers: req.headers as any,
-        send: (data: any) => { 
-          if (!res.headersSent) {
-            if (typeof data === 'object') {
-              res.setHeader('Content-Type', 'application/json');
-              res.end(JSON.stringify(data));
-            } else {
-              res.end(String(data));
-            }
-          }
-          return res;
-        },
-        json: (data: any) => {
-          if (!res.headersSent) {
-            res.setHeader('Content-Type', 'application/json');
-            res.end(JSON.stringify(data));
-          }
-          return res;
-        },
-        status: (code: number) => {
-          if (!res.headersSent) {
-            res.statusCode = code;
-          }
-          return res;
-        }
+      const ctx: ServerRouteContext = {
+        req: req as ElitRequest,
+        res: res as ElitResponse,
+        params,
+        query: this.parseQuery(url),
+        body,
+        headers: req.headers as any
       };
 
       // Build middleware chain: global middlewares -> route middlewares -> final handler
@@ -300,8 +304,8 @@ export class ServerRouter {
         await mw(ctx, next);
       };
 
-      try { 
-        await next(); 
+      try {
+        await next();
       }
       catch (e) {
         console.error('[ServerRouter] Route error:', e);
@@ -1074,7 +1078,7 @@ export class StateManager {
 
 // ===== Development Server =====
 
-const defaultOptions: Omit<Required<DevServerOptions>, 'api' | 'clients' | 'root' | 'basePath' | 'ssr' | 'proxy' | 'index' | 'env'> = {
+const defaultOptions: Omit<Required<DevServerOptions>, 'api' | 'clients' | 'root' | 'basePath' | 'ssr' | 'proxy' | 'index' | 'env' | 'domain' | 'database'> = {
   port: 3000,
   host: 'localhost',
   https: false,
@@ -1106,6 +1110,14 @@ export function createDevServer(options: DevServerOptions): DevServer {
     clearImportMapCache();
   }
 
+  // Initialize database connections if provided
+  serverDatabase.initialize(config.database ? config.database : {
+    dir: resolve(process.cwd(), 'databases')
+  })
+
+
+
+
   // Normalize clients configuration - support both new API (clients array) and legacy API (root/basePath)
   const clientsToNormalize = config.clients?.length ? config.clients : config.root ? [{ root: config.root, basePath: config.basePath || '', index: config.index, ssr: config.ssr, api: config.api, proxy: config.proxy, mode: config.mode }] : null;
   if (!clientsToNormalize) throw new Error('DevServerOptions must include either "clients" array or "root" directory');
@@ -1146,6 +1158,19 @@ export function createDevServer(options: DevServerOptions): DevServer {
   // HTTP Server
   const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     const originalUrl = req.url || '/';
+    const hostHeader = req.headers.host;
+    const hostName = hostHeader ? (Array.isArray(hostHeader) ? hostHeader[0] : hostHeader).split(':')[0] : '';
+
+    // Handle domain mapping: redirect localhost:port to configured domain
+    if (config.domain && hostName === (config.host || 'localhost')) {
+      const redirectUrl = `http://${config.domain}${originalUrl}`;
+      if (config.logging) {
+        console.log(`[Domain Map] ${hostName}:${config.port}${originalUrl} -> ${redirectUrl}`);
+      }
+      res.writeHead(302, { Location: redirectUrl });
+      res.end();
+      return;
+    }
 
     // Find matching client based on basePath
     const matchedClient = normalizedClients.find(c => c.basePath && originalUrl.startsWith(c.basePath)) || normalizedClients.find(c => !c.basePath);

package/src/types.ts

@@ -72,6 +72,7 @@ export type ElementFactory = {
 
 import type { Server } from 'http';
 import type { WebSocketServer } from 'ws';
+import { DatabaseConfig } from './database';
 
 // Forward declarations to avoid circular dependency
 export type Router = import('./server').ServerRouter;
@@ -129,6 +130,8 @@ export interface DevServerOptions {
     port?: number;
     /** Host to bind to (default: 'localhost') */
     host?: string;
+    /** Domain to map (e.g., 'idevcoder.com') - redirects domain traffic to this server's port */
+    domain?: string;
     /** Root directory to serve files from */
     root?: string;
     /** Base path for the client application (e.g., '/app1', '/app2') */
@@ -159,6 +162,8 @@ export interface DevServerOptions {
     mode?: 'dev' | 'preview';
     /** Environment variables to inject (prefix with VITE_ for client access) */
     env?: Record<string, string>;
+    /** List of database directories to load */
+    database?: DatabaseConfig;
 }
 
 export interface DevServer {
@@ -239,6 +244,8 @@ export interface PreviewOptions {
     port?: number;
     /** Host to bind to (default: 'localhost') */
     host?: string;
+    /** Domain to map (e.g., 'idevcoder.com') - redirects domain traffic to this server's port */
+    domain?: string;
     /** Root directory to serve files from (default: dist or build.outDir) */
     root?: string;
     /** Base path for the application (e.g., '/app') */