alepha 0.14.3 → 0.15.0

package/dist/lock/core/index.d.ts

@@ -12,19 +12,19 @@ import * as dayjs_plugin_duration_js0 from "dayjs/plugin/duration.js";
  */
 declare abstract class LockProvider {
   /**
-   * Set the string value of a key.
-   *
-   * @param key The key of the value to set.
-   * @param value The value to set.
-   * @param nx If set to true, the key will only be set if it does not already exist.
-   * @param px Set the specified expire time, in milliseconds.
-   */
+       * Set the string value of a key.
+       *
+       * @param key The key of the value to set.
+       * @param value The value to set.
+       * @param nx If set to true, the key will only be set if it does not already exist.
+       * @param px Set the specified expire time, in milliseconds.
+       */
   abstract set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
   /**
-   * Remove the specified keys.
-   *
-   * @param keys The keys to delete.
-   */
+       * Remove the specified keys.
+       *
+       * @param keys The keys to delete.
+       */
   abstract del(...keys: string[]): Promise<void>;
 }
 //#endregion
@@ -84,205 +84,205 @@ declare const $lock: {
 };
 interface LockPrimitiveOptions<TFunc extends AsyncFn> {
   /**
-   * The function to execute when the lock is successfully acquired.
-   *
-   * This function:
-   * - Only executes on the instance that successfully acquires the lock
-   * - Has exclusive access to the protected resource during execution
-   * - Should contain the critical section logic that must not run concurrently
-   * - Can be async and perform any operations needed
-   * - Will automatically release the lock upon completion or error
-   * - Has access to the full Alepha dependency injection container
-   *
-   * **Handler Design Guidelines**:
-   * - Keep critical sections as short as possible to minimize lock contention
-   * - Include proper error handling to ensure locks are released
-   * - Use timeouts for external operations to prevent deadlocks
-   * - Log important operations for debugging and monitoring
-   * - Consider idempotency for handlers that might be retried
-   *
-   * @param ...args - The arguments passed to the lock execution
-   * @returns Promise that resolves when the protected operation is complete
-   *
-   * @example
-   * ```ts
-   * handler: async (batchId: string) => {
-   *   console.log(`Processing batch ${batchId} - only one instance will run this`);
-   *
-   *   const batch = await this.getBatchData(batchId);
-   *   const results = await this.processBatchItems(batch.items);
-   *   await this.saveBatchResults(batchId, results);
-   *
-   *   console.log(`Batch ${batchId} completed successfully`);
-   * }
-   * ```
-   */
+       * The function to execute when the lock is successfully acquired.
+       *
+       * This function:
+       * - Only executes on the instance that successfully acquires the lock
+       * - Has exclusive access to the protected resource during execution
+       * - Should contain the critical section logic that must not run concurrently
+       * - Can be async and perform any operations needed
+       * - Will automatically release the lock upon completion or error
+       * - Has access to the full Alepha dependency injection container
+       *
+       * **Handler Design Guidelines**:
+       * - Keep critical sections as short as possible to minimize lock contention
+       * - Include proper error handling to ensure locks are released
+       * - Use timeouts for external operations to prevent deadlocks
+       * - Log important operations for debugging and monitoring
+       * - Consider idempotency for handlers that might be retried
+       *
+       * @param ...args - The arguments passed to the lock execution
+       * @returns Promise that resolves when the protected operation is complete
+       *
+       * @example
+       * ```ts
+       * handler: async (batchId: string) => {
+       *   console.log(`Processing batch ${batchId} - only one instance will run this`);
+       *
+       *   const batch = await this.getBatchData(batchId);
+       *   const results = await this.processBatchItems(batch.items);
+       *   await this.saveBatchResults(batchId, results);
+       *
+       *   console.log(`Batch ${batchId} completed successfully`);
+       * }
+       * ```
+       */
   handler: TFunc;
   /**
-   * Whether the lock should wait for other instances to complete before giving up.
-   *
-   * **wait = false (default)**:
-   * - Non-blocking behavior - if lock is held, immediately return without executing
-   * - Perfect for scheduled tasks where you only want one execution per trigger
-   * - Use when multiple triggers are acceptable but concurrent execution is not
-   * - Examples: periodic cleanup, cron jobs, background maintenance
-   *
-   * **wait = true**:
-   * - Blocking behavior - wait for the current lock holder to finish
-   * - All instances will eventually execute (one after another)
-   * - Perfect for initialization tasks where all instances need the work completed
-   * - Examples: database migrations, cache warming, resource initialization
-   *
-   * **Trade-offs**:
-   * - Non-waiting: Better performance, may miss executions if timing is off
-   * - Waiting: Guaranteed execution order, slower overall throughput
-   *
-   * @default false
-   *
-   * @example
-   * ```ts
-   * // Scheduled task - don't wait, just skip if already running
-   * scheduledCleanup = $lock({
-   *   wait: false,  // Skip if cleanup already running
-   *   handler: async () => { } // perform cleanup
-   * });
-   *
-   * // Migration - wait for completion before proceeding
-   * migration = $lock({
-   *   wait: true,   // All instances wait for migration to complete
-   *   handler: async () => { } // perform migration
-   * });
-   * ```
-   */
+       * Whether the lock should wait for other instances to complete before giving up.
+       *
+       * **wait = false (default)**:
+       * - Non-blocking behavior - if lock is held, immediately return without executing
+       * - Perfect for scheduled tasks where you only want one execution per trigger
+       * - Use when multiple triggers are acceptable but concurrent execution is not
+       * - Examples: periodic cleanup, cron jobs, background maintenance
+       *
+       * **wait = true**:
+       * - Blocking behavior - wait for the current lock holder to finish
+       * - All instances will eventually execute (one after another)
+       * - Perfect for initialization tasks where all instances need the work completed
+       * - Examples: database migrations, cache warming, resource initialization
+       *
+       * **Trade-offs**:
+       * - Non-waiting: Better performance, may miss executions if timing is off
+       * - Waiting: Guaranteed execution order, slower overall throughput
+       *
+       * @default false
+       *
+       * @example
+       * ```ts
+       * // Scheduled task - don't wait, just skip if already running
+       * scheduledCleanup = $lock({
+       *   wait: false,  // Skip if cleanup already running
+       *   handler: async () => { } // perform cleanup
+       * });
+       *
+       * // Migration - wait for completion before proceeding
+       * migration = $lock({
+       *   wait: true,   // All instances wait for migration to complete
+       *   handler: async () => { } // perform migration
+       * });
+       * ```
+       */
   wait?: boolean;
   /**
-   * The unique identifier for the lock.
-   *
-   * Can be either:
-   * - **Static string**: A fixed identifier for the lock
-   * - **Dynamic function**: A function that generates the lock key based on arguments
-   *
-   * **Dynamic Lock Keys**:
-   * - Enable per-resource locking (e.g., per-user, per-file, per-product)
-   * - Allow fine-grained concurrency control
-   * - Prevent unnecessary blocking between unrelated operations
-   *
-   * **Key Design Guidelines**:
-   * - Use descriptive names that indicate the protected resource
-   * - Include relevant identifiers for dynamic keys
-   * - Keep keys reasonably short but unique
-   * - Consider using hierarchical naming (e.g., "service:operation:resource")
-   *
-   * If not provided, defaults to `{serviceName}:{propertyKey}`.
-   *
-   * @example "user-migration"
-   * @example "daily-report-generation"
-   * @example (userId: string) => `user-profile-update:${userId}`
-   * @example (fileId: string, operation: string) => `file-${operation}:${fileId}`
-   *
-   * @example
-   * ```ts
-   * // Static lock key - all instances compete for the same lock
-   * globalCleanup = $lock({
-   *   name: "system-cleanup",
-   *   handler: async () => { } // perform cleanup
-   * });
-   *
-   * // Dynamic lock key - per-user locks, users don't block each other
-   * updateUserProfile = $lock({
-   *   name: (userId: string) => `user-update:${userId}`,
-   *   handler: async (userId: string, data: UserData) => {
-   *     // Only one update per user at a time, but different users can update concurrently
-   *   }
-   * });
-   * ```
-   */
+       * The unique identifier for the lock.
+       *
+       * Can be either:
+       * - **Static string**: A fixed identifier for the lock
+       * - **Dynamic function**: A function that generates the lock key based on arguments
+       *
+       * **Dynamic Lock Keys**:
+       * - Enable per-resource locking (e.g., per-user, per-file, per-product)
+       * - Allow fine-grained concurrency control
+       * - Prevent unnecessary blocking between unrelated operations
+       *
+       * **Key Design Guidelines**:
+       * - Use descriptive names that indicate the protected resource
+       * - Include relevant identifiers for dynamic keys
+       * - Keep keys reasonably short but unique
+       * - Consider using hierarchical naming (e.g., "service:operation:resource")
+       *
+       * If not provided, defaults to `{serviceName}:{propertyKey}`.
+       *
+       * @example "user-migration"
+       * @example "daily-report-generation"
+       * @example (userId: string) => `user-profile-update:${userId}`
+       * @example (fileId: string, operation: string) => `file-${operation}:${fileId}`
+       *
+       * @example
+       * ```ts
+       * // Static lock key - all instances compete for the same lock
+       * globalCleanup = $lock({
+       *   name: "system-cleanup",
+       *   handler: async () => { } // perform cleanup
+       * });
+       *
+       * // Dynamic lock key - per-user locks, users don't block each other
+       * updateUserProfile = $lock({
+       *   name: (userId: string) => `user-update:${userId}`,
+       *   handler: async (userId: string, data: UserData) => {
+       *     // Only one update per user at a time, but different users can update concurrently
+       *   }
+       * });
+       * ```
+       */
   name?: string | ((...args: Parameters<TFunc>) => string);
   /**
-   * Maximum duration the lock can be held before it expires automatically.
-   *
-   * This prevents deadlocks when a process dies while holding a lock or when
-   * operations take longer than expected. The lock will be automatically released
-   * after this duration, allowing other instances to proceed.
-   *
-   * **Duration Guidelines**:
-   * - Set based on expected operation duration plus safety margin
-   * - Too short: Operations may be interrupted by early expiration
-   * - Too long: Failed processes block others for extended periods
-   * - Consider worst-case scenarios and external dependency timeouts
-   *
-   * **Typical Values**:
-   * - Quick operations: 30 seconds - 2 minutes
-   * - Database operations: 5 - 15 minutes
-   * - File processing: 10 - 30 minutes
-   * - Large migrations: 30 minutes - 2 hours
-   *
-   * @default [5, "minutes"]
-   *
-   * @example [30, "seconds"]    // Quick operations
-   * @example [10, "minutes"]    // Database migrations
-   * @example [1, "hour"]        // Long-running batch jobs
-   *
-   * @example
-   * ```ts
-   * quickTask = $lock({
-   *   maxDuration: [2, "minutes"],  // Quick timeout for fast operations
-   *   handler: async () => { } // perform quick task
-   * });
-   *
-   * heavyProcessing = $lock({
-   *   maxDuration: [30, "minutes"], // Longer timeout for heavy work
-   *   handler: async () => { } // perform heavy processing
-   * });
-   * ```
-   */
+       * Maximum duration the lock can be held before it expires automatically.
+       *
+       * This prevents deadlocks when a process dies while holding a lock or when
+       * operations take longer than expected. The lock will be automatically released
+       * after this duration, allowing other instances to proceed.
+       *
+       * **Duration Guidelines**:
+       * - Set based on expected operation duration plus safety margin
+       * - Too short: Operations may be interrupted by early expiration
+       * - Too long: Failed processes block others for extended periods
+       * - Consider worst-case scenarios and external dependency timeouts
+       *
+       * **Typical Values**:
+       * - Quick operations: 30 seconds - 2 minutes
+       * - Database operations: 5 - 15 minutes
+       * - File processing: 10 - 30 minutes
+       * - Large migrations: 30 minutes - 2 hours
+       *
+       * @default [5, "minutes"]
+       *
+       * @example [30, "seconds"]    // Quick operations
+       * @example [10, "minutes"]    // Database migrations
+       * @example [1, "hour"]        // Long-running batch jobs
+       *
+       * @example
+       * ```ts
+       * quickTask = $lock({
+       *   maxDuration: [2, "minutes"],  // Quick timeout for fast operations
+       *   handler: async () => { } // perform quick task
+       * });
+       *
+       * heavyProcessing = $lock({
+       *   maxDuration: [30, "minutes"], // Longer timeout for heavy work
+       *   handler: async () => { } // perform heavy processing
+       * });
+       * ```
+       */
   maxDuration?: DurationLike;
   /**
-   * Additional time to keep the lock active after the handler completes successfully.
-   *
-   * This provides a "cooling off" period that can be useful for:
-   * - Preventing immediate re-execution of the same operation
-   * - Giving time for related systems to process the results
-   * - Avoiding race conditions with dependent operations
-   * - Providing a buffer for cleanup operations
-   *
-   * Can be either:
-   * - **Static duration**: Fixed grace period for all executions
-   * - **Dynamic function**: Grace period determined by execution arguments
-   * - **undefined**: No grace period, lock released immediately after completion
-   *
-   * **Grace Period Use Cases**:
-   * - File processing: Prevent immediate reprocessing of uploaded files
-   * - Cache updates: Allow time for cache propagation
-   * - Batch operations: Prevent overlapping batch processing
-   * - External API calls: Respect rate limiting requirements
-   *
-   * @default undefined (no grace period)
-   *
-   * @example [5, "minutes"]     // Fixed 5-minute grace period
-   * @example [30, "seconds"]    // Short grace for quick operations
-   * @example (userId: string) => userId.startsWith("premium") ? [10, "minutes"] : [2, "minutes"]
-   *
-   * @example
-   * ```ts
-   * fileProcessor = $lock({
-   *   gracePeriod: [10, "minutes"],  // Prevent reprocessing same file immediately
-   *   handler: async (filePath: string) => {
-   *     await this.processFile(filePath);
-   *   }
-   * });
-   *
-   * userOperation = $lock({
-   *   gracePeriod: (userId: string, operation: string) => {
-   *     // Dynamic grace based on operation type
-   *     return operation === 'migration' ? [30, "minutes"] : [5, "minutes"];
-   *   },
-   *   handler: async (userId: string, operation: string) => {
-   *     await this.performUserOperation(userId, operation);
-   *   }
-   * });
-   * ```
-   */
+       * Additional time to keep the lock active after the handler completes successfully.
+       *
+       * This provides a "cooling off" period that can be useful for:
+       * - Preventing immediate re-execution of the same operation
+       * - Giving time for related systems to process the results
+       * - Avoiding race conditions with dependent operations
+       * - Providing a buffer for cleanup operations
+       *
+       * Can be either:
+       * - **Static duration**: Fixed grace period for all executions
+       * - **Dynamic function**: Grace period determined by execution arguments
+       * - **undefined**: No grace period, lock released immediately after completion
+       *
+       * **Grace Period Use Cases**:
+       * - File processing: Prevent immediate reprocessing of uploaded files
+       * - Cache updates: Allow time for cache propagation
+       * - Batch operations: Prevent overlapping batch processing
+       * - External API calls: Respect rate limiting requirements
+       *
+       * @default undefined (no grace period)
+       *
+       * @example [5, "minutes"]     // Fixed 5-minute grace period
+       * @example [30, "seconds"]    // Short grace for quick operations
+       * @example (userId: string) => userId.startsWith("premium") ? [10, "minutes"] : [2, "minutes"]
+       *
+       * @example
+       * ```ts
+       * fileProcessor = $lock({
+       *   gracePeriod: [10, "minutes"],  // Prevent reprocessing same file immediately
+       *   handler: async (filePath: string) => {
+       *     await this.processFile(filePath);
+       *   }
+       * });
+       *
+       * userOperation = $lock({
+       *   gracePeriod: (userId: string, operation: string) => {
+       *     // Dynamic grace based on operation type
+       *     return operation === 'migration' ? [30, "minutes"] : [5, "minutes"];
+       *   },
+       *   handler: async (userId: string, operation: string) => {
+       *     await this.performUserOperation(userId, operation);
+       *   }
+       * });
+       * ```
+       */
   gracePeriod?: ((...args: Parameters<TFunc>) => DurationLike | undefined) | DurationLike;
 }
 declare const envSchema: alepha1.TObject<{
@@ -307,8 +307,8 @@ declare class LockPrimitive<TFunc extends AsyncFn> extends Primitive<LockPrimiti
   }>;
   run(...args: Parameters<TFunc>): Promise<void>;
   /**
-   * Set the lock for the given key.
-   */
+       * Set the lock for the given key.
+       */
   protected lock(key: string): Promise<LockResult>;
   protected setGracePeriod(key: string, lock: LockResult, ...args: Parameters<TFunc>): Promise<void>;
   protected wait(key: string, maxDuration: DurationLike): Promise<void>;
