alepha/dist/logger/index.d.ts

Easy-to-use modern TypeScript framework for building many kind of applications.

import { Alepha, KIND, LogLevel, LoggerInterface, Static } from "alepha";
import { DateTimeProvider } from "alepha/datetime";
//#region ../../src/logger/schemas/logEntrySchema.d.ts
declare const logEntrySchema: import("zod").ZodObject<{
  level: import("zod").ZodEnum<{
    DEBUG: "DEBUG";
    ERROR: "ERROR";
    INFO: "INFO";
    SILENT: "SILENT";
    TRACE: "TRACE";
    WARN: "WARN";
  }>;
  message: import("zod").ZodString;
  service: import("zod").ZodString;
  module: import("zod").ZodString;
  context: import("zod").ZodOptional<import("zod").ZodString>;
  app: import("zod").ZodOptional<import("zod").ZodString>;
  data: import("zod").ZodOptional<import("zod").ZodAny>;
  timestamp: import("zod").ZodNumber;
}, import("zod/v4/core").$strip>;
type LogEntry = Static<typeof logEntrySchema>;
//#endregion
//#region ../../src/logger/providers/ConsoleColorProvider.d.ts
declare class ConsoleColorProvider {
  static readonly COLORS: {
    RESET: string;
    BLACK: string;
    RED: string;
    GREEN: string;
    ORANGE: string;
    BLUE: string;
    PURPLE: string;
    CYAN: string;
    GREY_LIGHT: string;
    GREY_LIGHT_BOLD: string;
    GREY_DARK: string;
    GREY_DARK_BOLD: string;
    WHITE: string;
    WHITE_BOLD: string;
    DIM: string;
    BOLD: string;
    INVERSE: string;
    SILENT: string;
    ERROR: string;
    WARN: string;
    INFO: string;
    DEBUG: string;
    TRACE: string;
  };
  protected readonly alepha: Alepha;
  protected enabled: boolean;
  constructor();
  isEnabled(): boolean;
  set(color: keyof typeof ConsoleColorProvider.COLORS, text: string, reset?: string): string;
}
//#endregion
//#region ../../src/logger/providers/LogFormatterProvider.d.ts
declare abstract class LogFormatterProvider {
  abstract format(entry: LogEntry): string;
}
//#endregion
//#region ../../src/logger/providers/PrettyFormatterProvider.d.ts
declare class PrettyFormatterProvider extends LogFormatterProvider {
  protected color: ConsoleColorProvider;
  protected alepha: Alepha;
  format(entry: LogEntry): string;
  formatTimestamp(timestamp: number): string;
  protected pad2: (n: number) => string;
  protected pad3: (n: number) => string;
  /**
   * Avoid to display the whole UUID in development mode
   */
  protected formatContext(context: string): string;
  protected formatError(error: Error): string;
}
//#endregion
//#region ../../src/logger/providers/CliFormatterProvider.d.ts
/**
 * Compact formatter for CLI output.
 *
 * Renders `HH:MM:SS L message {json}` — a short clock time, a single-letter
 * level colored by severity, the message, and any structured data appended
 * dim. Deliberately drops the `<module.service>`, app name and context UUID
 * that {@link PrettyFormatterProvider} prints: in an interactive CLI session
 * those are noise. Use `pretty` (or `--verbose`) when you need them, `raw`
 * when you want the bare message for piping, and `json` for aggregation.
 */
