@decohere/scribe 0.0.1-dev.126 → 0.0.1-dev.14

package/commonjs/src/redact.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "redact", {
-    enumerable: true,
-    get: function() {
-        return redact;
-    }
-});
-const _types = require("./types.js");
-function keysFromPaths(paths) {
-    const keys = new Set();
-    for (const path of paths){
-        const segments = path.split(".").filter((segment)=>segment.length > 0 && segment !== "*");
-        const key = segments.at(-1);
-        if (key != null) {
-            keys.add(key);
-        }
-    }
-    return keys;
-}
-function isPlainObject(value) {
-    if (value == null || typeof value !== "object" || Array.isArray(value) || value instanceof Error) {
-        return false;
-    }
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-function object(value, keys, censor = _types.DefaultCensor, copies = new WeakMap()) {
-    if (value == null || typeof value !== "object") {
-        return value;
-    }
-    if (value instanceof Error) {
-        return value;
-    }
-    // A cycle in the input stays a cycle in the copy.
-    const copied = copies.get(value);
-    if (copied !== undefined) {
-        return copied;
-    }
-    if (Array.isArray(value)) {
-        const out = [];
-        copies.set(value, out);
-        for (const item of value){
-            out.push(object(item, keys, censor, copies));
-        }
-        return out;
-    }
-    if (!isPlainObject(value)) {
-        return value;
-    }
-    const out = {};
-    copies.set(value, out);
-    for (const [key, nested] of Object.entries(value)){
-        out[key] = keys.has(key) ? censor : object(nested, keys, censor, copies);
-    }
-    return out;
-}
-function fromOptions(options) {
-    return keysFromPaths(options?.paths ?? _types.DefaultRedactions.paths);
-}
-const redact = {
-    object,
-    keysFromPaths,
-    fromOptions
-};

package/commonjs/src/testing/capture.adapter.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CaptureAdapter", {
-    enumerable: true,
-    get: function() {
-        return CaptureAdapter;
-    }
-});
-const _logentryadapter = require("../log-entry.adapter.js");
-class CaptureAdapter extends _logentryadapter.LogEntryAdapter {
-    entries = [];
-    /** Entries at `level`. */ at(level) {
-        return this.entries.filter((entry)=>entry.level === level);
-    }
-    clear() {
-        this.entries.length = 0;
-    }
-    write(entry) {
-        this.entries.push(entry);
-    }
-}

package/es6/src/log-entry.adapter.js

@@ -1,49 +0,0 @@
-import { logEntry } from "./log-entry.js";
-import { LogAdapter } from "./logger.adapter.js";
-import { redact } from "./redact.js";
-import { DefaultLogLevel, LogLevels } from "./types.js";
-/**
- * Base for adapters that write structured entries. It owns levels, the level
- * threshold, `child`, and censoring the `redactions` keys; a subclass only
- * writes each `LogEntry`.
- */ export class LogEntryAdapter extends LogAdapter {
-    levels = LogLevels;
-    level = DefaultLogLevel;
-    threshold = LogLevels.info;
-    redactionKeys = redact.fromOptions();
-    configure(scribeOptions) {
-        this.levels = this.getLogLevels(scribeOptions);
-        this.level = scribeOptions.logLevel ?? DefaultLogLevel;
-        this.threshold = this.levels[this.level] ?? LogLevels.info;
-        this.redactionKeys = redact.fromOptions(scribeOptions.redactions);
-    }
-    getLogger(name) {
-        return this.createLogger(name || "default", {});
-    }
-    createLogger(name, bindings) {
-        const { levels, level: currentLevel, threshold, redactionKeys } = this;
-        const baseLogger = {
-            get currentLevel () {
-                return currentLevel;
-            },
-            get logLevels () {
-                return levels;
-            }
-        };
-        const noop = ()=>{};
-        const methods = {};
-        for (const [level, value] of Object.entries(levels)){
-            methods[level] = value >= threshold ? (...args)=>this.write(logEntry.from(level, name, args, {
-                    bindings,
-                    redactionKeys
-                })) : noop;
-        }
-        return Object.assign(baseLogger, methods, {
-            isLevelEnabled: (level)=>(levels[level] ?? 0) >= threshold,
-            child: (fields)=>this.createLogger(name, {
-                    ...bindings,
-                    ...fields
-                })
-        });
-    }
-}

package/es6/src/log-entry.js

