@uipath/vertical-solutions-tool 1.204.0 → 1.205.0-preview.258

package/dist/tool-4z1dy1rn.js

@@ -0,0 +1,260 @@
+import {
+  optionalText
+} from "./tool-87e2ps7f.js";
+import {
+  exports_external
+} from "./tool-vf2mgth0.js";
+import {
+  catchError
+} from "./tool-pz9qm3dv.js";
+
+// src/api/vss-errors.ts
+class VssResponseError extends Error {
+  transient;
+  name = "VssResponseError";
+  constructor(message, transient = false) {
+    super(message);
+    this.transient = transient;
+  }
+}
+
+class VssApiError extends Error {
+  status;
+  statusText;
+  code;
+  correlationId;
+  details;
+  name = "VssApiError";
+  response;
+  constructor(message, status, statusText, code, correlationId, details, body = "") {
+    super(message);
+    this.status = status;
+    this.statusText = statusText;
+    this.code = code;
+    this.correlationId = correlationId;
+    this.details = details;
+    this.response = {
+      status,
+      statusText,
+      text: () => Promise.resolve(body)
+    };
+  }
+}
+function isCapacityError(error) {
+  return error instanceof VssApiError && error.status === 429;
+}
+function isTransientError(error) {
+  if (error instanceof VssResponseError)
+    return error.transient;
+  if (error instanceof VssApiError) {
+    return error.status === 429 || error.status >= 500;
+  }
+  return true;
+}
+function errorCodeOf(error) {
+  return error instanceof VssApiError ? error.code : undefined;
+}
+var RequiredVersionDetailsSchema = exports_external.object({ requiredVersion: exports_external.string() });
+function requiredVersionOf(error) {
+  if (!(error instanceof VssApiError))
+    return;
+  return RequiredVersionDetailsSchema.safeParse(error.details).data?.requiredVersion;
+}
+var ProblemSchema = exports_external.looseObject({
+  code: optionalText,
+  message: optionalText,
+  correlationId: optionalText,
+  details: exports_external.unknown().optional()
+});
+function toApiError(status, statusText, body, url) {
+  const [, json] = catchError(() => JSON.parse(body));
+  const problem = ProblemSchema.safeParse(json).data;
+  return new VssApiError(problem?.message || `Request to ${url} failed: ${status} ${statusText}`, status, statusText, problem?.code, problem?.correlationId, problem?.details, body);
+}
+
+// src/api/vss-client.ts
+var DEFAULT_TIMEOUT_MS = 30000;
+var DOWNLOAD_TIMEOUT_MS = 300000;
+var SEGMENT_PATTERNS = {
+  packageName: /^[A-Za-z0-9._-]+$/,
+  version: /^[0-9A-Za-z.+-]+$/,
+  id: /^[A-Za-z0-9._-]+$/
+};
+
+class VssInputError extends Error {
+  kind;
+  value;
+  constructor(kind, value) {
+    super(`Invalid ${kind} "${value}".`);
+    this.kind = kind;
+    this.value = value;
+    this.name = "VssInputError";
+  }
+}
+function isSafeSegment(kind, value) {
+  return SEGMENT_PATTERNS[kind].test(value) && !/^\.+$/.test(value);
+}
+function encodeSegment(kind, value) {
+  if (!isSafeSegment(kind, value)) {
+    throw new VssInputError(kind, value);
+  }
+  return encodeURIComponent(value);
+}
+function buildHeaders(config, extra) {
+  const headers = {
+    Authorization: `Bearer ${config.accessToken}`,
+    Accept: "application/json"
+  };
+  if (config.sendScopeIds) {
+    if (config.organizationId) {
+      headers["x-uipath-organizationid"] = config.organizationId;
+    }
+    if (config.tenantId)
+      headers["x-uipath-tenantid"] = config.tenantId;
+  }
+  return { ...headers, ...extra };
+}
+function scopeQuery(config) {
+  if (!config.sendScopeIds)
+    return {};
+  return {
+    organizationId: config.organizationId,
+    tenantId: config.tenantId
+  };
+}
+function buildUrl(config, path, query) {
+  const url = new URL(`${config.basePath}/${path.replace(/^\/+/, "")}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== undefined)
+      url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function wasTimedOut(error) {
+  return error.name === "TimeoutError";
+}
+async function vssRequest(config, path, options = {}) {
+  const url = buildUrl(config, path, options.query);
+  const headers = buildHeaders(config, options.body === undefined ? undefined : { "Content-Type": "application/json" });
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body === undefined ? undefined : JSON.stringify(options.body),
+    signal: combineSignals(options.signal, options.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+  });
+  const [readError, text] = await catchError(response.text());
+  if (readError || text === undefined) {
+    const reason = readError?.message ?? "the body was empty";
+    const stoppedByCaller = options.signal?.aborted === true;
+    if (readError && (stoppedByCaller || response.ok && wasTimedOut(readError))) {
+      throw readError;
+    }
+    if (!response.ok) {
+      throw new VssApiError(`Request to ${url} failed: ${response.status} ` + `${response.statusText}; the body could not be read: ${reason}`, response.status, response.statusText);
+    }
+    throw new VssResponseError(`Could not read the response from ${url}: ${reason}`, true);
+  }
+  if (!response.ok) {
+    throw toApiError(response.status, response.statusText, text, url);
+  }
+  if (!text)
+    return;
+  const [parseError, parsed] = catchError(() => JSON.parse(text));
+  if (parseError) {
+    throw new VssResponseError(`Failed to parse the response from ${url}: ${parseError.message}`);
+  }
+  return parsed;
+}
+async function vssRequestJson(config, path, options = {}) {
+  const result = await vssRequest(config, path, options);
+  if (result === undefined) {
+    throw new VssResponseError(`The service returned an empty body for ${path}.`);
+  }
+  return result;
+}
+async function vssRequestParsed(config, path, schema, options = {}) {
+  const body = await vssRequestJson(config, path, options);
+  const parsed = schema.safeParse(body, { error: describeUnreadableField });
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0]?.message ?? "with a body the CLI cannot read.";
+    throw new VssResponseError(`The service answered ${path} ${issue}`);
+  }
+  return parsed.data;
+}
+var describeUnreadableField = (issue) => {
+  const field = issue.path && issue.path.length > 0 ? `"${issue.path.join(".")}"` : "the body";
+  const expected = issue.code === "invalid_type" ? ` (expected ${issue.expected})` : "";
+  return `with a body the CLI cannot read: ${field} is not valid${expected}.`;
+};
+async function vssRequestBinary(config, path, options = {}) {
+  const url = buildUrl(config, path, options.query);
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers: buildHeaders(config, { Accept: "application/zip" }),
+    signal: combineSignals(options.signal, options.timeoutMs ?? DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const [bodyError, body] = await catchError(readBodyWithin(response, url, options.maxBytes));
+    if (bodyError && options.signal?.aborted === true)
+      throw bodyError;
+    if (bodyError && !(bodyError instanceof DownloadTooLargeError)) {
+      throw new VssApiError(`Request to ${url} failed: ${response.status} ` + `${response.statusText}; the body could not be read: ${bodyError.message}`, response.status, response.statusText);
+    }
+    throw toApiError(response.status, response.statusText, body ? new TextDecoder().decode(body) : "", url);
+  }
+  return {
+    bytes: await readBodyWithin(response, url, options.maxBytes),
+    headers: response.headers
+  };
+}
+
+class DownloadTooLargeError extends Error {
+}
+async function readBodyWithin(response, url, maxBytes) {
+  if (maxBytes === undefined) {
+    return new Uint8Array(await response.arrayBuffer());
+  }
+  const tooLarge = () => new DownloadTooLargeError(`The download from ${url} is larger than ${maxBytes} bytes; refusing it.`);
+  if (Number(response.headers.get("content-length") ?? 0) > maxBytes) {
+    if (response.body)
+      await catchError(response.body.cancel());
+    throw tooLarge();
+  }
+  if (!response.body) {
+    const whole = new Uint8Array(await response.arrayBuffer());
+    if (whole.length > maxBytes)
+      throw tooLarge();
+    return whole;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.length;
+    if (size > maxBytes) {
+      await catchError(reader.cancel());
+      throw tooLarge();
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+function combineSignals(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  if (!signal)
+    return timeout;
+  return AbortSignal.any([signal, timeout]);
+}
+
+export { VssResponseError, VssApiError, isCapacityError, isTransientError, errorCodeOf, requiredVersionOf, VssInputError, isSafeSegment, encodeSegment, scopeQuery, vssRequestParsed, vssRequestBinary };
+
+//# debugId=A01840E2A19A371364756E2164756E21

package/dist/tool-53w8skv5.js

@@ -0,0 +1,262 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/clients/generated/first-party-service.js
+var first_party_service_DeploymentAction = /* @__PURE__ */ function(DeploymentAction) {
+  DeploymentAction["Install"] = "Install";
+  DeploymentAction["Link"] = "Link";
+  DeploymentAction["Uninstall"] = "Uninstall";
+  DeploymentAction["Unlink"] = "Unlink";
+  DeploymentAction["Merge"] = "Merge";
+  DeploymentAction["UseExisting"] = "UseExisting";
+  DeploymentAction["Activate"] = "Activate";
+  return DeploymentAction;
+}({});
+var first_party_service_SolutionDeploymentAction = /* @__PURE__ */ function(SolutionDeploymentAction) {
+  SolutionDeploymentAction["Install"] = "Install";
+  SolutionDeploymentAction["Uninstall"] = "Uninstall";
+  SolutionDeploymentAction["Upgrade"] = "Upgrade";
+  SolutionDeploymentAction["Rollback"] = "Rollback";
+  SolutionDeploymentAction["Activate"] = "Activate";
+  return SolutionDeploymentAction;
+}({});
+var first_party_service_SolutionStatus = /* @__PURE__ */ function(SolutionStatus) {
+  SolutionStatus["Installed"] = "Installed";
+  SolutionStatus["Uninstalled"] = "Uninstalled";
+  SolutionStatus["Installing"] = "Installing";
+  SolutionStatus["Uninstalling"] = "Uninstalling";
+  SolutionStatus["InstallError"] = "InstallError";
+  SolutionStatus["UninstallError"] = "UninstallError";
+  SolutionStatus["Unknown"] = "Unknown";
+  return SolutionStatus;
+}({});
+var first_party_service_QueryOptions = /* @__PURE__ */ function(QueryOptions) {
+  QueryOptions["Contains"] = "Contains";
+  QueryOptions["Equals"] = "Equals";
+  return QueryOptions;
+}({});
+var first_party_service_DeploymentResourceValidationErrorLevel = /* @__PURE__ */ function(DeploymentResourceValidationErrorLevel) {
+  DeploymentResourceValidationErrorLevel["Error"] = "Error";
+  DeploymentResourceValidationErrorLevel["Warning"] = "Warning";
+  DeploymentResourceValidationErrorLevel["Info"] = "Info";
+  return DeploymentResourceValidationErrorLevel;
+}({});
+var first_party_service_DeploymentResourceValidationErrorKind = /* @__PURE__ */ function(DeploymentResourceValidationErrorKind) {
+  DeploymentResourceValidationErrorKind["Conflict"] = "Conflict";
+  DeploymentResourceValidationErrorKind["ConfigurationError"] = "ConfigurationError";
+  return DeploymentResourceValidationErrorKind;
+}({});
+var first_party_service_DeploymentResourceValidationAction = /* @__PURE__ */ function(DeploymentResourceValidationAction) {
+  DeploymentResourceValidationAction["RenameExisting"] = "RenameExisting";
+  DeploymentResourceValidationAction["RenameInSolution"] = "RenameInSolution";
+  DeploymentResourceValidationAction["UseExisting"] = "UseExisting";
+  DeploymentResourceValidationAction["FixConfiguration"] = "FixConfiguration";
+  DeploymentResourceValidationAction["Delete"] = "Delete";
+  DeploymentResourceValidationAction["SkipDelete"] = "SkipDelete";
+  DeploymentResourceValidationAction["MergeConfiguration"] = "MergeConfiguration";
+  DeploymentResourceValidationAction["Replace"] = "Replace";
+  return DeploymentResourceValidationAction;
+}({});
+var first_party_service_ContentType = /* @__PURE__ */ function(ContentType) {
+  ContentType["Json"] = "application/json";
+  ContentType["JsonApi"] = "application/vnd.api+json";
+  ContentType["FormData"] = "multipart/form-data";
+  ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+  ContentType["Text"] = "text/plain";
+  return ContentType;
+}({});
+
+class HttpClient {
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value == "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter((key) => query[key] !== undefined);
+    return keys.map((key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://localhost:7008";
+    this.securityData = null;
+    this.abortControllers = new Map;
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["application/vnd.api+json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["text/plain"]: (input) => input !== null && typeof input != "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data"]: (input) => {
+        if (input instanceof FormData)
+          return input;
+        return Object.keys(input || {}).reduce((formData, key) => {
+          const property = input[key];
+          formData.append(key, property instanceof Blob ? property : typeof property == "object" && property !== null ? JSON.stringify(property) : `${property}`);
+          return formData;
+        }, new FormData);
+      },
+      ["application/x-www-form-urlencoded"]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController2 = this.abortControllers.get(cancelToken);
+        if (abortController2)
+          return abortController2.signal;
+        return;
+      }
+      const abortController = new AbortController;
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+      const secureParams = (typeof secure == "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json"];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type && type !== "multipart/form-data" ? {
+            "Content-Type": type
+          } : {}
+        },
+        signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+        body: body == null ? null : payloadFormatter(body)
+      }).then(async (response) => {
+        const r = response;
+        r.data = null;
+        r.error = null;
+        const responseToParse = responseFormat ? response.clone() : response;
+        const data = responseFormat ? await responseToParse[responseFormat]().then((data2) => {
+          if (r.ok)
+            r.data = data2;
+          else
+            r.error = data2;
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        }) : r;
+        if (cancelToken)
+          this.abortControllers.delete(cancelToken);
+        if (!response.ok)
+          throw data;
+        return data.data;
+      });
+    };
+    Object.assign(this, apiConfig);
+  }
+}
+
+class FirstPartyServiceApi extends HttpClient {
+  constructor(...args) {
+    super(...args), this.v2 = {
+      automationSolutionsGetMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "GET",
+        ...params
+      }),
+      automationSolutionsHeadMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "HEAD",
+        ...params
+      }),
+      automationSolutionsSetState: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PATCH",
+        query,
+        body: data,
+        type: "application/json",
+        ...params
+      }),
+      automationSolutionsInstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PUT",
+        query,
+        body: data,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsUninstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "DELETE",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsExport: (data, params = {}) => this.request({
+        path: "/v2/automationsolutions/export",
+        method: "POST",
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsGetTranslations: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/translations",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsValidate: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions/validate",
+        method: "POST",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsLookup: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/lookup",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      })
+    };
+  }
+}
+export { first_party_service_DeploymentAction, first_party_service_SolutionDeploymentAction, first_party_service_SolutionStatus, first_party_service_QueryOptions, first_party_service_DeploymentResourceValidationErrorLevel, first_party_service_DeploymentResourceValidationErrorKind, first_party_service_DeploymentResourceValidationAction, first_party_service_ContentType, HttpClient, FirstPartyServiceApi };
+
+//# debugId=AC88CC622210E15664756E2164756E21