@hkdigital/lib-core 0.4.15 → 0.4.17

package/dist/auth/jwt/util.d.ts

@@ -36,3 +36,9 @@ export function sign(claims: import("./typedef.js").JwtPayload, secretOrPrivateK
  * @returns {import('./typedef.js').JwtPayload} claims - The decoded JWT payload
  */
 export function verify(token: string, secretOrPrivateKey: import("./typedef.js").Secret, options?: import("./typedef.js").VerifyOptions): import("./typedef.js").JwtPayload;
+/**
+ * Casts jsonwebtoken library errors to internal error types
+ * @param {Error} error - The original jsonwebtoken error
+ * @returns {Error} - The corresponding internal error
+ */
+export function castJwtError(error: Error): Error;

package/dist/auth/jwt/util.js

@@ -131,7 +131,7 @@ export function verify( token, secretOrPrivateKey, options=VERIFY_OPTIONS )
  * @param {Error} error - The original jsonwebtoken error
  * @returns {Error} - The corresponding internal error
  */
-function castJwtError(error) {
+export function castJwtError(error) {
   if (error instanceof JwtTokenExpiredError) {
     return new TokenExpiredError(error.message, error.expiredAt, error);
   }

package/dist/generic/errors/generic.d.ts

@@ -6,15 +6,11 @@ export class InternalEventOrLogError extends Error {
 }
 export class DetailedError extends Error {
     /**
-     * @param {string} message - Error message
-     * @param {string|{[key: string]: any}|null} [details] - Additional details
-     * @param {Error|string} [cause] - Original error
+     * @param {string} [message]
+     * @param {import('./typedef.js').ErrorDetails} [details] - Additional details
+     * @param {Error|null} [cause] - Original error
      */
-    constructor(message: string, details?: string | {
-        [key: string]: any;
-    } | null, cause?: Error | string);
-    details: string | {
-        [key: string]: any;
-    };
-    cause: string | Error;
+    constructor(message?: string, details?: import("./typedef.js").ErrorDetails, cause?: Error | null);
+    details: import("./typedef.js").ErrorDetails;
+    cause: unknown;
 }

package/dist/generic/errors/generic.js

@@ -7,14 +7,24 @@ export class InternalEventOrLogError extends Error {}
 export class DetailedError extends Error
 {
   /**
-   * @param {string} message - Error message
-   * @param {string|{[key: string]: any}|null} [details] - Additional details
-   * @param {Error|string} [cause] - Original error
+   * @param {string} [message]
+   * @param {import('./typedef.js').ErrorDetails} [details] - Additional details
+   * @param {Error|null} [cause] - Original error
    */
   constructor(message, details, cause ) {
     super(message);
     this.name = 'DetailedError';
     this.details = details ?? null;
-    this.cause = cause;
+
+    if( cause )
+    {
+      if( cause instanceof Error )
+      {
+        this.cause = cause;
+      }
+      else {
+        throw new Error('Parameter [cause] should be an Error');
+      }
+    }
   }
 }

package/dist/generic/errors/typedef.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {};
+export default _default;
+export type ErrorDetails = string | {
+    [key: string]: any;
+} | null;

package/dist/generic/errors/typedef.js

@@ -0,0 +1,3 @@
+/** @typedef {string|{[key: string]: any}|null} ErrorDetails */
+
+export default {};

package/dist/generic/typedef.d.ts

@@ -1,3 +1,4 @@
 export * from "./data/typedef.js";
+export * from "./errors/typedef.js";
 declare const _default: {};
 export default _default;

package/dist/generic/typedef.js

@@ -1,3 +1,4 @@
 export * from './data/typedef.js';
+export * from './errors/typedef.js';
 
 export default {};

package/dist/logging/README.md

@@ -109,11 +109,9 @@ const logger = createClientLogger('client');
 
 /** @type {import('@sveltejs/kit').HandleClientError} */
 export function handleError({ error, event }) {
-  logger.error('Client error occurred', {
-    message: error.message,
-    stack: error.stack,
-    url: event.url?.pathname,
-    userAgent: navigator.userAgent
+  logger.error(error, { 
+    url: event.url?.pathname, 
+    userAgent: navigator.userAgent 
   });
 }
 
@@ -126,19 +124,12 @@ export function init() {
   
   // Log unhandled errors
   window.addEventListener('error', (event) => {
-    logger.error('Unhandled error', {
-      message: event.error?.message || event.message,
-      filename: event.filename,
-      lineno: event.lineno,
-      colno: event.colno
-    });
+    logger.error(event, { url: window.location.pathname });
   });
   
   // Log unhandled promise rejections
   window.addEventListener('unhandledrejection', (event) => {
-    logger.error('Unhandled promise rejection', {
-      reason: event.reason
-    });
+    logger.error(event, { url: window.location.pathname });
   });
 }
 

package/dist/logging/errors.js

@@ -6,6 +6,13 @@ export class LoggerError extends Error
   constructor( originalError ) {
     super('LoggerError');
     this.name = 'LoggerError';
-    this.cause = originalError;
+
+    if( originalError instanceof Error )
+    {
+      this.cause = originalError;
+    }
+    else {
+      throw new Error('Parameter [originalError] should be an Error');
+    }
   }
 }

package/dist/logging/internal/adapters/console.js

@@ -360,8 +360,6 @@ export class ConsoleAdapter {
 
       let cleaned = trimmed;
 
-      console.log(123, cleaned);
-
       // Convert Chrome format to Firefox format for consistency
       if (isChromeFormat) {
         // "at functionName (url:line:col)" -> "functionName@url:line:col"

package/dist/logging/internal/logger/Logger.d.ts

@@ -49,12 +49,18 @@ export default class Logger extends EventEmitter {
     /**
      * Log an error message
      *
-     * @param {Error|string} originalErrorOrMessage
-     * @param {Error} [originalError]
+     * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
+     *   errorOrMessage
+     *
+     * @param {Error|ErrorDetails} [errorOrDetails]
+     *   Error object (when first param is string) or details object
+     *
+     * @param {ErrorDetails} [details]
+     *   Additional context details (when using string + error pattern)
      *
      * @returns {boolean} True if the log was emitted
      */
-    error(originalErrorOrMessage: Error | string, originalError?: Error, ...args: any[]): boolean;
+    error(errorOrMessage: Error | ErrorEvent | PromiseRejectionEvent | string, errorOrDetails?: Error | ErrorDetails, details?: ErrorDetails, ...args: any[]): boolean;
     /**
      * Create a child logger with additional context
      *
@@ -77,4 +83,5 @@ export default class Logger extends EventEmitter {
     logFromEvent(eventName: string, eventData: import("../../typedef.js").LogEventData): boolean;
     #private;
 }
+export type ErrorDetails = import("../../../generic/typedef.js").ErrorDetails;
 import { EventEmitter } from '../../../generic/events.js';

package/dist/logging/internal/logger/Logger.js

@@ -32,6 +32,8 @@
  * logger.setLevel(DEBUG); // Now debug messages will also be logged
  */
 
+/** @typedef {import('../../../generic/typedef.js').ErrorDetails} ErrorDetails */
+
 import { EventEmitter } from '../../../generic/events.js';
 
 import {
@@ -44,9 +46,17 @@ import {
 } from '../../constants.js';
 
 import { DetailedError } from '../../../generic/errors.js';
-import { LoggerError } from '../../errors.js';
+// import { LoggerError } from '../../errors.js';
+
+import { toArray } from '../../../util/array.js';
+import { exportNotNullish } from '../../../util/object.js';
+
+// import {
+//   castErrorEventToDetailedError,
+//   castPromiseRejectionToDetailedError
+// } from './util.js';
 
-import { toArray } from '../../../util/array/index.js';
+import * as is from '../../../util/is.js';
 
 /**
  * Logger class for consistent logging
@@ -126,36 +136,73 @@ export default class Logger extends EventEmitter {
   /**
    * Log an error message
    *
-   * @param {Error|string} originalErrorOrMessage
-   * @param {Error} [originalError]
+   * @param {Error|ErrorEvent|PromiseRejectionEvent|string}
+   *   errorOrMessage
+   *
+   * @param {Error|ErrorDetails} [errorOrDetails]
+   *   Error object (when first param is string) or details object
+   *
+   * @param {ErrorDetails} [details]
+   *   Additional context details (when using string + error pattern)
    *
    * @returns {boolean} True if the log was emitted
    */
-  error(originalErrorOrMessage, originalError) {
+  error(errorOrMessage, errorOrDetails, details) {
+    let errorObject = null;
+
+    let message;
 
-    if( originalErrorOrMessage instanceof Error )
+    if( typeof errorOrMessage === 'string' )
     {
-      // params: {error} originalErrorOrMessage
-      const loggerError = new LoggerError(originalErrorOrMessage);
+      message = errorOrMessage;
+    }
+
+    if (message) {
+
+      // First param is a string (message)
+      // => Second param might be the error (string + error pattern)
+
+      if (this.#isErrorLike(errorOrDetails)) {
+        let errorLike = errorOrDetails;
+        errorObject = this.#toError(errorLike);
+      }
+    } else {
+
+      // First param is not an (not empty) string
+      // => First param should be the error
 
-      const message = originalErrorOrMessage.message;
+      if (this.#isErrorLike(errorOrMessage)) {
+        let errorLike = errorOrMessage;
+        errorObject = this.#toError(errorLike);
+      }
 
-      return this.#log(ERROR, message, loggerError);
+      // Second parameter could be the details
+      // Third parameter will be ignored (overwritten)
+      details = errorOrDetails;
     }
-    else if( typeof originalErrorOrMessage === 'string' && originalError instanceof Error ) {
-      // params: {string} message, {error} originalError
-      const detailedError = new DetailedError(
-        originalErrorOrMessage,
-        null,
-        originalError
-      );
 
-      return this.#log(ERROR, detailedError.message, detailedError);
+    if( errorObject && details )
+    {
+      // Additional Details supplied
+      // => Prepend additional DetailedError to chain
+      errorObject = new DetailedError(message, details, errorObject );
+    }
+
+    if( message && errorObject )
+    {
+      // Log with message
+      return this.#log(ERROR, message, errorObject);
+    }
+    else if (errorObject) {
+      // Log without message
+      return this.#log(ERROR, errorObject.message, errorObject);
     }
     else {
-      // wrong params
+      // Missing error like object
+      // => invalid parameters supplied to logger.error
+
       const detailedError = new DetailedError(
-        'Invalid parameters supplied to Logger.error',
+        'Missing error like object in Logger.error parameters',
         toArray(arguments)
       );
 
@@ -249,4 +296,84 @@ export default class Logger extends EventEmitter {
 
     return true;
   }
+
+  /**
+   * Returns true is the supplied parameter is loggable as error
+   *
+   * @param {any} thing
+   *
+   * @returns {boolean}
+   */
+  #isErrorLike(thing) {
+    return (
+      thing instanceof Error ||
+      is.ErrorEvent(thing) ||
+      is.PromiseRejectionEvent(thing)
+    );
+  }
+
+  /**
+   * Convert an Error like object (Error, ErrorEvent, PromiseRejectionEvent)
+   * to a DetailedError
+   *
+   * @param {any} errorLike
+   *
+   * @returns {Error}
+   */
+  #toError( errorLike ) {
+    if (is.ErrorEvent(errorLike)) {
+      // errorLike is an ErrorEvent
+      // => convert to DetailedError
+      const errorEvent = /** @type {ErrorEvent} */ (errorLike);
+
+      let errorEventDetails = exportNotNullish( errorEvent, [
+        'message',
+        'filename',
+        'lineno',
+        'colno'
+      ]);
+
+      errorEventDetails.type = 'ErrorEvent';
+
+      let cause = errorEvent.error;
+
+      return new DetailedError(
+        errorEvent.message,
+        errorEventDetails,
+        cause
+      );
+
+    } else if (is.PromiseRejectionEvent(errorLike)) {
+      // errorLike is a PromiseRejectionEvent
+      // => convert to DetailedError
+      const rejectionEvent = /** @type {PromiseRejectionEvent} */ (errorLike);
+
+      const reason = rejectionEvent.reason;
+
+      if (reason instanceof Error) {
+        return reason;
+      }
+      else if ( is.object(reason) && reason?.message ) {
+        // reason is  an object with message property
+        return new DetailedError(reason?.message, reason);
+      }
+      else if ( typeof reason === "string" ) {
+        // reason is a string
+        return new DetailedError(reason);
+      }
+      else {
+        // reason is not an Error or string
+        return new DetailedError('Promise rejected', reason);
+      }
+    } else if (errorLike instanceof Error) {
+      // errorLike is a plain Error
+      // => return it
+      return errorLike;
+    }
+
+    // errorLike cannot be converted to an Error
+    // => return logging error
+
+    return new DetailedError('Cannot convert to Error', errorLike);
+  }
 }

package/dist/services/README.md

@@ -104,7 +104,7 @@ Manages multiple services with dependency resolution and coordinated lifecycle o
 ### Usage
 
 ```javascript
-import { ServiceManager } from '$lib/services/index.js';
+import { ServiceManager } from '$hklib-core/services/index.js';
 import DatabaseService from './services/DatabaseService.js';
 import AuthService from './services/AuthService.js';
 
@@ -197,4 +197,4 @@ Services include comprehensive test suites demonstrating:
 - Health monitoring
 - Event emission
 
-Run tests with your project's test command to ensure service reliability.
+Run tests with your project's test command to ensure service reliability.

package/dist/util/exceptions/index.d.ts

@@ -4,13 +4,13 @@
  * - The originating Error is set as `cause` property
  *
  * @param {string} message - New error message
- * @param {Error|string} originalError
+ * @param {Error|string} originalErrorOrMessage
  * @param {string|Object.<string, any>|null} [details]
  *   New error details (a DetailError will be thrown)
  *
  * @throws {DetailedError}
  * @returns {never} This function never returns
  */
-export function rethrow(message: string, originalError: Error | string, details?: string | {
+export function rethrow(message: string, originalErrorOrMessage: Error | string, details?: string | {
     [x: string]: any;
 } | null): never;

package/dist/util/exceptions/index.js

@@ -7,20 +7,23 @@ import { DetailedError } from "../../generic/errors.js";
  * - The originating Error is set as `cause` property
  *
  * @param {string} message - New error message
- * @param {Error|string} originalError
+ * @param {Error|string} originalErrorOrMessage
  * @param {string|Object.<string, any>|null} [details]
  *   New error details (a DetailError will be thrown)
  *
  * @throws {DetailedError}
  * @returns {never} This function never returns
  */
-export function rethrow(message, originalError, details ) {
+export function rethrow(message, originalErrorOrMessage, details ) {
   let error;
 
-  if (!(originalError instanceof Error)) {
+  if ( typeof originalErrorOrMessage === 'string' ) {
     // Convert non-Error values to Error objects
-    error = new Error(String(originalError));
+    error = new Error( originalErrorOrMessage );
+  }
+  else {
+    error = originalErrorOrMessage;
   }
 
-  throw new DetailedError(message, details, error ?? originalError );
+  throw new DetailedError(message, details, error );
 }

package/dist/util/is/events.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check if object is an ErrorEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function ErrorEvent(obj: any): boolean;
+/**
+ * Check if object is a PromiseRejectionEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function PromiseRejectionEvent(obj: any): boolean;

package/dist/util/is/events.js

@@ -0,0 +1,25 @@
+/**
+ * Check if object is an ErrorEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function ErrorEvent(obj) {
+  return Boolean(obj && 
+                 typeof obj === 'object' && 
+                 obj.constructor?.name === 'ErrorEvent');
+}
+
+/**
+ * Check if object is a PromiseRejectionEvent
+ *
+ * @param {any} obj
+ *
+ * @returns {boolean}
+ */
+export function PromiseRejectionEvent(obj) {
+  return Boolean(obj && 
+                 typeof obj === 'object' && 
+                 obj.constructor?.name === 'PromiseRejectionEvent');
+}

package/dist/util/is/index.d.ts

@@ -68,3 +68,4 @@ export { argumentsCheck as arguments };
  * @returns {boolean} true if the value is an Arguments object
  */
 declare function argumentsCheck(value: any): boolean;
+export { ErrorEvent, PromiseRejectionEvent } from "./events.js";

package/dist/util/is/index.js

@@ -146,3 +146,5 @@ export function object(value) {
 
 	return true;
 }
+
+export { ErrorEvent, PromiseRejectionEvent } from './events.js';

package/dist/util/object/index.d.ts

@@ -29,7 +29,7 @@ export function size(obj: object): number;
  *
  * @returns {object} new object without the null properties
  */
-export function exportNotNull(obj: object, onlyKeys?: string[]): object;
+export function exportNotNullish(obj: object, onlyKeys?: string[]): object;
 /**
  * Create a shallow copy of the object's public properties. Properties that
  * start with an underscore are considered 'internal' properties and are not

package/dist/util/object/index.js

@@ -90,7 +90,7 @@ export function size(obj) {
  *
  * @returns {object} new object without the null properties
  */
-export function exportNotNull(obj, onlyKeys) {
+export function exportNotNullish(obj, onlyKeys) {
 	expect.object(obj);
 
 	const onlyKeysSet = onlyKeys ? new Set(onlyKeys) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.15",
+	"version": "0.4.17",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"