@prosopo/provider 4.15.13 → 4.15.15

package/dist/cjs/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/cjs/api/admin/apiAdminRoutesProvider.cjs

@@ -1,60 +1,41 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const apiClearAllCountersEndpoint = require("./apiClearAllCountersEndpoint.cjs");
-const apiDnsEventEndpoint = require("./apiDnsEventEndpoint.cjs");
-const apiGetAllDecisionMachinesEndpoint = require("./apiGetAllDecisionMachinesEndpoint.cjs");
-const apiGetDecisionMachineEndpoint = require("./apiGetDecisionMachineEndpoint.cjs");
-const apiRegisterSiteKeyEndpoint = require("./apiRegisterSiteKeyEndpoint.cjs");
-const apiRegisterSiteKeysEndpoint = require("./apiRegisterSiteKeysEndpoint.cjs");
-const apiRemoveAllDecisionMachinesEndpoint = require("./apiRemoveAllDecisionMachinesEndpoint.cjs");
-const apiRemoveDecisionMachineEndpoint = require("./apiRemoveDecisionMachineEndpoint.cjs");
-const apiRemoveDetectorKeyEndpoint = require("./apiRemoveDetectorKeyEndpoint.cjs");
-const apiRemoveSiteKeyEndpoint = require("./apiRemoveSiteKeyEndpoint.cjs");
-const apiRemoveSiteKeysEndpoint = require("./apiRemoveSiteKeysEndpoint.cjs");
-const apiToggleMaintenanceModeEndpoint = require("./apiToggleMaintenanceModeEndpoint.cjs");
-const apiUpdateDecisionMachineEndpoint = require("./apiUpdateDecisionMachineEndpoint.cjs");
-const apiUpdateDetectorKeyEndpoint = require("./apiUpdateDetectorKeyEndpoint.cjs");
-class ApiAdminRoutesProvider {
-  constructor(tasks) {
-    this.tasks = tasks;
-  }
-  getRoutes() {
-    return {
-      [types.AdminApiPaths.SiteKeyRegister]: new apiRegisterSiteKeyEndpoint.ApiRegisterSiteKeyEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.SiteKeysRegister]: new apiRegisterSiteKeysEndpoint.ApiRegisterSiteKeysEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.UpdateDetectorKey]: new apiUpdateDetectorKeyEndpoint.ApiUpdateDetectorKeyEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.RemoveDetectorKey]: new apiRemoveDetectorKeyEndpoint.ApiRemoveDetectorKeyEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.UpdateDecisionMachine]: new apiUpdateDecisionMachineEndpoint.ApiUpdateDecisionMachineEndpoint(this.tasks.clientTaskManager),
-      [types.AdminApiPaths.GetAllDecisionMachines]: new apiGetAllDecisionMachinesEndpoint.ApiGetAllDecisionMachinesEndpoint(this.tasks.clientTaskManager),
-      [types.AdminApiPaths.GetDecisionMachine]: new apiGetDecisionMachineEndpoint.ApiGetDecisionMachineEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.RemoveDecisionMachine]: new apiRemoveDecisionMachineEndpoint.ApiRemoveDecisionMachineEndpoint(this.tasks.clientTaskManager),
-      [types.AdminApiPaths.RemoveAllDecisionMachines]: new apiRemoveAllDecisionMachinesEndpoint.ApiRemoveAllDecisionMachinesEndpoint(this.tasks.clientTaskManager),
-      [types.AdminApiPaths.ClearAllCounters]: new apiClearAllCountersEndpoint.ApiClearAllCountersEndpoint(
-        this.tasks.usageCounters
-      ),
-      [types.AdminApiPaths.SiteKeyRemove]: new apiRemoveSiteKeyEndpoint.ApiRemoveSiteKeyEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.SiteKeysRemove]: new apiRemoveSiteKeysEndpoint.ApiRemoveSiteKeysEndpoint(
-        this.tasks.clientTaskManager
-      ),
-      [types.AdminApiPaths.ToggleMaintenanceMode]: new apiToggleMaintenanceModeEndpoint.ApiToggleMaintenanceModeEndpoint(),
-      [types.AdminApiPaths.DnsEvent]: new apiDnsEventEndpoint.ApiDnsEventEndpoint(
-        this.tasks.db,
-        this.tasks.env.ipInfoService
-      )
-    };
-  }
-}
+const require_apiToggleMaintenanceModeEndpoint = require("./apiToggleMaintenanceModeEndpoint.cjs");
+const require_apiClearAllCountersEndpoint = require("./apiClearAllCountersEndpoint.cjs");
+const require_apiDnsEventEndpoint = require("./apiDnsEventEndpoint.cjs");
+const require_apiGetAllDecisionMachinesEndpoint = require("./apiGetAllDecisionMachinesEndpoint.cjs");
+const require_apiGetDecisionMachineEndpoint = require("./apiGetDecisionMachineEndpoint.cjs");
+const require_apiRegisterSiteKeyEndpoint = require("./apiRegisterSiteKeyEndpoint.cjs");
+const require_apiRegisterSiteKeysEndpoint = require("./apiRegisterSiteKeysEndpoint.cjs");
+const require_apiRemoveAllDecisionMachinesEndpoint = require("./apiRemoveAllDecisionMachinesEndpoint.cjs");
+const require_apiRemoveDecisionMachineEndpoint = require("./apiRemoveDecisionMachineEndpoint.cjs");
+const require_apiRemoveDetectorKeyEndpoint = require("./apiRemoveDetectorKeyEndpoint.cjs");
+const require_apiRemoveSiteKeyEndpoint = require("./apiRemoveSiteKeyEndpoint.cjs");
+const require_apiRemoveSiteKeysEndpoint = require("./apiRemoveSiteKeysEndpoint.cjs");
+const require_apiUpdateDecisionMachineEndpoint = require("./apiUpdateDecisionMachineEndpoint.cjs");
+const require_apiUpdateDetectorKeyEndpoint = require("./apiUpdateDetectorKeyEndpoint.cjs");
+let _prosopo_types = require("@prosopo/types");
+//#region src/api/admin/apiAdminRoutesProvider.ts
+var ApiAdminRoutesProvider = class {
+	constructor(tasks) {
+		this.tasks = tasks;
+	}
+	getRoutes() {
+		return {
+			[_prosopo_types.AdminApiPaths.SiteKeyRegister]: new require_apiRegisterSiteKeyEndpoint.ApiRegisterSiteKeyEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.SiteKeysRegister]: new require_apiRegisterSiteKeysEndpoint.ApiRegisterSiteKeysEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.UpdateDetectorKey]: new require_apiUpdateDetectorKeyEndpoint.ApiUpdateDetectorKeyEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.RemoveDetectorKey]: new require_apiRemoveDetectorKeyEndpoint.ApiRemoveDetectorKeyEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.UpdateDecisionMachine]: new require_apiUpdateDecisionMachineEndpoint.ApiUpdateDecisionMachineEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.GetAllDecisionMachines]: new require_apiGetAllDecisionMachinesEndpoint.ApiGetAllDecisionMachinesEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.GetDecisionMachine]: new require_apiGetDecisionMachineEndpoint.ApiGetDecisionMachineEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.RemoveDecisionMachine]: new require_apiRemoveDecisionMachineEndpoint.ApiRemoveDecisionMachineEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.RemoveAllDecisionMachines]: new require_apiRemoveAllDecisionMachinesEndpoint.ApiRemoveAllDecisionMachinesEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.ClearAllCounters]: new require_apiClearAllCountersEndpoint.ApiClearAllCountersEndpoint(this.tasks.usageCounters),
+			[_prosopo_types.AdminApiPaths.SiteKeyRemove]: new require_apiRemoveSiteKeyEndpoint.ApiRemoveSiteKeyEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.SiteKeysRemove]: new require_apiRemoveSiteKeysEndpoint.ApiRemoveSiteKeysEndpoint(this.tasks.clientTaskManager),
+			[_prosopo_types.AdminApiPaths.ToggleMaintenanceMode]: new require_apiToggleMaintenanceModeEndpoint.ApiToggleMaintenanceModeEndpoint(),
+			[_prosopo_types.AdminApiPaths.DnsEvent]: new require_apiDnsEventEndpoint.ApiDnsEventEndpoint(this.tasks.db, this.tasks.env.ipInfoService)
+		};
+	}
+};
+//#endregion
 exports.ApiAdminRoutesProvider = ApiAdminRoutesProvider;

