@wireio/shared 1.0.70 → 1.0.72

package/lib/esm/errors/NestedError.d.ts

@@ -1,10 +1,114 @@
-export declare class NestedError extends Error {
-    readonly causes: Array<Error>;
-    constructor(message: string, ...causes: Array<Error | Error[]>);
+/**
+ * Structured, machine-readable diagnostic context captured at a {@link NestedError}
+ * throw site — the values that make a failure diagnosable (the `text` that failed to
+ * parse, a schema / type name, an id, …). Heterogeneous by nature, so the values are
+ * `unknown` (a documented type-erased bag, not a shortcut).
+ */
+export type NestedErrorContext = Record<string, unknown>;
+/**
+ * Options for {@link NestedError} — what it preserves about the failure it wraps.
+ */
+export interface NestedErrorOptions<Context extends NestedErrorContext = NestedErrorContext> {
+    /**
+     * The originating error(s) — the root-cause chain that must NOT be swallowed. A
+     * non-Error thrown value is coerced to an Error; the first becomes the native
+     * ES2022 `Error.cause`.
+     */
+    cause?: unknown;
+    /** Diagnostic context captured at the throw site. */
+    context?: Context;
+}
+/**
+ * An Error that PRESERVES what it wraps instead of restringing it. Given a new
+ * message string, it ALSO retains the full cause chain: the originating error(s)
+ * survive as {@link NestedError.causes} (and the native `Error.cause`) — the real
+ * Error objects, so **each cause keeps its own stack trace and message** — and a
+ * nested-exception `Caused by:` section per cause is appended to this error's
+ * {@link NestedError.stack}, so the whole chain (each cause's stack + message) is
+ * visible wherever the error is printed, not only via the programmatic accessors.
+ * The diagnostic {@link NestedError.context} (the `text`, the schema / type name, …)
+ * is BOTH a structured property AND folded into the message.
+ *
+ * Never rewrite a caught error into a bare ``new Error(`… ${err.message}`)`` — that
+ * SWALLOWS the cause and the context. Wrap it:
+ * `new NestedError("…", { cause: err, context: { … } })`.
+ */
+export declare class NestedError<Context extends NestedErrorContext = NestedErrorContext> extends Error {
+    /** The originating error chain (flattened + coerced to Error); `causes[0]` is the native `.cause`. */
+    readonly causes: Error[];
+    /** The diagnostic context captured at the throw site. */
+    readonly context: Context;
+    /**
+     * @param message - The high-level failure description.
+     * @param options - The {@link NestedErrorOptions.cause} to preserve + the {@link NestedErrorOptions.context} to capture.
+     */
+    constructor(message: string, options?: NestedErrorOptions<Context>);
 }
 export declare namespace NestedError {
-    function create(message: string, ...causes: Array<Error | Error[]>): NestedError;
-    function throwError(message: string, ...causes: Array<Error | Error[]>): never;
+    /** Max characters of any single context value folded into the message — long `text` is truncated. */
+    const ContextPreviewMaxChars = 200;
+    /** The marker appended when a folded context value is truncated. */
+    const TruncationSuffix = "\u2026";
+    /** Prefix marking each retained cause in the composed stack (nested-exception style). */
+    const CausedByPrefix = "Caused by: ";
+    /**
+     * Append a `Caused by:` section per cause to `stack`, so every cause's stack trace
+     * AND message stay visible in `.stack` (and any logger that prints it) — not only
+     * via the programmatic {@link NestedError.causes} / native `Error.cause`. Each
+     * cause's own `.stack` already begins with its `name: message`, so both are kept.
+     *
+     * @param stack - The wrapping error's own stack (may be undefined in exotic runtimes).
+     * @param causes - The retained cause chain.
+     * @returns The wrapping stack with one appended `Caused by:` section per cause.
+     */
+    function composeStack(stack: string | undefined, causes: Error[]): string;
+    /**
+     * Create a {@link NestedError}.
+     *
+     * @param message - The high-level failure description.
+     * @param options - The cause to preserve + the context to capture.
+     * @returns The constructed error.
+     */
+    function create<Context extends NestedErrorContext = NestedErrorContext>(message: string, options?: NestedErrorOptions<Context>): NestedError<Context>;
+    /**
+     * Create + throw a {@link NestedError}.
+     *
+     * @param message - The high-level failure description.
+     * @param options - The cause to preserve + the context to capture.
+     */
+    function throwError<Context extends NestedErrorContext = NestedErrorContext>(message: string, options?: NestedErrorOptions<Context>): never;
+    /**
+     * Coerce a thrown value (an Error, an array of them, or any value) into a flat
+     * `Error[]`, so a caught `unknown` can be preserved as a cause without loss.
+     *
+     * @param cause - The caught / rejected value.
+     * @returns The coerced error chain (empty when `cause` is nullish).
+     */
+    function toErrors(cause: unknown): Error[];
+    /**
+     * Coerce a single thrown value into an Error (Errors pass through unchanged).
+     *
+     * @param value - The caught value.
+     * @returns `value` when it is an Error, else a new Error wrapping its string form.
+     */
+    function toError(value: unknown): Error;
+    /**
+     * Fold a compact, truncated {@link NestedErrorContext} summary into the message so
+     * it is visible wherever the message is (logs, stack traces), not only on the
+     * `.context` property.
+     *
+     * @param message - The base message.
+     * @param context - The context to summarize, if any.
+     * @returns `message` with a ` (key=value, …)` suffix when context is non-empty.
+     */
+    function composeMessage(message: string, context?: NestedErrorContext): string;
+    /**
+     * Render one context value for the message suffix — strings verbatim, everything
+     * else via a bigint-/cycle-safe form, truncated to {@link ContextPreviewMaxChars}.
+     *
+     * @param value - The context value.
+     * @returns The truncated preview string.
+     */
+    function previewValue(value: unknown): string;
 }
-export default NestedError;
 //# sourceMappingURL=NestedError.d.ts.map

package/lib/esm/errors/NestedError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NestedError.d.ts","sourceRoot":"","sources":["../../../src/errors/NestedError.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;gBAEjB,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC;CAK/D;AAED,yBAAiB,WAAW,CAAC;IAC3B,SAAgB,MAAM,CACpB,OAAO,EAAE,MAAM,EACf,GAAG,MAAM,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,GAChC,WAAW,CAEb;IAED,SAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,GAAG,MAAM,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,GAChC,KAAK,CAEP;CACF;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"NestedError.d.ts","sourceRoot":"","sources":["../../../src/errors/NestedError.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAExD;;GAEG;AACH,MAAM,WAAW,kBAAkB,CACjC,OAAO,SAAS,kBAAkB,GAAG,kBAAkB;IAEvD;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,qDAAqD;IACrD,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW,CACtB,OAAO,SAAS,kBAAkB,GAAG,kBAAkB,CACvD,SAAQ,KAAK;IACb,sGAAsG;IACtG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAA;IAExB,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IAEzB;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAkB,CAAC,OAAO,CAAM;CAcvE;AAED,yBAAiB,WAAW,CAAC;IAC3B,qGAAqG;IAC9F,MAAM,sBAAsB,MAAM,CAAA;IAEzC,oEAAoE;IAC7D,MAAM,gBAAgB,WAAM,CAAA;IAEnC,yFAAyF;IAClF,MAAM,cAAc,gBAAgB,CAAA;IAE3C;;;;;;;;;OASG;IACH,SAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAM/E;IAED;;;;;;OAMG;IACH,SAAgB,MAAM,CAAC,OAAO,SAAS,kBAAkB,GAAG,kBAAkB,EAC5E,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,kBAAkB,CAAC,OAAO,CAAM,GACxC,WAAW,CAAC,OAAO,CAAC,CAEtB;IAED;;;;;OAKG;IACH,SAAgB,UAAU,CACxB,OAAO,SAAS,kBAAkB,GAAG,kBAAkB,EACvD,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAkB,CAAC,OAAO,CAAM,GAAG,KAAK,CAEnE;IAED;;;;;;OAMG;IACH,SAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,EAAE,CAIhD;IAED;;;;;OAKG;IACH,SAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAE7C;IAED;;;;;;;;OAQG;IACH,SAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,MAAM,CAOR;IAED;;;;;;OAMG;IACH,SAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKnD;CACF"}

package/lib/esm/errors/NestedError.js

@@ -1,20 +1,150 @@
+/**
+ * An Error that PRESERVES what it wraps instead of restringing it. Given a new
+ * message string, it ALSO retains the full cause chain: the originating error(s)
+ * survive as {@link NestedError.causes} (and the native `Error.cause`) — the real
+ * Error objects, so **each cause keeps its own stack trace and message** — and a
+ * nested-exception `Caused by:` section per cause is appended to this error's
+ * {@link NestedError.stack}, so the whole chain (each cause's stack + message) is
+ * visible wherever the error is printed, not only via the programmatic accessors.
+ * The diagnostic {@link NestedError.context} (the `text`, the schema / type name, …)
+ * is BOTH a structured property AND folded into the message.
+ *
+ * Never rewrite a caught error into a bare ``new Error(`… ${err.message}`)`` — that
+ * SWALLOWS the cause and the context. Wrap it:
+ * `new NestedError("…", { cause: err, context: { … } })`.
+ */
 export class NestedError extends Error {
+    /** The originating error chain (flattened + coerced to Error); `causes[0]` is the native `.cause`. */
     causes;
-    constructor(message, ...causes) {
-        super(message);
+    /** The diagnostic context captured at the throw site. */
+    context;
+    /**
+     * @param message - The high-level failure description.
+     * @param options - The {@link NestedErrorOptions.cause} to preserve + the {@link NestedErrorOptions.context} to capture.
+     */
+    constructor(message, options = {}) {
+        const causes = NestedError.toErrors(options.cause);
+        super(NestedError.composeMessage(message, options.context), causes.length > 0 ? { cause: causes[0] } : undefined);
         this.name = "NestedError";
-        this.causes = causes.flat();
+        this.causes = causes;
+        this.context = options.context ?? {};
+        // Retain each cause's stack + message VISIBLY: append a `Caused by:` section
+        // per cause so the full chain shows in `.stack` (and any logger that prints it),
+        // not only via the programmatic `.causes` / native `.cause`.
+        this.stack = NestedError.composeStack(this.stack, causes);
     }
 }
 (function (NestedError) {
-    function create(message, ...causes) {
-        return new NestedError(message, ...causes);
+    /** Max characters of any single context value folded into the message — long `text` is truncated. */
+    NestedError.ContextPreviewMaxChars = 200;
+    /** The marker appended when a folded context value is truncated. */
+    NestedError.TruncationSuffix = "…";
+    /** Prefix marking each retained cause in the composed stack (nested-exception style). */
+    NestedError.CausedByPrefix = "Caused by: ";
+    /**
+     * Append a `Caused by:` section per cause to `stack`, so every cause's stack trace
+     * AND message stay visible in `.stack` (and any logger that prints it) — not only
+     * via the programmatic {@link NestedError.causes} / native `Error.cause`. Each
+     * cause's own `.stack` already begins with its `name: message`, so both are kept.
+     *
+     * @param stack - The wrapping error's own stack (may be undefined in exotic runtimes).
+     * @param causes - The retained cause chain.
+     * @returns The wrapping stack with one appended `Caused by:` section per cause.
+     */
+    function composeStack(stack, causes) {
+        return causes.reduce((composed, cause) => `${composed}\n${NestedError.CausedByPrefix}${cause.stack ?? `${cause.name}: ${cause.message}`}`, stack ?? "");
+    }
+    NestedError.composeStack = composeStack;
+    /**
+     * Create a {@link NestedError}.
+     *
+     * @param message - The high-level failure description.
+     * @param options - The cause to preserve + the context to capture.
+     * @returns The constructed error.
+     */
+    function create(message, options = {}) {
+        return new NestedError(message, options);
     }
     NestedError.create = create;
-    function throwError(message, ...causes) {
-        throw create(message, ...causes);
+    /**
+     * Create + throw a {@link NestedError}.
+     *
+     * @param message - The high-level failure description.
+     * @param options - The cause to preserve + the context to capture.
+     */
+    function throwError(message, options = {}) {
+        throw create(message, options);
     }
     NestedError.throwError = throwError;
+    /**
+     * Coerce a thrown value (an Error, an array of them, or any value) into a flat
+     * `Error[]`, so a caught `unknown` can be preserved as a cause without loss.
+     *
+     * @param cause - The caught / rejected value.
+     * @returns The coerced error chain (empty when `cause` is nullish).
+     */
+    function toErrors(cause) {
+        return (Array.isArray(cause) ? cause : cause == null ? [] : [cause]).map(toError);
+    }
+    NestedError.toErrors = toErrors;
+    /**
+     * Coerce a single thrown value into an Error (Errors pass through unchanged).
+     *
+     * @param value - The caught value.
+     * @returns `value` when it is an Error, else a new Error wrapping its string form.
+     */
+    function toError(value) {
+        return value instanceof Error ? value : new Error(String(value));
+    }
+    NestedError.toError = toError;
+    /**
+     * Fold a compact, truncated {@link NestedErrorContext} summary into the message so
+     * it is visible wherever the message is (logs, stack traces), not only on the
+     * `.context` property.
+     *
+     * @param message - The base message.
+     * @param context - The context to summarize, if any.
+     * @returns `message` with a ` (key=value, …)` suffix when context is non-empty.
+     */
+    function composeMessage(message, context) {
+        const entries = context == null ? [] : Object.entries(context);
+        return entries.length === 0
+            ? message
+            : `${message} (${entries
+                .map(([key, value]) => `${key}=${previewValue(value)}`)
+                .join(", ")})`;
+    }
+    NestedError.composeMessage = composeMessage;
+    /**
+     * Render one context value for the message suffix — strings verbatim, everything
+     * else via a bigint-/cycle-safe form, truncated to {@link ContextPreviewMaxChars}.
+     *
+     * @param value - The context value.
+     * @returns The truncated preview string.
+     */
+    function previewValue(value) {
+        const rendered = typeof value === "string" ? value : safeStringify(value);
+        return rendered.length > NestedError.ContextPreviewMaxChars
+            ? `${rendered.slice(0, NestedError.ContextPreviewMaxChars)}${NestedError.TruncationSuffix}`
+            : rendered;
+    }
+    NestedError.previewValue = previewValue;
 })(NestedError || (NestedError = {}));
-export default NestedError;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmVzdGVkRXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXJyb3JzL05lc3RlZEVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxXQUFZLFNBQVEsS0FBSztJQUMzQixNQUFNLENBQWM7SUFFN0IsWUFBWSxPQUFlLEVBQUUsR0FBRyxNQUE4QjtRQUM1RCxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDZCxJQUFJLENBQUMsSUFBSSxHQUFHLGFBQWEsQ0FBQTtRQUN6QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQTtJQUM3QixDQUFDO0NBQ0Y7QUFFRCxXQUFpQixXQUFXO0lBQzFCLFNBQWdCLE1BQU0sQ0FDcEIsT0FBZSxFQUNmLEdBQUcsTUFBOEI7UUFFakMsT0FBTyxJQUFJLFdBQVcsQ0FBQyxPQUFPLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQTtJQUM1QyxDQUFDO0lBTGUsa0JBQU0sU0FLckIsQ0FBQTtJQUVELFNBQWdCLFVBQVUsQ0FDeEIsT0FBZSxFQUNmLEdBQUcsTUFBOEI7UUFFakMsTUFBTSxNQUFNLENBQUMsT0FBTyxFQUFFLEdBQUcsTUFBTSxDQUFDLENBQUE7SUFDbEMsQ0FBQztJQUxlLHNCQUFVLGFBS3pCLENBQUE7QUFDSCxDQUFDLEVBZGdCLFdBQVcsS0FBWCxXQUFXLFFBYzNCO0FBRUQsZUFBZSxXQUFXLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTmVzdGVkRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIHJlYWRvbmx5IGNhdXNlczogQXJyYXk8RXJyb3I+XG5cbiAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCAuLi5jYXVzZXM6IEFycmF5PEVycm9yIHwgRXJyb3JbXT4pIHtcbiAgICBzdXBlcihtZXNzYWdlKVxuICAgIHRoaXMubmFtZSA9IFwiTmVzdGVkRXJyb3JcIlxuICAgIHRoaXMuY2F1c2VzID0gY2F1c2VzLmZsYXQoKVxuICB9XG59XG5cbmV4cG9ydCBuYW1lc3BhY2UgTmVzdGVkRXJyb3Ige1xuICBleHBvcnQgZnVuY3Rpb24gY3JlYXRlKFxuICAgIG1lc3NhZ2U6IHN0cmluZyxcbiAgICAuLi5jYXVzZXM6IEFycmF5PEVycm9yIHwgRXJyb3JbXT5cbiAgKTogTmVzdGVkRXJyb3Ige1xuICAgIHJldHVybiBuZXcgTmVzdGVkRXJyb3IobWVzc2FnZSwgLi4uY2F1c2VzKVxuICB9XG5cbiAgZXhwb3J0IGZ1bmN0aW9uIHRocm93RXJyb3IoXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIC4uLmNhdXNlczogQXJyYXk8RXJyb3IgfCBFcnJvcltdPlxuICApOiBuZXZlciB7XG4gICAgdGhyb3cgY3JlYXRlKG1lc3NhZ2UsIC4uLmNhdXNlcylcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBOZXN0ZWRFcnJvclxuIl19
+/**
+ * A best-effort rendering of `value` for a message preview: JSON when serializable,
+ * else `String(value)`. Pure display fallback — a BigInt or a circular object makes
+ * `JSON.stringify` throw — NOT error handling, so the catch is a deliberate render
+ * fallback rather than a swallow.
+ *
+ * @param value - The value to render.
+ * @returns A single-line string form of `value`.
+ */
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NestedError.js","sourceRoot":"","sources":["../../../src/errors/NestedError.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,WAEX,SAAQ,KAAK;IACb,sGAAsG;IAC7F,MAAM,CAAS;IAExB,yDAAyD;IAChD,OAAO,CAAS;IAEzB;;;OAGG;IACH,YAAY,OAAe,EAAE,UAAuC,EAAE;QACpE,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAClD,KAAK,CACH,WAAW,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACpD,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CACrD,CAAA;QACD,IAAI,CAAC,IAAI,GAAG,aAAa,CAAA;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAK,EAAc,CAAA;QACjD,6EAA6E;QAC7E,iFAAiF;QACjF,6DAA6D;QAC7D,IAAI,CAAC,KAAK,GAAG,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAC3D,CAAC;CACF;AAED,WAAiB,WAAW;IAC1B,qGAAqG;IACxF,kCAAsB,GAAG,GAAG,CAAA;IAEzC,oEAAoE;IACvD,4BAAgB,GAAG,GAAG,CAAA;IAEnC,yFAAyF;IAC5E,0BAAc,GAAG,aAAa,CAAA;IAE3C;;;;;;;;;OASG;IACH,SAAgB,YAAY,CAAC,KAAyB,EAAE,MAAe;QACrE,OAAO,MAAM,CAAC,MAAM,CAClB,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAClB,GAAG,QAAQ,KAAK,YAAA,cAAc,GAAG,KAAK,CAAC,KAAK,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE,EACrF,KAAK,IAAI,EAAE,CACZ,CAAA;IACH,CAAC;IANe,wBAAY,eAM3B,CAAA;IAED;;;;;;OAMG;IACH,SAAgB,MAAM,CACpB,OAAe,EACf,UAAuC,EAAE;QAEzC,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAC1C,CAAC;IALe,kBAAM,SAKrB,CAAA;IAED;;;;;OAKG;IACH,SAAgB,UAAU,CAExB,OAAe,EAAE,UAAuC,EAAE;QAC1D,MAAM,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAChC,CAAC;IAJe,sBAAU,aAIzB,CAAA;IAED;;;;;;OAMG;IACH,SAAgB,QAAQ,CAAC,KAAc;QACrC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CACtE,OAAO,CACR,CAAA;IACH,CAAC;IAJe,oBAAQ,WAIvB,CAAA;IAED;;;;;OAKG;IACH,SAAgB,OAAO,CAAC,KAAc;QACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAClE,CAAC;IAFe,mBAAO,UAEtB,CAAA;IAED;;;;;;;;OAQG;IACH,SAAgB,cAAc,CAC5B,OAAe,EACf,OAA4B;QAE5B,MAAM,OAAO,GAAG,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAC9D,OAAO,OAAO,CAAC,MAAM,KAAK,CAAC;YACzB,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,GAAG,OAAO,KAAK,OAAO;iBACnB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;iBACtD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;IACtB,CAAC;IAVe,0BAAc,iBAU7B,CAAA;IAED;;;;;;OAMG;IACH,SAAgB,YAAY,CAAC,KAAc;QACzC,MAAM,QAAQ,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;QACzE,OAAO,QAAQ,CAAC,MAAM,GAAG,YAAA,sBAAsB;YAC7C,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,YAAA,sBAAsB,CAAC,GAAG,YAAA,gBAAgB,EAAE;YACnE,CAAC,CAAC,QAAQ,CAAA;IACd,CAAC;IALe,wBAAY,eAK3B,CAAA;AACH,CAAC,EA/GgB,WAAW,KAAX,WAAW,QA+G3B;AAED;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,KAAc;IACnC,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAA;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;IACtB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Structured, machine-readable diagnostic context captured at a {@link NestedError}\n * throw site — the values that make a failure diagnosable (the `text` that failed to\n * parse, a schema / type name, an id, …). Heterogeneous by nature, so the values are\n * `unknown` (a documented type-erased bag, not a shortcut).\n */\nexport type NestedErrorContext = Record<string, unknown>\n\n/**\n * Options for {@link NestedError} — what it preserves about the failure it wraps.\n */\nexport interface NestedErrorOptions<\n  Context extends NestedErrorContext = NestedErrorContext\n> {\n  /**\n   * The originating error(s) — the root-cause chain that must NOT be swallowed. A\n   * non-Error thrown value is coerced to an Error; the first becomes the native\n   * ES2022 `Error.cause`.\n   */\n  cause?: unknown\n  /** Diagnostic context captured at the throw site. */\n  context?: Context\n}\n\n/**\n * An Error that PRESERVES what it wraps instead of restringing it. Given a new\n * message string, it ALSO retains the full cause chain: the originating error(s)\n * survive as {@link NestedError.causes} (and the native `Error.cause`) — the real\n * Error objects, so **each cause keeps its own stack trace and message** — and a\n * nested-exception `Caused by:` section per cause is appended to this error's\n * {@link NestedError.stack}, so the whole chain (each cause's stack + message) is\n * visible wherever the error is printed, not only via the programmatic accessors.\n * The diagnostic {@link NestedError.context} (the `text`, the schema / type name, …)\n * is BOTH a structured property AND folded into the message.\n *\n * Never rewrite a caught error into a bare ``new Error(`… ${err.message}`)`` — that\n * SWALLOWS the cause and the context. Wrap it:\n * `new NestedError(\"…\", { cause: err, context: { … } })`.\n */\nexport class NestedError<\n  Context extends NestedErrorContext = NestedErrorContext\n> extends Error {\n  /** The originating error chain (flattened + coerced to Error); `causes[0]` is the native `.cause`. */\n  readonly causes: Error[]\n\n  /** The diagnostic context captured at the throw site. */\n  readonly context: Context\n\n  /**\n   * @param message - The high-level failure description.\n   * @param options - The {@link NestedErrorOptions.cause} to preserve + the {@link NestedErrorOptions.context} to capture.\n   */\n  constructor(message: string, options: NestedErrorOptions<Context> = {}) {\n    const causes = NestedError.toErrors(options.cause)\n    super(\n      NestedError.composeMessage(message, options.context),\n      causes.length > 0 ? { cause: causes[0] } : undefined\n    )\n    this.name = \"NestedError\"\n    this.causes = causes\n    this.context = options.context ?? ({} as Context)\n    // Retain each cause's stack + message VISIBLY: append a `Caused by:` section\n    // per cause so the full chain shows in `.stack` (and any logger that prints it),\n    // not only via the programmatic `.causes` / native `.cause`.\n    this.stack = NestedError.composeStack(this.stack, causes)\n  }\n}\n\nexport namespace NestedError {\n  /** Max characters of any single context value folded into the message — long `text` is truncated. */\n  export const ContextPreviewMaxChars = 200\n\n  /** The marker appended when a folded context value is truncated. */\n  export const TruncationSuffix = \"…\"\n\n  /** Prefix marking each retained cause in the composed stack (nested-exception style). */\n  export const CausedByPrefix = \"Caused by: \"\n\n  /**\n   * Append a `Caused by:` section per cause to `stack`, so every cause's stack trace\n   * AND message stay visible in `.stack` (and any logger that prints it) — not only\n   * via the programmatic {@link NestedError.causes} / native `Error.cause`. Each\n   * cause's own `.stack` already begins with its `name: message`, so both are kept.\n   *\n   * @param stack - The wrapping error's own stack (may be undefined in exotic runtimes).\n   * @param causes - The retained cause chain.\n   * @returns The wrapping stack with one appended `Caused by:` section per cause.\n   */\n  export function composeStack(stack: string | undefined, causes: Error[]): string {\n    return causes.reduce(\n      (composed, cause) =>\n        `${composed}\\n${CausedByPrefix}${cause.stack ?? `${cause.name}: ${cause.message}`}`,\n      stack ?? \"\"\n    )\n  }\n\n  /**\n   * Create a {@link NestedError}.\n   *\n   * @param message - The high-level failure description.\n   * @param options - The cause to preserve + the context to capture.\n   * @returns The constructed error.\n   */\n  export function create<Context extends NestedErrorContext = NestedErrorContext>(\n    message: string,\n    options: NestedErrorOptions<Context> = {}\n  ): NestedError<Context> {\n    return new NestedError(message, options)\n  }\n\n  /**\n   * Create + throw a {@link NestedError}.\n   *\n   * @param message - The high-level failure description.\n   * @param options - The cause to preserve + the context to capture.\n   */\n  export function throwError<\n    Context extends NestedErrorContext = NestedErrorContext\n  >(message: string, options: NestedErrorOptions<Context> = {}): never {\n    throw create(message, options)\n  }\n\n  /**\n   * Coerce a thrown value (an Error, an array of them, or any value) into a flat\n   * `Error[]`, so a caught `unknown` can be preserved as a cause without loss.\n   *\n   * @param cause - The caught / rejected value.\n   * @returns The coerced error chain (empty when `cause` is nullish).\n   */\n  export function toErrors(cause: unknown): Error[] {\n    return (Array.isArray(cause) ? cause : cause == null ? [] : [cause]).map(\n      toError\n    )\n  }\n\n  /**\n   * Coerce a single thrown value into an Error (Errors pass through unchanged).\n   *\n   * @param value - The caught value.\n   * @returns `value` when it is an Error, else a new Error wrapping its string form.\n   */\n  export function toError(value: unknown): Error {\n    return value instanceof Error ? value : new Error(String(value))\n  }\n\n  /**\n   * Fold a compact, truncated {@link NestedErrorContext} summary into the message so\n   * it is visible wherever the message is (logs, stack traces), not only on the\n   * `.context` property.\n   *\n   * @param message - The base message.\n   * @param context - The context to summarize, if any.\n   * @returns `message` with a ` (key=value, …)` suffix when context is non-empty.\n   */\n  export function composeMessage(\n    message: string,\n    context?: NestedErrorContext\n  ): string {\n    const entries = context == null ? [] : Object.entries(context)\n    return entries.length === 0\n      ? message\n      : `${message} (${entries\n          .map(([key, value]) => `${key}=${previewValue(value)}`)\n          .join(\", \")})`\n  }\n\n  /**\n   * Render one context value for the message suffix — strings verbatim, everything\n   * else via a bigint-/cycle-safe form, truncated to {@link ContextPreviewMaxChars}.\n   *\n   * @param value - The context value.\n   * @returns The truncated preview string.\n   */\n  export function previewValue(value: unknown): string {\n    const rendered = typeof value === \"string\" ? value : safeStringify(value)\n    return rendered.length > ContextPreviewMaxChars\n      ? `${rendered.slice(0, ContextPreviewMaxChars)}${TruncationSuffix}`\n      : rendered\n  }\n}\n\n/**\n * A best-effort rendering of `value` for a message preview: JSON when serializable,\n * else `String(value)`. Pure display fallback — a BigInt or a circular object makes\n * `JSON.stringify` throw — NOT error handling, so the catch is a deliberate render\n * fallback rather than a swallow.\n *\n * @param value - The value to render.\n * @returns A single-line string form of `value`.\n */\nfunction safeStringify(value: unknown): string {\n  try {\n    return JSON.stringify(value) ?? String(value)\n  } catch {\n    return String(value)\n  }\n}\n"]}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseAppender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AWSFirehoseAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"AAOA,OAAO,4BAEN,MAAM,mCAAmC,CAAA;AAI1C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAmB5C,qBAAa,mBAAmB,CAC9B,MAAM,SAAS,SAAS,GAAG,SAAS,CACpC,YAAW,QAAQ,CAAC,MAAM,CAAC;aAOC,qBAAqB,EAAE,MAAM;IANzD,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,eAAe,CAAO;IAE9B,SAAgB,iBAAiB,EAAE,4BAA4B,CAAA;gBAEnC,qBAAqB,EAAE,MAAM;IAoBzD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmB5B;;;;OAIG;YACW,WAAW;IAgBzB;;;;OAIG;YACW,KAAK;CA0EpB;AAED,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"AWSFirehoseAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"AAMA,OAAO,4BAEN,MAAM,mCAAmC,CAAA;AAI1C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAmB5C,qBAAa,mBAAmB,CAC9B,MAAM,SAAS,SAAS,GAAG,SAAS,CACpC,YAAW,QAAQ,CAAC,MAAM,CAAC;aAOC,qBAAqB,EAAE,MAAM;IANzD,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,eAAe,CAAO;IAE9B,SAAgB,iBAAiB,EAAE,4BAA4B,CAAA;gBAEnC,qBAAqB,EAAE,MAAM;IAoBzD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmB5B;;;;OAIG;YACW,WAAW;IAgBzB;;;;OAIG;YACW,KAAK;CA0EpB;AAED,eAAe,mBAAmB,CAAA"}

package/lib/esm/logging/appenders/aws-firehose/AWSFirehoseAppender.js

@@ -134,4 +134,4 @@ export class AWSFirehoseAppender {
     }
 }
 export default AWSFirehoseAppender;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AWSFirehoseAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type {\n  FirehoseClient,\n  PutRecordBatchInput\n} from \"@aws-sdk/client-firehose\"\nimport { Level } from \"../../Level.js\"\n\nimport AWSFirehoseCredentialManager, {\n  type AWSCredentials\n} from \"./AWSFirehoseCredentialManager.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\nimport { pick } from \"lodash\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\n\nconst LogQueueMaxRecords = 10000\nconst ExpiredTokenExceptionCode = \"ExpiredTokenException\"\n\nconst log = getInternalLogger()\nlet firehoseModule: Promise<typeof import(\"@aws-sdk/client-firehose\")> = null\n\nfunction getFirehoseModule() {\n  if (!firehoseModule) {\n    firehoseModule = import(\"@aws-sdk/client-firehose\").catch(err => {\n      firehoseModule = null\n      throw err\n    })\n  }\n\n  return firehoseModule\n}\n\nexport class AWSFirehoseAppender<\n  Record extends LogRecord = LogRecord\n> implements Appender<Record> {\n  private pendingRecords = Array<LogRecord>()\n  private flushDeferred: Deferred<void>\n  private flushIntervalMs = 1000\n\n  public readonly credentialManager: AWSFirehoseCredentialManager\n\n  constructor(public readonly credentialEndpointUrl: string) {\n    this.credentialManager = new AWSFirehoseCredentialManager(\n      credentialEndpointUrl\n    )\n    this.credentialManager.on(\"received\", () => {\n      log.info(\"Credentials received, initializing firehose client\")\n      if (!this.pendingRecords.length || !!this.flushDeferred) {\n        log.debug(\n          \"Nothing to flush upon credential receipt OR flush already in progress\"\n        )\n        return\n      }\n      this.flush().catch((e: Error) => {\n        log.error(\n          `Error flushing logs after credential receipt: ${e.message}`,\n          e\n        )\n      })\n    })\n  }\n  append(record: Record): void {\n    const pendingCount = this.pendingRecords.length + 1,\n      removeCount = LogQueueMaxRecords - pendingCount\n\n    if (removeCount < 0) {\n      this.pendingRecords.splice(0, Math.abs(removeCount))\n    }\n\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app?.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env?.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href\n    })\n\n    this.flush()\n  }\n\n  /**\n   * Create the Firehose client for a loaded credential set.\n   * @param creds Loaded Firehose credentials.\n   * @returns Firehose client.\n   */\n  private async getFirehose(creds: AWSCredentials): Promise<FirehoseClient> {\n    const { region, streamName } = creds\n\n    if (!region || !streamName) {\n      throw new Error(\"Region or stream name not available\")\n    }\n\n    const { FirehoseClient } = await getFirehoseModule()\n    const client = new FirehoseClient({\n      region: creds.region,\n      credentials: pick(creds, \"accessKeyId\", \"secretAccessKey\", \"sessionToken\")\n    })\n\n    return client\n  }\n\n  /**\n   * Flush pending records\n   *\n   * @returns {Promise<void>}\n   */\n  private async flush(): Promise<void> {\n    if (!!this.flushDeferred) {\n      log.debug(\"Flush already in progress, skipping\")\n      return\n    }\n\n    if (!this.pendingRecords.length) {\n      log.debug(\"No pending records to flush\")\n      return\n    }\n    const creds = this.credentialManager.getCredentials()\n    if (!creds) {\n      log.warn(\"No credentials available for flush\")\n      return\n    }\n\n    const deferred = (this.flushDeferred = new Deferred<void>())\n    try {\n      const { streamName } = creds,\n        client = await this.getFirehose(creds),\n        { PutRecordBatchCommand } = await getFirehoseModule()\n\n      while (this.pendingRecords.length) {\n        const chunkSize = Math.min(this.pendingRecords.length, 10),\n          records = this.pendingRecords.splice(0, chunkSize),\n          recordJsons = records.map(record => JSON.stringify(record))\n\n        if (log.isDebugEnabled()) log.debug(\"Records\", records)\n\n        const textEncoder = new TextEncoder(),\n          batch: PutRecordBatchInput[\"Records\"] = recordJsons.map(jsonStr => ({\n            Data: textEncoder.encode(jsonStr)\n          }))\n\n        log.info(`Pushing ${records.length} records to firehose`)\n\n        const cmd = new PutRecordBatchCommand({\n          DeliveryStreamName: streamName,\n          Records: batch\n        })\n\n        const resp = await client.send(cmd)\n        const failed = resp.FailedPutCount || 0\n        if (failed) {\n          const rr = resp.RequestResponses || []\n          for (let i = 0; i < rr.length; i++) {\n            if (rr[i].ErrorCode) {\n              log.warn(\n                `Record failed: ${rr[i].ErrorCode} ${rr[i].ErrorMessage}`\n              )\n              //this.pendingRecords.unshift(records[i])\n            }\n          }\n          log.info(`PutRecordBatch failed=${failed}; requeued failed records`)\n        } else {\n          log.info(`PutRecordBatch ok count=${records.length}`)\n        }\n      }\n      deferred.resolve()\n    } catch (err) {\n      log.error(\"Failed to push logs\", err)\n      if (err.name === ExpiredTokenExceptionCode) {\n        this.credentialManager.forceUpdateCredentials()\n      }\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // if (this.pendingRecords.length)\n      //   this.flush()\n    }\n\n    return deferred.promise\n  }\n}\n\nexport default AWSFirehoseAppender\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AWSFirehoseAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/aws-firehose/AWSFirehoseAppender.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  FirehoseClient,\n  PutRecordBatchInput\n} from \"@aws-sdk/client-firehose\"\nimport { Level } from \"../../Level.js\"\n\nimport AWSFirehoseCredentialManager, {\n  type AWSCredentials\n} from \"./AWSFirehoseCredentialManager.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\nimport { pick } from \"lodash\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\n\nconst LogQueueMaxRecords = 10000\nconst ExpiredTokenExceptionCode = \"ExpiredTokenException\"\n\nconst log = getInternalLogger()\nlet firehoseModule: Promise<typeof import(\"@aws-sdk/client-firehose\")> = null\n\nfunction getFirehoseModule() {\n  if (!firehoseModule) {\n    firehoseModule = import(\"@aws-sdk/client-firehose\").catch(err => {\n      firehoseModule = null\n      throw err\n    })\n  }\n\n  return firehoseModule\n}\n\nexport class AWSFirehoseAppender<\n  Record extends LogRecord = LogRecord\n> implements Appender<Record> {\n  private pendingRecords = Array<LogRecord>()\n  private flushDeferred: Deferred<void>\n  private flushIntervalMs = 1000\n\n  public readonly credentialManager: AWSFirehoseCredentialManager\n\n  constructor(public readonly credentialEndpointUrl: string) {\n    this.credentialManager = new AWSFirehoseCredentialManager(\n      credentialEndpointUrl\n    )\n    this.credentialManager.on(\"received\", () => {\n      log.info(\"Credentials received, initializing firehose client\")\n      if (!this.pendingRecords.length || !!this.flushDeferred) {\n        log.debug(\n          \"Nothing to flush upon credential receipt OR flush already in progress\"\n        )\n        return\n      }\n      this.flush().catch((e: Error) => {\n        log.error(\n          `Error flushing logs after credential receipt: ${e.message}`,\n          e\n        )\n      })\n    })\n  }\n  append(record: Record): void {\n    const pendingCount = this.pendingRecords.length + 1,\n      removeCount = LogQueueMaxRecords - pendingCount\n\n    if (removeCount < 0) {\n      this.pendingRecords.splice(0, Math.abs(removeCount))\n    }\n\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app?.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env?.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href\n    })\n\n    this.flush()\n  }\n\n  /**\n   * Create the Firehose client for a loaded credential set.\n   * @param creds Loaded Firehose credentials.\n   * @returns Firehose client.\n   */\n  private async getFirehose(creds: AWSCredentials): Promise<FirehoseClient> {\n    const { region, streamName } = creds\n\n    if (!region || !streamName) {\n      throw new Error(\"Region or stream name not available\")\n    }\n\n    const { FirehoseClient } = await getFirehoseModule()\n    const client = new FirehoseClient({\n      region: creds.region,\n      credentials: pick(creds, \"accessKeyId\", \"secretAccessKey\", \"sessionToken\")\n    })\n\n    return client\n  }\n\n  /**\n   * Flush pending records\n   *\n   * @returns {Promise<void>}\n   */\n  private async flush(): Promise<void> {\n    if (!!this.flushDeferred) {\n      log.debug(\"Flush already in progress, skipping\")\n      return\n    }\n\n    if (!this.pendingRecords.length) {\n      log.debug(\"No pending records to flush\")\n      return\n    }\n    const creds = this.credentialManager.getCredentials()\n    if (!creds) {\n      log.warn(\"No credentials available for flush\")\n      return\n    }\n\n    const deferred = (this.flushDeferred = new Deferred<void>())\n    try {\n      const { streamName } = creds,\n        client = await this.getFirehose(creds),\n        { PutRecordBatchCommand } = await getFirehoseModule()\n\n      while (this.pendingRecords.length) {\n        const chunkSize = Math.min(this.pendingRecords.length, 10),\n          records = this.pendingRecords.splice(0, chunkSize),\n          recordJsons = records.map(record => JSON.stringify(record))\n\n        if (log.isDebugEnabled()) log.debug(\"Records\", records)\n\n        const textEncoder = new TextEncoder(),\n          batch: PutRecordBatchInput[\"Records\"] = recordJsons.map(jsonStr => ({\n            Data: textEncoder.encode(jsonStr)\n          }))\n\n        log.info(`Pushing ${records.length} records to firehose`)\n\n        const cmd = new PutRecordBatchCommand({\n          DeliveryStreamName: streamName,\n          Records: batch\n        })\n\n        const resp = await client.send(cmd)\n        const failed = resp.FailedPutCount || 0\n        if (failed) {\n          const rr = resp.RequestResponses || []\n          for (let i = 0; i < rr.length; i++) {\n            if (rr[i].ErrorCode) {\n              log.warn(\n                `Record failed: ${rr[i].ErrorCode} ${rr[i].ErrorMessage}`\n              )\n              //this.pendingRecords.unshift(records[i])\n            }\n          }\n          log.info(`PutRecordBatch failed=${failed}; requeued failed records`)\n        } else {\n          log.info(`PutRecordBatch ok count=${records.length}`)\n        }\n      }\n      deferred.resolve()\n    } catch (err) {\n      log.error(\"Failed to push logs\", err)\n      if (err.name === ExpiredTokenExceptionCode) {\n        this.credentialManager.forceUpdateCredentials()\n      }\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // if (this.pendingRecords.length)\n      //   this.flush()\n    }\n\n    return deferred.promise\n  }\n}\n\nexport default AWSFirehoseAppender\n"]}

