@hkdigital/lib-core 0.3.8 → 0.3.10

package/dist/services/internal/service-manager/ServiceManager.js

@@ -110,7 +110,7 @@ export class ServiceManager extends EventEmitter {
       logConfig: config.logConfig || {}
     };
 
-    this._setupLogging();
+    this.#setupLogging();
   }
 
   /**
@@ -140,7 +140,7 @@ export class ServiceManager extends EventEmitter {
     };
 
     // Track dependents
-    entry.dependencies.forEach(dep => {
+    entry.dependencies.forEach((dep) => {
       const depEntry = this.services.get(dep);
       if (depEntry) {
         depEntry.dependents.add(name);
@@ -175,7 +175,7 @@ export class ServiceManager extends EventEmitter {
         entry.instance = new entry.ServiceClass(name);
 
         // Apply log level
-        const logLevel = this._getServiceLogLevel(name);
+        const logLevel = this.#getServiceLogLevel(name);
         if (logLevel) {
           entry.instance.setLogLevel(logLevel);
         }
@@ -224,8 +224,7 @@ export class ServiceManager extends EventEmitter {
 
     // Start dependencies first
     for (const dep of entry.dependencies) {
-      if (!await this.isRunning(dep)) {
-
+      if (!(await this.isRunning(dep))) {
         this.logger.debug(`Starting dependency '${dep}' for '${name}'`);
 
         const started = await this.startService(dep);
@@ -309,7 +308,7 @@ export class ServiceManager extends EventEmitter {
     this.logger.info('Starting all services');
 
     // Sort by priority and dependencies
-    const sorted = this._topologicalSort();
+    const sorted = this.#topologicalSort();
     const results = new Map();
 
     for (const name of sorted) {
@@ -347,7 +346,7 @@ export class ServiceManager extends EventEmitter {
     };
 
     // Stop in reverse order
-    const sorted = this._topologicalSort().reverse();
+    const sorted = this.#topologicalSort().reverse();
     const results = new Map();
 
     // Handle global timeout if specified
@@ -362,7 +361,7 @@ export class ServiceManager extends EventEmitter {
       try {
         // Race between stopping all services and timeout
         await Promise.race([
-          this._stopAllSequentially(sorted, results, stopOptions),
+          this.#stopAllSequentially(sorted, results, stopOptions),
           timeoutPromise
         ]);
       } catch (error) {
@@ -380,31 +379,12 @@ export class ServiceManager extends EventEmitter {
       }
     } else {
       // No timeout, just stop sequentially
-      await this._stopAllSequentially(sorted, results, stopOptions);
+      await this.#stopAllSequentially(sorted, results, stopOptions);
     }
 
     return Object.fromEntries(results);
   }
 
-  /**
-   * Stop services sequentially
-   *
-   * @private
-   * @param {string[]} serviceNames - Ordered list of service names
-   * @param {Map<string, boolean>} results - Results map to populate
-   * @param {StopOptions} options - Stop options
-   */
-  async _stopAllSequentially(serviceNames, results, options) {
-    for (const name of serviceNames) {
-      try {
-        const success = await this.stopService(name, options);
-        results.set(name, success);
-      } catch (error) {
-        this.logger.error(`Error stopping '${name}'`, error);
-        results.set(name, false);
-      }
-    }
-  }
 
   /**
    * Get health status for all services
@@ -492,14 +472,41 @@ export class ServiceManager extends EventEmitter {
     return services;
   }
 
-  // Private methods
 
   /**
-   * Setup logging configuration based on config.dev
+   * Attach event listeners to forward service events
    *
-   * @private
+   * @param {string} name - Service name
+   * @param {import('../service-base/typedef.js').ServiceInstance} instance
+   *   Service instance
    */