package/dist/cjs/api/admin/apiClearAllCountersEndpoint.cjs

@@ -1,59 +1,64 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-class ApiClearAllCountersEndpoint {
-  constructor(usageCounters) {
-    this.usageCounters = usageCounters;
-  }
-  async processRequest(args, logger$1) {
-    logger$1 = logger$1 ? logger$1.with({}, "admin:counters:clear-all") : logger.getLogger("info", "provider:admin:counters:clear-all");
-    const dappAccount = args.dapp;
-    const scope = dappAccount ?? "all";
-    try {
-      logger$1.info(() => ({
-        msg: "Clearing usage counters",
-        data: { scope }
-      }));
-      if (!this.usageCounters) {
-        return {
-          status: apiRoute.ApiEndpointResponseStatus.FAIL,
-          error: "Usage counters not available (Redis unreachable)"
-        };
-      }
-      const deleted = await this.usageCounters.clearAll(dappAccount);
-      if (deleted === null) {
-        return {
-          status: apiRoute.ApiEndpointResponseStatus.FAIL,
-          error: "Counter clear failed"
-        };
-      }
-      logger$1.info(() => ({
-        msg: "Usage counters cleared",
-        data: { scope, deletedCount: deleted }
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-        data: types.ClearAllCountersResponse.parse({
-          success: true,
-          deletedCount: deleted,
-          scope
-        })
-      };
-    } catch (error) {
-      logger$1.error(() => ({
-        msg: "Error clearing usage counters",
-        err: error
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.FAIL,
-        error: error.message
-      };
-    }
-  }
-  getRequestArgsSchema() {
-    return types.ClearAllCountersBody;
-  }
-}
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/admin/apiClearAllCountersEndpoint.ts
+/**
+* Admin endpoint: delete every per-sitekey usage counter (optionally scoped
+* to a single dappAccount). Intended for manual integration testing and
+* staging-environment resets — not part of the hot path. Returns the number
+* of Redis keys deleted.
+*/
+var ApiClearAllCountersEndpoint = class {
+	constructor(usageCounters) {
+		this.usageCounters = usageCounters;
+	}
+	async processRequest(args, logger) {
+		logger = logger ? logger.with({}, "admin:counters:clear-all") : (0, _prosopo_logger.getLogger)("info", "provider:admin:counters:clear-all");
+		const dappAccount = args.dapp;
+		const scope = dappAccount ?? "all";
+		try {
+			logger.info(() => ({
+				msg: "Clearing usage counters",
+				data: { scope }
+			}));
+			if (!this.usageCounters) return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.FAIL,
+				error: "Usage counters not available (Redis unreachable)"
+			};
+			const deleted = await this.usageCounters.clearAll(dappAccount);
+			if (deleted === null) return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.FAIL,
+				error: "Counter clear failed"
+			};
+			logger.info(() => ({
+				msg: "Usage counters cleared",
+				data: {
+					scope,
+					deletedCount: deleted
+				}
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+				data: _prosopo_types.ClearAllCountersResponse.parse({
+					success: true,
+					deletedCount: deleted,
+					scope
+				})
+			};
+		} catch (error) {
+			logger.error(() => ({
+				msg: "Error clearing usage counters",
+				err: error
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.FAIL,
+				error: error.message
+			};
+		}
+	}
+	getRequestArgsSchema() {
+		return _prosopo_types.ClearAllCountersBody;
+	}
+};
+//#endregion
 exports.ApiClearAllCountersEndpoint = ApiClearAllCountersEndpoint;

package/dist/cjs/api/admin/apiDnsEventEndpoint.cjs

@@ -1,96 +1,85 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-const enrichDnsEvent = require("../../tasks/dnsEvent/enrichDnsEvent.cjs");
-const dnsEventToFields = (event) => {
-  if (event.kind === "dns") {
-    return { resolverIp: event.src_ip };
-  }
-  const out = {
-    peerIp: event.src_ip
-  };
-  if (typeof event.path_valid === "boolean") {
-    out.pathValid = event.path_valid;
-  }
-  return out;
+const require_enrichDnsEvent = require("../../tasks/dnsEvent/enrichDnsEvent.cjs");
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/admin/apiDnsEventEndpoint.ts
+var dnsEventToFields = (event) => {
+	if (event.kind === "dns") return { resolverIp: event.src_ip };
+	const out = { peerIp: event.src_ip };
+	if (typeof event.path_valid === "boolean") out.pathValid = event.path_valid;
+	return out;
 };
-class ApiDnsEventEndpoint {
-  constructor(db, ipInfoService) {
-    this.db = db;
-    this.ipInfoService = ipInfoService;
-  }
-  async processRequest(args, logger$1) {
-    logger$1 = logger$1 ? logger$1.with({}, "admin:dns-event:ingest") : logger.getLogger("info", "provider:admin:dns-event:ingest");
-    const { events } = args;
-    let stored = 0;
-    let errors = 0;
-    const now = /* @__PURE__ */ new Date();
-    for (const event of events) {
-      const sessionId = event.jti;
-      if (!sessionId) {
-        continue;
-      }
-      try {
-        const fields = dnsEventToFields(event);
-        const matched = await this.db.mergeSessionDnsEvent(
-          sessionId,
-          fields,
-          now
-        );
-        if (matched) {
-          stored += 1;
-          await this.recomputeDnsAsymmetry(sessionId, logger$1);
-        }
-      } catch (err) {
-        errors += 1;
-        logger$1.warn(() => ({
-          err,
-          data: { sessionId, kind: event.kind },
-          msg: "Failed to merge DNS event into session"
-        }));
-      }
-    }
-    logger$1.info(() => ({
-      data: { received: events.length, stored, errors },
-      msg: "Processed DNS event batch"
-    }));
-    return {
-      status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-      data: { stored, errors }
-    };
-  }
-  getRequestArgsSchema() {
-    return types.DnsEventBatchSchema;
-  }
-  async recomputeDnsAsymmetry(sessionId, logger2) {
-    if (!this.ipInfoService) return;
-    try {
-      const session = await this.db.getSessionRecordBySessionId(sessionId);
-      if (!session?.dnsEvent) return;
-      const enriched = await enrichDnsEvent.enrichDnsEvent(
-        session.dnsEvent,
-        this.ipInfoService,
-        session.ipInfo?.ip
-      );
-      const dnsAsymmetry = enrichDnsEvent.computeDnsAsymmetry(enriched, session.ipInfo);
-      if (dnsAsymmetry > 0) {
-        await this.db.updateSessionRecord(sessionId, {
-          scoreComponents: {
-            ...session.scoreComponents,
-            dnsAsymmetry
-          }
-        });
-      }
-    } catch (err) {
-      logger2.warn(() => ({
-        err,
-        data: { sessionId },
-        msg: "Failed to recompute dnsAsymmetry after DNS event merge"
-      }));
-    }
-  }
-}
+var ApiDnsEventEndpoint = class {
+	constructor(db, ipInfoService) {
+		this.db = db;
+		this.ipInfoService = ipInfoService;
+	}
+	async processRequest(args, logger) {
+		logger = logger ? logger.with({}, "admin:dns-event:ingest") : (0, _prosopo_logger.getLogger)("info", "provider:admin:dns-event:ingest");
+		const { events } = args;
+		let stored = 0;
+		let errors = 0;
+		const now = /* @__PURE__ */ new Date();
+		for (const event of events) {
+			const sessionId = event.jti;
+			if (!sessionId) continue;
+			try {
+				const fields = dnsEventToFields(event);
+				if (await this.db.mergeSessionDnsEvent(sessionId, fields, now)) {
+					stored += 1;
+					await this.recomputeDnsAsymmetry(sessionId, logger);
+				}
+			} catch (err) {
+				errors += 1;
+				logger.warn(() => ({
+					err,
+					data: {
+						sessionId,
+						kind: event.kind
+					},
+					msg: "Failed to merge DNS event into session"
+				}));
+			}
+		}
+		logger.info(() => ({
+			data: {
+				received: events.length,
+				stored,
+				errors
+			},
+			msg: "Processed DNS event batch"
+		}));
+		return {
+			status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+			data: {
+				stored,
+				errors
+			}
+		};
+	}
+	getRequestArgsSchema() {
+		return _prosopo_types.DnsEventBatchSchema;
+	}
+	async recomputeDnsAsymmetry(sessionId, logger) {
+		if (!this.ipInfoService) return;
+		try {
+			const session = await this.db.getSessionRecordBySessionId(sessionId);
+			if (!session?.dnsEvent) return;
+			const enriched = await require_enrichDnsEvent.enrichDnsEvent(session.dnsEvent, this.ipInfoService, session.ipInfo?.ip);
+			const dnsAsymmetry = require_enrichDnsEvent.computeDnsAsymmetry(enriched, session.ipInfo);
+			if (dnsAsymmetry > 0) await this.db.updateSessionRecord(sessionId, { scoreComponents: {
+				...session.scoreComponents,
+				dnsAsymmetry
+			} });
+		} catch (err) {
+			logger.warn(() => ({
+				err,
+				data: { sessionId },
+				msg: "Failed to recompute dnsAsymmetry after DNS event merge"
+			}));
+		}
+	}
+};
+//#endregion
 exports.ApiDnsEventEndpoint = ApiDnsEventEndpoint;
 exports.dnsEventToFields = dnsEventToFields;

package/dist/cjs/api/admin/apiGetAllDecisionMachinesEndpoint.cjs

@@ -1,49 +1,47 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-const zod = require("zod");
-class ApiGetAllDecisionMachinesEndpoint {
-  constructor(clientTaskManager) {
-    this.clientTaskManager = clientTaskManager;
-  }
-  async processRequest(args, logger$1) {
-    logger$1 = logger$1 ? logger$1.with({}, "admin:decision-machines:get-all") : logger.getLogger("info", "provider:admin:decision-machines:get-all");
-    try {
-      logger$1.info(() => ({
-        msg: "Getting all decision machines"
-      }));
-      const result = await this.clientTaskManager.getAllDecisionMachines();
-      logger$1.info(() => ({
-        msg: "Retrieved all decision machines",
-        data: { count: result.length }
-      }));
-      logger$1.info(() => ({
-        msg: "Result before parsing",
-        data: { result }
-      }));
-      logger$1.info(() => ({
-        msg: "Schema definition",
-        data: { schema: types.GetAllDecisionMachinesResponse.toString() }
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-        data: types.GetAllDecisionMachinesResponse.parse(result)
-      };
-    } catch (error) {
-      logger$1.error(() => ({
-        msg: "Error getting all decision machines",
-        err: error
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.FAIL,
-        error: error.message
-      };
-    }
-  }
-  getRequestArgsSchema() {
-    return zod.object({});
-  }
-}
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+let zod = require("zod");
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/admin/apiGetAllDecisionMachinesEndpoint.ts
+var ApiGetAllDecisionMachinesEndpoint = class {
+	constructor(clientTaskManager) {
+		this.clientTaskManager = clientTaskManager;
+	}
+	async processRequest(args, logger) {
+		logger = logger ? logger.with({}, "admin:decision-machines:get-all") : (0, _prosopo_logger.getLogger)("info", "provider:admin:decision-machines:get-all");
+		try {
+			logger.info(() => ({ msg: "Getting all decision machines" }));
+			const result = await this.clientTaskManager.getAllDecisionMachines();
+			logger.info(() => ({
+				msg: "Retrieved all decision machines",
+				data: { count: result.length }
+			}));
+			logger.info(() => ({
+				msg: "Result before parsing",
+				data: { result }
+			}));
+			logger.info(() => ({
+				msg: "Schema definition",
+				data: { schema: _prosopo_types.GetAllDecisionMachinesResponse.toString() }
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+				data: _prosopo_types.GetAllDecisionMachinesResponse.parse(result)
+			};
+		} catch (error) {
+			logger.error(() => ({
+				msg: "Error getting all decision machines",
+				err: error
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.FAIL,
+				error: error.message
+			};
+		}
+	}
+	getRequestArgsSchema() {
+		return (0, zod.object)({});
+	}
+};
+//#endregion
 exports.ApiGetAllDecisionMachinesEndpoint = ApiGetAllDecisionMachinesEndpoint;

package/dist/cjs/api/admin/apiGetDecisionMachineEndpoint.cjs

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const apiRoute = require("@prosopo/api-route");
-const logger = require("@prosopo/logger");
-const types = require("@prosopo/types");
-class ApiGetDecisionMachineEndpoint {
-  constructor(clientTaskManager) {
-    this.clientTaskManager = clientTaskManager;
-  }
-  async processRequest(args, logger$1) {
-    logger$1 = logger$1 ? logger$1.with({}, "admin:decision-machine:get") : logger.getLogger("info", "provider:admin:decision-machine:get");
-    try {
-      const { id } = args;
-      logger$1.info(() => ({
-        msg: "Getting decision machine",
-        data: { id }
-      }));
-      const result = await this.clientTaskManager.getDecisionMachine(id);
-      logger$1.info(() => ({
-        msg: "Retrieved decision machine",
-        data: { id }
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.SUCCESS,
-        data: types.GetDecisionMachineResponse.parse(result)
-      };
-    } catch (error) {
-      logger$1.error(() => ({
-        msg: "Error getting decision machine",
-        err: error
-      }));
-      return {
-        status: apiRoute.ApiEndpointResponseStatus.FAIL,
-        error: error.message
-      };
-    }
-  }
-  getRequestArgsSchema() {
-    return types.GetDecisionMachineBody;
-  }
-}
+let _prosopo_logger = require("@prosopo/logger");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_api_route = require("@prosopo/api-route");
+//#region src/api/admin/apiGetDecisionMachineEndpoint.ts
+var ApiGetDecisionMachineEndpoint = class {
+	constructor(clientTaskManager) {
+		this.clientTaskManager = clientTaskManager;
+	}
+	async processRequest(args, logger) {
+		logger = logger ? logger.with({}, "admin:decision-machine:get") : (0, _prosopo_logger.getLogger)("info", "provider:admin:decision-machine:get");
+		try {
+			const { id } = args;
+			logger.info(() => ({
+				msg: "Getting decision machine",
+				data: { id }
+			}));
+			const result = await this.clientTaskManager.getDecisionMachine(id);
+			logger.info(() => ({
+				msg: "Retrieved decision machine",
+				data: { id }
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.SUCCESS,
+				data: _prosopo_types.GetDecisionMachineResponse.parse(result)
+			};
+		} catch (error) {
+			logger.error(() => ({
+				msg: "Error getting decision machine",
+				err: error
+			}));
+			return {
+				status: _prosopo_api_route.ApiEndpointResponseStatus.FAIL,
+				error: error.message
+			};
+		}
+	}
+	getRequestArgsSchema() {
+		return _prosopo_types.GetDecisionMachineBody;
+	}
+};
+//#endregion
 exports.ApiGetDecisionMachineEndpoint = ApiGetDecisionMachineEndpoint;