package/lib/esm/logging/appenders/push/PushLogRecordsAppender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PushLogRecordsAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAa5C,UAAU,uCAAuC;IAC/C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,aAAa,CAAC,uCAAuC,CAAC;aAK7E,WAAW,EAAE,MAAM;IAJ/C,OAAO,CAAC,YAAY,CAA6C;IACjE,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,oBAAoB,CAAsB;gBAEtB,WAAW,EAAE,MAAM;IAI/C;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAoB3C;;OAEG;IACH,YAAY,IAAI,IAAI;IAkBpB;;OAEG;YACW,gBAAgB;IAsC9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,IAAI,IAAI;CAahB;AAED;;;GAGG;AACH,qBAAa,sBAAsB,CACjC,MAAM,SAAS,SAAS,GAAG,SAAS,CACpC,YAAW,QAAQ,CAAC,MAAM,CAAC;aAOC,WAAW,EAAE,MAAM;IAN/C,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,UAAU,CAA6C;IAE/D,SAAgB,iBAAiB,EAAE,+BAA+B,CAAA;gBAEtC,WAAW,EAAE,MAAM;IAa/C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAsB5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;OAEG;YACW,KAAK;IA0DnB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAQpC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB;AAED,eAAe,sBAAsB,CAAA"}
+{"version":3,"file":"PushLogRecordsAppender.d.ts","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAa5C,UAAU,uCAAuC;IAC/C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;GAGG;AACH,qBAAa,+BAAgC,SAAQ,aAAa,CAAC,uCAAuC,CAAC;aAK7E,WAAW,EAAE,MAAM;IAJ/C,OAAO,CAAC,YAAY,CAA6C;IACjE,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,oBAAoB,CAAsB;gBAEtB,WAAW,EAAE,MAAM;IAI/C;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC;IAoB3C;;OAEG;IACH,YAAY,IAAI,IAAI;IAkBpB;;OAEG;YACW,gBAAgB;IAsC9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAevB;;OAEG;IACH,OAAO,IAAI,IAAI;CAahB;AAED;;;GAGG;AACH,qBAAa,sBAAsB,CACjC,MAAM,SAAS,SAAS,GAAG,SAAS,CACpC,YAAW,QAAQ,CAAC,MAAM,CAAC;aAOC,WAAW,EAAE,MAAM;IAN/C,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,UAAU,CAA6C;IAE/D,SAAgB,iBAAiB,EAAE,+BAA+B,CAAA;gBAEtC,WAAW,EAAE,MAAM;IAa/C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAsB5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;OAEG;YACW,KAAK;IA0DnB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAQpC;;OAEG;IACH,OAAO,IAAI,IAAI;CAehB;AAED,eAAe,sBAAsB,CAAA"}

