s3db.js 19.3.17 → 19.3.19

package/dist/clients/recker-http-handler.js

@@ -159,10 +159,15 @@ export class ReckerHttpHandler {
             connectTimeout: 10000,
             headersTimeout: 30000,
             bodyTimeout: 60000,
+            keepAlive: options.keepAlive ?? true,
             keepAliveTimeout: 4000,
             keepAliveMaxTimeout: 600000,
+            keepAliveTimeoutThreshold: 1000,
             connections: 100,
             pipelining: 10,
+            maxRequestsPerClient: 100,
+            clientTtl: null,
+            maxCachedSessions: 100,
             http2: true,
             http2MaxConcurrentStreams: 100,
             http2Preset: 'performance', // Default to performance preset for S3 workloads
@@ -204,9 +209,14 @@ export class ReckerHttpHandler {
                 agent: {
                     connections: this.options.connections,
                     pipelining: this.options.pipelining,
-                    keepAlive: true,
+                    keepAlive: this.options.keepAlive,
                     keepAliveTimeout: this.options.keepAliveTimeout,
                     keepAliveMaxTimeout: this.options.keepAliveMaxTimeout,
+                    keepAliveTimeoutThreshold: this.options.keepAliveTimeoutThreshold,
+                    maxRequestsPerClient: this.options.maxRequestsPerClient,
+                    clientTtl: this.options.clientTtl ?? null,
+                    maxCachedSessions: this.options.maxCachedSessions,
+                    ...(this.options.localAddress ? { localAddress: this.options.localAddress } : {}),
                 },
             },
             hooks,
@@ -350,9 +360,21 @@ export class ReckerHttpHandler {
         };
     }
     destroy() {
+        void this.destroyAsync();
+    }
+    async destroyAsync() {
+        const client = this.client;
         this.client = null;
         this.deduplicator = null;
         this.circuitBreaker = null;
+        if (client) {
+            try {
+                await client.destroy();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
     }
 }
 export default ReckerHttpHandler;

package/dist/clients/s3-client.class.js

@@ -19,6 +19,8 @@ export class S3Client extends EventEmitter {
     connectionString;
     httpClientOptions;
     client;
+    httpHandler = null;
+    _rawHttpClientOptions;
     _inflightCoalescing;
     taskExecutorConfig;
     taskExecutor;
@@ -36,6 +38,7 @@ export class S3Client extends EventEmitter {
         this.id = id ?? idGenerator(77);
         this.config = new ConnectionString(connectionString);
         this.connectionString = connectionString;
+        this._rawHttpClientOptions = httpClientOptions || {};
         this.httpClientOptions = {
             keepAlive: true,
             keepAliveMsecs: 1000,
@@ -99,6 +102,26 @@ export class S3Client extends EventEmitter {
         };
         return normalized;
     }
+    _normalizeHttpHandlerOptions() {
+        const options = this.httpClientOptions;
+        const raw = this._rawHttpClientOptions;
+        const connections = typeof raw.connections === 'number'
+            ? raw.connections
+            : raw.maxSockets;
+        const keepAliveTimeout = raw.keepAliveTimeout ?? raw.keepAliveMsecs;
+        const bodyTimeout = raw.bodyTimeout ?? raw.timeout;
+        const normalized = { ...options };
+        if (connections !== undefined) {
+            normalized.connections = connections;
+        }
+        if (keepAliveTimeout !== undefined) {
+            normalized.keepAliveTimeout = keepAliveTimeout;
+        }
+        if (bodyTimeout !== undefined) {
+            normalized.bodyTimeout = bodyTimeout;
+        }
+        return normalized;
+    }
     _createTasksPool() {
         const poolConfig = {
             concurrency: this.taskExecutorConfig.concurrency,
@@ -200,7 +223,11 @@ export class S3Client extends EventEmitter {
             return;
         this.taskExecutor.stop();
     }
-    destroy() {
+    async destroy() {
+        if (this.httpHandler) {
+            await this.httpHandler.destroyAsync();
+            this.httpHandler = null;
+        }
         if (this.client && typeof this.client.destroy === 'function') {
             this.client.destroy();
         }
@@ -208,11 +235,11 @@ export class S3Client extends EventEmitter {
         this.removeAllListeners();
     }
     createClient() {
-        const httpHandler = new ReckerHttpHandler(this.httpClientOptions);
+        this.httpHandler = new ReckerHttpHandler(this._normalizeHttpHandlerOptions());
         const options = {
             region: this.config.region,
             endpoint: this.config.endpoint,
-            requestHandler: httpHandler,
+            requestHandler: this.httpHandler,
         };
         if (this.config.forcePathStyle)
             options.forcePathStyle = true;

package/dist/concerns/async-event-emitter.js

@@ -47,6 +47,9 @@ export class AsyncEventEmitter extends EventEmitter {
     setAsyncMode(enabled) {
         this._asyncMode = enabled;
     }
+    destroy() {
+        this.removeAllListeners();
+    }
 }
 export default AsyncEventEmitter;
 //# sourceMappingURL=async-event-emitter.js.map

package/dist/database/database-connection.class.js

@@ -199,7 +199,7 @@ export class DatabaseConnection {
                     db.client.removeAllListeners();
                 }
                 if (typeof db.client.destroy === 'function') {
-                    db.client.destroy();
+                    await db.client.destroy();
                 }
             }
             await db.emit('db:disconnected', new Date());

package/dist/plugins/api/server.js

@@ -46,6 +46,7 @@ export class ApiServer {
     _signalHandlersSetup = false;
     _boundSigtermHandler = null;
     _boundSigintHandler = null;
+    _metricsListeners = new Map();
     constructor(options = {}) {
         this.options = {
             port: options.port || 3000,
@@ -351,6 +352,7 @@ export class ApiServer {
         if (this.metrics) {
             this.metrics.stop();
         }
+        this._removeMetricsEventListeners();
         if (this.failban) {
             await this.failban.cleanup();
         }
@@ -483,60 +485,84 @@ export class ApiServer {
         }
     }
     _setupMetricsEventListeners() {
-        this.events.on('request:end', (data) => {
+        const requestEndHandler = (data) => {
             this.metrics.recordRequest({
                 method: data.method,
                 path: data.path,
                 status: data.status,
                 duration: data.duration
             });
-        });
-        this.events.on('request:error', (data) => {
+        };
+        this._metricsListeners.set('request:end', requestEndHandler);
+        this.events.on('request:end', requestEndHandler);
+        const requestErrorHandler = (data) => {
             this.metrics.recordError({
                 error: data.error.message,
                 type: 'request'
             });
-        });
-        this.events.on('auth:success', (data) => {
+        };
+        this._metricsListeners.set('request:error', requestErrorHandler);
+        this.events.on('request:error', requestErrorHandler);
+        const authSuccessHandler = (data) => {
             this.metrics.recordAuth({
                 success: true,
                 method: data.method
             });
-        });
-        this.events.on('auth:failure', (data) => {
+        };
+        this._metricsListeners.set('auth:success', authSuccessHandler);
+        this.events.on('auth:success', authSuccessHandler);
+        const authFailureHandler = (data) => {
             this.metrics.recordAuth({
                 success: false,
                 method: data.allowedMethods?.[0] || 'unknown'
             });
-        });
-        this.events.on('resource:created', (data) => {
+        };
+        this._metricsListeners.set('auth:failure', authFailureHandler);
+        this.events.on('auth:failure', authFailureHandler);
+        const resourceCreatedHandler = (data) => {
             this.metrics.recordResourceOperation({
                 action: 'created',
                 resource: data.resource
             });
-        });
-        this.events.on('resource:updated', (data) => {
+        };
+        this._metricsListeners.set('resource:created', resourceCreatedHandler);
+        this.events.on('resource:created', resourceCreatedHandler);
+        const resourceUpdatedHandler = (data) => {
             this.metrics.recordResourceOperation({
                 action: 'updated',
                 resource: data.resource
             });
-        });
-        this.events.on('resource:deleted', (data) => {
+        };
+        this._metricsListeners.set('resource:updated', resourceUpdatedHandler);
+        this.events.on('resource:updated', resourceUpdatedHandler);
+        const resourceDeletedHandler = (data) => {
             this.metrics.recordResourceOperation({
                 action: 'deleted',
                 resource: data.resource
             });
-        });
-        this.events.on('user:created', () => {
+        };
+        this._metricsListeners.set('resource:deleted', resourceDeletedHandler);
+        this.events.on('resource:deleted', resourceDeletedHandler);
+        const userCreatedHandler = () => {
             this.metrics.recordUserEvent({ action: 'created' });
-        });
-        this.events.on('user:login', () => {
+        };
+        this._metricsListeners.set('user:created', userCreatedHandler);
+        this.events.on('user:created', userCreatedHandler);
+        const userLoginHandler = () => {
             this.metrics.recordUserEvent({ action: 'login' });
-        });
+        };
+        this._metricsListeners.set('user:login', userLoginHandler);
+        this.events.on('user:login', userLoginHandler);
         if (this.options.logLevel) {
             this.logger.debug('Metrics event listeners configured');
         }
     }
+    _removeMetricsEventListeners() {
+        for (const [event, handler] of this._metricsListeners) {
+            this.events.removeListener(event, handler);
+        }
+        this._metricsListeners.clear();
+    }
     _setupDocumentationRoutes() {
         if (this.options.logLevel) {
             this.logger.debug({ docsEnabled: this.options.docsEnabled, docsUI: this.options.docsUI }, 'Setting up documentation routes');

package/dist/plugins/spider/security-analyzer.js

@@ -30,25 +30,28 @@ export class SecurityAnalyzer {
             vulnerabilities: [],
             securityScore: 0
         };
+        let responseHeaders = {};
+        let captureHeaders = null;
+        let consoleListener = null;
+        const consoleLogs = [];
         try {
-            let responseHeaders = {};
-            const captureHeaders = (response) => {
+            captureHeaders = (response) => {
                 if (response.url() === baseUrl || response.url().startsWith(baseUrl)) {
                     const headers = response.headers();
                     responseHeaders = { ...headers };
                 }
             };
             page.on('response', captureHeaders);
-            const consoleLogs = [];
             if (activities.includes('security_console_logs')) {
-                page.on('console', (msg) => {
+                consoleListener = (msg) => {
                     consoleLogs.push({
                         type: msg.type(),
                         text: msg.text(),
                         location: msg.location(),
                         args: msg.args().length
                     });
-                });
+                };
+                page.on('console', consoleListener);
             }
             if (activities.includes('security_headers')) {
                 result.securityHeaders = this._analyzeSecurityHeaders(responseHeaders);
@@ -80,12 +83,19 @@ export class SecurityAnalyzer {
                 result.vulnerabilities = this._checkVulnerabilities(responseHeaders, result);
             }
             result.securityScore = this._calculateSecurityScore(result);
-            page.removeListener('response', captureHeaders);
             return result;
         }
         catch {
             return result;
         }
+        finally {
+            if (captureHeaders) {
+                page.removeListener('response', captureHeaders);
+            }
+            if (consoleListener) {
+                page.removeListener('console', consoleListener);
+            }
+        }
     }
     async analyze(page, baseUrl, html = null) {
         const result = {
@@ -99,25 +109,28 @@ export class SecurityAnalyzer {
             vulnerabilities: [],
             securityScore: 0
         };
+        let responseHeaders = {};
+        let captureHeaders = null;
+        let consoleListener = null;
+        const consoleLogs = [];
         try {
-            let responseHeaders = {};
-            const captureHeaders = (response) => {
+            captureHeaders = (response) => {
                 if (response.url() === baseUrl || response.url().startsWith(baseUrl)) {
                     const headers = response.headers();
                     responseHeaders = { ...headers };
                 }
             };
             page.on('response', captureHeaders);
-            const consoleLogs = [];
             if (this.config.captureConsoleLogs) {
-                page.on('console', (msg) => {
+                consoleListener = (msg) => {
                     consoleLogs.push({
                         type: msg.type(),
                         text: msg.text(),
                         location: msg.location(),
                         args: msg.args().length
                     });
-                });
+                };
+                page.on('console', consoleListener);
             }
             if (this.config.analyzeSecurityHeaders) {
                 result.securityHeaders = this._analyzeSecurityHeaders(responseHeaders);
@@ -147,13 +160,20 @@ export class SecurityAnalyzer {
                 result.vulnerabilities = this._checkVulnerabilities(responseHeaders, result);
             }
             result.securityScore = this._calculateSecurityScore(result);
-            page.removeListener('response', captureHeaders);
             return result;
         }
         catch (error) {
             this.logger?.error('[SecurityAnalyzer] Error during analysis:', error);
             return result;
         }
+        finally {
+            if (captureHeaders) {
+                page.removeListener('response', captureHeaders);
+            }
+            if (consoleListener) {
+                page.removeListener('console', consoleListener);
+            }
+        }
     }
     _analyzeSecurityHeaders(headers) {
         const analysis = {

package/dist/plugins/websocket/server.js

@@ -965,14 +965,23 @@ export class WebSocketServer extends EventEmitter {
             const resource = this.database.resources?.[resourceName];
             if (!resource)
                 continue;
-            const listener = (event, data) => {
-                this._broadcastResourceEvent(resourceName, event, data);
+            const insertListener = (data) => {
+                this._broadcastResourceEvent(resourceName, 'insert', data);
             };
-            // Listen to resource events
-            resource.on('insert', (data) => listener('insert', data));
-            resource.on('update', (data) => listener('update', data));
-            resource.on('delete', (data) => listener('delete', data));
-            this._resourceListeners.set(resourceName, listener);
+            const updateListener = (data) => {
+                this._broadcastResourceEvent(resourceName, 'update', data);
+            };
+            const deleteListener = (data) => {
+                this._broadcastResourceEvent(resourceName, 'delete', data);
+            };
+            resource.on('insert', insertListener);
+            resource.on('update', updateListener);
+            resource.on('delete', deleteListener);
+            this._resourceListeners.set(resourceName, {
+                insert: insertListener,
+                update: updateListener,
+                delete: deleteListener
+            });
         }
     }
     /**
@@ -980,12 +989,12 @@ export class WebSocketServer extends EventEmitter {
      * @private
      */
     _removeResourceListeners() {
-        for (const [resourceName, listener] of this._resourceListeners) {
+        for (const [resourceName, listeners] of this._resourceListeners) {
             const resource = this.database.resources?.[resourceName];
             if (resource) {
-                resource.removeListener('insert', listener);
-                resource.removeListener('update', listener);
-                resource.removeListener('delete', listener);
+                resource.removeListener('insert', listeners.insert);
+                resource.removeListener('update', listeners.update);
+                resource.removeListener('delete', listeners.delete);
             }
         }
         this._resourceListeners.clear();

package/dist/s3db-lite.cjs

@@ -40162,7 +40162,7 @@ function getDefaultUserAgent() {
     return `recker/${VERSION$1}`;
 }
 
-const VERSION = '1.0.66';
+const VERSION = '1.0.68';
 let _version = null;
 async function getVersion() {
     if (_version)
@@ -51197,10 +51197,15 @@ class ReckerHttpHandler {
             connectTimeout: 10000,
             headersTimeout: 30000,
             bodyTimeout: 60000,
+            keepAlive: options.keepAlive ?? true,
             keepAliveTimeout: 4000,
             keepAliveMaxTimeout: 600000,
+            keepAliveTimeoutThreshold: 1000,
             connections: 100,
             pipelining: 10,
+            maxRequestsPerClient: 100,
+            clientTtl: null,
+            maxCachedSessions: 100,
             http2: true,
             http2MaxConcurrentStreams: 100,
             http2Preset: 'performance', // Default to performance preset for S3 workloads
@@ -51242,9 +51247,14 @@ class ReckerHttpHandler {
                 agent: {
                     connections: this.options.connections,
                     pipelining: this.options.pipelining,
-                    keepAlive: true,
+                    keepAlive: this.options.keepAlive,
                     keepAliveTimeout: this.options.keepAliveTimeout,
                     keepAliveMaxTimeout: this.options.keepAliveMaxTimeout,
+                    keepAliveTimeoutThreshold: this.options.keepAliveTimeoutThreshold,
+                    maxRequestsPerClient: this.options.maxRequestsPerClient,
+                    clientTtl: this.options.clientTtl ?? null,
+                    maxCachedSessions: this.options.maxCachedSessions,
+                    ...(this.options.localAddress ? { localAddress: this.options.localAddress } : {}),
                 },
             },
             hooks,
@@ -51388,9 +51398,21 @@ class ReckerHttpHandler {
         };
     }
     destroy() {
+        void this.destroyAsync();
+    }
+    async destroyAsync() {
+        const client = this.client;
         this.client = null;
         this.deduplicator = null;
         this.circuitBreaker = null;
+        if (client) {
+            try {
+                await client.destroy();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
     }
 }
 
@@ -55047,6 +55069,8 @@ class S3Client extends EventEmitter {
     connectionString;
     httpClientOptions;
     client;
+    httpHandler = null;
+    _rawHttpClientOptions;
     _inflightCoalescing;
     taskExecutorConfig;
     taskExecutor;
@@ -55064,6 +55088,7 @@ class S3Client extends EventEmitter {
         this.id = id ?? idGenerator(77);
         this.config = new ConnectionString(connectionString);
         this.connectionString = connectionString;
+        this._rawHttpClientOptions = httpClientOptions || {};
         this.httpClientOptions = {
             keepAlive: true,
             keepAliveMsecs: 1000,
@@ -55127,6 +55152,26 @@ class S3Client extends EventEmitter {
         };
         return normalized;
     }
+    _normalizeHttpHandlerOptions() {
+        const options = this.httpClientOptions;
+        const raw = this._rawHttpClientOptions;
+        const connections = typeof raw.connections === 'number'
+            ? raw.connections
+            : raw.maxSockets;
+        const keepAliveTimeout = raw.keepAliveTimeout ?? raw.keepAliveMsecs;
+        const bodyTimeout = raw.bodyTimeout ?? raw.timeout;
+        const normalized = { ...options };
+        if (connections !== undefined) {
+            normalized.connections = connections;
+        }
+        if (keepAliveTimeout !== undefined) {
+            normalized.keepAliveTimeout = keepAliveTimeout;
+        }
+        if (bodyTimeout !== undefined) {
+            normalized.bodyTimeout = bodyTimeout;
+        }
+        return normalized;
+    }
     _createTasksPool() {
         const poolConfig = {
             concurrency: this.taskExecutorConfig.concurrency,
@@ -55228,7 +55273,11 @@ class S3Client extends EventEmitter {
             return;
         this.taskExecutor.stop();
     }
-    destroy() {
+    async destroy() {
+        if (this.httpHandler) {
+            await this.httpHandler.destroyAsync();
+            this.httpHandler = null;
+        }
         if (this.client && typeof this.client.destroy === 'function') {
             this.client.destroy();
         }
@@ -55236,11 +55285,11 @@ class S3Client extends EventEmitter {
         this.removeAllListeners();
     }
     createClient() {
-        const httpHandler = new ReckerHttpHandler(this.httpClientOptions);
+        this.httpHandler = new ReckerHttpHandler(this._normalizeHttpHandlerOptions());
         const options = {
             region: this.config.region,
             endpoint: this.config.endpoint,
-            requestHandler: httpHandler,
+            requestHandler: this.httpHandler,
         };
         if (this.config.forcePathStyle)
             options.forcePathStyle = true;
@@ -62752,6 +62801,9 @@ class AsyncEventEmitter extends EventEmitter {
     setAsyncMode(enabled) {
         this._asyncMode = enabled;
     }
+    destroy() {
+        this.removeAllListeners();
+    }
 }
 
 /**
@@ -70304,7 +70356,7 @@ class DatabaseConnection {
                     db.client.removeAllListeners();
                 }
                 if (typeof db.client.destroy === 'function') {
-                    db.client.destroy();
+                    await db.client.destroy();
                 }
             }
             await db.emit('db:disconnected', new Date());
@@ -70383,8 +70435,8 @@ class Database extends SafeEventEmitter {
         })();
         this.version = '1';
         this.s3dbVersion = (() => {
-            const [ok, , version] = tryFnSync(() => (typeof globalThis['19.3.17'] !== 'undefined' && globalThis['19.3.17'] !== '19.3.17'
-                ? globalThis['19.3.17']
+            const [ok, , version] = tryFnSync(() => (typeof globalThis['19.3.19'] !== 'undefined' && globalThis['19.3.19'] !== '19.3.19'
+                ? globalThis['19.3.19']
                 : 'latest'));
             return ok ? version : 'latest';
         })();