@siddharatha/adapter-node-rolldown 1.0.0

package/files/index.js

@@ -0,0 +1,217 @@
+import { createServer } from 'node:http';
+import polka from 'polka';
+import { config } from 'ENV';
+import { initTelemetry, shutdownTelemetry } from 'TELEMETRY';
+import { createCompressionMiddleware, createStaticMiddleware, createBodyParser } from 'MIDDLEWARES';
+import { handler } from 'HANDLER';
+
+// WebSocket support
+let wss = null;
+if (config.websocket.enabled) {
+    const { WebSocketServer } = await import('ws');
+    wss = WebSocketServer;
+}
+
+// Track server state
+let isShuttingDown = false;
+let server = null;
+let wsServer = null;
+
+// Export for instrumentation support
+export const path = '/';
+export let port = config.port;
+export let host = config.host;
+export { server };
+
+/**
+ * Initialize and start the server
+ */
+async function start() {
+    console.log('Starting SvelteKit high-performance server...');
+
+    // Initialize OpenTelemetry first (for request tracing)
+    await initTelemetry();
+
+    // Create HTTP server
+    server = createServer();
+
+    // Configure server performance settings
+    server.keepAliveTimeout = config.keepAliveTimeout;
+    server.headersTimeout = config.headersTimeout;
+    if (config.maxRequestsPerSocket) {
+        server.maxRequestsPerSocket = config.maxRequestsPerSocket;
+    }
+
+    // Create Polka app
+    const app = polka({ server });
+
+    // Health check endpoints (before other middleware)
+    if (config.healthCheck.enabled) {
+        app.get('/health', (req, res) => {
+            if (isShuttingDown) {
+                res.writeHead(503, { 'Content-Type': 'text/plain' });
+                res.end('Shutting down');
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end('OK');
+        });
+
+        app.get('/readiness', async (req, res) => {
+            if (isShuttingDown) {
+                res.writeHead(503, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'not ready', reason: 'shutting down' }));
+                return;
+            }
+
+            // Add custom readiness checks here (database, cache, etc.)
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ready' }));
+        });
+    }
+
+    // Apply compression middleware
+    app.use(createCompressionMiddleware());
+
+    // Apply body parser
+    app.use(createBodyParser());
+
+    // Serve prerendered pages and static assets
+    app.use(createStaticMiddleware('client', true));
+    app.use(createStaticMiddleware('prerendered', false));
+
+    // Handle all other requests with SvelteKit
+    app.use((req, res) => {
+        // Convert Polka request to format expected by SvelteKit
+        handler(req, res);
+    });
+
+    // Initialize WebSocket server if enabled
+    if (config.websocket.enabled && wss) {
+        wsServer = new wss({
+            server,
+            path: config.websocket.path
+        });
+
+        wsServer.on('connection', (ws, req) => {
+            console.log(`WebSocket connection established: ${req.url}`);
+
+            ws.on('message', (data) => {
+                // Handle WebSocket messages
+                // You can add custom logic here or expose via hooks
+                try {
+                    const message = JSON.parse(data.toString());
+                    console.log('WebSocket message:', message);
+
+                    // Echo back for now (customize as needed)
+                    ws.send(JSON.stringify({ type: 'echo', data: message }));
+                } catch (error) {
+                    console.error('WebSocket message error:', error);
+                    ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' }));
+                }
+            });
+
+            ws.on('close', () => {
+                console.log('WebSocket connection closed');
+            });
+
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+            });
+
+            // Send welcome message
+            ws.send(JSON.stringify({ type: 'connected', message: 'WebSocket connected' }));
+        });
+
+        console.log(`WebSocket server enabled on path: ${config.websocket.path}`);
+    }
+
+    // Start listening
+    server.listen(config.port, config.host, () => {
+        console.log(`\n✓ Server running on http://${config.host}:${config.port}`);
+        console.log(`  - Compression: ${config.compression ? 'enabled' : 'disabled'}`);
+        console.log(`  - WebSocket: ${config.websocket.enabled ? `enabled (${config.websocket.path})` : 'disabled'}`);
+        console.log(`  - OpenTelemetry: ${config.telemetry.enabled ? 'enabled' : 'disabled'}`);
+        console.log(`  - Health checks: ${config.healthCheck.enabled ? 'enabled (/health, /readiness)' : 'disabled'}`);
+        console.log(`  - Body limit: ${config.bodyLimit}`);
+        console.log('');
+    });
+}
+
+/**
+ * Graceful shutdown handler
+ */
+async function gracefulShutdown(signal) {
+    if (isShuttingDown) {
+        console.log('Shutdown already in progress...');
+        return;
+    }
+
+    isShuttingDown = true;
+    console.log(`\n${signal} received, starting graceful shutdown...`);
+
+    // Set a timeout to force shutdown
+    const forceShutdownTimer = setTimeout(() => {
+        console.error('Forced shutdown after timeout');
+        process.exit(1);
+    }, config.gracefulShutdownTimeout);
+
+    try {
+        // Stop accepting new connections
+        if (server) {
+            await new Promise((resolve) => {
+                server.close(() => {
+                    console.log('✓ HTTP server closed');
+                    resolve();
+                });
+            });
+        }
+
+        // Close WebSocket connections
+        if (wsServer) {
+            console.log('Closing WebSocket connections...');
+            wsServer.clients.forEach((ws) => {
+                ws.close(1001, 'Server shutting down');
+            });
+
+            await new Promise((resolve) => {
+                wsServer.close(() => {
+                    console.log('✓ WebSocket server closed');
+                    resolve();
+                });
+            });
+        }
+
+        // Shutdown OpenTelemetry and flush traces
+        await shutdownTelemetry();
+
+        clearTimeout(forceShutdownTimer);
+        console.log('✓ Graceful shutdown complete');
+        process.exit(0);
+    } catch (error) {
+        console.error('Error during shutdown:', error);
+        clearTimeout(forceShutdownTimer);
+        process.exit(1);
+    }
+}
+
+// Register shutdown handlers
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    console.error('Uncaught exception:', error);
+    gracefulShutdown('UNCAUGHT_EXCEPTION');
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled rejection at:', promise, 'reason:', reason);
+    gracefulShutdown('UNHANDLED_REJECTION');
+});
+
+// Start the server
+start().catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});

