@likec4/log 1.43.0 → 1.45.0

package/dist/index.d.mts

@@ -14,6 +14,41 @@ declare function getConsoleSink(options?: ConsoleSinkOptions): Sink;
 declare function getConsoleStderrSink(options?: ConsoleSinkOptions): Sink;
 
 declare function loggable(error: unknown): string;
+type NormalizeError<ErrorArg> = ErrorArg extends Error ? ErrorArg : Error;
+/**
+ * Appends `message` to `error.message`. If `message` ends with `:` or `:\n`,
+ * prepends it instead.
+ *
+ * Returns `error`. If `error` is not an `Error` instance, it is converted to
+ * one.
+ *
+ * @example
+ * ```js
+ * wrapErrorMessage(new Error('Message.'), 'Additional message.')
+ * // Error: Message.
+ * // Additional message.
+ *
+ * wrapErrorMessage(new Error('Message.'), 'Additional message:')
+ * // Error: Additional message: Message.
+ *
+ * wrapErrorMessage(new Error('Message.'), 'Additional message:\n')
+ * // Error: Additional message:
+ * // Message.
+ *
+ * wrapErrorMessage(new Error('Message.'), '')
+ * // Error: Message.
+ *
+ * const invalidError = 'Message.'
+ * wrapErrorMessage(invalidError, 'Additional message.')
+ * // Error: Message.
+ * // Additional message.
+ *
+ * wrapErrorMessage(new Error('  Message with spaces  '), '  Additional message  ')
+ * // Error: Message with spaces
+ * // Additional message
+ * ```
+ */
+declare function wrapError<ErrorArg>(error: ErrorArg, newMessage: string): NormalizeError<ErrorArg>;
 
 declare const logger: _logtape_logtape.Logger;
 
@@ -26,4 +61,4 @@ declare const logger: _logtape_logtape.Logger;
 declare function createLogger(subcategory: string | readonly [string] | readonly [string, ...string[]]): _logtape_logtape.Logger;
 declare function configureLogger<TSinkId extends string, TFilterId extends string>(config?: Partial<Config<TSinkId, TFilterId>>): void;
 
-export { configureLogger, logger as consola, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, logger, logger as rootLogger };
+export { configureLogger, logger as consola, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, logger, logger as rootLogger, wrapError };

package/dist/index.mjs

@@ -1283,9 +1283,10 @@ const parseStack = (stack) => {
   });
   return lines;
 };
