@iskra-bun/web-kit 0.1.0

package/src/kernel.ts

@@ -0,0 +1,257 @@
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { Context, Next } from "hono";
+import type { Feature, KernelConfig } from "./types";
+
+/**
+ * Core microkernel orchestrator that manages features, dependencies, and application lifecycle.
+ */
+export class Kernel {
+    private app: Hono;
+    private config: KernelConfig;
+    private features: Map<string, Feature> = new Map();
+    private initialized = false;
+
+    constructor(config: KernelConfig = {}) {
+        this.config = {
+            port: 8000,
+            hostname: "localhost",
+            ...config,
+        };
+        this.app = new Hono();
+
+        // Add default error handler for HTTPException
+        this.app.onError((err: Error, c: Context): Response | Promise<Response> => {
+            if (err instanceof HTTPException) {
+                return c.json(
+                    { message: err.message },
+                    err.status,
+                );
+            }
+
+            console.error("Unhandled error:", err);
+            return c.json(
+                { message: "Internal Server Error" },
+                500,
+            );
+        });
+    }
+
+    async initialize(): Promise<void> {
+        if (this.initialized) {
+            throw new Error("Kernel already initialized");
+        }
+
+        console.log("🚀 Initializing Web-Kit Kernel...");
+
+        this.validateFeatureDependencies();
+        await this.validatePeerDependencies();
+        this.applySecurityHeaders();
+
+        const orderedFeatures = this.sortFeaturesByDependencies();
+        for (const feature of orderedFeatures) {
+            await this.initializeFeature(feature);
+        }
+
+        this.initialized = true;
+        console.log("✅ Web-Kit Kernel initialized");
+    }
+
+    private applySecurityHeaders(): void {
+        if (!this.config.securityHeaders) {
+            this.config.securityHeaders = {
+                xFrameOptions: "SAMEORIGIN",
+                xContentTypeOptions: true,
+                xXssProtection: true,
+                referrerPolicy: "strict-origin-when-cross-origin",
+            };
+        }
+
+        const headers = this.config.securityHeaders;
+
+        this.app.use("*", async (c: Context, next: Next) => {
+            await next();
+
+            if (headers.xFrameOptions) {
+                c.res.headers.set("X-Frame-Options", headers.xFrameOptions);
+            }
+            if (headers.xContentTypeOptions) {
+                c.res.headers.set("X-Content-Type-Options", "nosniff");
+            }
+            if (headers.xXssProtection) {
+                c.res.headers.set("X-XSS-Protection", "1; mode=block");
+            }
+            if (headers.referrerPolicy) {
+                c.res.headers.set("Referrer-Policy", headers.referrerPolicy);
+            }
+            if (headers.strictTransportSecurity) {
+                const hsts = headers.strictTransportSecurity;
+                let hstsValue = `max-age=${hsts.maxAge || 31536000}`;
+                if (hsts.includeSubDomains) hstsValue += "; includeSubDomains";
+                if (hsts.preload) hstsValue += "; preload";
+                c.res.headers.set("Strict-Transport-Security", hstsValue);
+            }
+            if (headers.contentSecurityPolicy) {
+                if (typeof headers.contentSecurityPolicy === "string") {
+                    c.res.headers.set(
+                        "Content-Security-Policy",
+                        headers.contentSecurityPolicy,
+                    );
+                } else if (headers.contentSecurityPolicy.directives) {
+                    const directives = Object.entries(
+                        headers.contentSecurityPolicy.directives,
+                    )
+                        .map(([key, value]) => {
+                            const values = Array.isArray(value) ? value.join(" ") : value;
+                            return `${key} ${values}`;
+                        })
+                        .join("; ");
+                    c.res.headers.set("Content-Security-Policy", directives);
+                }
+            }
+            if (headers.permissionsPolicy) {
+                const policy = Object.entries(headers.permissionsPolicy)
+                    .map(([key, value]) => `${key}=(${value.join(" ")})`)
+                    .join(", ");
+                c.res.headers.set("Permissions-Policy", policy);
+            }
+        });
+    }
+
+    registerFeature(feature: Feature): void {
+        if (this.initialized) {
+            throw new Error("Cannot register features after initialization");
+        }
+
+        if (feature.peerDependencies) {
+            for (const dep of feature.peerDependencies) {
+                try {
+                    import(dep);
+                } catch {
+                    console.warn(
+                        `⚠️  Warning: Feature '${feature.name}' requires peer dependency: ${dep}`,
+                    );
+                }
+            }
+        }
+
+        this.features.set(feature.name, feature);
+        console.log(`📦 Registered feature: ${feature.name}`);
+    }
+
+    private validateFeatureDependencies(): void {
+        for (const [name, feature] of this.features) {
+            if (feature.dependencies) {
+                for (const dep of feature.dependencies) {
+                    if (!this.features.has(dep)) {
+                        throw new Error(
+                            `Feature '${name}' requires feature '${dep}' which is not registered`,
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    private async validatePeerDependencies(): Promise<void> {
+        for (const [featureName, feature] of this.features) {
+            if (feature.peerDependencies) {
+                for (const dep of feature.peerDependencies) {
+                    // In Node/Bun dynamic import usually works for installed packages
+                    // We can skip hard failure here or make it safer
+                }
+            }
+        }
+    }
+
+    private sortFeaturesByDependencies(): Feature[] {
+        const sorted: Feature[] = [];
+        const visited = new Set<string>();
+        const visiting = new Set<string>();
+
+        const visit = (name: string) => {
+            if (visited.has(name)) return;
+            if (visiting.has(name)) {
+                throw new Error(`Circular dependency detected for feature: ${name}`);
+            }
+
+            visiting.add(name);
+            const feature = this.features.get(name)!;
+
+            if (feature.dependencies) {
+                for (const dep of feature.dependencies) {
+                    visit(dep);
+                }
+            }
+
+            visiting.delete(name);
+            visited.add(name);
+            sorted.push(feature);
+        };
+
+        for (const name of this.features.keys()) {
+            visit(name);
+        }
+
+        return sorted;
+    }
+
+    private async initializeFeature(feature: Feature): Promise<void> {
+        console.log(`⚙️  Initializing feature: ${feature.name}`);
+        await feature.initialize(this);
+
+        if (feature.routes) {
+            feature.routes(this.app);
+        }
+    }
+
+    getApp(): Hono {
+        return this.app;
+    }
+
+    getFeature<T extends Feature>(name: string): T | undefined {
+        return this.features.get(name) as T;
+    }
+
+    private server: any;
+
+    async start(): Promise<void> {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+
+        // Iskra uses Bun, so we can use Bun.serve
+        // Hono handles this automatically if using the right adapter or just passing app.fetch to Bun.serve
+        // But let's assume standard Bun usage from the user
+        console.log(
+            `🌐 Server running at http://${this.config.hostname}:${this.config.port}`,
+        );
+
+        if (typeof Bun !== "undefined") {
+            this.server = Bun.serve({
+                port: this.config.port,
+                hostname: this.config.hostname,
+                fetch: this.app.fetch,
+            });
+        } else {
+            console.warn("Not running in Bun, start() might strictly need an adapter.");
+        }
+    }
+
+    async shutdown(): Promise<void> {
+        console.log("🛑 Shutting down...");
+
+        if (this.server) {
+            this.server.stop();
+            this.server = null;
+        }
+
+        const features = Array.from(this.features.values()).reverse();
+        for (const feature of features) {
+            if (feature.shutdown) {
+                await feature.shutdown();
+            }
+        }
+        console.log("👋 Server shut down gracefully");
+    }
+}

package/src/responses.ts

@@ -0,0 +1,37 @@
+export interface SuccessResponse<T = unknown> {
+    success: true;
+    data?: T;
+    message?: string;
+}
+
+export interface ErrorResponse {
+    success: false;
+    error: string;
+    code?: string;
+    details?: unknown;
+    timestamp?: string;
+}
+
+export type ApiResponse<T = unknown> = SuccessResponse<T> | ErrorResponse;
+
+export function successResponse<T = unknown>(data?: T, message?: string): SuccessResponse<T> {
+    const response: SuccessResponse<T> = { success: true };
+    if (data !== undefined) response.data = data;
+    if (message) response.message = message;
+    return response;
+}
+
+export function errorResponse(error: string | Error, code?: string, details?: unknown): ErrorResponse {
+    const message = error instanceof Error ? error.message : error;
+    const response: ErrorResponse = {
+        success: false,
+        error: message,
+        timestamp: new Date().toISOString(),
+    };
+    if (code) response.code = code;
+    if (details !== undefined) response.details = details;
+    return response;
+}
+
+// Re-exportado desde @iskra-bun/core para compatibilidad
+export { ErrorCodes, type ErrorCode } from '@iskra-bun/core';

package/src/router.ts

@@ -0,0 +1,31 @@
+import type { Hono, Context } from 'hono';
+import { z } from 'zod';
+import { zValidator } from '@hono/zod-validator';
+import type { App } from '@iskra-bun/core';
+import type { Driver } from '@iskra-bun/core';
+
+export interface RouteOptions<B = any, Q = any> {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    schema?: {
+        body?: z.ZodType<B>;
+        query?: z.ZodType<Q>;
+        params?: z.ZodType;
+    };
+    handler: (ctx: WebContext<B, Q>) => Promise<any> | any;
+    doc?: {
+        summary?: string;
+        tags?: string[];
+        description?: string;
+    };
+}
+
+export interface WebContext<B = any, Q = any> {
+    raw: Context;
+    body: B;
+    query: Q;
+    params: Record<string, string>;
+    app: App;
+}
+
+export const createRouter = (routes: RouteOptions[]) => routes;

package/src/server.ts

@@ -0,0 +1,135 @@
+import { OpenAPIHono, createRoute } from '@hono/zod-openapi';
+import { z } from 'zod';
+import type { Driver, App } from '@iskra-bun/core';
+import type { RouteOptions } from './router';
+
+export interface WebServerOptions {
+    port?: number;
+    routes?: RouteOptions[];
+    debug?: boolean;
+    openApi?: {
+        path: string;
+        title: string;
+        version: string;
+    };
+}
+
+export class WebDriver implements Driver {
+    name = 'WebDriver';
+    private app: App | null = null;
+    private server: OpenAPIHono;
+    private options: WebServerOptions;
+    private runningServer: any;
+
+    constructor(options: WebServerOptions = {}) {
+        this.options = options;
+        this.server = new OpenAPIHono();
+    }
+
+    init(app: App) {
+        this.app = app;
+        this.setupRoutes();
+        this.setupOpenApi();
+    }
+
+    private setupOpenApi() {
+        if (this.options.openApi) {
+            this.server.doc(this.options.openApi.path, {
+                openapi: '3.0.0',
+                info: {
+                    version: this.options.openApi.version,
+                    title: this.options.openApi.title,
+                },
+            });
+        }
+    }
+
+    private setupRoutes() {
+        if (!this.options.routes) return;
+
+        for (const route of this.options.routes) {
+            // Map simple RouteOptions to OpenAPI RouteConfig
+            // We assume JSON for body
+
+            const routeConfig: any = {
+                method: route.method.toLowerCase(),
+                path: route.path,
+                tags: route.doc?.tags,
+                summary: route.doc?.summary,
+                description: route.doc?.description,
+                request: {},
+                responses: {
+                    200: {
+                        description: 'Successful response',
+                        content: {
+                            'application/json': {
+                                schema: z.any() // We don't enforce response schema yet
+                            }
+                        }
+                    },
+                    500: {
+                        description: 'Internal Server Error'
+                    }
+                }
+            };
+
+            if (route.schema?.body) {
+                routeConfig.request.body = {
+                    content: {
+                        'application/json': {
+                            schema: route.schema.body
+                        }
+                    }
+                };
+            }
+            if (route.schema?.query) {
+                routeConfig.request.query = route.schema.query;
+            }
+            if (route.schema?.params) {
+                routeConfig.request.params = route.schema.params;
+            }
+
+            const openApiRoute = createRoute(routeConfig);
+
+            this.server.openapi(openApiRoute, async (c) => {
+                if (!this.app) throw new Error('App not initialized');
+
+                const webCtx = {
+                    raw: c,
+                    // Hono/zod-openapi puts validated data in c.req.valid('json') etc similar to validator middleware
+                    body: route.schema?.body ? (c as any).req.valid('json') : undefined,
+                    query: route.schema?.query ? (c as any).req.valid('query') : undefined,
+                    params: c.req.param(),
+                    app: this.app
+                };
+
+                try {
+                    const result = await route.handler(webCtx);
+                    if (result instanceof Response) return result;
+                    return c.json(result);
+                } catch (err: any) {
+                    this.app.logger.error(err);
+                    return c.json({ error: err.message }, 500);
+                }
+            });
+        }
+    }
+
+    start() {
+        const port = this.options.port || 3000;
+        this.app?.logger.info(`Starting WebServer on port ${port}...`);
+
+        // Bun.serve works with OpenAPIHono just like Hono
+        this.runningServer = Bun.serve({
+            fetch: this.server.fetch,
+            port
+        });
+    }
+
+    stop() {
+        if (this.runningServer) {
+            this.runningServer.stop();
+        }
+        this.app?.logger.info('WebServer stopped');
+    }
+}