webspresso 0.0.100 → 0.0.102

package/core/compression/middleware.js

@@ -1,12 +1,11 @@
 /**
  * HTTP Compression Middleware
  * Provides threshold-based streaming response compression for Webspresso applications.
+ * Backed by the official Express compression package with native Brotli (br), Gzip, and Deflate support.
  * @module core/compression/middleware
  */
 
-const { selectEncoding, getDefaultSupportedEncodings } = require('./negotiate');
-const { isCompressible } = require('./compressible');
-const { createCompressionStream } = require('./compression-stream');
+const compression = require('compression');
 
 /**
  * Safely append a field to the HTTP Vary header
@@ -30,6 +29,15 @@ function appendVary(res, field) {
   res.setHeader('Vary', `${currentStr}, ${field}`);
 }
 
+/**
+ * Response helper to opt-out of compression for a specific route
+ * @param {boolean} [enable=true]
+ */
+function resCompress(enable = true) {
+  this._noCompression = !enable;
+  return this;
+}
+
 /**
  * Create Webspresso HTTP Response Compression Middleware
  * @param {Object} [options]
@@ -42,271 +50,47 @@ function appendVary(res, field) {
  * @param {Object} [options.deflate] - Custom Deflate options
  * @returns {import('express').RequestHandler}
  */