declare class CliFormatterProvider extends PrettyFormatterProvider {
  format(entry: LogEntry): string;
  /**
   * Short clock time without milliseconds (HH:MM:SS).
   */
  protected formatClockTime(timestamp: number): string;
}
//#endregion
//#region ../../src/logger/providers/JsonFormatterProvider.d.ts
declare class JsonFormatterProvider extends LogFormatterProvider {
  format(entry: LogEntry): string;
  formatJsonError(error: Error): object;
}
//#endregion
//#region ../../src/logger/providers/LogDestinationProvider.d.ts
declare abstract class LogDestinationProvider {
  abstract write(message: string, entry: LogEntry): void;
}
//#endregion
//#region ../../src/logger/providers/RawFormatterProvider.d.ts
declare class RawFormatterProvider extends LogFormatterProvider {
  format(entry: LogEntry): string;
}
//#endregion
//#region ../../src/logger/services/Logger.d.ts
declare class Logger implements LoggerInterface {
  protected readonly alepha: Alepha;
  /**
   * Formatter chosen at register time (from `LOG_FORMAT`, honoring any
   * custom `LogFormatterProvider` substitution). Used unless a runtime
   * `alepha.logger.format` override is set — see {@link formatter}.
   */
  protected readonly defaultFormatter: LogFormatterProvider;
  protected readonly jsonFormatter: JsonFormatterProvider;
  protected readonly prettyFormatter: PrettyFormatterProvider;
  protected readonly rawFormatter: RawFormatterProvider;
  protected readonly cliFormatter: CliFormatterProvider;
  protected readonly destination: LogDestinationProvider;
  protected readonly dateTimeProvider: DateTimeProvider;
  protected readonly levels: Record<string, number>;
  protected readonly service: string;
  protected readonly module: string;
  protected readonly app?: string;
  protected appLogLevel: string;
  protected logLevel: LogLevel;
  constructor(service: string, module: string);
  get context(): string | undefined;
  get level(): string;
  /**
   * Active formatter. Honors a runtime `alepha.logger.format` override
   * (read live, like {@link level}); otherwise falls back to the
   * register-time {@link defaultFormatter} so custom substitutions and the
   * `LOG_FORMAT` default keep working.
   */
  protected get formatter(): LogFormatterProvider;
  parseLevel(level: string, app: string): LogLevel;
  protected matchesPattern(moduleName: string, pattern: string): boolean;
  asLogLevel(something: string): LogLevel;
  /**
   * Whether a message at `level` would actually be emitted given the current
   * active level (read live from state). Mirrors the threshold used by
   * {@link log}: a level is enabled when it sits at or above the active one.
   *
   * @example
   * // active level = INFO
   * log.isLevelEnabled("DEBUG"); // false
   * log.isLevelEnabled("WARN");  // true
   */
  isLevelEnabled(level: LogLevel): boolean;
  error(message: string, data?: unknown): void;
  warn(message: string, data?: unknown): void;
  info(message: string, data?: unknown): void;
  debug(message: string, data?: unknown): void;
  trace(message: string, data?: unknown): void;
  protected log(level: LogLevel, message: string, data?: unknown): void;
  protected emit(entry: LogEntry, message?: string): void;
}
//#endregion
//#region ../../src/logger/primitives/$logger.d.ts
/**
 * Create a logger.
 *
 * `name` is optional, by default it will use the name of the service.
 *
 * @example
 * ```ts
 * import { $logger } from "alepha";
 *
 * class MyService {
 * 	log = $logger();
 *
 *   constructor() {
 *     this.log.info("Service initialized");
 *     // print something like '[23:45:53.326] INFO <app.MyService>: Service initialized'
 *   }
 * }
 * ```
 */
declare const $logger: {
  (options?: LoggerPrimitiveOptions): Logger;
  [KIND]: typeof Logger;
};
interface LoggerPrimitiveOptions {
  name?: string;
}
//#endregion
//#region ../../src/logger/providers/ConsoleDestinationProvider.d.ts
declare class ConsoleDestinationProvider extends LogDestinationProvider {
  write(message: string): void;
}
//#endregion
//#region ../../src/logger/providers/MemoryDestinationProvider.d.ts
declare class MemoryDestinationProvider extends LogDestinationProvider {
  protected entries: Array<LogEntry & {
    formatted: string;
  }>;
  readonly options: {
    maxEntries: number;
  };
  write(formatted: string, entry: LogEntry): void;
  get logs(): ({
    level: "DEBUG" | "ERROR" | "INFO" | "SILENT" | "TRACE" | "WARN";
    message: string;
    service: string;
    module: string;
    context?: string | undefined;
    app?: string | undefined;
    data?: any;
    timestamp: number;
  } & {
    formatted: string;
  })[];
  clear(): void;
}
//#endregion
//#region ../../src/logger/index.d.ts
/**
 * Configurable logging with multiple outputs.
 *
 * **Features:**
 * - Global logger access
 * - JSON format
 * - Pretty colored output
 * - Compact CLI format
 * - Raw text format
 * - Console destination
 * - Memory destination (for devtools)
 * - Custom handlers
 * - Configuration via `LOG_LEVEL`, `LOG_FORMAT`, and `DEBUG`
 *
 * @module alepha.logger
 */
declare const AlephaLogger: import("alepha").Service<import("alepha").Module>;
declare const envSchema: import("zod").ZodObject<{
  DEBUG: import("zod").ZodOptional<import("zod").ZodString>;
  LOG_LEVEL: import("zod").ZodOptional<import("zod").ZodString>;
  LOG_FORMAT: import("zod").ZodOptional<import("zod").ZodEnum<{
    cli: "cli";
    json: "json";
    pretty: "pretty";
    raw: "raw";
  }>>;
}, import("zod/v4/core").$strip>;
declare module "alepha" {
  interface Env extends Partial<Static<typeof envSchema>> {}
  interface State {
    /**
     * Current log level for the application or specific modules.
     */
    "alepha.logger.level"?: string;
    /**
     * Runtime override for the log format (`json` | `pretty` | `raw`).
     *
     * Unset → the formatter chosen at register time from `LOG_FORMAT`
     * (honoring any custom `LogFormatterProvider` substitution) is used.
     * When set, it overrides both the active formatter and the CLI's
     * dynamic/"stylish" task UI (which is enabled only for `raw`). Set it
     * to flip output at runtime — e.g. the CLI `--verbose` flag forces
     * `pretty`.
     */
    "alepha.logger.format"?: string;
  }
  interface Hooks {
    log: {
      message?: string;
      entry: LogEntry;
    };
  }
}
//#endregion
export { $logger, AlephaLogger, CliFormatterProvider, ConsoleColorProvider, ConsoleDestinationProvider, JsonFormatterProvider, LogDestinationProvider, LogEntry, LogFormatterProvider, Logger, LoggerPrimitiveOptions, MemoryDestinationProvider, PrettyFormatterProvider, RawFormatterProvider, logEntrySchema };
//# sourceMappingURL=index.d.ts.map