package/lib/esm/logging/appenders/push/PushLogRecordsAppender.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import EventEmitter3 from "eventemitter3";
 import { Deferred } from "../../../helpers/index.js";
 import { getInternalLogger } from "../../InternalLogger.js";
@@ -288,4 +287,4 @@ export class PushLogRecordsAppender {
     }
 }
 export default PushLogRecordsAppender;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PushLogRecordsAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,aAAa,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAGpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAE3D,mDAAmD;AACnD,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA,CAAC,aAAa;AACxD,MAAM,wBAAwB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAA,CAAC,sCAAsC;AACrF,MAAM,iBAAiB,GAAG,IAAI,CAAA;AAC9B,MAAM,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAA,CAAC,aAAa;AAChD,MAAM,qBAAqB,GAAG,KAAK,CAAA;AACnC,MAAM,WAAW,GAAG,cAAc,CAAA;AAElC,MAAM,GAAG,GAAG,iBAAiB,EAAE,CAAA;AAO/B;;;GAGG;AACH,MAAM,OAAO,+BAAgC,SAAQ,aAAsD;IAK7E;IAJpB,YAAY,GAAyC,IAAI,CAAA;IACzD,kBAAkB,GAA0B,IAAI,CAAA;IAChD,oBAAoB,GAAkB,IAAI,CAAA;IAElD,YAA4B,WAAmB;QAC7C,KAAK,EAAE,CAAA;QADmB,gBAAW,GAAX,WAAW,CAAQ;IAE/C,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAA;QACd,CAAC;QAED,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5C,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAA;YAChC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YACpB,OAAO,KAAK,CAAA;QACd,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,iBAAiB;QACrB,mDAAmD;QACnD,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAA;QACb,CAAC;QAED,iDAAiD;QACjD,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,CAAC;YACpE,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAA;gBACrC,OAAO,IAAI,CAAC,cAAc,EAAE,CAAA;YAC9B,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,KAAK,CAAA;YACd,CAAC;QACH,CAAC;QAED,wBAAwB;QACxB,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAA;IAChC,CAAC;IAED;;OAEG;IACH,YAAY;QACV,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;YAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QAC1B,CAAC;QAED,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAA;QAEhC,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,CAAC;YACpE,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC,CAAA;QACtE,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAA;QAE9B,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;YACjC,yEAAyE;QAC3E,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,kBAAkB,GAAG,IAAI,QAAQ,EAAQ,CAAC,CAAA;QAEjE,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE;gBAC7C,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,MAAM;gBACZ,WAAW,EAAE,SAAS;gBACtB,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;iBACnC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;aACzB,CAAC,CAAA;YAEF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CACb,yCAAyC,QAAQ,CAAC,MAAM,EAAE,CAC3D,CAAA;YACH,CAAC;YAED,uEAAuE;YACvE,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,oBAAoB,CAAA;YAE7D,qCAAqC;YACrC,IAAI,CAAC,eAAe,EAAE,CAAA;YAEtB,QAAQ,CAAC,OAAO,EAAE,CAAA;YAClB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAErB,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,GAAG,CAAC,IAAI,CAAC,sCAAsC,EAAE,GAAG,CAAC,CAAA;YACrD,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;YACpB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAA;YAC9B,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QACjC,CAAC;QAED,MAAM,SAAS,GAAG,oBAAoB,GAAG,wBAAwB,CAAA;QACjE,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE;YAClC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAA;YAC9B,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;gBACjC,mDAAmD;gBACnD,GAAG,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAA;YAClD,CAAC,CAAC,CAAA;QACJ,CAAC,EAAE,SAAS,CAAC,CAAA;IACf,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;YAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAA;QAC1B,CAAC;QAED,IAAI,IAAI,CAAC,kBAAkB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,CAAC;YACpE,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAA;QAC3E,CAAC;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAA;QAC9B,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAA;IAClC,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IASL;IANpB,cAAc,GAAgB,EAAE,CAAA;IAChC,aAAa,GAA0B,IAAI,CAAA;IAC3C,UAAU,GAAyC,IAAI,CAAA;IAE/C,iBAAiB,CAAiC;IAElE,YAA4B,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;QAC7C,IAAI,CAAC,iBAAiB,GAAG,IAAI,+BAA+B,CAAC,WAAW,CAAC,CAAA;QAEzE,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE;YACzC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACtD,OAAM;YACR,CAAC;YACD,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;gBACtB,0BAA0B;YAC5B,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAc;QACnB,wCAAwC;QACxC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YACvB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,GAAG,MAAM;YACT,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;YACjE,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;YACjE,GAAG,EAAE,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI;SACvE,CAAC,CAAA;QACF,IAAI,CAAC,4BAA4B,EAAE,CAAA;QAEnC,0DAA0D;QAC1D,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,iBAAiB,EAAE,CAAC;YACpD,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;gBACtB,0BAA0B;YAC5B,CAAC,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,4CAA4C;YAC5C,IAAI,CAAC,aAAa,EAAE,CAAA;QACtB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAM,CAAC,oBAAoB;QAC7B,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;YACtB,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;gBACtB,0BAA0B;YAC5B,CAAC,CAAC,CAAA;QACJ,CAAC,EAAE,iBAAiB,CAAC,CAAA;IACvB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,KAAK;QACjB,6BAA6B;QAC7B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAA;QACnC,CAAC;QAED,mBAAmB;QACnB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;YAChC,OAAM;QACR,CAAC;QAED,mCAAmC;QACnC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,EAAE,CAAA;QACvE,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,GAAG,CAAC,KAAK,CAAC,4BAA4B,EAAE,gCAAgC,CAAC,CAAA;YACzE,OAAM;QACR,CAAC;QAED,MAAM,QAAQ,GAAG,CAAC,IAAI,CAAC,aAAa,GAAG,IAAI,QAAQ,EAAQ,CAAC,CAAA;QAE5D,IAAI,CAAC;YACH,0CAA0C;YAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;YACzE,MAAM,OAAO,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAA;YAE1E,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE;gBAC7C,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;gBACZ,WAAW,EAAE,SAAS;gBACtB,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;iBACnC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;aAC9B,CAAC,CAAA;YAEF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,8BAA8B;gBAC9B,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAA;gBACvC,IAAI,CAAC,4BAA4B,EAAE,CAAA;gBACnC,MAAM,IAAI,KAAK,CAAC,2BAA2B,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;YAC/D,CAAC;YAED,QAAQ,CAAC,OAAO,EAAE,CAAA;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,GAAG,CAAC,KAAK,CAAC,4BAA4B,EAAE,GAAG,CAAC,CAAA;YAC5C,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACtB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;YAEzB,6DAA6D;YAC7D,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACnC,IAAI,CAAC,aAAa,EAAE,CAAA;YACtB,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC,OAAO,CAAA;IACzB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACxB,CAAC;QAED,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED;;OAEG;IACK,4BAA4B;QAClC,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,GAAG,qBAAqB,CAAA;QAEtE,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,CAAA;QAC5C,CAAC;IACH,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAC7B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACxB,CAAC;QAED,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAA;QAEhC,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC;YAC1D,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAA;QAC5D,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAA;QACzB,IAAI,CAAC,cAAc,GAAG,EAAE,CAAA;IAC1B,CAAC;CACF;AAED,eAAe,sBAAsB,CAAA","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport EventEmitter3 from \"eventemitter3\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\n\n// Constants for tuning (adjustable in development)\nconst COOKIE_EXPIRATION_MS = 5 * 60 * 1000 // 30 minutes\nconst COOKIE_REFRESH_BUFFER_MS = 2 * 60 * 1000 // Refresh 2 minutes before expiration\nconst FLUSH_QUEUE_DEPTH = 1000\nconst FLUSH_INTERVAL_MS = 5 * 1000 // 10 seconds\nconst LOG_QUEUE_MAX_RECORDS = 10000\nconst COOKIE_NAME = \"wire_logs_id\"\n\nconst log = getInternalLogger()\n\ninterface PushLogRecordsCredentialManagerEventMap {\n  received: () => void\n  expired: () => void\n}\n\n/**\n * Manages credential cookie for PushLogRecordsAppender.\n * Invokes the endpoint via POST to obtain a session cookie.\n */\nexport class PushLogRecordsCredentialManager extends EventEmitter3<PushLogRecordsCredentialManagerEventMap> {\n  private refreshTimer: ReturnType<typeof setTimeout> | null = null\n  private credentialDeferred: Deferred<void> | null = null\n  private cookieExpirationTime: number | null = null\n\n  constructor(public readonly endpointUrl: string) {\n    super()\n  }\n\n  /**\n   * Check if valid credentials exist\n   */\n  hasCredentials(): boolean {\n    if (!this.cookieExpirationTime) {\n      return false\n    }\n\n    if (Date.now() >= this.cookieExpirationTime) {\n      this.cookieExpirationTime = null\n      this.emit(\"expired\")\n      return false\n    }\n\n    return true\n  }\n\n  /**\n   * Get credentials, fetching them if necessary\n   */\n  async ensureCredentials(): Promise<boolean> {\n    // If we have valid credentials, return immediately\n    if (this.hasCredentials()) {\n      return true\n    }\n\n    // If a fetch is already in progress, wait for it\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      try {\n        await this.credentialDeferred.promise\n        return this.hasCredentials()\n      } catch {\n        return false\n      }\n    }\n\n    // Fetch new credentials\n    return this.fetchCredentials()\n  }\n\n  /**\n   * Force refresh of credentials\n   */\n  forceRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    this.cookieExpirationTime = null\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Force refresh requested\"))\n    }\n    this.credentialDeferred = null\n\n    this.fetchCredentials().catch(() => {\n      // Ignore errors during force refresh, they'll be handled on next request\n    })\n  }\n\n  /**\n   * Fetch credentials from the endpoint\n   */\n  private async fetchCredentials(): Promise<boolean> {\n    const deferred = (this.credentialDeferred = new Deferred<void>())\n\n    try {\n      const response = await fetch(this.endpointUrl, {\n        method: \"POST\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify({})\n      })\n\n      if (!response.ok) {\n        throw new Error(\n          `Credential request failed with status ${response.status}`\n        )\n      }\n\n      // Cookie is set by Set-Cookie header, we just need to track expiration\n      this.cookieExpirationTime = Date.now() + COOKIE_EXPIRATION_MS\n\n      // Schedule refresh before expiration\n      this.scheduleRefresh()\n\n      deferred.resolve()\n      this.emit(\"received\")\n\n      return true\n    } catch (err) {\n      log.warn(\"Failed to fetch push log credentials\", err)\n      deferred.reject(err)\n      this.credentialDeferred = null\n      return false\n    }\n  }\n\n  /**\n   * Schedule a credential refresh before expiration\n   */\n  private scheduleRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n    }\n\n    const refreshIn = COOKIE_EXPIRATION_MS - COOKIE_REFRESH_BUFFER_MS\n    this.refreshTimer = setTimeout(() => {\n      this.credentialDeferred = null\n      this.fetchCredentials().catch(() => {\n        // Log but don't throw - will retry on next request\n        log.debug(\"Scheduled credential refresh failed\")\n      })\n    }, refreshIn)\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Credential manager destroyed\"))\n    }\n\n    this.credentialDeferred = null\n    this.cookieExpirationTime = null\n  }\n}\n\n/**\n * Appender that pushes log records to a remote endpoint via HTTP PUT.\n * Batches records and sends when queue reaches FLUSH_QUEUE_DEPTH or FLUSH_INTERVAL_MS has elapsed.\n */\nexport class PushLogRecordsAppender<\n  Record extends LogRecord = LogRecord\n> implements Appender<Record> {\n  private pendingRecords: LogRecord[] = []\n  private flushDeferred: Deferred<void> | null = null\n  private flushTimer: ReturnType<typeof setTimeout> | null = null\n\n  public readonly credentialManager: PushLogRecordsCredentialManager\n\n  constructor(public readonly endpointUrl: string) {\n    this.credentialManager = new PushLogRecordsCredentialManager(endpointUrl)\n\n    this.credentialManager.on(\"received\", () => {\n      if (!this.pendingRecords.length || this.flushDeferred) {\n        return\n      }\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    })\n  }\n\n  /**\n   * Append a log record to the queue\n   */\n  append(record: Record): void {\n    // Add the record with enriched metadata\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app && record.app.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env && record.env.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href\n    })\n    this.trimPendingRecordsToQueueCap()\n\n    // Check if we should flush immediately due to queue depth\n    if (this.pendingRecords.length >= FLUSH_QUEUE_DEPTH) {\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    } else {\n      // Schedule a flush if not already scheduled\n      this.scheduleFlush()\n    }\n  }\n\n  /**\n   * Schedule a flush after the interval\n   */\n  private scheduleFlush(): void {\n    if (this.flushTimer) {\n      return // Already scheduled\n    }\n\n    this.flushTimer = setTimeout(() => {\n      this.flushTimer = null\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    }, FLUSH_INTERVAL_MS)\n  }\n\n  /**\n   * Flush pending records to the endpoint\n   */\n  private async flush(): Promise<void> {\n    // Prevent concurrent flushes\n    if (this.flushDeferred) {\n      return this.flushDeferred.promise\n    }\n\n    // Nothing to flush\n    if (!this.pendingRecords.length) {\n      return\n    }\n\n    // Ensure we have valid credentials\n    const hasCredentials = await this.credentialManager.ensureCredentials()\n    if (!hasCredentials) {\n      log.debug(\"Failed to push log records\", \"No valid credentials available\")\n      return\n    }\n\n    const deferred = (this.flushDeferred = new Deferred<void>())\n\n    try {\n      // Take all pending records for this flush\n      const records = this.pendingRecords.splice(0, this.pendingRecords.length)\n      const payload = { records: records.map(record => JSON.stringify(record)) }\n\n      const response = await fetch(this.endpointUrl, {\n        method: \"PUT\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify(payload)\n      })\n\n      if (!response.ok) {\n        // Re-queue records on failure\n        this.pendingRecords.unshift(...records)\n        this.trimPendingRecordsToQueueCap()\n        throw new Error(`Push failed with status ${response.status}`)\n      }\n\n      deferred.resolve()\n    } catch (err) {\n      log.debug(\"Failed to push log records\", err)\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // If more records accumulated during flush, schedule another\n      if (this.pendingRecords.length > 0) {\n        this.scheduleFlush()\n      }\n    }\n\n    return deferred.promise\n  }\n\n  /**\n   * Force an immediate flush\n   */\n  async forceFlush(): Promise<void> {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    return this.flush()\n  }\n\n  /**\n   * Enforce the pending queue cap by dropping the oldest records.\n   */\n  private trimPendingRecordsToQueueCap(): void {\n    const removeCount = this.pendingRecords.length - LOG_QUEUE_MAX_RECORDS\n\n    if (removeCount > 0) {\n      this.pendingRecords.splice(0, removeCount)\n    }\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    this.credentialManager.destroy()\n\n    if (this.flushDeferred && !this.flushDeferred.isSettled()) {\n      this.flushDeferred.reject(new Error(\"Appender destroyed\"))\n    }\n\n    this.flushDeferred = null\n    this.pendingRecords = []\n  }\n}\n\nexport default PushLogRecordsAppender\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PushLogRecordsAppender.js","sourceRoot":"","sources":["../../../../../src/logging/appenders/push/PushLogRecordsAppender.ts"],"names":[],"mappings":"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","sourcesContent":["import EventEmitter3 from \"eventemitter3\"\nimport { Deferred } from \"../../../helpers/index.js\"\nimport { LogRecord } from \"../../LogRecord.js\"\nimport { Appender } from \"../../Appender.js\"\nimport { getInternalLogger } from \"../../InternalLogger.js\"\n\n// Constants for tuning (adjustable in development)\nconst COOKIE_EXPIRATION_MS = 5 * 60 * 1000 // 30 minutes\nconst COOKIE_REFRESH_BUFFER_MS = 2 * 60 * 1000 // Refresh 2 minutes before expiration\nconst FLUSH_QUEUE_DEPTH = 1000\nconst FLUSH_INTERVAL_MS = 5 * 1000 // 10 seconds\nconst LOG_QUEUE_MAX_RECORDS = 10000\nconst COOKIE_NAME = \"wire_logs_id\"\n\nconst log = getInternalLogger()\n\ninterface PushLogRecordsCredentialManagerEventMap {\n  received: () => void\n  expired: () => void\n}\n\n/**\n * Manages credential cookie for PushLogRecordsAppender.\n * Invokes the endpoint via POST to obtain a session cookie.\n */\nexport class PushLogRecordsCredentialManager extends EventEmitter3<PushLogRecordsCredentialManagerEventMap> {\n  private refreshTimer: ReturnType<typeof setTimeout> | null = null\n  private credentialDeferred: Deferred<void> | null = null\n  private cookieExpirationTime: number | null = null\n\n  constructor(public readonly endpointUrl: string) {\n    super()\n  }\n\n  /**\n   * Check if valid credentials exist\n   */\n  hasCredentials(): boolean {\n    if (!this.cookieExpirationTime) {\n      return false\n    }\n\n    if (Date.now() >= this.cookieExpirationTime) {\n      this.cookieExpirationTime = null\n      this.emit(\"expired\")\n      return false\n    }\n\n    return true\n  }\n\n  /**\n   * Get credentials, fetching them if necessary\n   */\n  async ensureCredentials(): Promise<boolean> {\n    // If we have valid credentials, return immediately\n    if (this.hasCredentials()) {\n      return true\n    }\n\n    // If a fetch is already in progress, wait for it\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      try {\n        await this.credentialDeferred.promise\n        return this.hasCredentials()\n      } catch {\n        return false\n      }\n    }\n\n    // Fetch new credentials\n    return this.fetchCredentials()\n  }\n\n  /**\n   * Force refresh of credentials\n   */\n  forceRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    this.cookieExpirationTime = null\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Force refresh requested\"))\n    }\n    this.credentialDeferred = null\n\n    this.fetchCredentials().catch(() => {\n      // Ignore errors during force refresh, they'll be handled on next request\n    })\n  }\n\n  /**\n   * Fetch credentials from the endpoint\n   */\n  private async fetchCredentials(): Promise<boolean> {\n    const deferred = (this.credentialDeferred = new Deferred<void>())\n\n    try {\n      const response = await fetch(this.endpointUrl, {\n        method: \"POST\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify({})\n      })\n\n      if (!response.ok) {\n        throw new Error(\n          `Credential request failed with status ${response.status}`\n        )\n      }\n\n      // Cookie is set by Set-Cookie header, we just need to track expiration\n      this.cookieExpirationTime = Date.now() + COOKIE_EXPIRATION_MS\n\n      // Schedule refresh before expiration\n      this.scheduleRefresh()\n\n      deferred.resolve()\n      this.emit(\"received\")\n\n      return true\n    } catch (err) {\n      log.warn(\"Failed to fetch push log credentials\", err)\n      deferred.reject(err)\n      this.credentialDeferred = null\n      return false\n    }\n  }\n\n  /**\n   * Schedule a credential refresh before expiration\n   */\n  private scheduleRefresh(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n    }\n\n    const refreshIn = COOKIE_EXPIRATION_MS - COOKIE_REFRESH_BUFFER_MS\n    this.refreshTimer = setTimeout(() => {\n      this.credentialDeferred = null\n      this.fetchCredentials().catch(() => {\n        // Log but don't throw - will retry on next request\n        log.debug(\"Scheduled credential refresh failed\")\n      })\n    }, refreshIn)\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.refreshTimer) {\n      clearTimeout(this.refreshTimer)\n      this.refreshTimer = null\n    }\n\n    if (this.credentialDeferred && !this.credentialDeferred.isSettled()) {\n      this.credentialDeferred.reject(new Error(\"Credential manager destroyed\"))\n    }\n\n    this.credentialDeferred = null\n    this.cookieExpirationTime = null\n  }\n}\n\n/**\n * Appender that pushes log records to a remote endpoint via HTTP PUT.\n * Batches records and sends when queue reaches FLUSH_QUEUE_DEPTH or FLUSH_INTERVAL_MS has elapsed.\n */\nexport class PushLogRecordsAppender<\n  Record extends LogRecord = LogRecord\n> implements Appender<Record> {\n  private pendingRecords: LogRecord[] = []\n  private flushDeferred: Deferred<void> | null = null\n  private flushTimer: ReturnType<typeof setTimeout> | null = null\n\n  public readonly credentialManager: PushLogRecordsCredentialManager\n\n  constructor(public readonly endpointUrl: string) {\n    this.credentialManager = new PushLogRecordsCredentialManager(endpointUrl)\n\n    this.credentialManager.on(\"received\", () => {\n      if (!this.pendingRecords.length || this.flushDeferred) {\n        return\n      }\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    })\n  }\n\n  /**\n   * Append a log record to the queue\n   */\n  append(record: Record): void {\n    // Add the record with enriched metadata\n    this.pendingRecords.push({\n      timestamp: Date.now(),\n      ...record,\n      app: record.app && record.app.length > 0 ? record.app : \"UNKNOWN\",\n      env: record.env && record.env.length > 0 ? record.env : \"UNKNOWN\",\n      url: typeof window === \"undefined\" ? \"local://\" : window.location.href\n    })\n    this.trimPendingRecordsToQueueCap()\n\n    // Check if we should flush immediately due to queue depth\n    if (this.pendingRecords.length >= FLUSH_QUEUE_DEPTH) {\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    } else {\n      // Schedule a flush if not already scheduled\n      this.scheduleFlush()\n    }\n  }\n\n  /**\n   * Schedule a flush after the interval\n   */\n  private scheduleFlush(): void {\n    if (this.flushTimer) {\n      return // Already scheduled\n    }\n\n    this.flushTimer = setTimeout(() => {\n      this.flushTimer = null\n      this.flush().catch(() => {\n        // Errors handled in flush\n      })\n    }, FLUSH_INTERVAL_MS)\n  }\n\n  /**\n   * Flush pending records to the endpoint\n   */\n  private async flush(): Promise<void> {\n    // Prevent concurrent flushes\n    if (this.flushDeferred) {\n      return this.flushDeferred.promise\n    }\n\n    // Nothing to flush\n    if (!this.pendingRecords.length) {\n      return\n    }\n\n    // Ensure we have valid credentials\n    const hasCredentials = await this.credentialManager.ensureCredentials()\n    if (!hasCredentials) {\n      log.debug(\"Failed to push log records\", \"No valid credentials available\")\n      return\n    }\n\n    const deferred = (this.flushDeferred = new Deferred<void>())\n\n    try {\n      // Take all pending records for this flush\n      const records = this.pendingRecords.splice(0, this.pendingRecords.length)\n      const payload = { records: records.map(record => JSON.stringify(record)) }\n\n      const response = await fetch(this.endpointUrl, {\n        method: \"PUT\",\n        mode: \"cors\",\n        credentials: \"include\",\n        headers: {\n          \"Content-Type\": \"application/json\"\n        },\n        body: JSON.stringify(payload)\n      })\n\n      if (!response.ok) {\n        // Re-queue records on failure\n        this.pendingRecords.unshift(...records)\n        this.trimPendingRecordsToQueueCap()\n        throw new Error(`Push failed with status ${response.status}`)\n      }\n\n      deferred.resolve()\n    } catch (err) {\n      log.debug(\"Failed to push log records\", err)\n      deferred.reject(err)\n    } finally {\n      this.flushDeferred = null\n\n      // If more records accumulated during flush, schedule another\n      if (this.pendingRecords.length > 0) {\n        this.scheduleFlush()\n      }\n    }\n\n    return deferred.promise\n  }\n\n  /**\n   * Force an immediate flush\n   */\n  async forceFlush(): Promise<void> {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    return this.flush()\n  }\n\n  /**\n   * Enforce the pending queue cap by dropping the oldest records.\n   */\n  private trimPendingRecordsToQueueCap(): void {\n    const removeCount = this.pendingRecords.length - LOG_QUEUE_MAX_RECORDS\n\n    if (removeCount > 0) {\n      this.pendingRecords.splice(0, removeCount)\n    }\n  }\n\n  /**\n   * Clean up resources\n   */\n  destroy(): void {\n    if (this.flushTimer) {\n      clearTimeout(this.flushTimer)\n      this.flushTimer = null\n    }\n\n    this.credentialManager.destroy()\n\n    if (this.flushDeferred && !this.flushDeferred.isSettled()) {\n      this.flushDeferred.reject(new Error(\"Appender destroyed\"))\n    }\n\n    this.flushDeferred = null\n    this.pendingRecords = []\n  }\n}\n\nexport default PushLogRecordsAppender\n"]}