@uipath/insights-sdk 1.199.0 → 1.200.0-preview.117

package/dist/index.browser.js

@@ -26,6 +26,422 @@ function settlePromiseLike(thenable) {
   ]);
 }
 
+// src/errors.ts
+class InsightsHttpError extends Error {
+  status;
+  method;
+  endpoint;
+  bodyKind;
+  requestId;
+  retryAfterSeconds;
+  constructor(init) {
+    super(`Insights request failed with HTTP ${init.status} for ${init.endpoint}`);
+    this.name = "InsightsHttpError";
+    this.status = init.status;
+    this.method = init.method;
+    this.endpoint = init.endpoint;
+    this.bodyKind = init.bodyKind;
+    this.requestId = init.requestId;
+    this.retryAfterSeconds = init.retryAfterSeconds;
+  }
+}
+
+class InsightsNetworkError extends Error {
+  endpoint;
+  constructor(endpoint, cause) {
+    super(`Insights request failed before a response was received for ${endpoint}`, { cause });
+    this.name = "InsightsNetworkError";
+    this.endpoint = endpoint;
+  }
+}
+
+class InsightsProtocolError extends Error {
+  endpoint;
+  constructor(endpoint, reason) {
+    super(`Insights returned a malformed success response for ${endpoint}: ${reason}`);
+    this.name = "InsightsProtocolError";
+    this.endpoint = endpoint;
+  }
+}
+
+// ../common/src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// ../common/src/telemetry/global-telemetry-properties.ts
+var telemetryPropsSlot = singleton("TelemetryDefaultProps");
+
+// ../common/src/sdk-user-agent.ts
+var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
+function splitUserAgentTokens(value) {
+  return value?.trim().split(/\s+/).filter(Boolean) ?? [];
+}
+function appendUserAgentToken(value, userAgent) {
+  const tokens = splitUserAgentTokens(value);
+  const seen = new Set(tokens);
+  for (const token of splitUserAgentTokens(userAgent)) {
+    if (!seen.has(token)) {
+      tokens.push(token);
+      seen.add(token);
+    }
+  }
+  return tokens.join(" ");
+}
+function getEffectiveUserAgent(userAgent) {
+  return appendUserAgentToken(sdkUserAgentHostToken.get(), userAgent);
+}
+function getSdkUserAgentToken(pkg) {
+  const packageName = pkg.name.replace(/^@uipath\//, "");
+  return getEffectiveUserAgent(`${packageName}/${pkg.version}`);
+}
+// package.json
+var package_default = {
+  name: "@uipath/insights-sdk",
+  license: "MIT",
+  version: "1.200.0-preview.117",
+  description: "SDK for the UiPath Insights API — jobs, failures, and performance metrics.",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/insights-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "insights",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      browser: {
+        types: "./dist/src/index.browser.d.ts",
+        default: "./dist/index.browser.js"
+      },
+      default: {
+        types: "./dist/src/index.d.ts",
+        default: "./dist/index.js"
+      }
+    }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && bun build ./src/index.browser.ts --outdir dist --format esm --target browser --external @uipath/auth --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@types/node": "^25.5.2",
+    typescript: "^7.0.2"
+  }
+};
+
+// src/user-agent.ts
+function buildInsightsUserAgent() {
+  return getSdkUserAgentToken(package_default);
+}
+
+// src/transport.ts
+var SERVICE_ROOTS = {
+  rtm: "insightsrtm_",
+  portal: "insights_/api"
+};
+var INSIGHTS_ROUTES = {
+  alertDefinitionsList: {
+    service: "rtm",
+    method: "POST",
+    template: "AlertDefinitions/getDefinitions/{tenantId}/{accountName}/{tenantName}"
+  },
+  alertDefinitionsListAgentic: {
+    service: "rtm",
+    method: "GET",
+    template: "AlertDefinitions/agentic/{tenantId}/{processKey}"
+  },
+  alertDefinitionsGet: {
+    service: "rtm",
+    method: "GET",
+    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}"
+  },
+  alertDefinitionsCreate: {
+    service: "rtm",
+    method: "POST",
+    template: "AlertDefinitions/{tenantId}/{accountName}/{tenantName}"
+  },
+  alertDefinitionsUpdate: {
+    service: "rtm",
+    method: "PUT",
+    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}/{accountName}/{tenantName}"
+  },
+  alertDefinitionsSnooze: {
+    service: "rtm",
+    method: "PUT",
+    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}/{accountName}/{tenantName}/snooze?isSnoozed={isSnoozed}"
+  },
+  alertDefinitionsDelete: {
+    service: "rtm",
+    method: "DELETE",
+    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}",
+    allowsEmptyResponse: true
+  },
+  alertDefinitionsCheckEntitlement: {
+    service: "rtm",
+    method: "GET",
+    template: "AlertDefinitions/checkEntitlement/{tenantId}"
+  },
+  alertHistoryDetails: {
+    service: "rtm",
+    method: "POST",
+    template: "AlertHistory/details"
+  },
+  alertHistoryMetrics: {
+    service: "rtm",
+    method: "POST",
+    template: "AlertHistory/metrics"
+  },
+  defaultDeliveryGet: {
+    service: "rtm",
+    method: "GET",
+    template: "DefaultDelivery/{tenantId}/{alertDeliveryId}"
+  },
+  filtersAllFolders: {
+    service: "rtm",
+    method: "POST",
+    template: "Filters/allFolders/{accountName}/{tenantName}"
+  },
+  filtersAllProcesses: {
+    service: "rtm",
+    method: "POST",
+    template: "Filters/allProcesses/{accountName}/{tenantName}"
+  },
+  filtersAllQueues: {
+    service: "rtm",
+    method: "POST",
+    template: "Filters/allQueues/{accountName}/{tenantName}"
+  },
+  filtersAllMachines: {
+    service: "rtm",
+    method: "POST",
+    template: "Filters/allMachines"
+  },
+  usersList: { service: "portal", method: "GET", template: "User" },
+  usersGet: { service: "portal", method: "GET", template: "User/{userId}" },
+  rolesList: { service: "portal", method: "GET", template: "Role" },
+  rolesGet: { service: "portal", method: "GET", template: "Role/{roleId}" },
+  groupsList: { service: "portal", method: "GET", template: "Group" },
+  groupsGet: {
+    service: "portal",
+    method: "GET",
+    template: "Group/{groupId}"
+  },
+  authorizationCheckAccess: {
+    service: "portal",
+    method: "POST",
+    template: "Authorization/tenant/insights"
+  }
+};
+function insightsRouteTemplate(routeKey) {
+  return INSIGHTS_ROUTES[routeKey].template;
+}
+var SESSION_PARAM_NAMES = new Set(["tenantId", "accountName", "tenantName"]);
+function sessionPathParams(config) {
+  return {
+    tenantId: config.tenantId,
+    accountName: config.accountName,
+    tenantName: config.tenantName
+  };
+}
+function encodePathSegment(routeKey, name, value) {
+  if (value.trim() === "" || value === "." || value === "..") {
+    throw new Error(`Insights route "${routeKey}" has an invalid value for "{${name}}".`);
+  }
+  return encodeURIComponent(value);
+}
+function buildRoutePath(routeKey, template, config, pathParams) {
+  for (const name of Object.keys(pathParams)) {
+    if (SESSION_PARAM_NAMES.has(name)) {
+      throw new Error(`Insights route segment "{${name}}" is session-derived and cannot be overridden.`);
+    }
+    if (!template.includes(`{${name}}`)) {
+      throw new Error(`Insights route "${routeKey}" has no "{${name}}" segment.`);
+    }
+  }
+  const values = {
+    ...sessionPathParams(config),
+    ...pathParams
+  };
+  return template.replace(/\{([A-Za-z]+)\}/g, (_, name) => {
+    const value = values[name];
+    if (value === undefined) {
+      throw new Error(`Insights route "${routeKey}" is missing a value for "{${name}}".`);
+    }
+    return encodePathSegment(routeKey, name, value);
+  });
+}
+function buildServiceHeaders(config, service, hasBody) {
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    Accept: "application/json"
+  };
+  if (hasBody) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (service === "rtm") {
+    headers["X-UiPath-Internal-AccountName"] = config.accountName;
+    headers["X-UiPath-Internal-TenantName"] = config.tenantName;
+  } else {
+    headers["X-UiPath-Internal-AccountId"] = config.organizationId;
+    headers["X-UiPath-Internal-TenantId"] = config.tenantId;
+  }
+  const userAgent = buildInsightsUserAgent();
+  if (userAgent) {
+    headers["User-Agent"] = userAgent;
+  }
+  return headers;
+}
+function classifyErrorBody(text) {
+  if (!text.trim()) {
+    return "absent";
+  }
+  const head = text.trimStart().toLowerCase();
+  if (head.startsWith("<!doctype") || head.startsWith("<html")) {
+    return "html";
+  }
+  const [parseError] = catchError(() => JSON.parse(text));
+  if (!parseError) {
+    return "json";
+  }
+  return head.startsWith("{") || head.startsWith("[") ? "invalid-json" : "text";
+}
+function parseRetryAfterSeconds(header) {
+  if (header === null) {
+    return;
+  }
+  const seconds = Number.parseInt(header, 10);
+  return Number.isNaN(seconds) || seconds < 0 ? undefined : seconds;
+}
+async function requestInsightsRoute(config, routeKey, request = {}) {
+  const route = INSIGHTS_ROUTES[routeKey];
+  if (!route) {
+    throw new Error(`Unsupported Insights route "${routeKey}".`);
+  }
+  const path = buildRoutePath(routeKey, route.template, config, request.pathParams ?? {});
+  const url = `${config.baseUrl}/${encodePathSegment(routeKey, "organizationId", config.organizationId)}/${encodePathSegment(routeKey, "tenantName", config.tenantName)}/${SERVICE_ROOTS[route.service]}/${path}`;
+  const hasBody = request.body !== undefined;
+  const [fetchError, response] = await catchError(fetch(url, {
+    method: route.method,
+    headers: buildServiceHeaders(config, route.service, hasBody),
+    body: hasBody ? JSON.stringify(request.body) : undefined
+  }));
+  if (fetchError) {
+    throw new InsightsNetworkError(route.template, fetchError);
+  }
+  const [readError, text] = await catchError(response.text());
+  if (readError) {
+    throw new InsightsNetworkError(route.template, readError);
+  }
+  if (!response.ok) {
+    throw new InsightsHttpError({
+      status: response.status,
+      method: route.method,
+      endpoint: route.template,
+      bodyKind: classifyErrorBody(text),
+      requestId: response.headers.get("x-request-id") ?? undefined,
+      retryAfterSeconds: parseRetryAfterSeconds(response.headers.get("retry-after"))
+    });
+  }
+  if (!text.trim()) {
+    if (route.allowsEmptyResponse) {
+      return;
+    }
+    throw new InsightsProtocolError(route.template, "empty response body");
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(text));
+  if (parseError) {
+    throw new InsightsProtocolError(route.template, "response body is not valid JSON");
+  }
+  return parsed;
+}
+
+// src/alerts.ts
+async function listAlertDefinitions(config, request) {
+  return requestInsightsRoute(config, "alertDefinitionsList", {
+    body: request ?? {}
+  });
+}
+async function listAgenticAlertDefinitions(config, processKey) {
+  return requestInsightsRoute(config, "alertDefinitionsListAgentic", {
+    pathParams: { processKey }
+  });
+}
+async function getAlertDefinition(config, alertDefinitionId) {
+  return requestInsightsRoute(config, "alertDefinitionsGet", {
+    pathParams: { alertDefinitionId }
+  });
+}
+async function deleteAlertDefinition(config, alertDefinitionId) {
+  return requestInsightsRoute(config, "alertDefinitionsDelete", {
+    pathParams: { alertDefinitionId }
+  });
+}
+async function checkAlertEntitlement(config) {
+  return requestInsightsRoute(config, "alertDefinitionsCheckEntitlement");
+}
+function withSessionTenantId(config, request) {
+  const base = typeof request === "object" && request !== null && !Array.isArray(request) ? request : {};
+  return { ...base, tenantId: config.tenantId };
+}
+async function listAlertHistoryDetails(config, request) {
+  return requestInsightsRoute(config, "alertHistoryDetails", {
+    body: withSessionTenantId(config, request)
+  });
+}
+async function getAlertHistoryMetrics(config, request) {
+  return requestInsightsRoute(config, "alertHistoryMetrics", {
+    body: withSessionTenantId(config, request)
+  });
+}
+async function getDefaultDelivery(config, alertDeliveryId) {
+  return requestInsightsRoute(config, "defaultDeliveryGet", {
+    pathParams: { alertDeliveryId }
+  });
+}
 // src/client.ts
 function buildInsightsUrl(config, path) {
   return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/insightsrtm_/api/v1.0/InsightsJobs${path}`;
@@ -80,9 +496,128 @@ async function createInsightsConfig(tenantOverride) {
     tenantName: ctx.tenantName
   };
 }
+// src/types.ts
+function isStringArrayOrNullish(value) {
+  if (value === undefined || value === null) {
+    return true;
+  }
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function hasStringArrayFields(value, fields) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!fields.every((field) => isStringArrayOrNullish(record[field]))) {
+    return false;
+  }
+  return Object.keys(record).length === 0 || fields.some((field) => (field in record));
+}
+function isFolderFiltersResponse(value) {
+  return hasStringArrayFields(value, [
+    "folderKeys",
+    "folderNames"
+  ]);
+}
+function isProcessFiltersResponse(value) {
+  return hasStringArrayFields(value, [
+    "processNames",
+    "folderKeys",
+    "processKeys",
+    "processVersions",
+    "projectKeys"
+  ]);
+}
+function isQueueFiltersResponse(value) {
+  return hasStringArrayFields(value, [
+    "queueNames",
+    "folderKeys"
+  ]);
+}
+function isMachineFiltersResponse(value) {
+  return hasStringArrayFields(value, [
+    "filterOptions",
+    "filtersExtraOptions"
+  ]);
+}
+
+// src/filters.ts
+async function listFilters(config, routeKey, guard, contractName) {
+  const parsed = await requestInsightsRoute(config, routeKey, {
+    body: { tenantId: config.tenantId }
+  });
+  if (!guard(parsed)) {
+    throw new InsightsProtocolError(insightsRouteTemplate(routeKey), `body does not match the ${contractName} contract`);
+  }
+  return parsed;
+}
+async function listFolderFilters(config) {
+  return listFilters(config, "filtersAllFolders", isFolderFiltersResponse, "folder filters");
+}
+async function listProcessFilters(config) {
+  return listFilters(config, "filtersAllProcesses", isProcessFiltersResponse, "process filters");
+}
+async function listQueueFilters(config) {
+  return listFilters(config, "filtersAllQueues", isQueueFiltersResponse, "queue filters");
+}
+async function listMachineFilters(config) {
+  return listFilters(config, "filtersAllMachines", isMachineFiltersResponse, "machine filters");
+}
+// src/rbac.ts
+async function listUsers(config) {
+  return requestInsightsRoute(config, "usersList");
+}
+async function getUser(config, userId) {
+  return requestInsightsRoute(config, "usersGet", {
+    pathParams: { userId }
+  });
+}
+async function listRoles(config) {
+  return requestInsightsRoute(config, "rolesList");
+}
+async function getRole(config, roleId) {
+  return requestInsightsRoute(config, "rolesGet", {
+    pathParams: { roleId }
+  });
+}
+async function listGroups(config) {
+  return requestInsightsRoute(config, "groupsList");
+}
+async function getGroup(config, groupId) {
+  return requestInsightsRoute(config, "groupsGet", {
+    pathParams: { groupId }
+  });
+}
+async function checkInsightsAccess(config, request) {
+  return requestInsightsRoute(config, "authorizationCheckAccess", {
+    body: request
+  });
+}
 export {
+  listUsers,
+  listRoles,
+  listQueueFilters,
+  listProcessFilters,
+  listMachineFilters,
+  listGroups,
+  listFolderFilters,
+  listAlertHistoryDetails,
+  listAlertDefinitions,
+  listAgenticAlertDefinitions,
   insightsPost,
-  createInsightsConfig
+  getUser,
+  getRole,
+  getGroup,
+  getDefaultDelivery,
+  getAlertHistoryMetrics,
+  getAlertDefinition,
+  deleteAlertDefinition,
+  createInsightsConfig,
+  checkInsightsAccess,
+  checkAlertEntitlement,
+  InsightsProtocolError,
+  InsightsNetworkError,
+  InsightsHttpError
 };
 
-//# debugId=D4177847864883E864756E2164756E21
+//# debugId=98D65697D55F700864756E2164756E21