webspresso 0.0.107 → 0.0.108

package/core/compileSchema.js

@@ -1,69 +1,4 @@
-/**
- * Schema Compiler
- * Compiles schema definitions from API files
- */
-
-const { z: zForApi } = require('./validation');
-const schemaCache = require('./schema-cache');
-
-/**
- * Compile schema from an API module
- * @param {string} filePath - Absolute file path to API module
- * @param {Object} apiModule - The loaded API module
- * @returns {Object|null} Compiled schema object or null if no schema
- */
-function compileSchema(filePath, apiModule) {
-  // Return cached schema if exists
-  if (schemaCache.has(filePath)) {
-    return schemaCache.get(filePath);
-  }
-
-  // Check if module exports schema
-  const schemaFn = apiModule.schema;
-  
-  // Schema is optional
-  if (schemaFn === undefined) {
-    schemaCache.set(filePath, null);
-    return null;
-  }
-
-  // Schema must be a function
-  if (typeof schemaFn !== 'function') {
-    throw new Error(`Schema in ${filePath} must be a function`);
-  }
-
-  // Call schema function with { z } (extended with z.nanoid, same as generateNanoid / zdb.nanoid)
-  const compiled = schemaFn({ z: zForApi });
-
-  // Validate compiled schema structure
-  if (compiled !== null && typeof compiled !== 'object') {
-    throw new Error(`Schema function in ${filePath} must return an object or null`);
-  }
-
-  // Cache and return
-  schemaCache.set(filePath, compiled);
-  return compiled;
-}
-
-/**
- * Clear schema cache for a file (for hot-reload)
- * @param {string} filePath - Absolute file path
- */
-function invalidateSchema(filePath) {
-  schemaCache.del(filePath);
-}
-
-/**
- * Clear all cached schemas
- */
-function clearAllSchemas() {
-  schemaCache.clear();
-}
-
-module.exports = {
-  compileSchema,
-  invalidateSchema,
-  clearAllSchemas
-};
-
+'use strict';
 
+// Backward-compatibility shim
+module.exports = require('./validation/compiler');

package/core/compression/compressible.js

