@kronos-integration/service 15.2.5 → 15.3.0

package/README.md

@@ -95,6 +95,7 @@ The transitions are:
         *   [Parameters](#parameters-14)
     *   [getCredentials](#getcredentials)
         *   [Parameters](#parameters-15)
+    *   [storePersistentCredentials](#storepersistentcredentials)
     *   [log](#log)
         *   [Parameters](#parameters-16)
     *   [attributes](#attributes)
@@ -410,6 +411,10 @@ Retrieve all credential attribute values.
 
 Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)<[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)>**&#x20;
 
+### storePersistentCredentials
+
+Load and store persistent credentials in the service attributes.
+
 ### log
 
 Adds service name to the log event.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kronos-integration/service",
-  "version": "15.2.5",
+  "version": "15.3.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -40,7 +40,7 @@
     "@kronos-integration/endpoint": "^11.0.7",
     "@kronos-integration/interceptor": "^13.1.2",
     "loglevel-mixin": "^7.2.6",
-    "pacc": "^6.5.0",
+    "pacc": "^6.6.0",
     "statetransition-mixin": "^8.1.4"
   },
   "devDependencies": {

package/src/initialization-context.mjs

@@ -162,7 +162,7 @@ export const InitializationContext = LogLevelMixin(
 
     /**
      *
-     * @param {string|(new() => type)} type name if type
+     * @param {string|typeof Service} type name if type
      */
     async getServiceFactory(type) {
       const sp = this.serviceProvider;

package/src/service-logger.mjs

@@ -27,6 +27,11 @@ export class ServiceLogger extends Service {
     return e;
   }
 
+  /**
+   * 
+   * @param {Object} entry 
+   * @param {string} entry.severity
+   */
   async logEntry(entry)
   {
     if (entry.severity === 'error') {

package/src/service-provider-mixin.mjs

@@ -1,3 +1,4 @@
+import { prepareAttributesDefinitions, version_attribute } from "pacc";
 import { Interceptor } from "@kronos-integration/interceptor";
 import { Service } from "./service.mjs";
 import { ServiceLogger } from "./service-logger.mjs";
@@ -9,8 +10,9 @@ import { InitializationContext } from "./initialization-context.mjs";
  * By default a service provider has two build in services
  * 'logger' and 'config'.
  *
- * @param {new(Object,InitializationContext) => serviceLoggerClass} serviceLoggerClass where the logging houtd go
- * @param {new(Object,InitializationContext) => serviceConfigClass} serviceConfigClass where the config comes from
+ * @param {typeof Service} superclass
+ * @param {typeof ServiceLogger} serviceLoggerClass where the logging houtd go
+ * @param {typeof ServiceConfig} serviceConfigClass where the config comes from
  */
 export function ServiceProviderMixin(
   superclass,
@@ -18,11 +20,23 @@ export function ServiceProviderMixin(
   serviceConfigClass = ServiceConfig
 ) {
   return class ServiceProvider extends superclass {
+    static attributes = prepareAttributesDefinitions(
+      {
+        version: version_attribute
+      },
+      superclass.attributes
+    );
+
     listeners = {};
     interceptorFactories = {};
     serviceFactories = {};
-    services = {};
+    /** @typedef {Object} */ services = {};
 
+    /**
+     *
+     * @param {Object} config
+     * @param {InitializationContext} [ic]
+     */
     constructor(config, ic = new InitializationContext()) {
       super(Array.isArray(config) ? config[0] : config, ic);
 
@@ -47,6 +61,11 @@ export function ServiceProviderMixin(
       configService.configure(config);
     }
 
+    /**
+     *
+     * @param {string} name
+     * @param  {...any} args
+     */
     emit(name, ...args) {
       const listeners = this.listeners[name];
       if (listeners) {
@@ -89,11 +108,11 @@ export function ServiceProviderMixin(
     /**
      * Register service or interceptor factories.
      *
-     * @param {[Function|string]} factories
+     * @param {[typeof Service|string]} factories
      */
     async registerFactories(factories) {
       for (let factory of factories) {
-        if(typeof factory === 'string') {
+        if (typeof factory === "string") {
           const module = await import(factory);
           factory = new module.default();
         }
@@ -111,8 +130,8 @@ export function ServiceProviderMixin(
      * Registers a interceptor factory for later use by
      * @see {instantiateInterceptor}.
      *
-     * @param {new() => factory} factory
-     * @returns {new() => factory} factory
+     * @param {typeof Interceptor} factory
+     * @returns {typeof Interceptor} factory
      */
     registerInterceptorFactory(factory) {
       this.interceptorFactories[factory.name] = factory;
@@ -120,6 +139,10 @@ export function ServiceProviderMixin(
       return factory;
     }
 
+    /**
+     *
+     * @param {typeof Interceptor} factory
+     */
     unregisterInterceptorFactory(factory) {
       delete this.interceptorFactories[factory.name];
     }
@@ -139,25 +162,51 @@ export function ServiceProviderMixin(
       }
     }
 
+    /**
+     *
+     * @param {Service} service
+     * @param {string} oldState
+     * @param {string} newState
+     */
     serviceStateChanged(service, oldState, newState) {
       this.emit("serviceStateChanged", service, oldState, newState);
     }
 
+    /**
+     *
+     * @param {typeof Service} factory
+     * @returns {Promise<typeof Service>}
+     */
     async registerServiceFactory(factory) {
       this.serviceFactories[factory.name] = factory;
       this.emit("serviceFactoryRegistered", factory);
       return factory;
     }
 
+    /**
+     *
+     * @param {typeof Service} factory
+     * @returns {Promise<any>}
+     */
     async unregisterServiceFactory(factory) {
       delete this.serviceFactories[factory.name];
     }
 
+    /**
+     *
+     * @param {Service} service
+     * @returns {Promise<Service>}
+     */
     async registerService(service) {
       this.services[service.name] = service;
       return service;
     }
 
+    /**
+     *
+     * @param {string} serviceName
+     * @returns {Promise<any>}
+     */
     async unregisterService(serviceName) {
       const service = this.services[serviceName];
 
@@ -171,10 +220,21 @@ export function ServiceProviderMixin(
         : Object.keys(this.services).sort();
     }
 
+    /**
+     *
+     * @param {string} name
+     * @returns {Service|undefined}
+     */
     getService(name) {
       return this.services?.[name];
     }
 
+    /**
+     *
+     * @param {Object} config
+     * @param {string} config.name
+     * @returns {Promise<Service>}
+     */
     async declareService(config) {
       const name = config.name;
       const services = await this.declareServices({ [name]: config });
@@ -223,7 +283,7 @@ export function ServiceProviderMixin(
 
     /**
      * Stop all services.
-     * @return {Promise} that resolves when all services are stopped
+     * @return {Promise<any>} that resolves when all services are stopped
      */
     async _stop() {
       await Promise.all(

package/src/service.mjs

@@ -133,11 +133,11 @@ export class Service extends EndpointsMixin(
 
   /**
    * @param {Object} config
-   * @param {string} config.name
-   * @param {string} config.logLevel
-   * @param {boolean} config.autostart defaults to false
-   * @param {string} config.description human readable description
-   * @param {Object} config.endpoints will be merged with the build in ones
+   * @param {string} [config.name]
+   * @param {string} [config.logLevel]
+   * @param {boolean} [config.autostart] defaults to false
+   * @param {string} [config.description] human readable description
+   * @param {Object} [config.endpoints] will be merged with the build in ones
    * @param {InitializationContext} ic
    */
   constructor(config, ic) {
@@ -265,7 +265,7 @@ export class Service extends EndpointsMixin(
   /**
    * Restart action.
    * default implementation does a _stop() and a _start()
-   * @return {Promise} fulfills after start
+   * @return {Promise<any>} fulfills after start
    */
   async _restart() {
     await this._stop();
@@ -275,7 +275,7 @@ export class Service extends EndpointsMixin(
   /**
    * Restarts if in running mode.
    * Otherwise does nothing.
-   * @returns {Promise} resolves when restart is done (or immediate if no restart triggered)
+   * @returns {Promise<any>} resolves when restart is done (or immediate if no restart triggered)
    */
   async restartIfRunning() {
     if (this.state === "running") {
@@ -448,7 +448,8 @@ export class Service extends EndpointsMixin(
   }
 
   /**
-   * Retrieve all credential attribute values.
+   * Retrieve all (filtered) credential attribute values.
+   * @param {Function} filter
    * @returns {Promise<Object>}
    */
   async getCredentials(filter = (name, attribute) => attribute.credential) {
@@ -466,6 +467,7 @@ export class Service extends EndpointsMixin(
 
   /**
    * Load and store persistent credentials in the service attributes.
+   * @return {Promise<undefined>}
    */
   async storePersistentCredentials() {
     for (const [path, attribute] of attributeIterator(

package/types/service-logger.d.mts

@@ -2,6 +2,13 @@
  * Log receiving service.
  */
 export class ServiceLogger extends Service {
-    logEntry(entry: any): Promise<void>;
+    /**
+     *
+     * @param {Object} entry
+     * @param {string} entry.severity
+     */
+    logEntry(entry: {
+        severity: string;
+    }): Promise<void>;
 }
 import { Service } from './service.mjs';

package/types/service-provider-mixin.d.mts

@@ -3,18 +3,24 @@
  * By default a service provider has two build in services
  * 'logger' and 'config'.
  *
- * @param {new(Object,InitializationContext) => serviceLoggerClass} serviceLoggerClass where the logging houtd go
- * @param {new(Object,InitializationContext) => serviceConfigClass} serviceConfigClass where the config comes from
+ * @param {typeof Service} superclass
+ * @param {typeof ServiceLogger} serviceLoggerClass where the logging houtd go
+ * @param {typeof ServiceConfig} serviceConfigClass where the config comes from
  */
-export function ServiceProviderMixin(superclass: any, serviceLoggerClass?: new (Object: any, InitializationContext: any) => new (Object: any, InitializationContext: any) => /*elided*/ any, serviceConfigClass?: new (Object: any, InitializationContext: any) => new (Object: any, InitializationContext: any) => /*elided*/ any): {
+export function ServiceProviderMixin(superclass: typeof Service, serviceLoggerClass?: typeof ServiceLogger, serviceConfigClass?: typeof ServiceConfig): {
     new (config: any, ic?: any): {
-        [x: string]: any;
+        new (): new () => /*elided*/ any;
         listeners: {};
         interceptorFactories: {};
         serviceFactories: {};
-        services: {};
+        /** @typedef {Object} */ services: {};
         ic: any;
-        emit(name: any, ...args: any[]): void;
+        /**
+         *
+         * @param {string} name
+         * @param  {...any} args
+         */
+        emit(name: string, ...args: any[]): void;
         addListener(name: any, listener: any): void;
         removeListener(name: any, listener: any): void;
         /**
@@ -30,18 +36,22 @@ export function ServiceProviderMixin(superclass: any, serviceLoggerClass?: new (
         /**
          * Register service or interceptor factories.
          *
-         * @param {[Function|string]} factories
+         * @param {[typeof Service|string]} factories
          */
-        registerFactories(factories: [Function | string]): Promise<void>;
+        registerFactories(factories: [typeof Service | string]): Promise<void>;
         /**
          * Registers a interceptor factory for later use by
          * @see {instantiateInterceptor}.
          *
-         * @param {new() => factory} factory
-         * @returns {new() => factory} factory
+         * @param {typeof Interceptor} factory
+         * @returns {typeof Interceptor} factory
          */
-        registerInterceptorFactory(factory: new () => new () => /*elided*/ any): new () => new () => /*elided*/ any;
-        unregisterInterceptorFactory(factory: any): void;
+        registerInterceptorFactory(factory: typeof Interceptor): typeof Interceptor;
+        /**
+         *
+         * @param {typeof Interceptor} factory
+         */
+        unregisterInterceptorFactory(factory: typeof Interceptor): void;
         /**
          * Instanciates an interceptor from its definition data.
          * @see {interceptorFactories}
@@ -49,14 +59,53 @@ export function ServiceProviderMixin(superclass: any, serviceLoggerClass?: new (
          * @returns {Interceptor|undefined}
          */
         instantiateInterceptor(definition: any): Interceptor | undefined;
-        serviceStateChanged(service: any, oldState: any, newState: any): void;
-        registerServiceFactory(factory: any): Promise<any>;
-        unregisterServiceFactory(factory: any): Promise<void>;
-        registerService(service: any): Promise<any>;
-        unregisterService(serviceName: any): Promise<void>;
+        /**
+         *
+         * @param {Service} service
+         * @param {string} oldState
+         * @param {string} newState
+         */
+        serviceStateChanged(service: Service, oldState: string, newState: string): void;
+        /**
+         *
+         * @param {typeof Service} factory
+         * @returns {Promise<typeof Service>}
+         */
+        registerServiceFactory(factory: typeof Service): Promise<typeof Service>;
+        /**
+         *
+         * @param {typeof Service} factory
+         * @returns {Promise<any>}
+         */
+        unregisterServiceFactory(factory: typeof Service): Promise<any>;
+        /**
+         *
+         * @param {Service} service
+         * @returns {Promise<Service>}
+         */
+        registerService(service: Service): Promise<Service>;
+        /**
+         *
+         * @param {string} serviceName
+         * @returns {Promise<any>}
+         */
+        unregisterService(serviceName: string): Promise<any>;
         get serviceNames(): string[];
-        getService(name: any): any;
-        declareService(config: any): Promise<any>;
+        /**
+         *
+         * @param {string} name
+         * @returns {Service|undefined}
+         */
+        getService(name: string): Service | undefined;
+        /**
+         *
+         * @param {Object} config
+         * @param {string} config.name
+         * @returns {Promise<Service>}
+         */
+        declareService(config: {
+            name: string;
+        }): Promise<Service>;
         /**
          * Add a new service based on its configuration.
          * If a service for the name is already present and it has a matching type
@@ -74,10 +123,45 @@ export function ServiceProviderMixin(superclass: any, serviceLoggerClass?: new (
         _start(): Promise<any[]>;
         /**
          * Stop all services.
-         * @return {Promise} that resolves when all services are stopped
+         * @return {Promise<any>} that resolves when all services are stopped
          */
         _stop(): Promise<any>;
+        "__#private@#description": any;
+        readonly attributes: any;
+        get type(): string;
+        description: any;
+        get extendetName(): string;
+        stateChanged(origin: any, oldState: string, newState: string): void;
+        stateTransitionRejection(rejected: any, newState: any): any;
+        rejectWrongState(action: string): Promise<void>;
+        timeoutForTransition(transition: any): number;
+        _restart(): Promise<any>;
+        restartIfRunning(): Promise<any>;
+        get toStringAttributes(): any;
+        toString(): string;
+        toJSON(): any;
+        toJSONWithOptions(options: {
+            includeRuntimeInfo: boolean;
+            includeDefaults: boolean;
+            includeName: boolean;
+            includeConfig: boolean;
+            includePrivate: boolean;
+        }): any;
+        get name(): string;
+        get autostart(): boolean;
+        _configure(config: any): Set<string>;
+        configure(config: any): Promise<undefined>;
+        getCredential(key: string): Promise<string | Uint8Array>;
+        getCredentials(filter?: Function): Promise<any>;
+        storePersistentCredentials(): Promise<undefined>;
+        log(level: string, arg: any): void;
     };
-    [x: string]: any;
+    attributes: any;
+    get description(): string;
+    get name(): string;
+    get endpoints(): any;
 };
+import { Service } from "./service.mjs";
+import { ServiceLogger } from "./service-logger.mjs";
+import { ServiceConfig } from "./service-config.mjs";
 import { Interceptor } from "@kronos-integration/interceptor";

package/types/service.d.mts

@@ -29,19 +29,19 @@ export class Service extends Service_base {
     static get endpoints(): any;
     /**
      * @param {Object} config
-     * @param {string} config.name
-     * @param {string} config.logLevel
-     * @param {boolean} config.autostart defaults to false
-     * @param {string} config.description human readable description
-     * @param {Object} config.endpoints will be merged with the build in ones
+     * @param {string} [config.name]
+     * @param {string} [config.logLevel]
+     * @param {boolean} [config.autostart] defaults to false
+     * @param {string} [config.description] human readable description
+     * @param {Object} [config.endpoints] will be merged with the build in ones
      * @param {InitializationContext} ic
      */
     constructor(config: {
-        name: string;
-        logLevel: string;
-        autostart: boolean;
-        description: string;
-        endpoints: any;
+        name?: string;
+        logLevel?: string;
+        autostart?: boolean;
+        description?: string;
+        endpoints?: any;
     }, ic: any);
     owner: any;
     instantiateInterceptor(options: any): any;
@@ -87,13 +87,13 @@ export class Service extends Service_base {
     /**
      * Restart action.
      * default implementation does a _stop() and a _start()
-     * @return {Promise} fulfills after start
+     * @return {Promise<any>} fulfills after start
      */
     _restart(): Promise<any>;
     /**
      * Restarts if in running mode.
      * Otherwise does nothing.
-     * @returns {Promise} resolves when restart is done (or immediate if no restart triggered)
+     * @returns {Promise<any>} resolves when restart is done (or immediate if no restart triggered)
      */
     restartIfRunning(): Promise<any>;
     /**
@@ -156,14 +156,16 @@ export class Service extends Service_base {
      */
     getCredential(key: string): Promise<string | Uint8Array>;
     /**
-     * Retrieve all credential attribute values.
+     * Retrieve all (filtered) credential attribute values.
+     * @param {Function} filter
      * @returns {Promise<Object>}
      */
-    getCredentials(filter?: (name: any, attribute: any) => any): Promise<any>;
+    getCredentials(filter?: Function): Promise<any>;
     /**
      * Load and store persistent credentials in the service attributes.
+     * @return {Promise<undefined>}
      */
-    storePersistentCredentials(): Promise<void>;
+    storePersistentCredentials(): Promise<undefined>;
     /**
      * Adds service name to the log event.
      * @param {string} level the log level

package/types/standalone-service-provider.d.mts

@@ -1,39 +1,73 @@
 declare const StandaloneServiceProvider_base: {
     new (config: any, ic?: any): {
-        [x: string]: any;
+        new (): new () => /*elided*/ any;
         listeners: {};
         interceptorFactories: {};
         serviceFactories: {};
         services: {};
         ic: any;
-        emit(name: any, ...args: any[]): void;
+        emit(name: string, ...args: any[]): void;
         addListener(name: any, listener: any): void;
         removeListener(name: any, listener: any): void;
         get owner(): /*elided*/ any;
         get isServiceProvider(): boolean;
-        registerFactories(factories: [Function | string]): Promise<void>;
-        registerInterceptorFactory(factory: new () => new () => /*elided*/ any): new () => new () => /*elided*/ any;
-        unregisterInterceptorFactory(factory: any): void;
+        registerFactories(factories: [typeof Service | string]): Promise<void>;
+        registerInterceptorFactory(factory: typeof import("@kronos-integration/interceptor").Interceptor): typeof import("@kronos-integration/interceptor").Interceptor;
+        unregisterInterceptorFactory(factory: typeof import("@kronos-integration/interceptor").Interceptor): void;
         instantiateInterceptor(definition: any): import("@kronos-integration/interceptor").Interceptor | undefined;
-        serviceStateChanged(service: any, oldState: any, newState: any): void;
-        registerServiceFactory(factory: any): Promise<any>;
-        unregisterServiceFactory(factory: any): Promise<void>;
-        registerService(service: any): Promise<any>;
-        unregisterService(serviceName: any): Promise<void>;
+        serviceStateChanged(service: Service, oldState: string, newState: string): void;
+        registerServiceFactory(factory: typeof Service): Promise<typeof Service>;
+        unregisterServiceFactory(factory: typeof Service): Promise<any>;
+        registerService(service: Service): Promise<Service>;
+        unregisterService(serviceName: string): Promise<any>;
         get serviceNames(): string[];
-        getService(name: any): any;
-        declareService(config: any): Promise<any>;
+        getService(name: string): Service | undefined;
+        declareService(config: {
+            name: string;
+        }): Promise<Service>;
         declareServices(configs: object): Promise<any>;
         _start(): Promise<any[]>;
         _stop(): Promise<any>;
+        "__#private@#description": any;
+        readonly attributes: any;
+        get type(): string;
+        description: any;
+        get extendetName(): string;
+        stateChanged(origin: any, oldState: string, newState: string): void;
+        stateTransitionRejection(rejected: any, newState: any): any;
+        rejectWrongState(action: string): Promise<void>;
+        timeoutForTransition(transition: any): number;
+        _restart(): Promise<any>;
+        restartIfRunning(): Promise<any>;
+        get toStringAttributes(): any;
+        toString(): string;
+        toJSON(): any;
+        toJSONWithOptions(options: {
+            includeRuntimeInfo: boolean;
+            includeDefaults: boolean;
+            includeName: boolean;
+            includeConfig: boolean;
+            includePrivate: boolean;
+        }): any;
+        get name(): string;
+        get autostart(): boolean;
+        _configure(config: any): Set<string>;
+        configure(config: any): Promise<undefined>;
+        getCredential(key: string): Promise<string | Uint8Array>;
+        getCredentials(filter?: Function): Promise<any>;
+        storePersistentCredentials(): Promise<undefined>;
+        log(level: string, arg: any): void;
     };
-    [x: string]: any;
+    attributes: any;
+    get description(): string;
+    get name(): string;
+    get endpoints(): any;
 };
 /**
  * Simple service manager (for examples and testing only).
  */
 export class StandaloneServiceProvider extends StandaloneServiceProvider_base {
-    static get description(): string;
     getCredential(key: any): Promise<void>;
 }
+import { Service } from "./service.mjs";
 export {};