package/files/middlewares.js

@@ -0,0 +1,162 @@
+import compression from 'compression';
+import sirv from 'sirv';
+import { config } from 'ENV';
+
+/**
+ * Create compression middleware with optimized settings
+ */
+export function createCompressionMiddleware() {
+    if (!config.compression) {
+        return (req, res, next) => next();
+    }
+
+    return compression({
+        level: config.compressionLevel,
+        threshold: 1024, // Only compress responses > 1KB
+        memLevel: 8,
+        filter: (req, res) => {
+            const contentType = res.getHeader('Content-Type');
+
+            // Don't compress images, videos, or already compressed content
+            if (contentType && (
+                contentType.includes('image/') ||
+                contentType.includes('video/') ||
+                contentType.includes('audio/') ||
+                contentType.includes('font/')
+            )) {
+                return false;
+            }
+
+            // Use default compression filter for everything else
+            return compression.filter(req, res);
+        }
+    });
+}
+
+/**
+ * Create static file serving middleware with optimized settings
+ */
+export function createStaticMiddleware(dir, precompressed = true) {
+    return sirv(dir, {
+        dev: false,
+        etag: true,
+        maxAge: 31536000, // 1 year for immutable assets
+        immutable: true,
+        gzip: precompressed, // Serve .gz files if available
+        brotli: precompressed, // Serve .br files if available
+        setHeaders: (res, pathname) => {
+            // Cache control based on file type
+            if (pathname.includes('immutable')) {
+                res.setHeader('Cache-Control', 'public, immutable, max-age=31536000');
+            } else if (pathname.endsWith('.html')) {
+                res.setHeader('Cache-Control', 'public, max-age=0, must-revalidate');
+            } else {
+                res.setHeader('Cache-Control', 'public, max-age=3600');
+            }
+        }
+    });
+}
+
+/**
+ * Simple body parser for JSON and URL-encoded data with configurable limits
+ */
+export function createBodyParser() {
+    const limitBytes = parseLimit(config.bodyLimit);
+
+    return (req, res, next) => {
+        // Skip if not a body method
+        if (req.method !== 'POST' && req.method !== 'PUT' && req.method !== 'PATCH') {
+            return next();
+        }
+
+        // Skip if body already parsed
+        if (req.body) {
+            return next();
+        }
+
+        const contentType = req.headers['content-type'] || '';
+
+        // Skip if not JSON or form data (SvelteKit will handle FormData/multipart)
+        if (!contentType.includes('application/json') &&
+            !contentType.includes('application/x-www-form-urlencoded')) {
+            return next();
+        }
+
+        let data = '';
+        let size = 0;
+
+        req.on('data', chunk => {
+            size += chunk.length;
+            if (size > limitBytes) {
+                req.removeAllListeners('data');
+                req.removeAllListeners('end');
+                res.writeHead(413, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Request body too large' }));
+                return;
+            }
+            data += chunk.toString();
+        });
+
+        req.on('end', () => {
+            try {
+                if (contentType.includes('application/json')) {
+                    req.body = data ? JSON.parse(data) : {};
+                } else if (contentType.includes('application/x-www-form-urlencoded')) {
+                    req.body = parseUrlEncoded(data);
+                }
+            } catch (error) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid request body' }));
+                return;
+            }
+            next();
+        });
+
+        req.on('error', (error) => {
+            console.error('Body parse error:', error);
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request error' }));
+        });
+    };
+}
+
+/**
+ * Parse size limit string to bytes
+ */
+function parseLimit(limit) {
+    if (typeof limit === 'number') return limit;
+
+    const match = limit.match(/^(\d+(?:\.\d+)?)\s*(kb|mb|gb)?$/i);
+    if (!match) return 10 * 1024 * 1024; // Default 10MB
+
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'b').toLowerCase();
+
+    const multipliers = {
+        b: 1,
+        kb: 1024,
+        mb: 1024 * 1024,
+        gb: 1024 * 1024 * 1024
+    };
+
+    return value * (multipliers[unit] || 1);
+}
+
+/**
+ * Parse URL-encoded form data
+ */
+function parseUrlEncoded(str) {
+    const obj = {};
+    const pairs = str.split('&');
+
+    for (const pair of pairs) {
+        const [key, value] = pair.split('=');
+        if (key) {
+            const decodedKey = decodeURIComponent(key);
+            const decodedValue = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';
+            obj[decodedKey] = decodedValue;
+        }
+    }
+
+    return obj;
+}