@@ -1,79 +0,0 @@
-import { serializeError } from "./logger.adapter.js";
-import { redact } from "./redact.js";
-function isFields(value) {
-    return value != null && typeof value === "object" && !Array.isArray(value);
-}
-/** Serialize errors passed as fields (`{ error }`), so they keep their message and stack. */ function serializeErrors(fields) {
-    const out = {};
-    for (const [key, value] of Object.entries(fields)){
-        out[key] = value instanceof Error ? serializeError(value) : value;
-    }
-    return out;
-}
-/**
- * Builds an entry from a log call's arguments:
- *
- * - `log.info("text")`, `log.info(42)` → `msg`
- * - `log.error(err)` → `msg` is `err.message`, `err` the serialized error
- * - `log.info({ fields })`, `log.info({ fields }, "text")` → `fields` (a string
- *   `msg` field becomes the message)
- * - `log.info("text", { fields })` → `msg` + `fields`
- * - `log.error("text", err)` → `msg` + `err`
- * - `log.info("text", value)` → `msg` + `fields.data`; any further arguments go
- *   in `fields.args`
- */ function from(level, name, [first, ...rest], { bindings, redactionKeys }) {
-    let msg;
-    let err;
-    let fields = {};
-    if (first instanceof Error) {
-        err = first;
-        msg = first.message;
-    } else if (isFields(first)) {
-        const { msg: fieldMsg, ...others } = first;
-        fields = others;
-        if (typeof fieldMsg === "string") {
-            msg = fieldMsg;
-        } else if (fieldMsg !== undefined) {
-            fields.msg = fieldMsg;
-        }
-        if (typeof rest[0] === "string") {
-            msg = rest.shift();
-        }
-    } else if (first !== undefined) {
-        msg = String(first);
-    }
-    const [second, ...extra] = rest;
-    if (second instanceof Error && err == null) {
-        err = second;
-    } else if (isFields(second)) {
-        fields = {
-            ...fields,
-            ...second
-        };
-    } else if (second !== undefined) {
-        fields.data = second;
-    }
-    if (extra.length > 0) {
-        fields.args = extra;
-    }
-    const allFields = serializeErrors({
-        ...bindings,
-        ...fields
-    });
-    const entry = {
-        level,
-        name,
-        fields: redactionKeys == null ? allFields : redact.object(allFields, redactionKeys)
-    };
-    if (msg !== undefined) {
-        entry.msg = msg;
-    }
-    if (err != null) {
-        const serialized = serializeError(err);
-        entry.err = redactionKeys == null ? serialized : redact.object(serialized, redactionKeys);
-    }
-    return entry;
-}
-export const logEntry = {
-    from
-};

package/es6/src/redact.js

