@orieljs/log 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+Oriel
+Copyright 2026 meeeet-dev and Oriel contributors
+
+This product includes software developed by the Oriel project
+(https://orieljs.vercel.app, https://github.com/orieljs).
+
+Oriel is licensed under the Apache License, Version 2.0 (see LICENSE).
+The Oriel name and logo are not covered by that license; see TRADEMARKS.md
+(https://github.com/orieljs/framework/blob/main/TRADEMARKS.md).

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+import { Logger, LogLevel, OrielError, ErrorKind, LogManager as LogManager$1, Container } from '@orieljs/contracts';
+import pino from 'pino';
+import { WriteStream } from 'node:fs';
+import { Writable } from 'node:stream';
+import * as _orieljs_support from '@orieljs/support';
+import { ServiceProvider } from '@orieljs/support';
+
+/**
+ * Implements the full `Logger` contract on top of one `write()` method: level filtering, merging in the current
+ * scope's context (`context.ts`) and serializing `Error` values (`levels.ts`) all happen here, once.
+ */
+declare abstract class BaseLogger implements Logger {
+    protected readonly minimumLevel: LogLevel;
+    constructor(minimumLevel?: LogLevel);
+    log(level: LogLevel, message: string, context?: Record<string, unknown>): void;
+    emergency(message: string, context?: Record<string, unknown>): void;
+    alert(message: string, context?: Record<string, unknown>): void;
+    critical(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    warning(message: string, context?: Record<string, unknown>): void;
+    notice(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    withContext(context: Record<string, unknown>): this;
+    /** Called only when `level` already meets this logger's configured minimum, with context fully resolved. */
+    protected abstract write(level: LogLevel, message: string, context: Record<string, unknown>): void;
+}
+
+/** A channel backed by a pino logger writing to an arbitrary destination stream (file, stderr, ...). */
+declare class PinoLogger extends BaseLogger {
+    private readonly pinoInstance;
+    constructor(pinoInstance: pino.Logger, minimumLevel?: LogLevel);
+    protected write(level: LogLevel, message: string, context: Record<string, unknown>): void;
+}
+
+/** The `single` channel: everything appended to one file, e.g. `storage/logs/oriel.log`. */
+declare function createSingleChannel(path: string, minimumLevel?: LogLevel): PinoLogger;
+/** The `daily` channel: one file per day under the same directory, pruned after `days`. */
+declare function createDailyChannel(path: string, days?: number, minimumLevel?: LogLevel, now?: () => Date): PinoLogger;
+/** The `stderr` channel. */
+declare function createStderrChannel(minimumLevel?: LogLevel): PinoLogger;
+
+/** Merges `context` into the log context for the current scope (Laravel's `Log::withContext()`). */
+declare function mergeLogContext(context: Record<string, unknown>): void;
+/** The merged log context for the current scope, or `{}` if none has been added. */
+declare function currentLogContext(): Record<string, unknown>;
+
+/**
+ * Writes to `<dir>/<stem>-<YYYY-MM-DD>.log`, switching files when the local calendar day changes and deleting files
+ * older than `days` each time it rolls over. `now` is injectable so tests can simulate day boundaries without a
+ * fake timer.
+ */
+declare class DailyRotatingStream extends Writable {
+    private readonly days;
+    private readonly now;
+    private readonly dir;
+    private readonly stem;
+    private currentDate;
+    private stream;
+    /**
+     * The in-flight `_write()`'s callback, if any, tagged with the exact child stream it was issued for. Resolved
+     * either by that stream's own write completing or by that same stream's `'error'` listener, whichever comes
+     * first, so a write can never hang on a broken destination. Scoping it to `stream` (rather than just tracking
+     * "the current callback") matters across a rollover: a superseded stream can still emit a late `'error'` (e.g.
+     * a failed flush during its fire-and-forget `end()`) after a write is already pending on the *new* stream, and
+     * that stale error must only produce its own stderr notice, never resolve someone else's pending write.
+     */
+    private pending;
+    constructor(basePath: string, days: number, now?: () => Date);
+    private pathFor;
+    private today;
+    /**
+     * Opens the file at `path` and attaches an `'error'` listener so an I/O failure (disk full, EACCES, EISDIR, ...)
+     * on this one child stream can never crash the process: it's reported as a one-line notice on `process.stderr`,
+     * the stream is dropped (the next write reopens it), and it is never re-emitted on `this`.
+     *
+     * `protected` rather than `private` only so a test can subclass and capture the real child streams this opens
+     * (node:fs's ESM module namespace can't be `vi.spyOn()`'d), to simulate a stream retired by rollover emitting a
+     * late error while a write is already pending on its replacement.
+     */
+    protected openStream(path: string): WriteStream;
+    private ensureStream;
+    /**
+     * Deletes this channel's files dated before the oldest of the `days` most recent local days (today included).
+     * Only names that are exactly `<stem>-<YYYY-MM-DD>.log` count, so a sibling channel sharing the prefix
+     * (e.g. `oriel-worker-<date>.log` next to `oriel-<date>.log`) is never touched.
+     */
+    private prune;
+    _write(chunk: unknown, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+}
+
+declare class UnknownLogChannelError extends Error implements OrielError {
+    readonly channel: string;
+    readonly kind: ErrorKind;
+    constructor(channel: string);
+}
+declare class UnknownLogDriverError extends Error implements OrielError {
+    readonly driver: string;
+    readonly kind: ErrorKind;
+    constructor(driver: string);
+}
+declare class LogChannelCycleError extends Error implements OrielError {
+    readonly channel: string;
+    readonly kind: ErrorKind;
+    constructor(channel: string);
+}
+declare class InvalidLogLevelError extends Error implements OrielError {
+    readonly level: string;
+    readonly kind: ErrorKind;
+    constructor(level: string);
+}
+
+/** The `Log` facade (Laravel's `Illuminate\Support\Facades\Log`). `Log.channel('single').info(...)`. */
+declare const Log: _orieljs_support.Facade<LogManager$1, object>;
+/** With no args, the LogManager itself. With a message, logs it at `debug` (Laravel's `logger()` helper). */
+declare function logger(): LogManager$1;
+declare function logger(message: string, context?: Record<string, unknown>): void;
+
+/** RFC 5424 severities, most severe first. Higher numbers are more severe. */
+declare const LEVEL_SEVERITY: Record<LogLevel, number>;
+/** True when `level` is at least as severe as `minimum` (e.g. `error` meets a `warning` threshold). */
+declare function meetsLevel(level: LogLevel, minimum: LogLevel): boolean;
+/**
+ * `Error` objects don't survive `JSON.stringify` (message/stack/name aren't own enumerable properties), so any
+ * `Error` values directly on the context object are expanded one level deep into a plain `{ name, message, stack }`.
+ * This is how `LogManager.error(message, { exception })` (Http's exception handler) ends up readable in log output.
+ */
+declare function serializeContext(context: Record<string, unknown> | undefined): Record<string, unknown>;
+
+/** `LogManager`: resolves channels by name from `config('logging')`, lazily and cached. */
+declare class LogManager implements LogManager$1 {
+    private readonly container;
+    private readonly channels;
+    private readonly drivers;
+    private readonly resolving;
+    constructor(container: Container);
+    private loggingConfig;
+    channel(name?: string): Logger;
+    stack(channels: string[]): Logger;
+    log(logLevel: LogLevel, message: string, context?: Record<string, unknown>): void;
+    emergency(message: string, context?: Record<string, unknown>): void;
+    alert(message: string, context?: Record<string, unknown>): void;
+    critical(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    warning(message: string, context?: Record<string, unknown>): void;
+    notice(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    withContext(context: Record<string, unknown>): this;
+}
+
+/** Binds the LogManager and merges Laravel 11's `logging` defaults (stack -> single, LOG_LEVEL=debug). */
+declare class LogServiceProvider extends ServiceProvider {
+    register(): void;
+}
+
+/** The `null` channel: discards every entry (Laravel's `NullHandler`). */
+declare class NullLogger extends BaseLogger {
+    protected write(): void;
+}
+
+/** `Log.stack([...])`: fans every entry out to each constituent channel, which does its own level filtering. */
+declare class StackLogger implements Logger {
+    private readonly channels;
+    constructor(channels: Logger[]);
+    log(level: LogLevel, message: string, context?: Record<string, unknown>): void;
+    emergency(message: string, context?: Record<string, unknown>): void;
+    alert(message: string, context?: Record<string, unknown>): void;
+    critical(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    warning(message: string, context?: Record<string, unknown>): void;
+    notice(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    /** Context is scoped by the container (see context.ts), not per-instance, so this affects every channel. */
+    withContext(context: Record<string, unknown>): this;
+}
+
+export { BaseLogger, DailyRotatingStream, InvalidLogLevelError, LEVEL_SEVERITY, Log, LogChannelCycleError, LogManager, LogServiceProvider, NullLogger, PinoLogger, StackLogger, UnknownLogChannelError, UnknownLogDriverError, createDailyChannel, createSingleChannel, createStderrChannel, currentLogContext, logger, meetsLevel, mergeLogContext, serializeContext };

package/dist/index.js

@@ -0,0 +1,472 @@
+// context.ts
+import { currentContainer } from "@orieljs/container";
+var rootKey = {};
+var contexts = /* @__PURE__ */ new WeakMap();
+function mergeLogContext(context) {
+  const key = currentContainer() ?? rootKey;
+  contexts.set(key, { ...contexts.get(key), ...context });
+}
+function currentLogContext() {
+  return contexts.get(currentContainer() ?? rootKey) ?? {};
+}
+
+// errors.ts
+var UnknownLogChannelError = class extends Error {
+  constructor(channel) {
+    super(`Log channel [${channel}] is not defined in config('logging.channels').`);
+    this.channel = channel;
+    this.name = "UnknownLogChannelError";
+  }
+  channel;
+  kind = "Server";
+};
+var UnknownLogDriverError = class extends Error {
+  constructor(driver) {
+    super(`Log driver [${driver}] is not registered.`);
+    this.driver = driver;
+    this.name = "UnknownLogDriverError";
+  }
+  driver;
+  kind = "Server";
+};
+var LogChannelCycleError = class extends Error {
+  constructor(channel) {
+    super(`Log channel [${channel}] includes itself.`);
+    this.channel = channel;
+    this.name = "LogChannelCycleError";
+  }
+  channel;
+  kind = "Server";
+};
+var InvalidLogLevelError = class extends Error {
+  constructor(level2) {
+    super(`Invalid log level [${level2}].`);
+    this.level = level2;
+    this.name = "InvalidLogLevelError";
+  }
+  level;
+  kind = "Server";
+};
+
+// levels.ts
+var LEVEL_SEVERITY = {
+  debug: 10,
+  info: 20,
+  notice: 30,
+  warning: 40,
+  error: 50,
+  critical: 60,
+  alert: 70,
+  emergency: 80
+};
+function assertLogLevel(level2) {
+  if (typeof level2 !== "string" || !Object.hasOwn(LEVEL_SEVERITY, level2)) throw new InvalidLogLevelError(String(level2));
+}
+function meetsLevel(level2, minimum) {
+  return LEVEL_SEVERITY[level2] >= LEVEL_SEVERITY[minimum];
+}
+function serializeContext(context) {
+  if (!context) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(context)) {
+    result[key] = value instanceof Error ? { name: value.name, message: value.message, stack: value.stack } : value;
+  }
+  return result;
+}
+
+// BaseLogger.ts
+var BaseLogger = class {
+  constructor(minimumLevel = "debug") {
+    this.minimumLevel = minimumLevel;
+    assertLogLevel(minimumLevel);
+  }
+  minimumLevel;
+  log(level2, message, context) {
+    if (!meetsLevel(level2, this.minimumLevel)) return;
+    this.write(level2, message, serializeContext({ ...currentLogContext(), ...context }));
+  }
+  emergency(message, context) {
+    this.log("emergency", message, context);
+  }
+  alert(message, context) {
+    this.log("alert", message, context);
+  }
+  critical(message, context) {
+    this.log("critical", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  warning(message, context) {
+    this.log("warning", message, context);
+  }
+  notice(message, context) {
+    this.log("notice", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  withContext(context) {
+    mergeLogContext(context);
+    return this;
+  }
+};
+
+// channels.ts
+import pino2 from "pino";
+
+// DailyRotatingStream.ts
+import { createWriteStream, mkdirSync, readdirSync, rmSync } from "fs";
+import { basename, dirname, extname, join } from "path";
+import { Writable } from "stream";
+
+// writeFailure.ts
+function reportLogWriteFailure(path, error) {
+  process.stderr.write(`Unable to write log file ${path}: ${error.message}
+`);
+}
+
+// DailyRotatingStream.ts
+function localDay(date) {
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+var DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+var DailyRotatingStream = class extends Writable {
+  constructor(basePath, days, now = () => /* @__PURE__ */ new Date()) {
+    super();
+    this.days = days;
+    this.now = now;
+    this.dir = dirname(basePath);
+    this.stem = basename(basePath, extname(basePath) || void 0);
+    mkdirSync(this.dir, { recursive: true });
+  }
+  days;
+  now;
+  dir;
+  stem;
+  currentDate = "";
+  stream;
+  /**
+   * The in-flight `_write()`'s callback, if any, tagged with the exact child stream it was issued for. Resolved
+   * either by that stream's own write completing or by that same stream's `'error'` listener, whichever comes
+   * first, so a write can never hang on a broken destination. Scoping it to `stream` (rather than just tracking
+   * "the current callback") matters across a rollover: a superseded stream can still emit a late `'error'` (e.g.
+   * a failed flush during its fire-and-forget `end()`) after a write is already pending on the *new* stream, and
+   * that stale error must only produce its own stderr notice, never resolve someone else's pending write.
+   */
+  pending;
+  pathFor(date) {
+    return join(this.dir, `${this.stem}-${date}.log`);
+  }
+  today() {
+    return localDay(this.now());
+  }
+  /**
+   * Opens the file at `path` and attaches an `'error'` listener so an I/O failure (disk full, EACCES, EISDIR, ...)
+   * on this one child stream can never crash the process: it's reported as a one-line notice on `process.stderr`,
+   * the stream is dropped (the next write reopens it), and it is never re-emitted on `this`.
+   *
+   * `protected` rather than `private` only so a test can subclass and capture the real child streams this opens
+   * (node:fs's ESM module namespace can't be `vi.spyOn()`'d), to simulate a stream retired by rollover emitting a
+   * late error while a write is already pending on its replacement.
+   */
+  openStream(path) {
+    const stream = createWriteStream(path, { flags: "a" });
+    stream.on("error", (error) => {
+      reportLogWriteFailure(path, error);
+      if (this.stream === stream) this.stream = void 0;
+      if (this.pending?.stream === stream) {
+        const { callback } = this.pending;
+        this.pending = void 0;
+        callback();
+      }
+    });
+    return stream;
+  }
+  ensureStream() {
+    const date = this.today();
+    const dateChanged = date !== this.currentDate;
+    if (dateChanged || !this.stream) {
+      this.stream?.end();
+      this.currentDate = date;
+      this.stream = this.openStream(this.pathFor(date));
+      if (dateChanged) this.prune();
+    }
+    return this.stream;
+  }
+  /**
+   * Deletes this channel's files dated before the oldest of the `days` most recent local days (today included).
+   * Only names that are exactly `<stem>-<YYYY-MM-DD>.log` count, so a sibling channel sharing the prefix
+   * (e.g. `oriel-worker-<date>.log` next to `oriel-<date>.log`) is never touched.
+   */
+  prune() {
+    if (this.days <= 0) return;
+    const prefix = `${this.stem}-`;
+    const now = this.now();
+    const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (this.days - 1)).getTime();
+    for (const file of readdirSync(this.dir)) {
+      if (!file.startsWith(prefix) || !file.endsWith(".log")) continue;
+      const match = DATE_PATTERN.exec(file.slice(prefix.length, -".log".length));
+      if (!match) continue;
+      const time = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3])).getTime();
+      if (time < cutoff) rmSync(join(this.dir, file), { force: true });
+    }
+  }
+  _write(chunk, encoding, callback) {
+    const stream = this.ensureStream();
+    this.pending = { stream, callback: () => callback() };
+    stream.write(chunk, encoding, () => {
+      if (this.pending?.stream === stream) {
+        this.pending = void 0;
+        callback();
+      }
+    });
+  }
+  _final(callback) {
+    const stream = this.stream;
+    if (!stream) {
+      callback();
+      return;
+    }
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      callback();
+    };
+    stream.once("finish", finish);
+    stream.once("error", finish);
+    stream.end();
+  }
+};
+
+// PinoLogger.ts
+import "pino";
+var PINO_METHOD = {
+  emergency: "fatal",
+  alert: "fatal",
+  critical: "fatal",
+  error: "error",
+  warning: "warn",
+  notice: "info",
+  info: "info",
+  debug: "debug"
+};
+var PinoLogger = class extends BaseLogger {
+  constructor(pinoInstance, minimumLevel = "debug") {
+    super(minimumLevel);
+    this.pinoInstance = pinoInstance;
+  }
+  pinoInstance;
+  write(level2, message, context) {
+    this.pinoInstance[PINO_METHOD[level2]]({ ...context, rfc5424Level: level2 }, message);
+  }
+};
+
+// channels.ts
+var PINO_OPTIONS = { level: "debug" };
+function createSingleChannel(path, minimumLevel = "debug") {
+  assertLogLevel(minimumLevel);
+  const destination = pino2.destination({ dest: path, mkdir: true, sync: false });
+  destination.on("error", (error) => reportLogWriteFailure(path, error));
+  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel);
+}
+function createDailyChannel(path, days = 14, minimumLevel = "debug", now) {
+  assertLogLevel(minimumLevel);
+  const stream = new DailyRotatingStream(path, days, now);
+  return new PinoLogger(pino2(PINO_OPTIONS, stream), minimumLevel);
+}
+function createStderrChannel(minimumLevel = "debug") {
+  assertLogLevel(minimumLevel);
+  const destination = pino2.destination({ dest: 2, sync: false });
+  destination.on("error", () => {
+  });
+  return new PinoLogger(pino2(PINO_OPTIONS, destination), minimumLevel);
+}
+
+// facade.ts
+import { LogManager as LogManagerToken } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+import { facade } from "@orieljs/support";
+var Log = facade(LogManagerToken);
+function logger(message, context) {
+  const manager = inject(LogManagerToken);
+  if (message === void 0) return manager;
+  manager.debug(message, context);
+}
+
+// LogManager.ts
+import { ConfigRepository } from "@orieljs/contracts";
+
+// NullLogger.ts
+var NullLogger = class extends BaseLogger {
+  write() {
+  }
+};
+
+// StackLogger.ts
+var StackLogger = class {
+  constructor(channels) {
+    this.channels = channels;
+  }
+  channels;
+  log(level2, message, context) {
+    for (const channel of this.channels) channel.log(level2, message, context);
+  }
+  emergency(message, context) {
+    this.log("emergency", message, context);
+  }
+  alert(message, context) {
+    this.log("alert", message, context);
+  }
+  critical(message, context) {
+    this.log("critical", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  warning(message, context) {
+    this.log("warning", message, context);
+  }
+  notice(message, context) {
+    this.log("notice", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  /** Context is scoped by the container (see context.ts), not per-instance, so this affects every channel. */
+  withContext(context) {
+    mergeLogContext(context);
+    return this;
+  }
+};
+
+// LogManager.ts
+var level = (config) => config.level ?? "debug";
+var LogManager = class {
+  constructor(container) {
+    this.container = container;
+    this.drivers.set("single", (config) => createSingleChannel(String(config.path ?? ""), level(config)));
+    this.drivers.set("daily", (config) => createDailyChannel(String(config.path ?? ""), Number(config.days ?? 14), level(config)));
+    this.drivers.set("stderr", (config) => createStderrChannel(level(config)));
+    this.drivers.set("null", () => new NullLogger());
+    this.drivers.set("stack", (config) => this.stack(config.channels ?? []));
+  }
+  container;
+  channels = /* @__PURE__ */ new Map();
+  drivers = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  loggingConfig() {
+    return this.container.make(ConfigRepository).get("logging", { default: "stack", channels: {} });
+  }
+  channel(name) {
+    const loggingConfig = this.loggingConfig();
+    const channelName = name ?? loggingConfig.default;
+    let channel = this.channels.get(channelName);
+    if (!channel) {
+      if (this.resolving.has(channelName)) throw new LogChannelCycleError(channelName);
+      const channelConfig = loggingConfig.channels[channelName];
+      if (!channelConfig) throw new UnknownLogChannelError(channelName);
+      const driverName = channelConfig.driver;
+      const driver = driverName ? this.drivers.get(driverName) : void 0;
+      if (!driver) throw new UnknownLogDriverError(String(driverName));
+      this.resolving.add(channelName);
+      try {
+        channel = driver(channelConfig);
+      } finally {
+        this.resolving.delete(channelName);
+      }
+      this.channels.set(channelName, channel);
+    }
+    return channel;
+  }
+  stack(channels) {
+    return new StackLogger(channels.map((name) => this.channel(name)));
+  }
+  log(logLevel, message, context) {
+    this.channel().log(logLevel, message, context);
+  }
+  emergency(message, context) {
+    this.channel().emergency(message, context);
+  }
+  alert(message, context) {
+    this.channel().alert(message, context);
+  }
+  critical(message, context) {
+    this.channel().critical(message, context);
+  }
+  error(message, context) {
+    this.channel().error(message, context);
+  }
+  warning(message, context) {
+    this.channel().warning(message, context);
+  }
+  notice(message, context) {
+    this.channel().notice(message, context);
+  }
+  info(message, context) {
+    this.channel().info(message, context);
+  }
+  debug(message, context) {
+    this.channel().debug(message, context);
+  }
+  withContext(context) {
+    mergeLogContext(context);
+    return this;
+  }
+};
+
+// LogServiceProvider.ts
+import { LogManager as LogManagerToken3 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var LogServiceProvider = class extends ServiceProvider {
+  register() {
+    const level2 = process.env.LOG_LEVEL ?? "debug";
+    this.mergeConfigFrom(
+      {
+        default: process.env.LOG_CHANNEL ?? "stack",
+        channels: {
+          stack: { driver: "stack", channels: (process.env.LOG_STACK ?? "single").split(",") },
+          single: { driver: "single", path: this.app.storagePath("logs/oriel.log"), level: level2 },
+          daily: { driver: "daily", path: this.app.storagePath("logs/oriel.log"), level: level2, days: 14 },
+          stderr: { driver: "stderr", level: level2 },
+          null: { driver: "null" }
+        }
+      },
+      "logging"
+    );
+    this.app.singleton(LogManagerToken3, (container) => new LogManager(container));
+  }
+};
+export {
+  BaseLogger,
+  DailyRotatingStream,
+  InvalidLogLevelError,
+  LEVEL_SEVERITY,
+  Log,
+  LogChannelCycleError,
+  LogManager,
+  LogServiceProvider,
+  NullLogger,
+  PinoLogger,
+  StackLogger,
+  UnknownLogChannelError,
+  UnknownLogDriverError,
+  createDailyChannel,
+  createSingleChannel,
+  createStderrChannel,
+  currentLogContext,
+  logger,
+  meetsLevel,
+  mergeLogContext,
+  serializeContext
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../context.ts","../errors.ts","../levels.ts","../BaseLogger.ts","../channels.ts","../DailyRotatingStream.ts","../writeFailure.ts","../PinoLogger.ts","../facade.ts","../LogManager.ts","../NullLogger.ts","../StackLogger.ts","../LogServiceProvider.ts"],"sourcesContent":["import { currentContainer } from '@orieljs/container'\n\n/** Used as the WeakMap key when there is no current container at all (context added outside any scope). */\nconst rootKey: object = {}\n\n/**\n * Log context, keyed by the current scope. `Application.handle()` creates a fresh child container per request\n * (`this.createScope()`) and runs the kernel inside `scope.run(...)`, so `currentContainer()` returns a distinct\n * object per in-flight request; two concurrent requests never share a key here, so context added during one never\n * leaks into the other. Outside of any scope (CLI, boot), everything shares `rootKey`.\n */\nconst contexts = new WeakMap<object, Record<string, unknown>>()\n\n/** Merges `context` into the log context for the current scope (Laravel's `Log::withContext()`). */\nexport function mergeLogContext(context: Record<string, unknown>): void {\n  const key = currentContainer() ?? rootKey\n  contexts.set(key, { ...contexts.get(key), ...context })\n}\n\n/** The merged log context for the current scope, or `{}` if none has been added. */\nexport function currentLogContext(): Record<string, unknown> {\n  return contexts.get(currentContainer() ?? rootKey) ?? {}\n}\n","import type { ErrorKind, OrielError } from '@orieljs/contracts'\n\nexport class UnknownLogChannelError extends Error implements OrielError {\n  readonly kind: ErrorKind = 'Server'\n  constructor(readonly channel: string) {\n    super(`Log channel [${channel}] is not defined in config('logging.channels').`)\n    this.name = 'UnknownLogChannelError'\n  }\n}\n\nexport class UnknownLogDriverError extends Error implements OrielError {\n  readonly kind: ErrorKind = 'Server'\n  constructor(readonly driver: string) {\n    super(`Log driver [${driver}] is not registered.`)\n    this.name = 'UnknownLogDriverError'\n  }\n}\n\nexport class LogChannelCycleError extends Error implements OrielError {\n  readonly kind: ErrorKind = 'Server'\n  constructor(readonly channel: string) {\n    super(`Log channel [${channel}] includes itself.`)\n    this.name = 'LogChannelCycleError'\n  }\n}\n\nexport class InvalidLogLevelError extends Error implements OrielError {\n  readonly kind: ErrorKind = 'Server'\n  constructor(readonly level: string) {\n    super(`Invalid log level [${level}].`)\n    this.name = 'InvalidLogLevelError'\n  }\n}\n","import type { LogLevel } from '@orieljs/contracts'\nimport { InvalidLogLevelError } from './errors'\n\n/** RFC 5424 severities, most severe first. Higher numbers are more severe. */\nexport const LEVEL_SEVERITY: Record<LogLevel, number> = {\n  debug: 10,\n  info: 20,\n  notice: 30,\n  warning: 40,\n  error: 50,\n  critical: 60,\n  alert: 70,\n  emergency: 80,\n}\n\n/** Throws `InvalidLogLevelError` unless `level` is one of the eight RFC 5424 names (no aliases like `warn`). */\nexport function assertLogLevel(level: unknown): asserts level is LogLevel {\n  if (typeof level !== 'string' || !Object.hasOwn(LEVEL_SEVERITY, level)) throw new InvalidLogLevelError(String(level))\n}\n\n/** True when `level` is at least as severe as `minimum` (e.g. `error` meets a `warning` threshold). */\nexport function meetsLevel(level: LogLevel, minimum: LogLevel): boolean {\n  return LEVEL_SEVERITY[level] >= LEVEL_SEVERITY[minimum]\n}\n\n/**\n * `Error` objects don't survive `JSON.stringify` (message/stack/name aren't own enumerable properties), so any\n * `Error` values directly on the context object are expanded one level deep into a plain `{ name, message, stack }`.\n * This is how `LogManager.error(message, { exception })` (Http's exception handler) ends up readable in log output.\n */\nexport function serializeContext(context: Record<string, unknown> | undefined): Record<string, unknown> {\n  if (!context) return {}\n  const result: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(context)) {\n    result[key] = value instanceof Error ? { name: value.name, message: value.message, stack: value.stack } : value\n  }\n  return result\n}\n","import type { Logger, LogLevel } from '@orieljs/contracts'\nimport { currentLogContext, mergeLogContext } from './context'\nimport { assertLogLevel, meetsLevel, serializeContext } from './levels'\n\n/**\n * Implements the full `Logger` contract on top of one `write()` method: level filtering, merging in the current\n * scope's context (`context.ts`) and serializing `Error` values (`levels.ts`) all happen here, once.\n */\nexport abstract class BaseLogger implements Logger {\n  constructor(protected readonly minimumLevel: LogLevel = 'debug') {\n    assertLogLevel(minimumLevel)\n  }\n\n  log(level: LogLevel, message: string, context?: Record<string, unknown>): void {\n    if (!meetsLevel(level, this.minimumLevel)) return\n    this.write(level, message, serializeContext({ ...currentLogContext(), ...context }))\n  }\n\n  emergency(message: string, context?: Record<string, unknown>): void {\n    this.log('emergency', message, context)\n  }\n  alert(message: string, context?: Record<string, unknown>): void {\n    this.log('alert', message, context)\n  }\n  critical(message: string, context?: Record<string, unknown>): void {\n    this.log('critical', message, context)\n  }\n  error(message: string, context?: Record<string, unknown>): void {\n    this.log('error', message, context)\n  }\n  warning(message: string, context?: Record<string, unknown>): void {\n    this.log('warning', message, context)\n  }\n  notice(message: string, context?: Record<string, unknown>): void {\n    this.log('notice', message, context)\n  }\n  info(message: string, context?: Record<string, unknown>): void {\n    this.log('info', message, context)\n  }\n  debug(message: string, context?: Record<string, unknown>): void {\n    this.log('debug', message, context)\n  }\n\n  withContext(context: Record<string, unknown>): this {\n    mergeLogContext(context)\n    return this\n  }\n\n  /** Called only when `level` already meets this logger's configured minimum, with context fully resolved. */\n  protected abstract write(level: LogLevel, message: string, context: Record<string, unknown>): void\n}\n","import pino from 'pino'\nimport type { LogLevel } from '@orieljs/contracts'\nimport { DailyRotatingStream } from './DailyRotatingStream'\nimport { assertLogLevel } from './levels'\nimport { PinoLogger } from './PinoLogger'\nimport { reportLogWriteFailure } from './writeFailure'\n\n/** Pino passes everything through; `BaseLogger` already filtered by the channel's own minimum level. */\nconst PINO_OPTIONS = { level: 'debug' } as const\n\n/** The `single` channel: everything appended to one file, e.g. `storage/logs/oriel.log`. */\nexport function createSingleChannel(path: string, minimumLevel: LogLevel = 'debug'): PinoLogger {\n  assertLogLevel(minimumLevel) // before opening the file, so a rejected channel leaves nothing open\n  const destination = pino.destination({ dest: path, mkdir: true, sync: false })\n  // Without a listener, an I/O error on the destination (EACCES, ENOTDIR, disk full, ...) is re-emitted as an\n  // unhandled 'error' event and takes the process down.\n  destination.on('error', (error: Error) => reportLogWriteFailure(path, error))\n  return new PinoLogger(pino(PINO_OPTIONS, destination), minimumLevel)\n}\n\n/** The `daily` channel: one file per day under the same directory, pruned after `days`. */\nexport function createDailyChannel(path: string, days = 14, minimumLevel: LogLevel = 'debug', now?: () => Date): PinoLogger {\n  assertLogLevel(minimumLevel)\n  const stream = new DailyRotatingStream(path, days, now)\n  return new PinoLogger(pino(PINO_OPTIONS, stream), minimumLevel)\n}\n\n/** The `stderr` channel. */\nexport function createStderrChannel(minimumLevel: LogLevel = 'debug'): PinoLogger {\n  assertLogLevel(minimumLevel)\n  const destination = pino.destination({ dest: 2, sync: false })\n  // Nowhere left to report a failure writing to stderr itself, so it's swallowed rather than crashing the process.\n  destination.on('error', () => {})\n  return new PinoLogger(pino(PINO_OPTIONS, destination), minimumLevel)\n}\n","import { createWriteStream, mkdirSync, readdirSync, rmSync, type WriteStream } from 'node:fs'\nimport { basename, dirname, extname, join } from 'node:path'\nimport { Writable } from 'node:stream'\nimport { reportLogWriteFailure } from './writeFailure'\n\n/** `YYYY-MM-DD` for the local calendar day of `date`. */\nfunction localDay(date: Date): string {\n  const month = String(date.getMonth() + 1).padStart(2, '0')\n  const day = String(date.getDate()).padStart(2, '0')\n  return `${date.getFullYear()}-${month}-${day}`\n}\n\nconst DATE_PATTERN = /^(\\d{4})-(\\d{2})-(\\d{2})$/\n\n/**\n * Writes to `<dir>/<stem>-<YYYY-MM-DD>.log`, switching files when the local calendar day changes and deleting files\n * older than `days` each time it rolls over. `now` is injectable so tests can simulate day boundaries without a\n * fake timer.\n */\nexport class DailyRotatingStream extends Writable {\n  private readonly dir: string\n  private readonly stem: string\n  private currentDate = ''\n  private stream: WriteStream | undefined\n  /**\n   * The in-flight `_write()`'s callback, if any, tagged with the exact child stream it was issued for. Resolved\n   * either by that stream's own write completing or by that same stream's `'error'` listener, whichever comes\n   * first, so a write can never hang on a broken destination. Scoping it to `stream` (rather than just tracking\n   * \"the current callback\") matters across a rollover: a superseded stream can still emit a late `'error'` (e.g.\n   * a failed flush during its fire-and-forget `end()`) after a write is already pending on the *new* stream, and\n   * that stale error must only produce its own stderr notice, never resolve someone else's pending write.\n   */\n  private pending: { readonly stream: WriteStream; readonly callback: () => void } | undefined\n\n  constructor(\n    basePath: string,\n    private readonly days: number,\n    private readonly now: () => Date = () => new Date(),\n  ) {\n    super()\n    this.dir = dirname(basePath)\n    this.stem = basename(basePath, extname(basePath) || undefined)\n    mkdirSync(this.dir, { recursive: true })\n  }\n\n  private pathFor(date: string): string {\n    return join(this.dir, `${this.stem}-${date}.log`)\n  }\n\n  private today(): string {\n    return localDay(this.now())\n  }\n\n  /**\n   * Opens the file at `path` and attaches an `'error'` listener so an I/O failure (disk full, EACCES, EISDIR, ...)\n   * on this one child stream can never crash the process: it's reported as a one-line notice on `process.stderr`,\n   * the stream is dropped (the next write reopens it), and it is never re-emitted on `this`.\n   *\n   * `protected` rather than `private` only so a test can subclass and capture the real child streams this opens\n   * (node:fs's ESM module namespace can't be `vi.spyOn()`'d), to simulate a stream retired by rollover emitting a\n   * late error while a write is already pending on its replacement.\n   */\n  protected openStream(path: string): WriteStream {\n    const stream = createWriteStream(path, { flags: 'a' })\n    stream.on('error', (error: Error) => {\n      reportLogWriteFailure(path, error)\n      if (this.stream === stream) this.stream = undefined\n      if (this.pending?.stream === stream) {\n        const { callback } = this.pending\n        this.pending = undefined\n        callback()\n      }\n    })\n    return stream\n  }\n\n  private ensureStream(): WriteStream {\n    const date = this.today()\n    const dateChanged = date !== this.currentDate\n    if (dateChanged || !this.stream) {\n      this.stream?.end()\n      this.currentDate = date\n      this.stream = this.openStream(this.pathFor(date))\n      if (dateChanged) this.prune()\n    }\n    return this.stream\n  }\n\n  /**\n   * Deletes this channel's files dated before the oldest of the `days` most recent local days (today included).\n   * Only names that are exactly `<stem>-<YYYY-MM-DD>.log` count, so a sibling channel sharing the prefix\n   * (e.g. `oriel-worker-<date>.log` next to `oriel-<date>.log`) is never touched.\n   */\n  private prune(): void {\n    if (this.days <= 0) return\n    const prefix = `${this.stem}-`\n    const now = this.now()\n    const cutoff = new Date(now.getFullYear(), now.getMonth(), now.getDate() - (this.days - 1)).getTime()\n    for (const file of readdirSync(this.dir)) {\n      if (!file.startsWith(prefix) || !file.endsWith('.log')) continue\n      const match = DATE_PATTERN.exec(file.slice(prefix.length, -'.log'.length))\n      if (!match) continue\n      const time = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3])).getTime()\n      if (time < cutoff) rmSync(join(this.dir, file), { force: true })\n    }\n  }\n\n  override _write(chunk: unknown, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {\n    const stream = this.ensureStream()\n    this.pending = { stream, callback: () => callback() }\n    stream.write(chunk as Uint8Array, encoding, () => {\n      if (this.pending?.stream === stream) {\n        this.pending = undefined\n        callback()\n      }\n    })\n  }\n\n  override _final(callback: (error?: Error | null) => void): void {\n    const stream = this.stream\n    if (!stream) {\n      callback()\n      return\n    }\n    let done = false\n    const finish = () => {\n      if (done) return\n      done = true\n      callback()\n    }\n    stream.once('finish', finish)\n    stream.once('error', finish)\n    stream.end()\n  }\n}\n","/** Reports a log destination I/O failure as one line on `process.stderr`, so it never crashes the process. */\nexport function reportLogWriteFailure(path: string, error: Error): void {\n  process.stderr.write(`Unable to write log file ${path}: ${error.message}\\n`)\n}\n","import pino from 'pino'\nimport type { LogLevel } from '@orieljs/contracts'\nimport { BaseLogger } from './BaseLogger'\n\n/** Maps an RFC 5424 level onto pino's own (narrower) level methods. The real level is kept in the payload. */\nconst PINO_METHOD: Record<LogLevel, 'fatal' | 'error' | 'warn' | 'info' | 'debug'> = {\n  emergency: 'fatal',\n  alert: 'fatal',\n  critical: 'fatal',\n  error: 'error',\n  warning: 'warn',\n  notice: 'info',\n  info: 'info',\n  debug: 'debug',\n}\n\n/** A channel backed by a pino logger writing to an arbitrary destination stream (file, stderr, ...). */\nexport class PinoLogger extends BaseLogger {\n  constructor(\n    private readonly pinoInstance: pino.Logger,\n    minimumLevel: LogLevel = 'debug',\n  ) {\n    super(minimumLevel)\n  }\n\n  protected write(level: LogLevel, message: string, context: Record<string, unknown>): void {\n    this.pinoInstance[PINO_METHOD[level]]({ ...context, rfc5424Level: level }, message)\n  }\n}\n","import type { LogManager } from '@orieljs/contracts'\nimport { LogManager as LogManagerToken } from '@orieljs/contracts'\nimport { inject } from '@orieljs/container'\nimport { facade } from '@orieljs/support'\n\n/** The `Log` facade (Laravel's `Illuminate\\Support\\Facades\\Log`). `Log.channel('single').info(...)`. */\nexport const Log = facade<LogManager>(LogManagerToken)\n\n/** With no args, the LogManager itself. With a message, logs it at `debug` (Laravel's `logger()` helper). */\nexport function logger(): LogManager\nexport function logger(message: string, context?: Record<string, unknown>): void\nexport function logger(message?: string, context?: Record<string, unknown>): LogManager | void {\n  const manager = inject(LogManagerToken)\n  if (message === undefined) return manager\n  manager.debug(message, context)\n}\n","import type { Container, Logger, LogLevel } from '@orieljs/contracts'\nimport { ConfigRepository, LogManager as LogManagerToken } from '@orieljs/contracts'\nimport { createDailyChannel, createSingleChannel, createStderrChannel } from './channels'\nimport { mergeLogContext } from './context'\nimport { LogChannelCycleError, UnknownLogChannelError, UnknownLogDriverError } from './errors'\nimport { NullLogger } from './NullLogger'\nimport { StackLogger } from './StackLogger'\n\ntype ChannelConfig = Record<string, unknown>\ntype Driver = (config: ChannelConfig) => Logger\n\ninterface LoggingConfig {\n  default: string\n  channels: Record<string, ChannelConfig>\n}\n\nconst level = (config: ChannelConfig): LogLevel => (config.level as LogLevel | undefined) ?? 'debug'\n\n/** `LogManager`: resolves channels by name from `config('logging')`, lazily and cached. */\nexport class LogManager implements LogManagerToken {\n  private readonly channels = new Map<string, Logger>()\n  private readonly drivers = new Map<string, Driver>()\n  private readonly resolving = new Set<string>()\n\n  constructor(private readonly container: Container) {\n    this.drivers.set('single', (config) => createSingleChannel(String(config.path ?? ''), level(config)))\n    this.drivers.set('daily', (config) => createDailyChannel(String(config.path ?? ''), Number(config.days ?? 14), level(config)))\n    this.drivers.set('stderr', (config) => createStderrChannel(level(config)))\n    this.drivers.set('null', () => new NullLogger())\n    this.drivers.set('stack', (config) => this.stack((config.channels as string[] | undefined) ?? []))\n  }\n\n  private loggingConfig(): LoggingConfig {\n    return this.container.make(ConfigRepository).get<LoggingConfig>('logging', { default: 'stack', channels: {} })\n  }\n\n  channel(name?: string): Logger {\n    const loggingConfig = this.loggingConfig()\n    const channelName = name ?? loggingConfig.default\n    let channel = this.channels.get(channelName)\n    if (!channel) {\n      if (this.resolving.has(channelName)) throw new LogChannelCycleError(channelName)\n      const channelConfig = loggingConfig.channels[channelName]\n      if (!channelConfig) throw new UnknownLogChannelError(channelName)\n      const driverName = channelConfig.driver as string | undefined\n      const driver = driverName ? this.drivers.get(driverName) : undefined\n      if (!driver) throw new UnknownLogDriverError(String(driverName))\n      this.resolving.add(channelName)\n      try {\n        channel = driver(channelConfig)\n      } finally {\n        this.resolving.delete(channelName)\n      }\n      this.channels.set(channelName, channel)\n    }\n    return channel\n  }\n\n  stack(channels: string[]): Logger {\n    return new StackLogger(channels.map((name) => this.channel(name)))\n  }\n\n  log(logLevel: LogLevel, message: string, context?: Record<string, unknown>): void {\n    this.channel().log(logLevel, message, context)\n  }\n  emergency(message: string, context?: Record<string, unknown>): void {\n    this.channel().emergency(message, context)\n  }\n  alert(message: string, context?: Record<string, unknown>): void {\n    this.channel().alert(message, context)\n  }\n  critical(message: string, context?: Record<string, unknown>): void {\n    this.channel().critical(message, context)\n  }\n  error(message: string, context?: Record<string, unknown>): void {\n    this.channel().error(message, context)\n  }\n  warning(message: string, context?: Record<string, unknown>): void {\n    this.channel().warning(message, context)\n  }\n  notice(message: string, context?: Record<string, unknown>): void {\n    this.channel().notice(message, context)\n  }\n  info(message: string, context?: Record<string, unknown>): void {\n    this.channel().info(message, context)\n  }\n  debug(message: string, context?: Record<string, unknown>): void {\n    this.channel().debug(message, context)\n  }\n\n  withContext(context: Record<string, unknown>): this {\n    mergeLogContext(context)\n    return this\n  }\n}\n","import { BaseLogger } from './BaseLogger'\n\n/** The `null` channel: discards every entry (Laravel's `NullHandler`). */\nexport class NullLogger extends BaseLogger {\n  protected write(): void {\n    // Intentionally does nothing.\n  }\n}\n","import type { Logger, LogLevel } from '@orieljs/contracts'\nimport { mergeLogContext } from './context'\n\n/** `Log.stack([...])`: fans every entry out to each constituent channel, which does its own level filtering. */\nexport class StackLogger implements Logger {\n  constructor(private readonly channels: Logger[]) {}\n\n  log(level: LogLevel, message: string, context?: Record<string, unknown>): void {\n    for (const channel of this.channels) channel.log(level, message, context)\n  }\n  emergency(message: string, context?: Record<string, unknown>): void {\n    this.log('emergency', message, context)\n  }\n  alert(message: string, context?: Record<string, unknown>): void {\n    this.log('alert', message, context)\n  }\n  critical(message: string, context?: Record<string, unknown>): void {\n    this.log('critical', message, context)\n  }\n  error(message: string, context?: Record<string, unknown>): void {\n    this.log('error', message, context)\n  }\n  warning(message: string, context?: Record<string, unknown>): void {\n    this.log('warning', message, context)\n  }\n  notice(message: string, context?: Record<string, unknown>): void {\n    this.log('notice', message, context)\n  }\n  info(message: string, context?: Record<string, unknown>): void {\n    this.log('info', message, context)\n  }\n  debug(message: string, context?: Record<string, unknown>): void {\n    this.log('debug', message, context)\n  }\n\n  /** Context is scoped by the container (see context.ts), not per-instance, so this affects every channel. */\n  withContext(context: Record<string, unknown>): this {\n    mergeLogContext(context)\n    return this\n  }\n}\n","import { LogManager as LogManagerToken } from '@orieljs/contracts'\nimport { ServiceProvider } from '@orieljs/support'\nimport { LogManager } from './LogManager'\n\n/** Binds the LogManager and merges Laravel 11's `logging` defaults (stack -> single, LOG_LEVEL=debug). */\nexport class LogServiceProvider extends ServiceProvider {\n  override register(): void {\n    const level = process.env.LOG_LEVEL ?? 'debug'\n    this.mergeConfigFrom(\n      {\n        default: process.env.LOG_CHANNEL ?? 'stack',\n        channels: {\n          stack: { driver: 'stack', channels: (process.env.LOG_STACK ?? 'single').split(',') },\n          single: { driver: 'single', path: this.app.storagePath('logs/oriel.log'), level },\n          daily: { driver: 'daily', path: this.app.storagePath('logs/oriel.log'), level, days: 14 },\n          stderr: { driver: 'stderr', level },\n          null: { driver: 'null' },\n        },\n      },\n      'logging',\n    )\n    this.app.singleton(LogManagerToken, (container) => new LogManager(container))\n  }\n}\n"],"mappings":"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","names":["level","level","level","pino","level","pino","level","LogManagerToken","level","LogManagerToken"]}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@orieljs/log",
+  "version": "0.1.0-alpha.1",
+  "description": "The Oriel Log component.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orieljs/framework.git",
+    "directory": "src/Oriel/Log"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "pino": "10.3.1",
+    "@orieljs/contracts": "0.1.0-alpha.1",
+    "@orieljs/support": "0.1.0-alpha.1",
+    "@orieljs/container": "0.1.0-alpha.1"
+  },
+  "scripts": {
+    "build": "tsup && node ../../../scripts/copy-license.mjs"
+  }
+}