package/files/shims.js

@@ -0,0 +1,6 @@
+// Polyfills for Node.js environment
+import { installPolyfills } from '@sveltejs/kit/node/polyfills';
+
+if (JSON.parse('POLYFILL')) {
+    installPolyfills();
+}

package/files/telemetry.js

@@ -0,0 +1,126 @@
+import { config } from 'ENV';
+
+let sdk = null;
+
+/**
+ * Initialize OpenTelemetry SDK for distributed tracing
+ */
+export async function initTelemetry() {
+    if (!config.telemetry.enabled) {
+        console.log('OpenTelemetry is disabled');
+        return null;
+    }
+
+    try {
+        // Dynamic imports to avoid loading if telemetry is disabled
+        const { NodeSDK } = await import('@opentelemetry/sdk-node');
+        const { getNodeAutoInstrumentations } = await import('@opentelemetry/auto-instrumentations-node');
+        const { Resource } = await import('@opentelemetry/resources');
+        const { SemanticResourceAttributes } = await import('@opentelemetry/semantic-conventions');
+
+        // Choose exporter based on protocol
+        let TraceExporter;
+        if (config.telemetry.protocol === 'grpc') {
+            const module = await import('@opentelemetry/exporter-trace-otlp-grpc');
+            TraceExporter = module.OTLPTraceExporter;
+        } else {
+            const module = await import('@opentelemetry/exporter-trace-otlp-http');
+            TraceExporter = module.OTLPTraceExporter;
+        }
+
+        const exporterConfig = {
+            url: config.telemetry.endpoint,
+            headers: {}
+        };
+
+        // Add Dynatrace API token if provided
+        if (config.telemetry.dynatraceToken) {
+            exporterConfig.headers['Authorization'] = `Api-Token ${config.telemetry.dynatraceToken}`;
+        }
+
+        // Merge custom headers from config
+        if (config.telemetry.customConfig.headers) {
+            Object.assign(exporterConfig.headers, config.telemetry.customConfig.headers);
+        }
+
+        sdk = new NodeSDK({
+            resource: new Resource({
+                [SemanticResourceAttributes.SERVICE_NAME]: config.telemetry.serviceName,
+                [SemanticResourceAttributes.SERVICE_VERSION]: config.telemetry.serviceVersion,
+                ...config.telemetry.customConfig.resourceAttributes
+            }),
+            traceExporter: new TraceExporter(exporterConfig),
+            instrumentations: [
+                getNodeAutoInstrumentations({
+                    // Disable noisy instrumentations
+                    '@opentelemetry/instrumentation-fs': {
+                        enabled: false
+                    },
+                    '@opentelemetry/instrumentation-http': {
+                        enabled: true,
+                        ignoreIncomingPaths: ['/health', '/readiness'],
+                        ignoreOutgoingUrls: [/\/health$/, /\/readiness$/]
+                    },
+                    '@opentelemetry/instrumentation-dns': {
+                        enabled: false
+                    },
+                    // Enable all others by default
+                    ...config.telemetry.customConfig.instrumentations
+                })
+            ],
+            // Sampling configuration
+            ...(config.telemetry.sampleRate < 1.0 && {
+                sampler: {
+                    shouldSample: () => {
+                        return Math.random() < config.telemetry.sampleRate
+                            ? { decision: 1 } // RECORD_AND_SAMPLED
+                            : { decision: 0 }; // NOT_RECORD
+                    }
+                }
+            })
+        });
+
+        await sdk.start();
+        console.log('OpenTelemetry SDK initialized successfully');
+        console.log(`  Service: ${config.telemetry.serviceName}`);
+        console.log(`  Endpoint: ${config.telemetry.endpoint || 'default'}`);
+        console.log(`  Protocol: ${config.telemetry.protocol}`);
+        console.log(`  Sample Rate: ${(config.telemetry.sampleRate * 100).toFixed(1)}%`);
+
+        return sdk;
+    } catch (error) {
+        console.error('Failed to initialize OpenTelemetry:', error.message);
+        return null;
+    }
+}
+
+/**
+ * Shutdown telemetry SDK and flush remaining spans
+ */
+export async function shutdownTelemetry() {
+    if (sdk) {
+        console.log('Shutting down OpenTelemetry SDK...');
+        try {
+            await sdk.shutdown();
+            console.log('OpenTelemetry SDK shutdown complete');
+        } catch (error) {
+            console.error('Error shutting down OpenTelemetry:', error.message);
+        }
+    }
+}
+
+/**
+ * Get tracer for custom instrumentation
+ */
+export function getTracer(name = 'sveltekit-adapter') {
+    if (!config.telemetry.enabled) {
+        return null;
+    }
+
+    try {
+        const { trace } = require('@opentelemetry/api');
+        return trace.getTracer(name);
+    } catch {
+        return null;
+    }
+}