@@ -1,57 +0,0 @@
-import { DefaultCensor, DefaultRedactions } from "./types.js";
-function keysFromPaths(paths) {
-    const keys = new Set();
-    for (const path of paths){
-        const segments = path.split(".").filter((segment)=>segment.length > 0 && segment !== "*");
-        const key = segments.at(-1);
-        if (key != null) {
-            keys.add(key);
-        }
-    }
-    return keys;
-}
-function isPlainObject(value) {
-    if (value == null || typeof value !== "object" || Array.isArray(value) || value instanceof Error) {
-        return false;
-    }
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-function object(value, keys, censor = DefaultCensor, copies = new WeakMap()) {
-    if (value == null || typeof value !== "object") {
-        return value;
-    }
-    if (value instanceof Error) {
-        return value;
-    }
-    // A cycle in the input stays a cycle in the copy.
-    const copied = copies.get(value);
-    if (copied !== undefined) {
-        return copied;
-    }
-    if (Array.isArray(value)) {
-        const out = [];
-        copies.set(value, out);
-        for (const item of value){
-            out.push(object(item, keys, censor, copies));
-        }
-        return out;
-    }
-    if (!isPlainObject(value)) {
-        return value;
-    }
-    const out = {};
-    copies.set(value, out);
-    for (const [key, nested] of Object.entries(value)){
-        out[key] = keys.has(key) ? censor : object(nested, keys, censor, copies);
-    }
-    return out;
-}
-function fromOptions(options) {
-    return keysFromPaths(options?.paths ?? DefaultRedactions.paths);
-}
-export const redact = {
-    object,
-    keysFromPaths,
-    fromOptions
-};

package/es6/src/testing/capture.adapter.js

@@ -1,17 +0,0 @@
-import { LogEntryAdapter } from "../log-entry.adapter.js";
-/**
- * Test double: keeps every entry that passes the level threshold, prints
- * nothing. `scribe.configure({ adapter: capture })`, run the code, then assert
- * on `capture.entries`.
- */ export class CaptureAdapter extends LogEntryAdapter {
-    entries = [];
-    /** Entries at `level`. */ at(level) {
-        return this.entries.filter((entry)=>entry.level === level);
-    }
-    clear() {
-        this.entries.length = 0;
-    }
-    write(entry) {
-        this.entries.push(entry);
-    }
-}

package/types/src/log-entry.adapter.d.ts

@@ -1,20 +0,0 @@
-import { type LogEntry } from "./log-entry.js";
-import { LogAdapter } from "./logger.adapter.js";
-import type { Logger } from "./logger.type.js";
-import { type ScribeOptions } from "./types.js";
-/**
- * Base for adapters that write structured entries. It owns levels, the level
- * threshold, `child`, and censoring the `redactions` keys; a subclass only
- * writes each `LogEntry`.
- */
-export declare abstract class LogEntryAdapter extends LogAdapter {
-    protected levels: Record<string, number>;
-    private level;
-    private threshold;
-    private redactionKeys;
-    configure<T extends string = never, CustomOnly extends true | false = false>(scribeOptions: ScribeOptions<T, CustomOnly>): void;
-    getLogger<T extends string = never, CustomOnly extends true | false = false>(name?: string): Logger<T, CustomOnly>;
-    /** Write one entry that passed the level threshold. */
-    protected abstract write(entry: LogEntry): void;
-    private createLogger;
-}

package/types/src/log-entry.d.ts

@@ -1,38 +0,0 @@
-import { type SerializedError } from "./logger.adapter.js";
-/**
- * One logged call. Adapters that write structured lines build it with
- * `logEntry.from`, and taps receive it.
- */
-export type LogEntry = {
-    level: string;
-    name: string;
-    msg?: string;
-    err?: SerializedError;
-    /** Bound fields (`child`), then the call's own fields. */
-    fields: Record<string, unknown>;
-};
-export type LogEntryOptions = {
-    bindings?: Record<string, unknown>;
-    /**
-     * Keys the adapter censors (`redact.fromOptions`). Redaction is the
-     * adapter's job, so the facade's tap passes none.
-     */
-    redactionKeys?: ReadonlySet<string>;
-};
-/**
- * Builds an entry from a log call's arguments:
- *
- * - `log.info("text")`, `log.info(42)` → `msg`
- * - `log.error(err)` → `msg` is `err.message`, `err` the serialized error
- * - `log.info({ fields })`, `log.info({ fields }, "text")` → `fields` (a string
- *   `msg` field becomes the message)
- * - `log.info("text", { fields })` → `msg` + `fields`
- * - `log.error("text", err)` → `msg` + `err`
- * - `log.info("text", value)` → `msg` + `fields.data`; any further arguments go
- *   in `fields.args`
- */
-declare function from(level: string, name: string, [first, ...rest]: readonly unknown[], { bindings, redactionKeys }: LogEntryOptions): LogEntry;
-export declare const logEntry: {
-    from: typeof from;
-};
-export {};

package/types/src/redact.d.ts

@@ -1,10 +0,0 @@
-import { type RedactionOptions } from "./types.js";
-declare function keysFromPaths(paths: string[]): Set<string>;
-declare function object(value: unknown, keys: ReadonlySet<string>, censor?: string, copies?: WeakMap<object, unknown>): unknown;
-declare function fromOptions(options?: RedactionOptions): Set<string>;
-export declare const redact: {
-    object: typeof object;
-    keysFromPaths: typeof keysFromPaths;
-    fromOptions: typeof fromOptions;
-};
-export {};

package/types/src/testing/capture.adapter.d.ts

@@ -1,14 +0,0 @@
-import { LogEntryAdapter } from "../log-entry.adapter.js";
-import type { LogEntry } from "../log-entry.js";
-/**
- * Test double: keeps every entry that passes the level threshold, prints
- * nothing. `scribe.configure({ adapter: capture })`, run the code, then assert
- * on `capture.entries`.
- */
-export declare class CaptureAdapter extends LogEntryAdapter {
-    readonly entries: LogEntry[];
-    /** Entries at `level`. */
-    at(level: string): LogEntry[];
-    clear(): void;
-    protected write(entry: LogEntry): void;
-}