@@ -333,12 +333,12 @@ declare class MemoryLockProvider implements LockProvider {
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly log: alepha_logger0.Logger;
   /**
-   * The in-memory store.
-   */
+       * The in-memory store.
+       */
   protected store: Record<string, string>;
   /**
-   * Timeouts used to expire keys.
-   */
+       * Timeouts used to expire keys.
+       */
   protected storeTimeout: Record<string, Timeout>;
   set(key: string, value: string, nx?: boolean, px?: number): Promise<string>;
   del(...keys: string[]): Promise<void>;

package/dist/lock/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;uBAGsB,YAAA;;;;;;AAAtB;;;uEAcK;ECoDQ;;;;;EAEV,SAAA,GAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,ED/CuC,OC+CvC,CAAA,IAAA,CAAA;;;;;;;;;;ADpEH;;;;ACkEA;;;;;;;;;AAQA;;;;;;;;;;;AAgNC;AAIc;;;;;;;;;AAQf;;;;;;;;;cApOa;iBAAuB,OAgPH,CAAA,CAAA,OAAA,EA/OtB,oBA+OsB,CA/OD,KA+OC,CAAA,CAAA,EA9O9B,aA8O8B,CA9OhB,KA8OgB,CAAA;EAUM,MAAA,EAAA,oBAAA;CAAX;AAAoB,UAlP/B,oBAkP+B,CAAA,cAlPI,OAkPJ,CAAA,CAAA;EA8CH;;;;;;;;;;;;;AA8E7C;;;;ACzbA;;;;ACMA;;;;;;;;;;;;;ECiBa,OAAA,EHuFF,KGvET;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BHyJ2B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAwCxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAiDC,WAAW,WAAW,4BACjC;;cAKA,WAEJ,OAAA,CAFa;mBAEb,OAAA,CAAA;;;wBAGsB,QAAQ,cAAc;;cAGjC,4BAA4B,iBAAiB,UACxD,qBAAqB;0BAAD,cAAA,CAEE;+BACK;;;;uCAEQ;;wBAAA,yBAAA,CAER;iDAII;;YAJJ,OAAA,CAAA;;;eAcD,WAAW,SAAS;;;;+BA8CX,QAAQ;8CAanC,qBACG,WAAW,SACnB;2CAmB4C,eAAe;yBAWvC,WAAW;kCAgBF;;UAiBjB,UAAA;;aAEJ;YACD;;;;;uBC5bU,iBAAA,SAA0B,aAAA;;;;;;cCMnC,kBAAA,YAA8B;uCACN;0BAAA,cAAA,CACb;;AHPxB;;mBGYmB;;AFsDnB;;EACgC,UAAA,YAAA,EElDN,MFkDM,CAAA,MAAA,EElDS,OFkDT,CAAA;EAArB,GAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,EAAA,EAAA,CAAA,EAAA,OAAA,EAAA,EAAA,CAAA,EAAA,MAAA,CAAA,EE3CN,OF2CM,CAAA,MAAA,CAAA;EACM,GAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAA,CAAA,EE9BsB,OF8BtB,CAAA,IAAA,CAAA;EAAd,QAAA,GAAA;;;;;;;;;ADpEH;;;;ACkEa,cG5CA,UHgDZ,EGhDsB,OAAA,CAAA,OHgDtB,CGhCC,OAAA,CAhBqB,MAAA,CHgDtB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/core/providers/LockProvider.ts","../../../src/lock/core/primitives/$lock.ts","../../../src/lock/core/providers/LockTopicProvider.ts","../../../src/lock/core/providers/MemoryLockProvider.ts","../../../src/lock/core/index.ts"],"mappings":"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"}

package/dist/lock/redis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/redis/providers/RedisLockProvider.ts","../../../src/lock/redis/index.ts"],"sourcesContent":[],"mappings":";;;;;;cAKa,iBAAA,YAA6B;0BAAX,cAAA,CACP;oCACU;8DAO7B;EATQ,GAAA,CAAA,GAAA,IAAA,EAAA,MAAA,EAAkB,CAAA,EA8BQ,OA9BR,CAAA,IAAA,CAAA;;;;;;;;;AAA/B;AAA+B,cCYlB,eDXW,ECWI,OAAA,CAAA,ODXJ,CC2BtB,OAAA,CAhB0B,MAAA,CDXJ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/lock/redis/providers/RedisLockProvider.ts","../../../src/lock/redis/index.ts"],"mappings":";;;;;;cAKa,iBAAA,YAA6B,YAAA;EAAA,mBAAA,GAAA,EAAX,cAAA,CACP,MAAA;EAAA,mBAAA,aAAA,EACU,aAAA;EAAA,IAAA,GAAA,UAAA,KAAA,UAAA,EAAA,YAAA,EAAA,YAO7B,OAAA;EAAA,IAAA,GAAA,IAAA,aAqBkC,OAAA;AAAA;;;;AClBvC;;;;;cAAa,eAAA,EAAe,OAAA,CAAA,OAAA,CAgB1B,OAAA,CAhB0B,MAAA"}

package/dist/logger/index.d.ts

@@ -159,8 +159,8 @@ declare class PrettyFormatterProvider extends LogFormatterProvider {
   protected pad2: (n: number) => string;
   protected pad3: (n: number) => string;
   /**
-   * Avoid to display the whole UUID in development mode
-   */
+       * Avoid to display the whole UUID in development mode
+       */
   protected formatContext(context: string): string;
   protected formatError(error: Error): string;
 }
@@ -237,36 +237,36 @@ declare class PrettyFormatterProvider extends LogFormatterProvider {
 declare const AlephaLogger: alepha6.Service<alepha6.Module>;
 declare const envSchema: alepha6.TObject<{
   /**
-   * Default log level for the application.
-   *
-   * Default by environment:
-   * - dev = info
-   * - prod = info
-   * - test = error
-   *
-   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
-   *
-   * Level can be set for a specific module:
-   *
-   * @example
-   * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
-   * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
-   */
+       * Default log level for the application.
+       *
+       * Default by environment:
+       * - dev = info
+       * - prod = info
+       * - test = error
+       *
+       * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
+       *
+       * Level can be set for a specific module:
+       *
+       * @example
+       * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
+       * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
+       */
   LOG_LEVEL: alepha6.TOptional<alepha6.TString>;
   /**
-   * Built-in log formats.
-   * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
-   * - "pretty" - Simple text format, human-readable, with colors. {@link PrettyFormatterProvider}
-   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
-   */
+       * Built-in log formats.
+       * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
+       * - "pretty" - Simple text format, human-readable, with colors. {@link PrettyFormatterProvider}
+       * - "raw" - Raw format, no formatting, just the message. {@link RawFormatterProvider}
+       */
   LOG_FORMAT: alepha6.TOptional<alepha6.TUnsafe<"json" | "pretty" | "raw">>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
     /**
-     * Current log level for the application or specific modules.
-     */
+             * Current log level for the application or specific modules.
+             */
     "alepha.logger.level"?: string;
   }
   interface Hooks {
@@ -275,8 +275,7 @@ declare module "alepha" {
       entry: LogEntry;
     };
   }
-}
-//# sourceMappingURL=index.d.ts.map
+} //# sourceMappingURL=index.d.ts.map
 //#endregion
 export { $logger, AlephaLogger, ConsoleColorProvider, ConsoleDestinationProvider, JsonFormatterProvider, LogDestinationProvider, LogEntry, LogFormatterProvider, Logger, LoggerPrimitiveOptions, MemoryDestinationProvider, PrettyFormatterProvider, logEntrySchema };
 //# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/logger/schemas/logEntrySchema.ts","../../src/logger/providers/LogDestinationProvider.ts","../../src/logger/providers/LogFormatterProvider.ts","../../src/logger/services/Logger.ts","../../src/logger/primitives/$logger.ts","../../src/logger/providers/ConsoleColorProvider.ts","../../src/logger/providers/ConsoleDestinationProvider.ts","../../src/logger/providers/JsonFormatterProvider.ts","../../src/logger/providers/MemoryDestinationProvider.ts","../../src/logger/providers/PrettyFormatterProvider.ts","../../src/logger/index.ts"],"sourcesContent":[],"mappings":";;;;;cAEa,wBAAc;SAWzB,OAAA,CAAA;;;EAXW,MAAA,iBAWX;EAAA,OAAA,mBAAA,iBAAA;;;;;KAEU,QAAA,GAAW,cAAc;;;uBCbf,sBAAA;yCAC0B;;;;uBCD1B,oBAAA;yBACU;;;;AFDnB,cGUA,MAAA,YAAkB,eHC7B,CAAA;EAAA,mBAAA,MAAA,EGAyB,MHAzB;gCGC4B;kCACE;uCACK;6BAER;;;;;sBAcP;;aH9BK,CAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,IAAA,KAAA,CAAA,CAAA,EAAA,MAAA;EAaf,UAAA,CAAQ,KAAA,EAAA,MAAiB,EAAA,GAAA,EAAA,MAAA,CAAd,EGsC0B,QHtCpB;;iCG6FW;;EF1GlB,IAAA,CAAA,OAAA,EAAA,MAAA,EAAA,IAAsB,CAAA,EAAA,OAAA,CACI,EAAA,IAAA;;;;ECD1B,UAAA,GAAA,CAAA,KAAA,ECyIC,QDzImB,EAAA,OACV,EAAA,MAAQ,EAAA,IAAA,CAAA,EAAA,OAAA,CAAA,EAAA,IAAA;wBC8KhB;;;;;;;AH/KxB;;;;;;;;;;;;;;AAaA;;cIOa;aAAoB,yBAA8B;EHpBzC,MAAA,EAAA,aAAA;;UGgCL,sBAAA;;AFhCjB;;;cGYa,oBAAA;;;;ILZA,GAAA,EAAA,MAAA;IAWX,KAAA,EAAA,MAAA;;;;;;;;;;;UAXyB,EAAA,MAAA;IAAA,KAAA,EAAA,MAAA;IAaf,IAAA,EAAA,MAAQ;;;;ECbE,CAAA;;;;ECAA,CAAA;6BGsCK;;;EF5Bd,SAAO,CAAA,CAAA,EAAA,OAAA;EACO,GAAA,CAAA,KAAA,EAAA,MAAA,OEgDH,oBAAA,CAAqB,MFhDlB,EAAA,IAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;;;cGXd,0BAAA,SAAmC,sBAAA;;;;;cCCnC,qBAAA,SAA8B,oBAAA;gBACpB;yBAoBS;APtBhC;;;cQCa,yBAAA,SAAkC,sBAAA;qBAC1B,MAAM;;ERFd,CAAA,CAAA;EAWX,SAAA,OAAA,EAAA;;;kCQHuC;;;;;;;;URRd,EAAA,MAAA;IAAA,SAAA,EAAA,MAAA;EAaf,CAAA,GAAA;;;;ACbZ;;;cQGa,uBAAA,SAAgC,oBAAA;ETHhC,UAAA,KAAA,ESII,oBTOf;EAAA,UAAA,MAAA,ESNgB,MTMhB;gBSJqB;;;;;;;;+BAyFQ;;;;;;;;;;;ATnF/B;;;;ACbA;;;;ACAA;;;;ACUA;;;;;;;;;;;;;;;;ACUA;;;;;;AAYA;;;;ACpBA;;;;ACZA;;;;ACCA;;;;;;;;ACAA;;;;;;;cE6Fa,cAAY,OAAA,CAAA,QAoFvB,OAAA,CApFuB,MAAA;cAwFnB,mBAAS;EDnLF;;;;;;;;;;AC2Fb;AAoFG;;;;;WAIY,mBAAA,CA4Bb,OAAA,CAAA,OAAA,CA5Ba;EAAA;AAAA;;;;;EAiCgB,UAAA,mBAAA,gBAAA,CAAA,MAAA,GAAA,QAAA,GAAA,KAAA,CAAA,CAAA;EAYlB;eAAQ,QAAA,CAAA;EAAA,UAAA,GAAA,SAZU,OAYV,CAZkB,MAYlB,CAAA,OAZgC,SAYhC,CAAA,CAAA,CAAA,CAAA;;;;;;;;;;aAAR"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/logger/schemas/logEntrySchema.ts","../../src/logger/providers/LogDestinationProvider.ts","../../src/logger/providers/LogFormatterProvider.ts","../../src/logger/services/Logger.ts","../../src/logger/primitives/$logger.ts","../../src/logger/providers/ConsoleColorProvider.ts","../../src/logger/providers/ConsoleDestinationProvider.ts","../../src/logger/providers/JsonFormatterProvider.ts","../../src/logger/providers/MemoryDestinationProvider.ts","../../src/logger/providers/PrettyFormatterProvider.ts","../../src/logger/index.ts"],"mappings":";;;;;cAEa,cAAA,UAAc,OAAA;EAAA,KAAA,EAWzB,OAAA,CAAA,OAAA;EAAA,OAAA;;;;;;;;KAEU,QAAA,GAAW,MAAA,QAAc,cAAA;;;uBCbf,sBAAA;EAAA,SAAA,MAAA,OAAA,UAAA,KAAA,EAC0B,QAAA;AAAA;;;uBCD1B,oBAAA;EAAA,SAAA,OAAA,KAAA,EACU,QAAA;AAAA;;;cCSnB,MAAA,YAAkB,eAAA;EAAA,mBAAA,MAAA,EACJ,MAAA;EAAA,mBAAA,SAAA,EACG,oBAAA;EAAA,mBAAA,WAAA,EACE,sBAAA;EAAA,mBAAA,gBAAA,EACK,gBAAA;EAAA,mBAAA,MAAA,EAER,MAAA;EAAA,mBAAA,OAAA;EAAA,mBAAA,MAAA;EAAA,mBAAA,GAAA;EAAA,UAAA,WAAA;EAAA,UAAA,QAAA,EAcP,QAAA;EAAA,YAAA,OAAA,UAAA,MAAA;EAAA,IAAA,QAAA;EAAA,IAAA,MAAA;EAAA,WAAA,KAAA,UAAA,GAAA,WAqB2B,QAAA;EAAA,QAAA,cAAA;EAAA,WAAA,SAAA,WAuDT,QAAA;EAAA,MAAA,OAAA,UAAA,IAAA;EAAA,KAAA,OAAA,UAAA,IAAA;EAAA,KAAA,OAAA,UAAA,IAAA;EAAA,MAAA,OAAA,UAAA,IAAA;EAAA,MAAA,OAAA,UAAA,IAAA;EAAA,UAAA,IAAA,KAAA,EA+BjB,QAAA,EAAA,OAAA,UAAA,IAAA;EAAA,UAAA,KAAA,KAAA,EAsCC,QAAA,EAAA,OAAA;AAAA;;;;AC3JxB;;;;;;AAYA;;;;ACpBA;;;;ACZA;;;;cFoBa,OAAA;EAAA,CAAA,OAAA,GAAoB,sBAAA,GAA8B,MAAA;EAAA;;UAY9C,sBAAA;EAAA,IAAA;AAAA;;;cCpBJ,oBAAA;EAAA,gBAAA,MAAA;IAAA,KAAA;IAAA,KAAA;IAAA,GAAA;IAAA,KAAA;IAAA,MAAA;IAAA,IAAA;IAAA,MAAA;IAAA,IAAA;IAAA,UAAA;IAAA,eAAA;IAAA,SAAA;IAAA,cAAA;IAAA,KAAA;IAAA,UAAA;IAAA,MAAA;IAAA,KAAA;IAAA,IAAA;IAAA,IAAA;IAAA,KAAA;IAAA,KAAA;EAAA;EAAA,mBAAA,GAAA;IAAA,QAAA;IAAA,WAAA;EAAA;EAAA,mBAAA,MAAA,EA0Bc,MAAA;EAAA,UAAA,OAAA;EAAA,YAAA;EAAA,UAAA;EAAA,IAAA,KAAA,eAqBH,oBAAA,CAAqB,MAAA,EAAA,IAAA,UAAA,KAAA;AAAA;;;cC3DhC,0BAAA,SAAmC,sBAAA;EAAA,MAAA,OAAA;AAAA;;;cCCnC,qBAAA,SAA8B,oBAAA;EAAA,OAAA,KAAA,EACpB,QAAA;EAAA,gBAAA,KAAA,EAoBS,KAAA;AAAA;;;cCrBnB,yBAAA,SAAkC,sBAAA;EAAA,UAAA,OAAA,EAC1B,KAAA,CAAM,QAAA;IAAA,SAAA;EAAA;EAAA,SAAA,OAAA;IAAA,UAAA;EAAA;EAAA,MAAA,SAAA,UAAA,KAAA,EAMc,QAAA;EAAA,IAAA,KAAA;IAAA,OAAA;IAAA,GAAA;IAAA,IAAA;IAAA,KAAA;IAAA,OAAA;IAAA,OAAA;IAAA,MAAA;IAAA,SAAA;EAAA;IAAA,SAAA;EAAA;EAAA,MAAA;AAAA;;;cCL5B,uBAAA,SAAgC,oBAAA;EAAA,UAAA,KAAA,EAC5B,oBAAA;EAAA,UAAA,MAAA,EACC,MAAA;EAAA,OAAA,KAAA,EAEK,QAAA;EAAA,gBAAA,SAAA;EAAA,UAAA,IAAA,GAAA,CAAA;EAAA,UAAA,IAAA,GAAA,CAAA;EAAA;;;EAAA,UAAA,cAAA,OAAA;EAAA,UAAA,YAAA,KAAA,EAyFQ,KAAA;AAAA;;;;ACF/B;AAoFG;;;;;;;AAIY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAxFF,YAAA,EAAY,OAAA,CAAA,OAAA,CAoFvB,OAAA,CApFuB,MAAA;AAAA,cAwFnB,SAAA,UAAS,OAAA;EAAA;;AAAA;;;;;;;;;;;;;;EAAA,SAAA,oBAwCb,OAAA,CAAA,OAAA;EAAA;;;;;;EAAA,UAAA;;;wBAK6B,OAAA,CAAQ,MAAA,QAAc,SAAA;EAAA,UAAA,KAAA;IAAA;;;IAAA;EAAA;EAAA,UAAA,KAAA;IAAA,GAAA;MAAA,OAAA;MAAA,KAAA,EAYxC,QAAA;IAAA;EAAA;AAAA"}

package/dist/logger/index.js

@@ -503,12 +503,22 @@ const AlephaLogger = $module({
 	}
 });
 const envSchema = t.object({
-	LOG_LEVEL: t.optional(t.text({ lowercase: true })),
+	LOG_LEVEL: t.optional(t.text({
+		description: `Application log level on startup.
+Levels are: trace, debug, info, warn, error, silent
+Level can be set for a specific module:
+"my.module.name:debug,info" -> Set debug level for my.module.name and info for all other modules
+"alepha:trace,info" -> Set trace level for all alepha modules and info for all other modules`,
+		lowercase: true
+	})),
 	LOG_FORMAT: t.optional(t.enum([
 		"json",
 		"pretty",
 		"raw"
-	], { lowercase: true }))
+	], {
+		description: "Default log format for the application.",
+		lowercase: true
+	}))
 });
 
 //#endregion