-function ident(value, identation = 2) {
+function indent(value, indentation = 2) {
   value = Array.isArray(value) ? value : value.split("\n");
-  return value.map((l) => `${" ".repeat(identation)}${l}`).join("\n");
+  const prefix = " ".repeat(indentation);
+  return value.map((l) => `${prefix}${l}`).join("\n");
 }
 function loggable(error) {
   if (typeof error === "string") {
@@ -1295,20 +1296,29 @@ function loggable(error) {
     const mergedErr = mergeErrorCause(error);
     if (mergedErr.stack) {
       const stack = parseStack(mergedErr.stack);
-      return mergedErr.message + "\n" + ident(stack.slice(1));
+      return mergedErr.message + "\n" + indent(stack.slice(1));
     }
     return mergedErr.message;
   }
-  return safeStringify(error);
+  return safeStringify(error, { indentation: "	" });
+}
+function wrapError(error, newMessage) {
+  return wrapErrorMessage(error, newMessage);
 }
 
 function gerErrorFromLogRecord(record) {
-  const errors = Object.values(record.properties).filter((v) => v instanceof Error).map((err) => {
-    const mergedErr = mergeErrorCause(err);
-    if (mergedErr.stack) {
-      mergedErr.stack = parseStack(mergedErr.stack).join("\n");
+  const errors = Object.entries(record.properties).flatMap(([k, err]) => {
+    if (err instanceof Error) {
+      const mergedErr = mergeErrorCause(err);
+      if (mergedErr.stack) {
+        mergedErr.stack = parseStack(mergedErr.stack).join("\n");
+      }
+      return [mergedErr];
+    }
+    if (k === "error" || k === "err") {
+      return [new Error(`${err}`)];
     }
-    return mergedErr;
+    return [];
   });
   if (errors.length === 0) {
     return null;
@@ -1322,19 +1332,19 @@ function errorFromLogRecord(record) {
   }
   return error;
 }
-function appendErrorToMessage(values, color) {
+function appendErrorToMessage(values, color = false) {
   const error = gerErrorFromLogRecord(values.record);
   if (error) {
     let errorMessge = error.message;
     if (error.stack) {
-      errorMessge = errorMessge + "\n" + ident(error.stack.split("\n").slice(1));
+      errorMessge = errorMessge + "\n" + indent(error.stack.split("\n").slice(1));
     }
     if (color) {
       errorMessge = `${ansiColors.red}${errorMessge}${RESET}`;
     }
     return {
       ...values,
-      message: values.message + "\n" + ident(errorMessge)
+      message: values.message + "\n" + indent(errorMessge)
     };
   }
   return values;
@@ -1445,4 +1455,4 @@ function configureLogger(config) {
   }
 }
 
-export { configureLogger, logger as consola, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, logger, logger as rootLogger };
+export { configureLogger, logger as consola, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, logger, logger as rootLogger, wrapError };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@likec4/log",
   "description": "Shared interface for logging",
   "license": "MIT",
-  "version": "1.43.0",
+  "version": "1.45.0",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -38,11 +38,11 @@
     "@types/node": "~20.19.22",
     "merge-error-cause": "^5.0.2",
     "safe-stringify": "^1.2.0",
-    "std-env": "^3.9.0",
+    "std-env": "^3.10.0",
     "typescript": "5.9.3",
     "unbuild": "3.5.0",
     "wrap-error-message": "^3.0.1",
-    "@likec4/tsconfig": "1.43.0",
+    "@likec4/tsconfig": "1.45.0",
     "@likec4/devops": "1.42.0"
   },
   "scripts": {

package/src/formatters.ts

@@ -13,18 +13,23 @@ import {
 } from '@logtape/logtape'
 import mergeErrorCause from 'merge-error-cause'
 import wrapErrorMessage from 'wrap-error-message'
-import { ident, parseStack } from './utils'
+import { indent, parseStack } from './utils'
 
 function gerErrorFromLogRecord(record: LogRecord): Error | null {
   const errors = Object
-    .values(record.properties)
-    .filter((v) => v instanceof Error)
-    .map(err => {
-      const mergedErr = mergeErrorCause(err)
-      if (mergedErr.stack) {
-        mergedErr.stack = parseStack(mergedErr.stack).join('\n')
+    .entries(record.properties)
+    .flatMap(([k, err]) => {
+      if (err instanceof Error) {
+        const mergedErr = mergeErrorCause(err)
+        if (mergedErr.stack) {
+          mergedErr.stack = parseStack(mergedErr.stack).join('\n')
+        }
+        return [mergedErr]
       }
-      return mergedErr
+      if (k === 'error' || k === 'err') {
+        return [new Error(`${err}`)]
+      }
+      return []
     })
   if (errors.length === 0) {
     return null
@@ -40,19 +45,19 @@ export function errorFromLogRecord(record: LogRecord): Error | null {
   return error
 }
 
-export function appendErrorToMessage(values: FormattedValues, color?: boolean): FormattedValues {
+export function appendErrorToMessage(values: FormattedValues, color = false): FormattedValues {
   const error = gerErrorFromLogRecord(values.record)
   if (error) {
     let errorMessge = error.message
     if (error.stack) {
-      errorMessge = errorMessge + '\n' + ident(error.stack.split('\n').slice(1))
+      errorMessge = errorMessge + '\n' + indent(error.stack.split('\n').slice(1))
     }
     if (color) {
       errorMessge = `${ansiColors.red}${errorMessge}${RESET}`
     }
     return {
       ...values,
-      message: values.message + '\n' + ident(errorMessge),
+      message: values.message + '\n' + indent(errorMessge),
     }
   }
   return values

package/src/index.ts

@@ -34,7 +34,10 @@ export {
   logger as rootLogger,
 }
 
-export { loggable } from './utils'
+export {
+  loggable,
+  wrapError,
+} from './utils'
 
 /**
  * Get a child logger with the given subcategory.

package/src/utils.ts

@@ -1,5 +1,6 @@
 import mergeErrorCause from 'merge-error-cause'
 import safeStringify from 'safe-stringify'
+import wrapErrorMessage from 'wrap-error-message'
 
 export const parseStack = (stack: string): string[] => {
   const lines = stack
@@ -16,9 +17,10 @@ export const parseStack = (stack: string): string[] => {
   return lines
 }
 
-export function ident(value: string | string[], identation = 2): string {
+export function indent(value: string | string[], indentation = 2): string {
   value = Array.isArray(value) ? value : value.split('\n')
-  return value.map((l) => `${' '.repeat(identation)}${l}`).join('\n')
+  const prefix = ' '.repeat(indentation)
+  return value.map((l) => `${prefix}${l}`).join('\n')
 }
 
 export function loggable(error: unknown): string {
@@ -29,9 +31,48 @@ export function loggable(error: unknown): string {
     const mergedErr = mergeErrorCause(error)
     if (mergedErr.stack) {
       const stack = parseStack(mergedErr.stack)
-      return mergedErr.message + '\n' + ident(stack.slice(1))
+      return mergedErr.message + '\n' + indent(stack.slice(1))
     }
     return mergedErr.message
   }
-  return safeStringify(error)
+  return safeStringify(error, { indentation: '\t' })
+}
+
+type NormalizeError<ErrorArg> = ErrorArg extends Error ? ErrorArg : Error
+
+/**
+ * Appends `message` to `error.message`. If `message` ends with `:` or `:\n`,
+ * prepends it instead.
+ *
+ * Returns `error`. If `error` is not an `Error` instance, it is converted to
+ * one.
+ *
+ * @example
+ * ```js
+ * wrapErrorMessage(new Error('Message.'), 'Additional message.')
+ * // Error: Message.
+ * // Additional message.
+ *
+ * wrapErrorMessage(new Error('Message.'), 'Additional message:')
+ * // Error: Additional message: Message.
+ *
+ * wrapErrorMessage(new Error('Message.'), 'Additional message:\n')
+ * // Error: Additional message:
+ * // Message.
+ *
+ * wrapErrorMessage(new Error('Message.'), '')
+ * // Error: Message.
+ *
+ * const invalidError = 'Message.'
+ * wrapErrorMessage(invalidError, 'Additional message.')
+ * // Error: Message.
+ * // Additional message.
+ *
+ * wrapErrorMessage(new Error('  Message with spaces  '), '  Additional message  ')
+ * // Error: Message with spaces
+ * // Additional message
+ * ```
+ */
+export function wrapError<ErrorArg>(error: ErrorArg, newMessage: string): NormalizeError<ErrorArg> {
+  return wrapErrorMessage(error, newMessage)
 }