-  _setupLogging() {
+  _attachServiceEvents(name, instance) {
+    // Forward service events
+    instance.on('stateChanged', (data) => {
+      this.emit('service:stateChanged', { service: name, data });
+    });
+
+    instance.on('healthChanged', (data) => {
+      this.emit('service:healthChanged', { service: name, data });
+    });
+
+    instance.on('error', (data) => {
+      this.emit('service:error', { service: name, data });
+    });
+
+    // Forward log events
+
+    instance.logger.on('log', (logEvent) => {
+      this.emit('service:log', logEvent);
+    });
+  }
+
+  // Internal methods
+
+  /**
+   * Setup logging configuration based on config.dev
+   */
+  #setupLogging() {
     // Set default log levels based on config.debug flag
     if (this.config.debug) {
       this.config.logConfig.defaultLevel = DEBUG;
@@ -516,12 +523,11 @@ export class ServiceManager extends EventEmitter {
   /**
    * Get the appropriate log level for a service
    *
-   * @private
    * @param {string} name - Service name
    *
    * @returns {string|undefined} Log level or undefined
    */
-  _getServiceLogLevel(name) {
+  #getServiceLogLevel(name) {
     const config = this.config.logConfig;
 
     // Check in order of precedence:
@@ -541,43 +547,31 @@ export class ServiceManager extends EventEmitter {
   }
 
   /**
-   * Attach event listeners to forward service events
+   * Stop services sequentially
    *
-   * @private
-   * @param {string} name - Service name
-   * @param {import('../service-base/typedef.js').ServiceInstance} instance
-   *   Service instance
+   * @param {string[]} serviceNames - Ordered list of service names
+   * @param {Map<string, boolean>} results - Results map to populate
+   * @param {StopOptions} options - Stop options
    */
-  _attachServiceEvents(name, instance) {
-    // Forward service events
-    instance.on('stateChanged', (data) => {
-      this.emit('service:stateChanged', { service: name, data });
-    });
-
-    instance.on('healthChanged', (data) => {
-      this.emit('service:healthChanged', { service: name, data });
-    });
-
-    instance.on('error', (data) => {
-      this.emit('service:error', { service: name, data });
-    });
-
-    // Forward log events
-
-    instance.logger.on('log', (logEvent) => {
-      this.emit('service:log', logEvent);
-    });
+  async #stopAllSequentially(serviceNames, results, options) {
+    for (const name of serviceNames) {
+      try {
+        const success = await this.stopService(name, options);
+        results.set(name, success);
+      } catch (error) {
+        this.logger.error(`Error stopping '${name}'`, error);
+        results.set(name, false);
+      }
+    }
   }
 
   /**
    * Sort services by dependencies using topological sort
    *
-   * @private
-   *
    * @returns {string[]} Service names in dependency order
    * @throws {Error} If circular dependencies are detected
    */
-  _topologicalSort() {
+  #topologicalSort() {
     const sorted = [];
     const visited = new Set();
     const visiting = new Set();

package/dist/util/expect/index.js

@@ -19,11 +19,11 @@
 
 import * as v from 'valibot';
 
-import { isObject } from '../is/index.js';
+import * as is from '../is/index.js';
 
 /** Internals */
 
-const ObjectSchema = v.custom(isObject, `Invalid type: Expected object`);
+const ObjectSchema = v.custom(is.object, `Invalid type: Expected object`);
 
 /** Exports */
 
@@ -181,7 +181,7 @@ export function iterable(value) {
 export function store(value) {
 	v.parse(
 		v.custom((value) => {
-			if (!isObject(value) || typeof value.subscribe !== 'function') {
+			if (!is.object(value) || typeof value.subscribe !== 'function') {
 				return false;
 			}
 
@@ -205,7 +205,7 @@ export function store(value) {
 export function objectNoArray(value) {
 	v.parse(
 		v.custom((value) => {
-			if (!isObject(value) || value instanceof Array) {
+			if (!is.object(value) || value instanceof Array) {
 				return false;
 			}
 
@@ -224,7 +224,7 @@ export function objectNoArray(value) {
 export function objectNoFunction(value) {
 	v.parse(
 		v.custom((value) => {
-			if (!isObject(value) || typeof value === 'function') {
+			if (!is.object(value) || typeof value === 'function') {
 				return false;
 			}
 

package/dist/util/http/response.js

@@ -1,4 +1,4 @@
-import { ResponseError } from '../../errors/index.js';
+import { ResponseError, HttpError } from '../../errors/index.js';
 import * as expect from '../expect/index.js';
 import { toURL } from './url.js';
 
@@ -155,11 +155,35 @@ export async function waitForAndCheckResponse(responsePromise, url) {
     response = await responsePromise;
 
     if (response && false === response.ok) {
-      // if response.ok is false, it also indicates a network error
-      throw new Error(`Response failed [response.ok=false]`);
+      // Check if this is a network error (status 0) vs HTTP error
+      if (response.status === 0) {
+        // Network error - treat as before
+        throw new Error(`Response failed [response.ok=false]`);
+      }
+      
+      // HTTP error - get response body for detailed error information
+      const responseBody = await response.text();
+      let errorDetails;
+
+      try {
+        // Try to parse as JSON (common for API errors)
+        errorDetails = JSON.parse(responseBody);
+      } catch {
+        // Fallback to plain text
+        errorDetails = responseBody;
+      }
+
+      throw new HttpError(
+        response.status,
+        `HTTP ${response.status}: ${response.statusText}`,
+        errorDetails
+      );
     }
   } catch (e) {
-    if (e instanceof TypeError || response?.ok === false) {
+    if (e instanceof HttpError) {
+      // Re-throw HttpError as-is
+      throw e;
+    } else if (e instanceof TypeError || response?.ok === false) {
       throw new ResponseError(
         `A network error occurred for request [${href(url)}]`,
         {

package/dist/util/index.d.ts

@@ -1,3 +1,5 @@
-export * as exceptions from "./exceptions/index.js";
+export { rethrow } from "./exceptions/index.js";
 export * as expect from "./expect/index.js";
+export * as is from "./is/index.js";
+export * as object from "./object/index.js";
 export * as singleton from "./singleton/index.js";

package/dist/util/index.js

@@ -1,3 +1,7 @@
-export * as exceptions from './exceptions/index.js';
+export { rethrow } from './exceptions/index.js';
+
 export * as expect from './expect/index.js';
+export * as is from './is/index.js';
+export * as object from './object/index.js';
+
 export * as singleton from './singleton/index.js';

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

@@ -6,15 +6,7 @@
  *
  * @return {boolean} true if the value looks like an array
  */
-export function isArrayLike(item: any): boolean;
-/**
- * Check if a value is an Arguments object
- *
- * @param {any} value
- *
- * @returns {boolean} true if the value is an Arguments object
- */
-export function isArguments(value: any): boolean;
+export function arrayLike(item: any): boolean;
 /**
  * Check if a value is an array that only contains primitives
  * - A primitive is a not-object value
@@ -23,7 +15,7 @@ export function isArguments(value: any): boolean;
  *
  * @return {boolean} true if the value is an array of primitives
  */
-export function isArrayOfPrimitives(arr: any): boolean;
+export function arrayOfPrimitives(value: any): boolean;
 /**
  * Check if the supplied value is async iterable
  * - Aync iterable objects must implement the "@@asyncIterator" method
@@ -32,7 +24,7 @@ export function isArrayOfPrimitives(arr: any): boolean;
  *
  * @returns {boolean} true if the value is async iterable
  */
-export function isAsyncIterator(value: any): boolean;
+export function asyncIterator(value: any): boolean;
 /**
  * Check if the supplied value is an async function
  * - Returns true for functions declared as "async function" or
@@ -45,7 +37,7 @@ export function isAsyncIterator(value: any): boolean;
  *
  * @returns {boolean} true if the value is an async function
  */
-export function isAsyncFunction(value: any): boolean;
+export function asyncFunction(value: any): boolean;
 /**
  * Check if the supplied value is iterable
  * - Iterable objects must implement the "@@iterator" method
@@ -55,7 +47,7 @@ export function isAsyncFunction(value: any): boolean;
  *
  * @returns {boolean} true if the value is (not async) iterable
  */
-export function isIterable(value: any): boolean;
+export function iterable(value: any): boolean;
 /**
  * Check if the supplied value is an object bu not a promise
  * - Promises return false
@@ -65,4 +57,13 @@ export function isIterable(value: any): boolean;
  *
  * @returns {boolean} true if the value is an Object, but not a Promise
  */
-export function isObject(value: any): boolean;
+export function object(value: any): boolean;
+export { argumentsCheck as arguments };
+/**
+ * Check if a value is an Arguments object
+ *
+ * @param {any} value
+ *
+ * @returns {boolean} true if the value is an Arguments object
+ */
+declare function argumentsCheck(value: any): boolean;

package/dist/util/is/index.js

@@ -16,7 +16,7 @@ const objectToString = Object.prototype.toString;
  *
  * @return {boolean} true if the value looks like an array
  */
-export function isArrayLike(item) {
+export function arrayLike(item) {
 	if (!(item instanceof Object)) {
 		return false;
 	}
@@ -35,9 +35,10 @@ export function isArrayLike(item) {
  *
  * @returns {boolean} true if the value is an Arguments object
  */
-export function isArguments(value) {
+function argumentsCheck(value) {
 	return objectToString.call(value) === '[object Arguments]';
 }
+export { argumentsCheck as arguments };
 
 /**
  * Check if a value is an array that only contains primitives
@@ -47,13 +48,13 @@ export function isArguments(value) {
  *
  * @return {boolean} true if the value is an array of primitives
  */
-export function isArrayOfPrimitives(arr) {
-	if (!Array.isArray(arr)) {
+export function arrayOfPrimitives(value) {
+	if (!Array.isArray(value)) {
 		return false;
 	}
 
-	for (let j = 0, n = arr.length; j < n; j = j + 1) {
-		if (arr[j] instanceof Object) {
+	for (let j = 0, n = value.length; j < n; j = j + 1) {
+		if (value[j] instanceof Object) {
 			// current value is not a primitive
 			return false;
 		}
@@ -70,8 +71,11 @@ export function isArrayOfPrimitives(arr) {
  *
  * @returns {boolean} true if the value is async iterable
  */
-export function isAsyncIterator(value) {
-	if (!(value instanceof Object) || typeof value[Symbol.asyncIterator] !== 'function') {
+export function asyncIterator(value) {
+	if (
+		!(value instanceof Object) ||
+		typeof value[Symbol.asyncIterator] !== 'function'
+	) {
 		return false;
 	}
 
@@ -90,7 +94,7 @@ export function isAsyncIterator(value) {
  *
  * @returns {boolean} true if the value is an async function
  */
-export function isAsyncFunction(value) {
+export function asyncFunction(value) {
 	if (value instanceof AsyncFunction) {
 		return true;
 	}
@@ -107,8 +111,11 @@ export function isAsyncFunction(value) {
  *
  * @returns {boolean} true if the value is (not async) iterable
  */
-export function isIterable(value) {
-	if (!(value instanceof Object) || typeof value[Symbol.iterator] !== 'function') {
+export function iterable(value) {
+	if (
+		!(value instanceof Object) ||
+		typeof value[Symbol.iterator] !== 'function'
+	) {
 		return false;
 	}
 
@@ -124,7 +131,7 @@ export function isIterable(value) {
  *
  * @returns {boolean} true if the value is an Object, but not a Promise
  */
-export function isObject(value) {
+export function object(value) {
 	if (!(value instanceof Object)) {
 		if (value && typeof value === 'object') {
 			// e.g. obj = Object.create(null);

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import('../../classes/data/typedef.js').IterableTreeOptions} IterableTreeOptions
+ */
 /**
  * Filter all iterated elements
  *
@@ -21,111 +24,76 @@ export function map(iterable: Iterable<any>, transformFn: Function): Generator;
  * Get an Iterator object that can be used to iterate over all
  * [ path, value ] entries in the object
  *
- * @param {Object} obj - Object to iterate
+ * @param {object} obj - Object to iterate
  *
- * @param {Object} [options] - Iteration options
+ * @param {object} [options] - Iteration options
  *
  * @param {boolean} [options.walkArrays=false]
  *   If set to true, the iterator will also iterate through Array objects
  *
- * @param {object} [options.expandPathKeys=false]
+ * @param {boolean} [options.expandPathKeys=false]
  *   If true, keys in the root object like "some.path.to" will be interpreted
  *   as paths in the object
  *
- * @param {object} [options.outputIntermediateNodes=false]
+ * @param {boolean} [options.outputIntermediateNodes=false]
  *   If true, intermediate object nodes (not leaves) will be outputted too
  *
- * @param {object} [options.ignoreEmptyObjectLeaves=false]
+ * @param {boolean} [options.ignoreEmptyObjectLeaves=false]
  *   If true, no output will be generated for empty objects at the leaves of
  *   the object tree
  *
+ * @param {boolean} [options.depthFirst=true]
+ *   If true, use depth-first traversal, otherwise breadth-first
+ *
  * @return {Iterator} iterator object
  */
-export function iterateObjectEntries(obj: any, options?: {
+export function iterateObjectEntries(obj: object, options?: {
     walkArrays?: boolean;
-    expandPathKeys?: object;
-    outputIntermediateNodes?: object;
-    ignoreEmptyObjectLeaves?: object;
+    expandPathKeys?: boolean;
+    outputIntermediateNodes?: boolean;
+    ignoreEmptyObjectLeaves?: boolean;
+    depthFirst?: boolean;
 }): Iterator<any, any, any>;
 /**
  * Get an Iterator object that can be used to iterate over all paths in
  * the object
  *
- * @param {Object} obj - Object to iterate
- *
- * @param {Object} [options] - Iteration options
- *
- * @param {boolean} [options.walkArrays=false]
- *   If set to true, the iterator will also iterate through Array objects
- *
- * @param {object} [options.expandPathKeys=false]
- *   If true, keys in the root object like "some.path.to" will be interpreted
- *   as paths in the object
- *
- * @param {object} [options.outputIntermediateNodes=false]
- *   If true, intermediate object nodes (not leaves) will be outputted too
- *
- * @param {object} [options.ignoreEmptyObjectLeaves=false]
- *   If true, no output will be generated for empty objects at the leaves of
- *   the object tree
+ * @param {object} obj - Object to iterate
+ * @param {IterableTreeOptions & { depthFirst: boolean}} [options]
  *
  * @return {Iterator} iterator object
  */
-export function iterateObjectPaths(obj: any, options?: {
-    walkArrays?: boolean;
-    expandPathKeys?: object;
-    outputIntermediateNodes?: object;
-    ignoreEmptyObjectLeaves?: object;
+export function iterateObjectPaths(obj: object, options?: IterableTreeOptions & {
+    depthFirst: boolean;
 }): Iterator<any, any, any>;
 /**
  * Get an Iterator object that can be used to iterate over all values in
  * the object (at the leaves of the object tree)
  *
- * @param {Object} obj - Object to iterate
- *
- * @param {Object} [options] - Iteration options
- *
- * @param {boolean} [options.walkArrays=false]
- *   If set to true, the iterator will also iterate through Array objects
- *
- * @param {object} [options.expandPathKeys=false]
- *   If true, keys in the root object like "some.path.to" will be interpreted
- *   as paths in the object
- *
- * @param {object} [options.outputIntermediateNodes=false]
- *   If true, intermediate object nodes (not leaves) will be outputted too
- *
- * @param {object} [options.ignoreEmptyObjectLeaves=false]
- *   If true, no output will be generated for empty objects at the leaves of
- *   the object tree
+ * @param {object} obj - Object to iterate
+ * @param {IterableTreeOptions} [options] - Iteration options
  *
  * @return {Iterator} iterator object
  */
-export function iterateObjectValues(obj: any, options?: {
-    walkArrays?: boolean;
-    expandPathKeys?: object;
-    outputIntermediateNodes?: object;
-    ignoreEmptyObjectLeaves?: object;
-}): Iterator<any, any, any>;
+export function iterateObjectValues(obj: object, options?: IterableTreeOptions): Iterator<any, any, any>;
 /**
  * Get a list of objects returned by an iterator in sorted order
  *
- * --
- *
  * @note Sorting requires that all values are evaluated, so all items must be
  *       iterated
  *
- * --
- *
- * @param {Iterable} it - Iterable items
- *
- * @param {function} getValueFn
+ * @param {object} _
+ * @param {Iterable} _.it - Iterable items
+ * @param {function} _.getValueFn
  *   Function that gets the value from the iterated objects
- *
- * @param {boolean} [reversed=false]
+ * @param {boolean} [_.reversed=false]
  *   Sort in reversed order
  *
- *
- * @returns {array} objects outputted in sorted order
+ * @returns {Promise<array>} objects outputted in sorted order
  */
-export function sortObjects({ it, getValueFn, reversed }: Iterable<any>): any[];
+export function sortObjects({ it, getValueFn, reversed }: {
+    it: Iterable<any>;
+    getValueFn: Function;
+    reversed?: boolean;
+}): Promise<any[]>;
+export type IterableTreeOptions = import("../../classes/data/typedef.js").IterableTreeOptions;