-function resCompress(enable = true) {
-  this._noCompression = !enable;
-  return this;
-}
-
 function createCompressionMiddleware(options = {}) {
   const threshold = typeof options.threshold === 'number' && options.threshold >= 0 ? options.threshold : 1024;
-  const supportedEncodings = Array.isArray(options.encodings) && options.encodings.length > 0
-    ? options.encodings
-    : getDefaultSupportedEncodings();
-
   const customFilter = typeof options.filter === 'function' ? options.filter : null;
 
-  return function compressionMiddleware(req, res, next) {
-    // Expose opt-out API on response object
-    res._noCompression = false;
-    res.compress = resCompress;
-
-    // Skip compression for HEAD requests
-    if (req.method === 'HEAD') {
-      return next();
-    }
-
-    const acceptEncoding = req.headers['accept-encoding'];
-    if (!acceptEncoding) {
-      return next();
-    }
-
-    let selectedEncoding = null;
-    let checkedEncoding = false;
-
-    function getSelectedEncoding() {
-      if (!checkedEncoding) {
-        checkedEncoding = true;
-        selectedEncoding = selectEncoding(acceptEncoding, supportedEncodings);
-      }
-      return selectedEncoding;
-    }
-
-    // Original methods to wrap (store references without .bind() allocation)
-    const origWrite = res.write;
-    const origEnd = res.end;
-    const origWriteHead = res.writeHead;
-
-    let compressStream = null;
-    let isCompressing = false;
-    let headersSent = false;
-    let bufferedChunks = [];
-    let bufferedLength = 0;
-    let decided = false;
-
-    /**
-     * Check if response should be compressed
-     * @param {number} [expectedLength]
-     * @returns {boolean}
-     */
-    function shouldCompress(expectedLength) {
+  const comp = compression({
+    threshold,
+    brotli: options.brotli,
+    level: options.level,
+    filter: (req, res) => {
+      // Respect Webspresso opt-out flags
       if (res._noCompression || res.locals?.compress === false || res.shouldCompress === false) {
         return false;
       }
-
-      // Check status codes that must not have a body
-      const statusCode = res.statusCode || 200;
-      if (statusCode === 204 || statusCode === 304 || statusCode === 205 || statusCode < 200) {
-        return false;
-      }
-
-      // If response already has a Content-Encoding, do not double-compress
-      if (res.getHeader('Content-Encoding')) {
-        return false;
-      }
-
-      // Check Content-Type compressibility
+      // Never compress server-sent event streams
       const contentType = res.getHeader('Content-Type');
-      if (!contentType || !isCompressible(contentType)) {
-        return false;
-      }
-
-      // Check threshold if length is known
-      if (typeof expectedLength === 'number' && expectedLength < threshold) {
-        return false;
-      }
-
-      // Custom filter hook
-      if (customFilter && !customFilter(req, res)) {
+      if (contentType && String(contentType).toLowerCase().includes('text/event-stream')) {
         return false;
       }
-
-      // Check if client supports any available encoding
-      const encoding = getSelectedEncoding();
-      if (!encoding || encoding === 'identity') {
-        return false;
-      }
-
-      return true;
-    }
-
-    /**
-     * Initialize compression stream and headers
-     */
-    function startCompression() {
-      const encoding = getSelectedEncoding();
-      compressStream = createCompressionStream(encoding, options);
-      if (!compressStream) {
-        isCompressing = false;
-        return;
-      }
-
-      isCompressing = true;
-      appendVary(res, 'Accept-Encoding');
-      res.setHeader('Content-Encoding', encoding);
-      res.removeHeader('Content-Length');
-
-      // Pipe compression stream chunks directly into underlying socket/response
-      compressStream.on('data', (chunk) => {
-        origWrite.call(res, chunk);
-      });
-
-      compressStream.on('end', () => {
-        origEnd.call(res);
-      });
-
-      compressStream.on('error', (err) => {
-        origEnd.call(res);
-      });
-    }
-
-    // Wrap writeHead
-    res.writeHead = function(statusCode, ...args) {
-      if (res.headersSent) return res;
-
-      if (typeof args[0] === 'object' && args[0] !== null) {
-        for (const [k, v] of Object.entries(args[0])) {
-          res.setHeader(k, v);
-        }
-      } else if (typeof args[1] === 'object' && args[1] !== null) {
-        for (const [k, v] of Object.entries(args[1])) {
-          res.setHeader(k, v);
-        }
-      }
-
-      if (isCompressing) {
-        const encoding = getSelectedEncoding();
-        if (encoding) {
-          res.setHeader('Content-Encoding', encoding);
-        }
-        res.removeHeader('Content-Length');
-        appendVary(res, 'Accept-Encoding');
-      }
-
-      return origWriteHead.call(res, statusCode, ...args);
-    };
-
-    // Wrap write
-    res.write = function(chunk, encoding, callback) {
-      if (typeof encoding === 'function') {
-        callback = encoding;
-        encoding = undefined;
-      }
-
-      if (!chunk) {
-        return true;
-      }
-
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-
-      if (!decided) {
-        bufferedChunks.push(buf);
-        bufferedLength += buf.length;
-
-        // If buffered size exceeds threshold, decide to start compression immediately
-        if (bufferedLength >= threshold) {
-          decided = true;
-          if (shouldCompress()) {
-            startCompression();
-            // Flush buffered chunks through compressor
-            for (const b of bufferedChunks) {
-              compressStream.write(b);
-            }
-            bufferedChunks = [];
-          } else {
-            // Send buffered chunks uncompressed
-            for (const b of bufferedChunks) {
-              origWrite.call(res, b);
-            }
-            bufferedChunks = [];
-          }
-        }
-        if (typeof callback === 'function') callback();
-        return true;
+      if (customFilter) {
+        return customFilter(req, res);
       }
+      return compression.filter(req, res);
+    },
+    ...options,
+  });
 
-      if (isCompressing && compressStream) {
-        return compressStream.write(buf, callback);
-      }
-
-      return origWrite.call(res, buf, callback);
-    };
-
-    // Wrap end
-    res.end = function(chunk, encoding, callback) {
-      if (typeof chunk === 'function') {
-        callback = chunk;
-        chunk = null;
-      } else if (typeof encoding === 'function') {
-        callback = encoding;
-        encoding = undefined;
-      }
-
-      if (chunk) {
-        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-        if (!decided) {
-          bufferedChunks.push(buf);
-          bufferedLength += buf.length;
-        } else if (isCompressing && compressStream) {
-          compressStream.write(buf);
-        } else {
-          origWrite.call(res, buf);
-        }
-      }
-
-      if (!decided) {
-        decided = true;
-        // Check if total length satisfies threshold and compressibility
-        if (shouldCompress(bufferedLength)) {
-          startCompression();
-          if (bufferedChunks.length === 1) {
-            if (typeof callback === 'function') {
-              compressStream.once('end', callback);
-            }
-            const singleBuf = bufferedChunks[0];
-            bufferedChunks = [];
-            compressStream.end(singleBuf);
-            return res;
-          }
-          for (const b of bufferedChunks) {
-            compressStream.write(b);
-          }
-          bufferedChunks = [];
-        } else {
-          // Output uncompressed
-          if (shouldCompress(Infinity) && bufferedLength < threshold) {
-            // Ensure Vary is set if content was compressible but just below threshold
-            appendVary(res, 'Accept-Encoding');
-          }
-          for (const b of bufferedChunks) {
-            origWrite.call(res, b);
-          }
-          bufferedChunks = [];
-          return origEnd.call(res, callback);
-        }
-      }
+  return function compressionMiddleware(req, res, next) {
+    // Expose opt-out API on response object
+    res._noCompression = false;
+    res.compress = resCompress;
 
-      if (isCompressing && compressStream) {
-        if (typeof callback === 'function') {
-          compressStream.once('end', callback);
-        }
-        compressStream.end();
+    // Prevent Content-Length header mismatch if setHeader is invoked after compression starts
+    const origSetHeader = res.setHeader;
+    res.setHeader = function(field, val) {
+      if (res.getHeader('Content-Encoding') && typeof field === 'string' && field.toLowerCase() === 'content-length') {
         return res;
       }
-
-      return origEnd.call(res, callback);
+      return origSetHeader.call(res, field, val);
     };
 
-    next();
+    return comp(req, res, next);
   };
 }
 

package/core/content/service.js

@@ -81,7 +81,10 @@ function createContentService(db, options = {}) {
     const cached = cache.get(key);
     if (cached) return cached;
 
-    const row = await TypeRepo().findById(id);
+    let row = await TypeRepo().findById(id);
+    if (!row && typeof id === 'string' && /^\d+$/.test(id)) {
+      row = await TypeRepo().findById(parseInt(id, 10));
+    }
     cacheTypeRow(row);
     return row;
   }
@@ -281,7 +284,10 @@ function createContentService(db, options = {}) {
     const cached = cache.get(key);
     if (cached) return cached;
 
-    const entry = await EntryRepo().findById(id);
+    let entry = await EntryRepo().findById(id);
+    if (!entry && typeof id === 'string' && /^\d+$/.test(id)) {
+      entry = await EntryRepo().findById(parseInt(id, 10));
+    }
     if (!entry) return null;
 
     const type = await getTypeById(entry.content_type_id);

package/core/events/discovery.js

@@ -0,0 +1,142 @@
+/**
+ * Webspresso Events - File-based Listener Discovery & Definition
+ * Auto-discovers event listeners from `listeners/` or `events/` directories.
+ * @module core/events/discovery
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Define a typed event listener
+ * @param {string|string[]} event - Event name or array of event names
+ * @param {Function} handler - Handler function (data, meta) => any
+ * @param {Object} [options] - Listener options ({ sender, priority, once })
+ * @returns {Object}
+ */
+function defineListener(event, handler, options = {}) {
+  if (!event) {
+    throw new TypeError('Listener event must be specified');
+  }
+  if (typeof handler !== 'function') {
+    throw new TypeError('Listener handler must be a function');
+  }
+  return {
+    event,
+    handle: handler,
+    ...options,
+  };
+}
+
+/**
+ * Convert file path to dot-notation event name fallback
+ * e.g. 'order/created.js' -> 'order.created'
+ * @param {string} relPath
+ * @returns {string}
+ */
+function filePathToEventName(relPath) {
+  const parsed = path.parse(relPath);
+  const parts = [];
+  if (parsed.dir) {
+    parts.push(...parsed.dir.split(path.sep));
+  }
+  parts.push(parsed.name);
+  return parts.join('.');
+}
+
+/**
+ * Recursively find all .js / .cjs files in a directory
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function walkDirectory(dir) {
+  const files = [];
+  if (!fs.existsSync(dir)) return files;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkDirectory(fullPath));
+    } else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.cjs'))) {
+      if (!entry.name.startsWith('_') && !entry.name.endsWith('.test.js')) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+/**
+ * Load and register listeners from a directory into an EventDispatcher
+ * @param {string} dirPath - Absolute or relative directory path
+ * @param {import('./dispatcher').EventDispatcher} dispatcher
+ * @param {Object} [options]
+ * @returns {Array<{ file: string, event: string, handler: Function }>}
+ */
+function loadListeners(dirPath, dispatcher, options = {}) {
+  if (!dispatcher || typeof dispatcher.on !== 'function') {
+    throw new TypeError('A valid EventDispatcher instance must be provided');
+  }
+
+  const resolvedDir = path.resolve(dirPath);
+  if (!fs.existsSync(resolvedDir)) {
+    return [];
+  }
+
+  const filePaths = walkDirectory(resolvedDir);
+  const loaded = [];
+
+  for (const filePath of filePaths) {
+    try {
+      const moduleContent = require(filePath);
+      const candidates = Array.isArray(moduleContent) ? moduleContent : [moduleContent];
+
+      for (const item of candidates) {
+        if (!item) continue;
+
+        let eventName = item.event;
+        let handler = item.handle || item.handler;
+
+        // If default export is a function directly
+        if (typeof item === 'function') {
+          handler = item;
+          eventName = item.event || filePathToEventName(path.relative(resolvedDir, filePath));
+        }
+
+        if (handler && typeof handler === 'function') {
+          if (!eventName) {
+            eventName = filePathToEventName(path.relative(resolvedDir, filePath));
+          }
+
+          const eventsList = Array.isArray(eventName) ? eventName : [eventName];
+          for (const evt of eventsList) {
+            dispatcher.on(evt, handler, {
+              sender: item.sender,
+              priority: item.priority,
+              once: item.once,
+            });
+
+            loaded.push({
+              file: filePath,
+              event: evt,
+              handler,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      if (options.logger && typeof options.logger.warn === 'function') {
+        options.logger.warn(`[loadListeners] Failed to load listener from ${filePath}:`, err.message);
+      }
+    }
+  }
+
+  return loaded;
+}
+
+module.exports = {
+  defineListener,
+  loadListeners,
+  filePathToEventName,
+};