@@ -11,7 +11,56 @@ const COMPRESSIBLE_TYPE_REGEX = /^(?:text\/[a-z0-9.+_-]+|application\/(?:javascr
 const INCOMPRESSIBLE_TYPE_REGEX = /^(?:text\/event-stream|image\/(?:jpeg|png|gif|webp|avif|heic|heif)|video\/[a-z0-9.+_-]+|audio\/[a-z0-9.+_-]+|application\/(?:zip|gzip|x-gzip|x-bzip2|x-compress|x-7z-compressed|x-rar-compressed|pdf|wasm|octet-stream))$/i;
 
 const compressibleCache = new Map();
-const MAX_MIME_CACHE_SIZE = 256;
+const MAX_MIME_CACHE_SIZE = 512;
+
+// Pre-fill standard common web & API MIME types for zero-lookup warmup
+const PREFILLED_MIMES = [
+  ['text/html', true],
+  ['text/html; charset=utf-8', true],
+  ['text/plain', true],
+  ['text/plain; charset=utf-8', true],
+  ['text/css', true],
+  ['text/css; charset=utf-8', true],
+  ['text/javascript', true],
+  ['text/javascript; charset=utf-8', true],
+  ['application/javascript', true],
+  ['application/javascript; charset=utf-8', true],
+  ['application/json', true],
+  ['application/json; charset=utf-8', true],
+  ['application/ld+json', true],
+  ['application/manifest+json', true],
+  ['application/graphql+json', true],
+  ['application/geo+json', true],
+  ['application/xml', true],
+  ['application/atom+xml', true],
+  ['application/rss+xml', true],
+  ['application/xhtml+xml', true],
+  ['image/svg+xml', true],
+  ['text/event-stream', false],
+  ['image/png', false],
+  ['image/jpeg', false],
+  ['image/webp', false],
+  ['image/gif', false],
+  ['image/avif', false],
+  ['application/pdf', false],
+  ['application/zip', false],
+  ['application/gzip', false],
+  ['application/octet-stream', false],
+  ['video/mp4', false],
+  ['audio/mpeg', false],
+];
+
+for (const [mime, val] of PREFILLED_MIMES) {
+  compressibleCache.set(mime, val);
+}
+
+function setCompressibleCache(key, value) {
+  if (compressibleCache.size >= MAX_MIME_CACHE_SIZE) {
+    const firstKey = compressibleCache.keys().next().value;
+    compressibleCache.delete(firstKey);
+  }
+  compressibleCache.set(key, value);
+}
 
 /**
  * Determine if a Content-Type is compressible
@@ -33,13 +82,13 @@ function isCompressible(contentType) {
   const mime = (semiIndex !== -1 ? contentType.slice(0, semiIndex) : contentType).trim().toLowerCase();
 
   if (!mime) {
-    if (compressibleCache.size < MAX_MIME_CACHE_SIZE) compressibleCache.set(contentType, false);
+    setCompressibleCache(contentType, false);
     return false;
   }
 
   // Fast negative check
   if (INCOMPRESSIBLE_TYPE_REGEX.test(mime)) {
-    if (compressibleCache.size < MAX_MIME_CACHE_SIZE) compressibleCache.set(contentType, false);
+    setCompressibleCache(contentType, false);
     return false;
   }
 
@@ -51,9 +100,7 @@ function isCompressible(contentType) {
     result = true;
   }
 
-  if (compressibleCache.size < MAX_MIME_CACHE_SIZE) {
-    compressibleCache.set(contentType, result);
-  }
+  setCompressibleCache(contentType, result);
 
   return result;
 }

package/core/compression/negotiate.js

@@ -71,9 +71,29 @@ function parseAcceptEncoding(header) {
 
 const DEFAULT_SUPPORTED_ENCODINGS = Object.freeze(getDefaultSupportedEncodings());
 const DEFAULT_SUPPORTED_STRING = DEFAULT_SUPPORTED_ENCODINGS.join(',');
+const DEFAULT_PREFERRED_ENCODING = DEFAULT_SUPPORTED_ENCODINGS[0] || 'identity';
 
 const selectEncodingCache = new Map();
-const MAX_ENCODING_CACHE_SIZE = 128;
+const MAX_ENCODING_CACHE_SIZE = 256;
+
+function setSelectEncodingCache(key, value) {
+  if (selectEncodingCache.size >= MAX_ENCODING_CACHE_SIZE) {
+    const firstKey = selectEncodingCache.keys().next().value;
+    selectEncodingCache.delete(firstKey);
+  }
+  selectEncodingCache.set(key, value);
+}
+
+// Pre-fill common browser patterns for default configuration
+if (DEFAULT_SUPPORTED_ENCODINGS.includes('br')) {
+  selectEncodingCache.set('gzip, deflate, br', 'br');
+  selectEncodingCache.set('gzip, deflate, br, zstd', 'br');
+  selectEncodingCache.set('br;q=1.0, gzip;q=0.8, *;q=0.1', 'br');
+}
+selectEncodingCache.set('gzip, deflate', 'gzip');
+selectEncodingCache.set('gzip', 'gzip');
+selectEncodingCache.set('*', DEFAULT_PREFERRED_ENCODING);
+selectEncodingCache.set('identity', 'identity');
 
 /**
  * Select the best compression encoding given client header and server supported list
@@ -82,14 +102,17 @@ const MAX_ENCODING_CACHE_SIZE = 128;
  * @returns {string|null} The selected encoding ('br', 'gzip', 'deflate', 'identity', or null)
  */
 function selectEncoding(acceptEncoding, supportedEncodings) {
-  if (!acceptEncoding) {
+  if (!acceptEncoding || typeof acceptEncoding !== 'string') {
+    return 'identity';
+  }
+
+  const raw = acceptEncoding.trim();
+  if (!raw) {
     return 'identity';
   }
 
   const isDefault = !supportedEncodings || !Array.isArray(supportedEncodings) || supportedEncodings.length === 0;
-  const cacheKey = isDefault
-    ? `${acceptEncoding}|${DEFAULT_SUPPORTED_STRING}`
-    : `${acceptEncoding}|${supportedEncodings.join(',')}`;
+  const cacheKey = isDefault ? raw : `${raw}|${supportedEncodings.join(',')}`;
 
   const cached = selectEncodingCache.get(cacheKey);
   if (cached !== undefined) {
@@ -100,11 +123,9 @@ function selectEncoding(acceptEncoding, supportedEncodings) {
     ? DEFAULT_SUPPORTED_ENCODINGS
     : supportedEncodings.map(e => e.toLowerCase()).filter(e => e !== 'br' || supportsBrotli());
 
-  const clientPreferences = parseAcceptEncoding(acceptEncoding);
+  const clientPreferences = parseAcceptEncoding(raw);
   if (clientPreferences.length === 0) {
-    if (selectEncodingCache.size < MAX_ENCODING_CACHE_SIZE) {
-      selectEncodingCache.set(cacheKey, 'identity');
-    }
+    setSelectEncodingCache(cacheKey, 'identity');
     return 'identity';
   }
 
@@ -157,9 +178,7 @@ function selectEncoding(acceptEncoding, supportedEncodings) {
     result = wildcardQ > 0 ? 'identity' : null;
   }
 
-  if (selectEncodingCache.size < MAX_ENCODING_CACHE_SIZE) {
-    selectEncodingCache.set(cacheKey, result);
-  }
+  setSelectEncodingCache(cacheKey, result);
 
   return result;
 }

package/core/context/app-context.js

@@ -0,0 +1,201 @@
+/**
+ * Process-wide app context set by createApp() — use from API handlers, jobs, etc.
+ * @module src/app-context
+ */
+
+const { circuitBreakerRegistry, retry } = require('../resilience');
+
+/** @type {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null, events: object|null, mailer: object|null, cache: object|null, breakers: object|null }} */
+let context = {
+  db: null,
+  shutdownManager: null,
+  serviceRegistry: null,
+  events: null,
+  mailer: null,
+  cache: null,
+  breakers: circuitBreakerRegistry,
+};
+
+/**
+ * Merge into the current context (typically called once from createApp).
+ * @param {{ db?: object|null, shutdownManager?: object|null, serviceRegistry?: object|null, events?: object|null, mailer?: object|null, cache?: object|null }} partial
+ */
+function setAppContext(partial) {
+  context = { ...context, ...partial };
+}
+
+/**
+ * @returns {{ db: object|null, shutdownManager: object|null, serviceRegistry: object|null, events: object|null, mailer: object|null }}
+ */
+function getAppContext() {
+  return context;
+}
+
+/**
+ * Database instance passed to createApp({ db }) (Knex + ORM helpers).
+ * @returns {object}
+ * @throws {Error} If createApp was not given a db instance
+ */
+function getDb() {
+  if (!context.db) {
+    throw new Error(
+      'No database registered. Create a DB with createDatabase(), then pass it to createApp({ db }). ' +
+        'Or use hasDb() before calling getDb().'
+    );
+  }
+  return context.db;
+}
+
+/**
+ * @returns {boolean}
+ */
+function hasDb() {
+  return context.db != null;
+}
+
+/**
+ * @returns {object|null}
+ */
+function getShutdownManager() {
+  return context.shutdownManager;
+}
+
+/**
+ * @returns {boolean}
+ */
+function hasShutdownManager() {
+  return context.shutdownManager != null;
+}
+
+/**
+ * Get the registered ServiceRegistry instance
+ * @returns {object|null}
+ */
+function getServiceRegistry() {
+  return context.serviceRegistry;
+}
+
+/**
+ * Check if a ServiceRegistry is registered
+ * @returns {boolean}
+ */
+function hasServiceRegistry() {
+  return context.serviceRegistry != null;
+}
+
+/**
+ * Get the registered EventDispatcher instance
+ * @returns {object|null}
+ */
+function getEvents() {
+  return context.events;
+}
+
+/**
+ * Check if an EventDispatcher is registered
+ * @returns {boolean}
+ */
+function hasEvents() {
+  return context.events != null;
+}
+
+/**
+ * Clear context (e.g. between tests).
+ */
+function resetAppContext() {
+  context = {
+    db: null,
+    shutdownManager: null,
+    serviceRegistry: null,
+    events: null,
+    mailer: null,
+    cache: null,
+    breakers: circuitBreakerRegistry,
+  };
+}
+
+/**
+ * @returns {object|null}
+ */
+function getMailer() {
+  return context.mailer;
+}
+
+/**
+ * @returns {boolean}
+ */
+function hasMailer() {
+  return context.mailer != null;
+}
+
+/**
+ * @returns {object|null}
+ */
+function getCache() {
+  return context.cache;
+}
+
+/**
+ * @returns {boolean}
+ */
+function hasCache() {
+  return context.cache != null;
+}
+
+/**
+ * Express middleware: sets `req.db`, `req.service`, `req.events`, `req.mailer`, and `req.cache` from registered app context.
+ * File-based `pages/api/*` routes attach this automatically; use in `setupRoutes`
+ * for manually registered handlers that need `req.db` and `req.service`.
+ * @type {import('express').RequestHandler}
+ */
+function attachDbMiddleware(req, res, next) {
+  if (context.db != null) {
+    req.db = context.db;
+  }
+  if (context.events != null) {
+    req.events = context.events;
+  }
+  if (context.mailer != null) {
+    req.mailer = context.mailer;
+  }
+  if (context.cache != null) {
+    req.cache = context.cache;
+  }
+  req.breakers = context.breakers || circuitBreakerRegistry;
+  req.breaker = (name, opts) => (context.breakers || circuitBreakerRegistry).getBreaker(name, opts);
+  req.retry = retry;
+  if (context.serviceRegistry != null) {
+    req.service = (name, input, opts) =>
+      context.serviceRegistry.call(name, input, req.context || {
+        req,
+        res,
+        db: context.db,
+        events: context.events,
+        mailer: context.mailer,
+        cache: context.cache,
+        breakers: req.breakers,
+        breaker: req.breaker,
+        retry,
+      }, opts);
+  }
+  next();
+}
+
+module.exports = {
+  setAppContext,
+  getAppContext,
+  getDb,
+  hasDb,
+  getShutdownManager,
+  hasShutdownManager,
+  getServiceRegistry,
+  hasServiceRegistry,
+  getEvents,
+  hasEvents,
+  getMailer,
+  hasMailer,
+  getCache,
+  hasCache,
+  resetAppContext,
+  attachDbMiddleware,
+};

package/core/context/index.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Webspresso Context Management Layer
+ * Process-wide application context and request-scoped AsyncLocalStorage ambient context.
+ *
+ * @module core/context
+ */
+
+const appContext = require('./app-context');
+const requestContext = require('./request');
+
+module.exports = {
+  // App context (process-wide)
+  setAppContext: appContext.setAppContext,
+  getAppContext: appContext.getAppContext,
+  getDb: appContext.getDb,
+  hasDb: appContext.hasDb,
+  getShutdownManager: appContext.getShutdownManager,
+  hasShutdownManager: appContext.hasShutdownManager,
+  getServiceRegistry: appContext.getServiceRegistry,
+  hasServiceRegistry: appContext.hasServiceRegistry,
+  getEvents: appContext.getEvents,
+  hasEvents: appContext.hasEvents,
+  getMailer: appContext.getMailer,
+  hasMailer: appContext.hasMailer,
+  getCache: appContext.getCache,
+  hasCache: appContext.hasCache,
+  resetAppContext: appContext.resetAppContext,
+  attachDbMiddleware: appContext.attachDbMiddleware,
+
+  // Request & ambient execution context (AsyncLocalStorage)
+  requestContextStorage: requestContext.requestContextStorage,
+  runWithContext: requestContext.runWithContext,
+  withContext: requestContext.withContext,
+  getContext: requestContext.getContext,
+  useContext: requestContext.useContext,
+  useDb: requestContext.useDb,
+  useAuth: requestContext.useAuth,
+  useUser: requestContext.useUser,
+  useLogger: requestContext.useLogger,
+  useReq: requestContext.useReq,
+  useRes: requestContext.useRes,
+  useParams: requestContext.useParams,
+  useQuery: requestContext.useQuery,
+  useService: requestContext.useService,
+  useQueue: requestContext.useQueue,
+  useCache: requestContext.useCache,
+  useBreaker: requestContext.useBreaker,
+  useTransaction: requestContext.useTransaction,
+
+  // Namespace accessors
+  appContext,
+  requestContext,
+};