@kronos-integration/interceptor 13.4.6 → 13.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kronos-integration/interceptor",
-  "version": "13.4.6",
+  "version": "13.5.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -35,10 +35,10 @@
     "lint:docs": "documentation lint ./src**/*.mjs"
   },
   "dependencies": {
-    "pacc": "^11.6.0"
+    "pacc": "^14.0.1"
   },
   "devDependencies": {
-    "@kronos-integration/test-interceptor": "^7.2.4",
+    "@kronos-integration/test-interceptor": "^7.2.6",
     "ava": "^8.0.1",
     "c8": "^12.0.0",
     "documentation": "^14.0.3",

package/src/interceptor.mjs

@@ -1,4 +1,10 @@
-import { setAttributes, getAttributes } from "pacc";
+import {
+  addType,
+  setAttributes,
+  extract,
+  type_attribute,
+  SCOPE_RUNTIME
+} from "pacc";
 
 /**
  * @typedef {Object} Endpoint
@@ -14,10 +20,16 @@ export class Interceptor {
    * Meta description of the configuration
    * @return {Object}
    */
-  static attributes = {};
+  static attributes = {
+    type: type_attribute
+  };
+
+  static {
+    addType(this);
+  }
 
   /**
-   * 
+   *
    * @param {Object} [config]
    */
   constructor(config) {
@@ -70,22 +82,22 @@ export class Interceptor {
    * @return {Object} json representation
    */
   toJSONWithOptions(options) {
-    if (!options.includeConfig) {
-      return { type: this.type };
-    }
-
-    let atts = getAttributes(this, this.attributes);
+    return extract(this, {
+      externalNames: true,
+      filter: attribute => {
+        if (attribute.scope === SCOPE_RUNTIME) {
+          return options.includeRuntimeInfo;
+        }
+        if (attribute.name === "type") {
+          return true;
+        }
 
-    if (!options.includePrivate) {
-      atts = Object.fromEntries(
-        Object.entries(atts).filter(([k, v]) => !v.private)
-      );
-    }
-
-    return {
-      type: this.type,
-      ...atts
-    };
+        return (
+          options.includeConfig &&
+          (options.includePrivate || !attribute.private)
+        );
+      }
+    });
   }
 
   /**

package/src/interval-interceptor.mjs

@@ -1,4 +1,4 @@
-import { prepareAttributesDefinitions, duration_ms_attribute } from "pacc";
+import { addType, duration_ms_attribute } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
 
 /**
@@ -6,17 +6,15 @@ import { Interceptor } from "./interceptor.mjs";
  * @property {number} interval
  */
 export class IntervalInterceptor extends Interceptor {
-  static attributes = prepareAttributesDefinitions(
-    {
-      interval: {
-        ...duration_ms_attribute,
-        name: "interval",
-        description: "min interval between two requests",
-        default: "60s",
-      }
-    },
-    Interceptor.attributes
-  );
+  static attributes = {
+    interval: {
+      ...duration_ms_attribute,
+      writable: true,
+      name: "interval",
+      description: "min interval between two requests",
+      default: "60s"
+    }
+  };
 
   /**
    * @return {string} 'interval'
@@ -25,6 +23,10 @@ export class IntervalInterceptor extends Interceptor {
     return "interval";
   }
 
+  static {
+    addType(this);
+  }
+
   async receive(endpoint, next, ...args) {
     const now = new Date();
 

package/src/limiting-interceptor.mjs

@@ -1,8 +1,8 @@
 import {
-  prepareAttributesDefinitions,
-  object_attribute,
+  addType,
   duration_ms_attribute,
-  count_attribute
+  count_attribute_writable,
+  default_collection_attribute_writable
 } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
 
@@ -29,39 +29,41 @@ export class LimitingInterceptor extends Interceptor {
     return "request-limit";
   }
 
-  static attributes = prepareAttributesDefinitions(
-    {
-      limits: {
-        ...object_attribute,
-        name: "limits",
-        default: [
-          {
-            count: 10
-          }
-        ],
-        attributes: {
-          count: count_attribute,
-          delay: { ...duration_ms_attribute, name: "delay" }
+  static attributes = {
+    limits: {
+      ...default_collection_attribute_writable,
+      //...object_attribute,
+      name: "limits",
+      default: [
+        {
+          count: 10
         }
+      ],
+      attributes: {
+        count: count_attribute_writable,
+        delay: { ...duration_ms_attribute, name: "delay" }
       }
-    },
-    Interceptor.attributes
-  );
+    }
+  };
+
+  static {
+    addType(this);
+  }
 
   /**
    *
    * @param {Object?} config
    */
-  constructor(config) {
+  /*constructor(config) {
     super(config);
     this.limits = config?.limits || this.attributes.limits.default;
-  }
+  }*/
 
-  toJSON() {
+  /*toJSON() {
     const json = super.toJSON();
     json.limits = this.limits;
     return json;
-  }
+  }*/
 
   reset() {
     this.ongoingResponses = new Set();

package/src/logging-interceptor.mjs

@@ -1,3 +1,4 @@
+import { addType } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
 
 /**
@@ -11,13 +12,19 @@ export class LoggingInterceptor extends Interceptor {
     return "logging";
   }
 
+  static {
+    addType(this);
+  }
+
   async receive(endpoint, next, ...args) {
     const logger = endpoint.owner;
     logger.info(`${endpoint.identifier}: > ${JSON.stringify([...args])}`);
 
     try {
       const result = await next(...args);
-      logger.info(`${endpoint.identifier}: < ${result === undefined ? '' : result}`);
+      logger.info(
+        `${endpoint.identifier}: < ${result === undefined ? "" : result}`
+      );
       return result;
     } catch (e) {
       logger.error(`${endpoint.identifier}: ${e}`);

package/src/monitoring-interceptor.mjs

@@ -1,25 +1,24 @@
-import { prepareAttributesDefinitions, duration_ms_attribute, default_attribute } from "pacc";
+import { addType, duration_ms_attribute } from "pacc";
 import { Interceptor } from "@kronos-integration/interceptor";
 
 /**
  *
  */
 export class MonitoringInterceptor extends Interceptor {
-  static attributes = prepareAttributesDefinitions(
-    {
-      gracePeriod: {
-        ...duration_ms_attribute,
-        name: "gracePeriod",
-        default: "120s"
-      },
-      settingPeriod: {
-        ...duration_ms_attribute,
-        name: "settingPeriod",
-        default: "300s"
-      }
+  static attributes = {
+    gracePeriod: {
+      ...duration_ms_attribute,
+      writable: true,
+      name: "gracePeriod",
+      default: "120s"
     },
-    Interceptor.attributes
-  );
+    settingPeriod: {
+      ...duration_ms_attribute,
+      writable: true,
+      name: "settingPeriod",
+      default: "300s"
+    }
+  };
 
   /**
    * @return {string} 'monitor'
@@ -28,6 +27,10 @@ export class MonitoringInterceptor extends Interceptor {
     return "monitor";
   }
 
+  static {
+    addType(this);
+  }
+
   reset() {
     this.endpointStates = new Map();
   }

package/src/stats-collector-interceptor.mjs

@@ -1,3 +1,4 @@
+import { addType } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
 
 /**
@@ -12,6 +13,10 @@ export class StatsCollectorInterceptor extends Interceptor {
     return "collect-request-stats";
   }
 
+    static {
+      addType(this);
+    }
+  
   reset() {
     this.numberOfRequests = 0;
     this.numberOfFailedRequests = 0;

package/src/template-interceptor.mjs

@@ -1,5 +1,5 @@
+import { addType, expand, object_attribute_writable } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
-import { expand, prepareAttributesDefinitions, object_attribute } from "pacc";
 
 /**
  * Map params into requests.
@@ -12,17 +12,24 @@ export class TemplateInterceptor extends Interceptor {
     return "template";
   }
 
-  static attributes = prepareAttributesDefinitions(
-    {
-      request: {
-        ...object_attribute,
-        name: "request",
-        description: "request template",
-        default: {}
-      }
-    },
-    Interceptor.attributes
-  );
+  static attributes = {
+    request: {
+      ...object_attribute_writable,
+      name: "request",
+      description: "request template",
+      default: {}
+    }
+  };
+
+  static {
+    addType(this);
+  }
+
+  toJSONWithOptions(options) {
+    const json = super.toJSONWithOptions(options);
+    json.request = this.request;
+    return json;
+  }
 
   async receive(endpoint, next, params) {
     return next(

package/src/timeout-interceptor.mjs

@@ -1,4 +1,4 @@
-import { prepareAttributesDefinitions, duration_ms_attribute } from "pacc";
+import { addType, duration_ms_attribute } from "pacc";
 import { Interceptor } from "./interceptor.mjs";
 
 /**
@@ -6,16 +6,14 @@ import { Interceptor } from "./interceptor.mjs";
  * @property {number} timeout
  */
 export class TimeoutInterceptor extends Interceptor {
-  static attributes = prepareAttributesDefinitions(
-    {
-      timeout: {
-        ...duration_ms_attribute,
-        description: "request timeout",
-        default: "10s",
-      }
-    },
-    Interceptor.attributes
-  );
+  static attributes = {
+    timeout: {
+      ...duration_ms_attribute,
+      writable: true,
+      description: "request timeout",
+      default: "100000"
+    }
+  };
 
   /**
    * @return {string} 'timeout'
@@ -24,6 +22,10 @@ export class TimeoutInterceptor extends Interceptor {
     return "timeout";
   }
 
+  static {
+    addType(this);
+  }
+
   receive(endpoint, next, ...args) {
     return rejectUnlessResolvedWithin(next(...args), this.timeout, this);
   }