package/index.d.ts

@@ -0,0 +1,125 @@
+export interface AdapterOptions {
+    /**
+     * Output directory for the build
+     * @default 'build'
+     */
+    out?: string;
+
+    /**
+     * Pre-compress static assets with gzip and brotli
+     * @default true
+     */
+    precompress?: boolean;
+
+    /**
+     * Prefix for environment variables
+     * @default ''
+     */
+    envPrefix?: string;
+
+    /**
+     * Enable runtime compression middleware
+     * @default true
+     */
+    compression?: boolean;
+
+    /**
+     * Compression level (1-9, where 9 is maximum compression)
+     * @default 6
+     */
+    compressionLevel?: number;
+
+    /**
+     * Maximum request body size
+     * @default '10mb'
+     */
+    bodyLimit?: string | number;
+
+    /**
+     * Enable WebSocket support
+     * @default true
+     */
+    websocket?: boolean;
+
+    /**
+     * WebSocket endpoint path
+     * @default '/ws'
+     */
+    websocketPath?: string;
+
+    /**
+     * Enable OpenTelemetry tracing
+     * @default true
+     */
+    telemetry?: boolean;
+
+    /**
+     * Additional OpenTelemetry configuration
+     */
+    telemetryConfig?: {
+        /**
+         * Custom resource attributes
+         */
+        resourceAttributes?: Record<string, string>;
+
+        /**
+         * Custom HTTP headers for exporter
+         */
+        headers?: Record<string, string>;
+
+        /**
+         * Instrumentation-specific configuration
+         */
+        instrumentations?: Record<string, any>;
+    };
+
+    /**
+     * Telemetry sampling rate (0.0 to 1.0)
+     * @default 1.0
+     */
+    telemetrySampleRate?: number;
+
+    /**
+     * Enable health check endpoints (/health, /readiness)
+     * @default true
+     */
+    healthCheck?: boolean;
+
+    /**
+     * Graceful shutdown timeout in milliseconds
+     * @default 30000
+     */
+    gracefulShutdownTimeout?: number;
+
+    /**
+     * Inject global polyfills (fetch, Headers, etc.)
+     * @default true
+     */
+    polyfill?: boolean;
+
+    /**
+     * External packages to exclude from bundle.
+     * Can be an array of package names or a function that receives package.json and returns an array.
+     * If not specified, uses package.json dependencies by default.
+     * @default undefined
+     * @example
+     * // Array of package names
+     * external: ['polka', 'sirv']
+     * 
+     * // Function to dynamically determine externals
+     * external: (pkg) => [...Object.keys(pkg.dependencies), 'some-other-package']
+     */
+    external?: string[] | ((pkg: any) => string[]);
+
+    /**
+     * Bundle all dependencies (ignore package.json dependencies).
+     * When true, all code including node_modules will be bundled.
+     * @default false
+     */
+    bundleAll?: boolean;
+
+    /**
+     * Additional rolldown configuration options.
+     * These will be merged with the default rolldown config.
+     */
+    rolldownOptions?: Record<string, any>;