@expressots/core 4.0.0-preview.1 → 4.0.0-preview.3

package/lib/esm/middleware/middleware-service.js

@@ -221,6 +221,8 @@ export class Middleware {
     profilingEnabled = false;
     // v4: Custom presets storage
     customPresets = new Map();
+    // v4: Last applied preset info (for Studio integration)
+    _lastPreset = null;
     // v4: Middleware registry reference
     registry = getMiddlewareRegistry();
     // v4: Buffered startup logs (displayed after banner)
@@ -274,7 +276,9 @@ export class Middleware {
      * @returns The type of the middleware.
      */
     getMiddlewareType(middleware) {
-        if (middleware && typeof middleware === "object" && "path" in middleware) {
+        if (middleware &&
+            typeof middleware === "object" &&
+            ("path" in middleware || "middlewares" in middleware)) {
             return MiddlewareType.Config;
         }
         if (typeof middleware === "function") {
@@ -337,7 +341,12 @@ export class Middleware {
         const middlewareType = this.getMiddlewareType(m.middleware);
         if (middlewareType === MiddlewareType.Config) {
             const config = m.middleware;
-            return config.path || "ConfigMiddleware";
+            if (config.path)
+                return config.path;
+            const names = config.middlewares
+                .map((fn) => typeof fn === "function" ? fn.name : fn?.constructor?.name)
+                .filter((n) => n && n !== "anonymous" && n !== "");
+            return names.length > 0 ? names.join(", ") : "ConfigMiddleware";
         }
         else if (middlewareType === MiddlewareType.IExpressoMiddleware) {
             return m.middleware.constructor.name;
@@ -434,7 +443,11 @@ export class Middleware {
             this._logger.warn(`No middlewares in the route [${config.path}]. Skipping...`, "middleware-service");
             return;
         }
-        const configKey = config.path || `config_${this.insertionOrder}`;
+        const inferredName = config.middlewares
+            .map((fn) => (typeof fn === "function" ? fn.name : fn?.constructor?.name))
+            .filter((n) => n && n !== "anonymous" && n !== "")
+            .join(", ");
+        const configKey = config.path || inferredName || `custom_${this.insertionOrder}`;
         if (this.middlewareExists(configKey)) {
             this._logger.warn(`[${config.path}] route already exists. Skipping...`, "middleware-service");
             return;
@@ -1206,6 +1219,7 @@ export class Middleware {
                     origin: true,
                     credentials: true,
                     methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+                    allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With"],
                 },
                 rateLimit: { windowMs: 60000, max: 100 },
             },
@@ -1459,6 +1473,11 @@ export class Middleware {
         const finalConfig = overrides
             ? this.mergeConfigs(config, overrides)
             : config;
+        this._lastPreset = {
+            name: preset,
+            hasOverrides: !!overrides,
+            config: finalConfig,
+        };
         // Apply each category
         if (finalConfig.parse) {
             if (typeof finalConfig.parse === "boolean") {
@@ -1508,31 +1527,62 @@ export class Middleware {
         const custom = Object.fromEntries(this.customPresets);
         return { ...builtIn, ...custom };
     }
+    /**
+     * Returns info about the last applied preset (name, whether overrides
+     * were used, and the effective merged config). Used by the adapter to
+     * forward preset metadata to Studio.
+     */
+    getLastAppliedPreset() {
+        return this._lastPreset;
+    }
     /**
      * Get built-in presets.
+     *
+     * Each preset is tuned for a specific workload:
+     * - api: REST APIs (large payloads, rate-limited, strict CORS)
+     * - web: traditional server-rendered apps (cookies, sessions, relaxed CORS)
+     * - spa: single-page apps served with static fallback
+     * - microservice: internal service-to-service (minimal surface, no security)
+     * - graphql: single endpoint with large JSON payloads
+     * - minimal: parsing only, no security or compression
+     * - development: relaxed for local iteration, verbose logging
+     * - production: hardened defaults for shipped deployments
      */
     getBuiltInPresets() {
         return {
             api: {
-                parse: true,
+                parse: {
+                    json: { limit: "10mb" },
+                    urlencoded: { extended: true, limit: "10mb" },
+                },
                 logger: { implementation: "auto" },
                 security: "api",
-                compress: true,
+                compress: { level: 6 },
             },
             web: {
-                parse: { json: true, urlencoded: true, cookies: true },
+                parse: {
+                    json: { limit: "5mb" },
+                    urlencoded: { extended: true, limit: "5mb" },
+                    cookies: true,
+                },
                 logger: { implementation: "auto" },
                 security: "standard",
                 compress: true,
             },
             spa: {
-                parse: { json: true, urlencoded: true },
+                parse: {
+                    json: { limit: "5mb" },
+                    urlencoded: { extended: true, limit: "5mb" },
+                },
                 security: "standard",
                 compress: true,
             },
             microservice: {
-                parse: { json: { limit: "1mb" } },
-                compress: true,
+                parse: {
+                    json: { limit: "1mb" },
+                    urlencoded: { extended: false, limit: "1mb" },
+                },
+                compress: { level: 6 },
             },
             graphql: {
                 parse: { json: { limit: "50mb" } },
@@ -1546,15 +1596,21 @@ export class Middleware {
                 parse: true,
             },
             development: {
-                parse: true,
+                parse: {
+                    json: { limit: "50mb" },
+                    urlencoded: { extended: true, limit: "50mb" },
+                },
                 logger: { implementation: "morgan", options: { format: "dev" } },
                 security: "relaxed",
             },
             production: {
-                parse: true,
+                parse: {
+                    json: { limit: "10mb" },
+                    urlencoded: { extended: true, limit: "10mb" },
+                },
                 logger: { implementation: "auto", disableInTest: true },
                 security: "strict",
-                compress: true,
+                compress: { level: 6 },
             },
         };
     }

package/lib/esm/middleware/presets-standalone.js

@@ -0,0 +1,87 @@
+/**
+ * Standalone (free-function) wrappers around the v4 middleware preset system.
+ *
+ * These exist alongside the `Middleware.definePreset` / `Middleware.applyPreset`
+ * instance methods so user code that doesn't have DI access to the `Middleware`
+ * provider — for example, declarative config files outside of the request
+ * lifecycle — can still register and apply presets.
+ *
+ * Usage:
+ * ```ts
+ * import { definePreset, applyPreset } from "@expressots/core";
+ *
+ * definePreset("my-api", {
+ *   parse: { json: { limit: "1mb" } },
+ *   security: { cors: { origin: "https://app.example.com" } },
+ * });
+ *
+ * // ...later, inside configureServices(), with the Middleware DI provider:
+ * applyPreset(this.services.middleware, "my-api");
+ * ```
+ *
+ * @public API
+ */
+/** Module-level registry of presets defined via the standalone helper. */
+const standalonePresets = new Map();
+/**
+ * Register a custom middleware preset under the given name.
+ *
+ * The preset is stored in a module-level registry so it can be referenced
+ * later by `applyPreset(middleware, name)`. Calling `definePreset` with an
+ * existing name overwrites the previous definition.
+ *
+ * @param name   unique identifier for the preset
+ * @param config v4 middleware config object describing the preset
+ *
+ * @public API
+ */
+export function definePreset(name, config) {
+    standalonePresets.set(name, config);
+}
+/**
+ * Apply a previously defined preset (built-in or registered via
+ * `definePreset`) to the supplied `Middleware` instance.
+ *
+ * Resolution order:
+ *  1. Built-in v4 presets (`api`, `web`, `spa`, `microservice`, `graphql`,
+ *     `minimal`, `development`, `production`) are matched by the
+ *     `Middleware` instance itself.
+ *  2. Custom presets previously registered via `Middleware.definePreset`
+ *     on the same instance.
+ *  3. Custom presets registered via the standalone `definePreset` here —
+ *     these are forwarded to the instance on demand.
+ *
+ * @param middleware the active `Middleware` provider (typically resolved from
+ *                   the DI container inside `configureServices()`)
+ * @param name       preset to apply
+ * @param overrides  optional partial config that is merged on top of the
+ *                   preset before application
+ *
+ * @public API
+ */
+export function applyPreset(middleware, name, overrides) {
+    const standalone = standalonePresets.get(name);
+    if (standalone !== undefined) {
+        middleware.definePreset(name, standalone);
+    }
+    middleware.applyPreset(name, overrides);
+}
+/**
+ * Returns the names of every preset registered through the standalone
+ * `definePreset` helper. Built-in presets and per-instance custom presets
+ * are NOT included — those live on the `Middleware` instance.
+ *
+ * @public API
+ */
+export function getStandalonePresetNames() {
+    return Array.from(standalonePresets.keys());
+}
+/**
+ * Remove every preset registered through the standalone `definePreset`
+ * helper. Useful in tests; rarely needed at runtime.
+ *
+ * @public API
+ */
+export function clearStandalonePresets() {
+    standalonePresets.clear();
+}

package/lib/esm/provider/db-in-memory/adapter/in-memory.adapter.js

@@ -383,6 +383,28 @@ export class InMemoryAdapter {
                     where: { id: foreignKeyValue },
                 });
             }
+            case "manyToMany": {
+                // Resolve through a join table. Convention: the `through` table holds
+                // link records with two foreign keys named `<sourceClass>Id` and
+                // `<targetClass>Id` (class names lowercased). For example, a
+                // Post <-> Tag relation through "post_tags" stores rows shaped like
+                // `{ postId, tagId }`.
+                if (!relation.through || !this.entityClass)
+                    return [];
+                const sourceKey = `${this.entityClass.name.toLowerCase()}Id`;
+                const targetKey = `${relation.target().name.toLowerCase()}Id`;
+                const joinAdapter = this.database.table(relation.through);
+                const joinRecords = await joinAdapter.findMany({
+                    where: { [sourceKey]: entity.id },
+                });
+                const targetIds = joinRecords
+                    .map((record) => record[targetKey])
+                    .filter((value) => typeof value === "string");
+                if (targetIds.length === 0)
+                    return [];
+                const related = await Promise.all(targetIds.map((id) => relatedAdapter.findUnique({ where: { id } })));
+                return related.filter((item) => item !== null);
+            }
             default:
                 return null;
         }
@@ -533,6 +555,7 @@ export class InMemoryDatabase {
                 entityClass,
                 timestamps: this.options.timestamps,
                 softDelete: this.options.softDelete,
+                maxRecordsPerTable: this.options.maxRecordsPerTable,
             }));
         }
         return this.tables.get(tableName);

package/lib/esm/provider/db-in-memory/index.js

@@ -4,6 +4,14 @@
  * A high-performance, Prisma-compatible in-memory database
  * for ExpressoTS applications.
  *
+ * Scope: this database is intended for development, testing, and
+ * prototyping. Data lives in process memory (with optional file
+ * snapshots) and does not provide the crash safety, concurrency, or
+ * multi-process guarantees of a real database engine. It implements the
+ * universal `IDataAdapter` contract so it can be swapped for a
+ * production adapter (Prisma, TypeORM, etc.) without rewriting
+ * repositories.
+ *
  * Features:
  * - Prisma-like query API
  * - Type-safe queries with TypeScript
@@ -81,7 +89,7 @@ QueryEngine, } from "./query/index.js";
 // ═══════════════════════════════════════════════════════════════════════════
 // STORAGE
 // ═══════════════════════════════════════════════════════════════════════════
-export { MemoryStore, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./storage/index.js";
+export { MemoryStore, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./storage/index.js";
 // Legacy provider (deprecated, use InMemoryDBProvider)
 export { InMemoryDataProvider, InMemoryDataTable, } from "./db-in-memory.provider.js";
 // Legacy errors (now exported from storage)

package/lib/esm/provider/db-in-memory/query/query-engine.js

@@ -409,6 +409,33 @@ export class QueryEngine {
         return result;
     }
     // ═══════════════════════════════════════════════════════════════════════════
+    // CURSOR
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Apply cursor-based pagination. The cursor identifies a record (by id or
+     * any other field combination) within the ordered result set; the returned
+     * slice starts at that record. Combine with `skip` (typically `skip: 1` to
+     * exclude the cursor itself) and `take`.
+     *
+     * Should be applied after `orderBy` and before `skip`/`take`.
+     *
+     * @param entities - Ordered entities to slice
+     * @param cursor - Unique cursor identifying the start record
+     * @returns Entities starting at the cursor (empty array if not found)
+     */
+    executeCursor(entities, cursor) {
+        if (!cursor)
+            return entities;
+        const keys = Object.keys(cursor).filter((key) => cursor[key] !== undefined);
+        if (keys.length === 0)
+            return entities;
+        const index = entities.findIndex((entity) => keys.every((key) => entity[key] ===
+            cursor[key]));
+        if (index === -1)
+            return [];
+        return entities.slice(index);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
     // DISTINCT
     // ═══════════════════════════════════════════════════════════════════════════
     /**
@@ -561,6 +588,7 @@ export class QueryEngine {
         let entities = this.executeWhere(args.where);
         entities = this.executeDistinct(entities, args.distinct);
         entities = this.executeOrderBy(entities, args.orderBy);
+        entities = this.executeCursor(entities, args.cursor);
         entities = this.executePagination(entities, args.skip, args.take);
         if (args.select) {
             return this.executeSelect(entities, args.select);

package/lib/esm/provider/db-in-memory/schema/decorators.js

@@ -376,6 +376,24 @@ export class SchemaRegistry {
     static getRelations(target) {
         return Reflect.getMetadata(DB_METADATA_KEYS.relation, target) || [];
     }
+    /**
+     * Get primary key field names for an entity.
+     * @param target - Entity class
+     * @returns Array of primary key field names
+     * @public API
+     */
+    static getPrimaryKeys(target) {
+        return Reflect.getMetadata(DB_METADATA_KEYS.primaryKey, target) || [];
+    }
+    /**
+     * Get nullable field names for an entity.
+     * @param target - Entity class
+     * @returns Array of nullable field names
+     * @public API
+     */
+    static getNullableFields(target) {
+        return Reflect.getMetadata(DB_METADATA_KEYS.nullable, target) || [];
+    }
     /**
      * Clear all registered entities (useful for testing).
      * @public API

package/lib/esm/provider/db-in-memory/storage/index.js

@@ -2,4 +2,4 @@
  * Storage Module Exports
  * @module db-in-memory/storage
  */
-export { MemoryStore, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, } from "./memory-store.js";
+export { MemoryStore, IndexManager, IdGenerator, UniqueConstraintError, EntityNotFoundError, EntityAlreadyExistsError, MaxRecordsExceededError, EntityValidationError, } from "./memory-store.js";

package/lib/esm/provider/db-in-memory/storage/memory-store.js

@@ -190,6 +190,35 @@ export class EntityNotFoundError extends Error {
         this.id = id;
     }
 }
+/**
+ * Error thrown when a table reaches its configured record limit.
+ * @public API
+ */
+export class MaxRecordsExceededError extends Error {
+    tableName;
+    limit;
+    constructor(tableName, limit) {
+        super(`Table '${tableName}' has reached its maximum of ${limit} records`);
+        this.name = "MaxRecordsExceededError";
+        this.tableName = tableName;
+        this.limit = limit;
+    }
+}
+/**
+ * Error thrown when entity validation fails (when `@Entity({ validate: true })`).
+ * @public API
+ */
+export class EntityValidationError extends Error {
+    tableName;
+    field;
+    constructor(tableName, field, message) {
+        super(message ??
+            `Validation failed on '${tableName}': field '${field}' is required`);
+        this.name = "EntityValidationError";
+        this.tableName = tableName;
+        this.field = field;
+    }
+}
 /**
  * Error thrown when an entity already exists.
  * @public API
@@ -291,11 +320,18 @@ export class MemoryStore {
     autoGenerateFields = {};
     /** Default values */
     defaultValues = {};
+    /** Maximum number of records allowed (0 = unlimited) */
+    maxRecords;
+    /** Enable runtime validation (from @Entity({ validate: true })) */
+    validate = false;
+    /** Fields that must be present and non-null when validation is enabled */
+    requiredFields = [];
     constructor(tableName, options = {}) {
         this.tableName = tableName;
         this.entityClass = options.entityClass;
         this.timestamps = options.timestamps ?? true;
         this.softDelete = options.softDelete ?? false;
+        this.maxRecords = options.maxRecordsPerTable ?? 0;
         // Load schema metadata if entity class is provided
         if (this.entityClass) {
             this.loadSchemaMetadata();
@@ -335,6 +371,37 @@ export class MemoryStore {
         if (entityMeta) {
             this.timestamps = entityMeta.timestamps;
             this.softDelete = entityMeta.softDelete;
+            this.validate = entityMeta.validate;
+        }
+        // When validation is enabled, treat primary-key and unique fields as
+        // required (must be present and non-null) unless explicitly @Nullable.
+        if (this.validate) {
+            const nullable = new Set(SchemaRegistry.getNullableFields(this.entityClass).map(String));
+            const required = new Set();
+            for (const field of SchemaRegistry.getPrimaryKeys(this.entityClass)) {
+                required.add(String(field));
+            }
+            for (const field of SchemaRegistry.getUniqueFields(this.entityClass)) {
+                required.add(String(field));
+            }
+            this.requiredFields = Array.from(required).filter((field) => !nullable.has(field));
+        }
+    }
+    /**
+     * Validate an entity against the schema (only when `validate` is enabled).
+     * Ensures required fields (primary key + unique, excluding @Nullable) are
+     * present and non-null.
+     * @private
+     * @throws ValidationError when a required field is missing or null
+     */
+    validateEntity(entity) {
+        if (!this.validate)
+            return;
+        for (const field of this.requiredFields) {
+            const value = entity[field];
+            if (value === undefined || value === null) {
+                throw new EntityValidationError(this.tableName, field);
+            }
         }
     }
     /**
@@ -384,6 +451,12 @@ export class MemoryStore {
         if (this.data.has(prepared.id)) {
             throw new EntityAlreadyExistsError(this.tableName, prepared.id);
         }
+        // Enforce per-table record limit (0 = unlimited)
+        if (this.maxRecords > 0 && this.data.size >= this.maxRecords) {
+            throw new MaxRecordsExceededError(this.tableName, this.maxRecords);
+        }
+        // Validate required fields (no-op unless @Entity({ validate: true }))
+        this.validateEntity(prepared);
         // Index first (will throw if unique constraint violated)
         this.indexManager.indexEntity(prepared);
         // Then store
@@ -430,6 +503,8 @@ export class MemoryStore {
         if (this.timestamps) {
             updated.updatedAt = new Date();
         }
+        // Validate required fields (no-op unless @Entity({ validate: true }))
+        this.validateEntity(updated);
         // Update indexes
         this.indexManager.updateIndex(existing, updated);
         // Store updated entity

package/lib/esm/provider/logger/logger.banner.js

@@ -1,5 +1,6 @@
 import { colorCodes } from "../../console/color-codes.js";
 import { formatMemory, } from "./logger.metrics.js";
+import { FRAMEWORK_VERSION } from "../../framework-version.js";
 // eslint-disable-next-line no-control-regex
 const ANSI_STRIP_REGEX = /\x1b\[[0-9;]*m/g;
 // Helper to write to stdout - uses process.stdout directly to allow runtime interception
@@ -53,22 +54,41 @@ function getExpressoTSLogo() {
         const ts = normalizedTs[i];
         return `║${padLeft}${green}${exp}${reset}${white}${ts}${reset}${padRight}║`;
     });
-    return `
-${topBorder}
-${emptyLine}
-${contentLines.join("\n")}
-${emptyLine}
-${bottomBorder}
+    return `
+${topBorder}
+${emptyLine}
+${contentLines.join("\n")}
+${emptyLine}
+${bottomBorder}
 `.trim();
 }
 /**
- * Compact ASCII art logo.
+ * Format a timestamp for structured log output.
  */
-const EXPRESSOTS_LOGO_COMPACT = `
-╔════════════════════════════════════════════════════════════════╗
-║  ExpressoTS  -  Enterprise TypeScript Framework                ║
-╚════════════════════════════════════════════════════════════════╝
-`.trim();
+function formatBannerTimestamp() {
+    const options = {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    };
+    return new Date().toLocaleString(undefined, options).replace(",", "");
+}
+/**
+ * Build a structured log line matching the standard ExpressoTS log format.
+ */
+function logLine(message) {
+    const timestamp = formatBannerTimestamp();
+    const pid = process.pid;
+    return (colorText("[ExpressoTS]", "green") +
+        ` ${timestamp}` +
+        ` ${colorText(`[PID:${pid}]`, "green")}` +
+        ` ${colorText("INFO ", "green")}` +
+        ` ${colorText("[app]", "green")}` +
+        ` ${message}\n`);
+}
 // Removed unused EXPRESSOTS_LOGO_MINIMAL constant
 /**
  * Color text helper.
@@ -117,7 +137,6 @@ export class BannerGenerator {
         const startupTime = Date.now() - this.startTime;
         const memoryUsage = process.memoryUsage().heapUsed;
         const memoryFormatted = formatMemory(memoryUsage);
-        writeStdout("\n");
         // Display logo based on style
         switch (this.config.style) {
             case "full":
@@ -130,7 +149,6 @@ export class BannerGenerator {
                 this.displayMinimalBanner(port, environment, appInfo);
                 break;
         }
-        writeStdout("\n");
     }
     /**
      * Display full banner with clean 3-column layout.
@@ -138,6 +156,7 @@ export class BannerGenerator {
      * Optional (user-enabled): Features, Middleware Pipeline, Provider Registry, Resources
      */
     displayFullBanner(port, environment, appInfo, metrics, features, config, startupTime, memoryFormatted, bannerData) {
+        writeStdout("\n");
         // Banner box width is ~93 chars, calculate column widths for 3 columns
         const totalWidth = 93;
         const colWidth = 29;
@@ -148,7 +167,7 @@ export class BannerGenerator {
         // ══════════════════════════════════════════════════════════════════════
         // Version info line (matches banner width)
         // ══════════════════════════════════════════════════════════════════════
-        const frameworkVersion = "4.0.0-beta.1";
+        const frameworkVersion = FRAMEWORK_VERSION;
         const nodeVersion = process.version;
         const platform = process.platform;
         const appName = appInfo?.appName || "App";
@@ -384,27 +403,17 @@ export class BannerGenerator {
         writeStdout("\n");
     }
     /**
-     * Display compact banner.
+     * Display compact banner using structured log format (cloud-friendly).
      */
-    displayCompactBanner(port, environment, appInfo, metrics, features, startupTime, memoryFormatted) {
-        writeStdout(colorText(EXPRESSOTS_LOGO_COMPACT, "green"));
-        writeStdout("\n\n");
+    displayCompactBanner(port, environment, appInfo, metrics, _features, startupTime, memoryFormatted) {
         const appName = appInfo?.appName || "App";
         const appVersion = appInfo?.appVersion || "not provided";
-        writeStdout(colorText(`ExpressoTS v4.0.0-beta.1`, "green") +
-            colorText(` | ${appName} v${appVersion}`, "blue") +
-            colorText(` | Node ${process.version}`, "blue") +
-            "\n");
-        writeStdout(colorText(`Environment: ${this.colorEnvironment(environment)}`, "yellow") +
-            colorText(` | Port: ${port}`, "blue") +
-            colorText(` | PID: ${process.pid}`, "blue") +
-            "\n");
+        writeStdout(logLine(`ExpressoTS v${FRAMEWORK_VERSION} | ${appName} v${appVersion} | Node ${process.version}`));
+        writeStdout(logLine(`Environment: ${environment} | Port: ${port} | PID: ${process.pid}`));
         if (metrics) {
-            writeStdout(colorText(`Controllers: ${metrics.controllers} | Providers: ${metrics.providers} | Routes: ${metrics.routes}`, "white") + "\n");
+            writeStdout(logLine(`Controllers: ${metrics.controllers} | Providers: ${metrics.providers} | Routes: ${metrics.routes}`));
         }
-        writeStdout(colorText(`Startup: ${startupTime.toFixed(2)}ms`, "yellow") +
-            colorText(` | Memory: ${memoryFormatted}`, "yellow") +
-            "\n");
+        writeStdout(logLine(`Startup: ${startupTime.toFixed(2)}ms | Memory: ${memoryFormatted}`));
     }
     /**
      * Display minimal banner.

package/lib/esm/provider/logger/logger.config.js

@@ -1,12 +1,22 @@
-import { LogLevel } from "./utils/log-levels.js";
+import { LogLevel, parseLogLevel } from "./utils/log-levels.js";
 /**
  * Default logger configuration.
+ *
+ * Honours `process.env.LOG_LEVEL` when set so that any logs emitted
+ * BEFORE the application's `globalConfiguration()` runs (e.g. interceptor
+ * registration during container construction) are gated by the user's
+ * desired log level instead of the development default of `DEBUG`.
+ * Falls back to `DEBUG` in development and `INFO` in production.
+ *
  * @public API
  */
 export function getDefaultLoggerConfig() {
     const isDevelopment = process.env.NODE_ENV !== "production";
+    const envLevel = process.env.LOG_LEVEL;
+    const defaultLevel = isDevelopment ? LogLevel.DEBUG : LogLevel.INFO;
+    const level = envLevel ? parseLogLevel(envLevel) : defaultLevel;
     return {
-        level: isDevelopment ? LogLevel.DEBUG : LogLevel.INFO,
+        level,
         transports: [], // Will be populated with ConsoleTransport by default
         filters: {},
         structured: !isDevelopment, // JSON in production, pretty in dev