@nextera.one/axis-server-sdk 2.3.22 → 2.3.23

package/dist/sensors/index.mjs

@@ -977,7 +977,8 @@ var require_dto_schema_util = __commonJS({
           required: m.options.required,
           maxLen: m.options.maxLen,
           max: m.options.max,
-          scope: m.options.scope
+          scope: m.options.scope,
+          encode: m.options.encode
         };
       });
       const validatorMetas = Reflect.getMetadata(tlv_field_decorator_1.TLV_VALIDATORS_KEY, dto) || [];
@@ -8987,9 +8988,11 @@ var init_axis_observation = __esm({
 });
 
 // src/security/axis-sensor-chain.service.ts
+import "reflect-metadata";
 var AxisSensorChainService;
 var init_axis_sensor_chain_service = __esm({
   "src/security/axis-sensor-chain.service.ts"() {
+    init_sensor_decorator();
     init_axis_sensor();
     init_axis_observation();
     AxisSensorChainService = class {
@@ -9032,6 +9035,9 @@ var init_axis_sensor_chain_service = __esm({
       async evaluateSensors(sensors, input, baseDecision) {
         const relevantSensors = [];
         for (const sensor of sensors) {
+          if (!this.matchesProofKind(sensor, input)) {
+            continue;
+          }
           if (!sensor.supports) {
             relevantSensors.push(sensor);
             continue;
@@ -9131,6 +9137,28 @@ var init_axis_sensor_chain_service = __esm({
           } : void 0
         };
       }
+      matchesProofKind(sensor, input) {
+        const meta = Reflect.getMetadata(
+          SENSOR_METADATA_KEY,
+          sensor.constructor
+        );
+        if (!meta || meta === true) return true;
+        const currentProofKinds = this.normalizeProofKinds(
+          input.metadata?.proofKind ?? input.requiredProof
+        );
+        const excludedProofKinds = this.normalizeProofKinds(meta.excludeProofKind);
+        if (excludedProofKinds.length > 0 && currentProofKinds.some((kind) => excludedProofKinds.includes(kind))) {
+          return false;
+        }
+        const requiredProofKinds = this.normalizeProofKinds(meta.proofKind);
+        if (requiredProofKinds.length === 0) return true;
+        return currentProofKinds.some((kind) => requiredProofKinds.includes(kind));
+      }
+      normalizeProofKinds(value) {
+        if (value === void 0 || value === null) return [];
+        const items = Array.isArray(value) ? value : [value];
+        return items.map((item) => String(item).trim().toUpperCase()).filter(Boolean);
+      }
     };
   }
 });
@@ -9504,10 +9532,11 @@ var init_timeline_store = __esm({
 });
 
 // src/utils/axis-tlv-codec.ts
-function encodeAxisTlvDto(dtoClass, data) {
+function encodeAxisTlvDto(dtoClass, data, context = {}) {
   const schema = (0, import_dto_schema2.extractDtoSchema)(dtoClass);
   const items = schema.fields.flatMap((field) => {
     const value = data[field.name];
+    if (!shouldEncodeField(field, value, data, context)) return [];
     if (value === void 0 || value === null) {
       if (field.required) {
         throw new Error(`Missing required TLV response field: ${field.name}`);
@@ -9518,6 +9547,42 @@ function encodeAxisTlvDto(dtoClass, data) {
   });
   return buildTLVs(items);
 }
+function projectAxisTlvDto(dtoClass, data, context = {}) {
+  const schema = (0, import_dto_schema2.extractDtoSchema)(dtoClass);
+  const result = {};
+  for (const field of schema.fields) {
+    const value = data[field.name];
+    if (!shouldEncodeField(field, value, data, context)) continue;
+    if (value === void 0 || value === null) continue;
+    result[field.name] = value;
+  }
+  return result;
+}
+function shouldEncodeField(field, value, data, context) {
+  const rule = field.encode;
+  if (rule === void 0) return true;
+  if (rule === false) return false;
+  if (rule.onlyRoles?.length && !hasAnyRole(context, rule.onlyRoles)) {
+    return false;
+  }
+  if (rule.exceptRoles?.length && hasAnyRole(context, rule.exceptRoles)) {
+    return false;
+  }
+  if (rule.policy) {
+    const policy = context.policies?.[rule.policy];
+    if (!policy) {
+      throw new Error(`Missing TLV encode policy: ${rule.policy}`);
+    }
+    if (!policy({ field, value, data, context })) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasAnyRole(context, expectedRoles) {
+  const actualRoles = context.roles ?? [];
+  return expectedRoles.some((role) => actualRoles.includes(role));
+}
 function encodeField(field, value) {
   switch (field.kind) {
     case "utf8":
@@ -11261,6 +11326,7 @@ __export(index_exports, {
   parseScope: () => parseScope,
   parseStreamEntries: () => parseStreamEntries,
   projectAt: () => projectAt,
+  projectAxisTlvDto: () => projectAxisTlvDto,
   queryFabric: () => queryFabric,
   recordOccurrence: () => recordOccurrence,
   recordSensor: () => recordSensor,