@uipath/solution-tool 1.203.0-preview.203 → 1.204.0-preview.206

package/dist/{packager-tool-j2cqgegq.js → packager-tool-he7ak44z.js}

@@ -1,25 +1,25 @@
 import {
   Configuration,
-  PipelinesApi,
+  PipelinesApi
+} from "./packager-tool-qgaqqq41.js";
+import {
   feedScopeInitOverride,
   resolveFeedScope
-} from "./packager-tool-h4wn0y42.js";
-import {
-  Configuration as Configuration2,
-  PackagesApi
-} from "./packager-tool-ge4rvy7p.js";
+} from "./packager-tool-dh0m3ebf.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-2syrt51a.js";
+} from "./packager-tool-f5gq77m5.js";
 import {
   PollOutcome,
   catchError,
   extractErrorDetails,
-  getFileSystem,
   logger,
   mapPollFailure,
   pollUntil
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getFileSystem
+} from "./packager-tool-zf3929se.js";
 import {
   strFromU8,
   strToU8,
@@ -248,15 +248,16 @@ async function publishSolutionAsync(packagePath, options = {}) {
       message: scopeError.message
     };
   }
-  if (scope.kind !== "tenant") {
-    return publishToFeed(auth, fileBuffer, scope, options);
-  }
   const configuration = new Configuration({
     basePath: auth.basePath,
     accessToken: auth.accessToken
   });
   const api = new PipelinesApi(configuration);
-  const [uploadError, uploadResult] = await catchError(api.pipelinesPackageUpload({ body: fileBuffer }));
+  const feedScope = feedScopeInitOverride(scope);
+  const [uploadError, uploadResult] = await catchError(api.pipelinesPackageUpload({
+    body: fileBuffer,
+    locationKey: scope.folderKey
+  }));
   if (uploadError) {
     return mapUploadError(uploadError);
   }
@@ -266,7 +267,7 @@ async function publishSolutionAsync(packagePath, options = {}) {
       fn: () => api.pipelinesGetPackageVersion({
         packageName: uploadResult.packageName,
         packageVersion: uploadResult.packageVersion
-      }),
+      }, feedScope),
       until: (result) => TERMINAL_STATES.has(result.state),
       getStatus: (result) => result.state,
       label: `publish ${uploadResult.packageName}:${uploadResult.packageVersion}`,
@@ -301,65 +302,6 @@ async function publishSolutionAsync(packagePath, options = {}) {
     packageName: packageVersionInfo.packageName,
     packageVersion: packageVersionInfo.packageVersion,
     state: packageVersionInfo.state,
-    feedKind: "tenant"
-  };
-}
-async function publishToFeed(auth, fileBuffer, scope, options) {
-  const config = new Configuration2({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  });
-  const api = new PackagesApi(config);
-  const [uploadError, packageVersionKey] = await catchError(api.packagesUpload({
-    body: fileBuffer,
-    locationKey: scope.folderKey
-  }));
-  if (uploadError) {
-    return mapUploadError(uploadError);
-  }
-  const feedScope = feedScopeInitOverride(scope);
-  const [getError, initialInfo] = await catchError(api.packagesGetVersion({ packageVersionKey }, feedScope));
-  if (getError) {
-    logger.warn(`Package uploaded (key ${packageVersionKey}) but its metadata was not yet retrievable; PackageName/PackageVersion/State will be absent from output: ${getError.message}`);
-  }
-  let packageVersionInfo = getError ? undefined : initialInfo;
-  if (options.wait) {
-    const pollResult = await pollUntil({
-      fn: () => api.packagesGetVersion({ packageVersionKey }, feedScope),
-      until: (result) => TERMINAL_STATES.has(result.state),
-      getStatus: (result) => result.state,
-      label: `publish ${packageVersionInfo ? `${packageVersionInfo.packageName}:${packageVersionInfo.packageVersion}` : packageVersionKey}`,
-      logPrefix: "publish",
-      timeoutMs: (options.timeout ?? 360) * 1000,
-      intervalMs: options.pollInterval ?? 5000,
-      signal: options.signal
-    });
-    if (pollResult.outcome !== PollOutcome.Completed) {
-      const { reason, message } = mapPollFailure(pollResult, "Package publish");
-      return { ok: false, reason, message };
-    }
-    if (!pollResult.data) {
-      return {
-        ok: false,
-        reason: "poll_failed",
-        message: "Package publish did not return a final state."
-      };
-    }
-    packageVersionInfo = pollResult.data;
-    if (packageVersionInfo.state === "Failed") {
-      return {
-        ok: false,
-        reason: "publish_failed",
-        message: `Package publish failed with state: ${packageVersionInfo.state}`
-      };
-    }
-  }
-  return {
-    ok: true,
-    packageVersionKey: packageVersionInfo?.key ?? packageVersionKey,
-    packageName: packageVersionInfo?.packageName,
-    packageVersion: packageVersionInfo?.packageVersion,
-    state: packageVersionInfo?.state,
     feedKind: scope.kind
   };
 }
@@ -392,4 +334,4 @@ async function mapUploadError(uploadError) {
 
 export { publishSolutionAsync };
 
-//# debugId=A863118C75768F1764756E2164756E21
+//# debugId=1A9ADF95167C0E9D64756E2164756E21

package/dist/packager-tool-myn57mc3.js

@@ -0,0 +1,322 @@
+import {
+  Configuration as Configuration2,
+  PipelinesApi
+} from "./packager-tool-qgaqqq41.js";
+import {
+  Configuration,
+  DeploymentSearchItemDto2FromJSON,
+  SearchApi
+} from "./packager-tool-t12hj6pd.js";
+import {
+  classifyFeedSession
+} from "./packager-tool-bqre28m1.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/http-status.ts
+function httpStatusOf(error) {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const response = error.response;
+  const fromResponse = response && typeof response === "object" ? response.status : undefined;
+  const status = typeof fromResponse === "number" ? fromResponse : error.status;
+  return typeof status === "number" ? status : undefined;
+}
+function isAuthRefusal(error) {
+  const status = httpStatusOf(error);
+  return status === 401 || status === 403;
+}
+
+// src/services/legacy-deployment-search-v3.ts
+async function searchDeploymentsLegacyV3(auth, query, scope) {
+  const api = new SearchApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const result = await api.searchSearchDeployments22({ deploymentsSearchRequest2: toLegacyV3Request(query) }, scope);
+  const values = result.values ?? [];
+  return { count: result.count, values };
+}
+function toLegacyV3Request(query) {
+  return {
+    searchTerm: query.searchTerm ?? query.deploymentName ?? query.packageName,
+    packageName: query.packageName,
+    ...query.targetFolderName ? { targetFolderName: query.targetFolderName } : {},
+    take: query.take,
+    skip: query.skip,
+    orderByColumn: query.orderByColumn,
+    orderByDirection: query.orderByDirection,
+    operationStatuses: query.operationStatuses ?? [],
+    activationStatuses: query.activationStatuses ?? []
+  };
+}
+
+// src/services/deployment-search-client.ts
+var PIPELINES_SEARCH_ROUTE = "POST /v1/pipelines/deployments/search";
+
+class DeploymentSearchNeedsUserSessionError extends Error {
+  constructor() {
+    super("This server's deployment search reads user sessions only; an application (client-credentials) login cannot read it. Sign in with 'uip login' to use it.");
+    this.name = "DeploymentSearchNeedsUserSessionError";
+  }
+}
+var serversWithoutPipelinesSearch = new Set;
+async function isMissingPipelinesSearchRoute(error) {
+  const status = httpStatusOf(error);
+  if (status === 405) {
+    return true;
+  }
+  if (status !== 404) {
+    return false;
+  }
+  const response = error.response;
+  const [, body] = await catchError(response ? response.clone().text() : Promise.resolve(""));
+  return (body ?? "").trim() === "";
+}
+async function searchDeploymentsPage(auth, query, scope) {
+  if (!serversWithoutPipelinesSearch.has(auth.basePath)) {
+    const [error, page2] = await catchError(searchViaPipelines(auth, query, scope));
+    if (!error) {
+      return { ...page2, source: "pipelines" };
+    }
+    if (!await isMissingPipelinesSearchRoute(error)) {
+      throw error;
+    }
+    serversWithoutPipelinesSearch.add(auth.basePath);
+    logger.debug(`${PIPELINES_SEARCH_ROUTE} is not served at ${auth.basePath}; using the deprecated POST /api/v3/search/deployments.`);
+  }
+  if (classifyFeedSession(auth) === "application") {
+    throw new DeploymentSearchNeedsUserSessionError;
+  }
+  const page = await searchDeploymentsLegacyV3(auth, query, scope);
+  return { ...page, source: "legacy-v3" };
+}
+async function searchViaPipelines(auth, query, scope) {
+  const api = new PipelinesApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const response = await api.pipelinesSearchDeploymentsRaw({
+    pipelineDeploymentsSearchRequest: {
+      take: query.take,
+      skip: query.skip,
+      deploymentName: query.deploymentName,
+      packageName: query.packageName,
+      targetFolderName: query.targetFolderName,
+      searchTerm: query.searchTerm,
+      orderByColumn: query.orderByColumn,
+      orderByDirection: query.orderByDirection,
+      operationStatuses: query.operationStatuses,
+      activationStatuses: query.activationStatuses
+    }
+  }, scope);
+  const body = await response.raw.json();
+  const values = (body.values ?? []).map((row) => DeploymentSearchItemDto2FromJSON(row));
+  return { count: body.count, values };
+}
+
+// src/services/deployment-search.ts
+async function findDeploymentByName(auth, deploymentName, scope) {
+  return newestDeploymentRow(await findDeploymentsByName(auth, deploymentName, scope));
+}
+async function findLiveDeploymentByName(auth, deploymentName, scope) {
+  const newest = await findDeploymentByName(auth, deploymentName, scope);
+  return isCompletedUninstall(newest) ? undefined : newest;
+}
+function isCompletedUninstall(row) {
+  return row?.operation === "Uninstall" && row.operationStatus === "Successful";
+}
+async function findDeploymentsByPackageName(auth, packageName, options = {}) {
+  const take = 50;
+  const maxPages = 20;
+  const matches = [];
+  for (let page = 0, skip = 0;page < maxPages; page++) {
+    const result = await searchDeploymentsPage(auth, { packageName, take, skip }, options.scope);
+    const values = result.values ?? [];
+    for (const deployment of values) {
+      if (deployment.packageName === packageName && (options.folderPath === undefined || deployment.folderPath === options.folderPath)) {
+        matches.push(deployment);
+      }
+    }
+    if (values.length < take) {
+      break;
+    }
+    skip += values.length;
+  }
+  return matches;
+}
+async function findCurrentDeploymentAsync(auth, deployment, scope) {
+  const installKey = deployment.installDeploymentKey ?? deployment.key;
+  const rows = await findDeploymentsByPackageName(auth, deployment.packageName, { scope });
+  return rows.find((row) => (row.installDeploymentKey ?? row.key) === installKey);
+}
+function blocksRedeploy(deployment) {
+  if (deployment.operationStatus === "InProgress") {
+    return true;
+  }
+  if (deployment.operationStatus === "Successful") {
+    return deployment.operation !== "Uninstall";
+  }
+  if (deployment.operationStatus === "Draft" || deployment.operationStatus === "Failed" || deployment.operationStatus === "FailedRollback") {
+    return deployment.operation !== undefined && deployment.operation !== null && deployment.operation !== "Install";
+  }
+  return false;
+}
+var MAX_LISTED_DEPLOYMENTS = 5;
+function formatExistingDeployments(deployments, folderByKey) {
+  const described = deployments.slice(0, MAX_LISTED_DEPLOYMENTS).map((deployment) => {
+    const resolved = deployment.installedRootFolderKey ? folderByKey?.get(deployment.installedRootFolderKey) : undefined;
+    const folder = resolved ?? deployment.folderPath ?? "an unknown folder";
+    const current = deployment.currentPackageVersion ?? deployment.packageVersion ?? "an unknown version";
+    const target = deployment.targetPackageVersion ?? deployment.newPackageVersionAvailable;
+    const version = target && target !== current ? `${current} → ${target}` : current;
+    const state = [
+      deployment.operation,
+      deployment.operationStatus,
+      deployment.activationStatus
+    ].filter((part) => part !== undefined && part !== null).join("/");
+    return `'${deployment.name}' in ${folder} (version ${version}${state ? `, ${state}` : ""})`;
+  }).join("; ");
+  const remaining = deployments.length - MAX_LISTED_DEPLOYMENTS;
+  return remaining > 0 ? `${described}; and ${remaining} more (see: uip solution deploy list)` : described;
+}
+async function findDeploymentsByName(auth, deploymentName, scope) {
+  const matches = [];
+  const take = 50;
+  for (let skip = 0;; ) {
+    const result = await searchDeploymentsPage(auth, { deploymentName, take, skip }, scope);
+    const values = result.values ?? [];
+    matches.push(...values.filter((deployment) => deployment.name === deploymentName));
+    skip += values.length;
+    const total = result.count;
+    if (values.length < take || typeof total === "number" && skip >= total || skip >= MAX_SEARCH_ROWS) {
+      return matches;
+    }
+  }
+}
+var MAX_SEARCH_ROWS = 5000;
+async function findDeploymentBestEffort(auth, deploymentName, scope, prefer = {}) {
+  const [lookupError, rows] = await catchError(findDeploymentsByName(auth, deploymentName, scope));
+  if (lookupError || !rows) {
+    return;
+  }
+  if (prefer.deploymentKey) {
+    return rows.find((row) => row.key === prefer.deploymentKey && row.operation !== "Uninstall");
+  }
+  const candidates = rows.filter((row) => row.operation !== "Uninstall");
+  return candidates.sort((a, b) => creationMillis(b) - creationMillis(a))[0];
+}
+function newestDeploymentRow(rows) {
+  return [...rows].sort((a, b) => creationMillis(b) - creationMillis(a))[0];
+}
+function creationMillis(row) {
+  const millis = row.deploymentCreationTime ? new Date(row.deploymentCreationTime).getTime() : Number.NaN;
+  return Number.isFinite(millis) ? millis : 0;
+}
+async function isPipelineDeploymentNotFoundError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const response = error.response;
+  if (!response || typeof response !== "object") {
+    return false;
+  }
+  const status = response.status;
+  if (status !== 404) {
+    return false;
+  }
+  const [bodyError, body] = await catchError(response.clone().text());
+  if (bodyError || !body) {
+    return false;
+  }
+  return body.includes("PipelineDeploymentNotFound");
+}
+function interpretFailedDeployPoll(deployment) {
+  if (!deployment) {
+    return;
+  }
+  if (deployment.operationStatus === "Failed" || deployment.operationStatus === "FailedRollback") {
+    return {
+      kind: "DeployFailed",
+      operationStatus: deployment.operationStatus
+    };
+  }
+  if (deployment.operationStatus !== "Successful") {
+    return;
+  }
+  switch (deployment.activationStatus) {
+    case "Active":
+      return { kind: "Active", instanceId: deployment.instanceId };
+    case "NeedsSetupToActivate":
+      return { kind: "NeedsSetupToActivate" };
+    case "ReadyToActivate":
+    case "Inactive":
+      return { kind: "ReadyToActivate" };
+    case "ActivationFailed":
+      return { kind: "ActivationFailed" };
+    default:
+      return;
+  }
+}
+function mapOperationStatusToPipelineStatus(operationStatus) {
+  switch (operationStatus) {
+    case "Successful":
+      return "DeploymentSucceeded";
+    case "Failed":
+    case "FailedRollback":
+    case "Draft":
+      return "DeploymentFailed";
+    default:
+      return;
+  }
+}
+function deploymentToTerminalPipelineResult(deployment) {
+  const status = mapOperationStatusToPipelineStatus(deployment.operationStatus);
+  if (!status) {
+    return;
+  }
+  return {
+    status,
+    validationResult: { validationErrors: [], conflictErrors: [] },
+    deploymentKey: deployment.key,
+    configurationKey: deployment.configurationKey,
+    instanceId: deployment.instanceId,
+    conflictFixingErrors: [],
+    deploymentScheduleErrors: []
+  };
+}
+async function resolveInstalledFolder(deployment, requested, resolveFolderByKey) {
+  const fallback = {
+    folderName: requested.folderName,
+    folderPath: requested.folderPath,
+    requestedMatched: true
+  };
+  const pathFor = (name, path) => path ?? (requested.parentFolderPath ? `${requested.parentFolderPath}/${name}` : name);
+  const folderKey = deployment?.installedRootFolderKey;
+  if (folderKey && resolveFolderByKey) {
+    const [lookupError, folder] = await catchError(resolveFolderByKey(folderKey));
+    if (!lookupError && folder?.name) {
+      return {
+        folderName: folder.name,
+        folderPath: pathFor(folder.name, folder.path ?? deployment?.folderPath ?? undefined),
+        requestedMatched: folder.name === requested.folderName
+      };
+    }
+  }
+  const resolvedName = deployment?.installedRootFolderName;
+  if (resolvedName) {
+    return {
+      folderName: resolvedName,
+      folderPath: pathFor(resolvedName, deployment?.folderPath ?? undefined),
+      requestedMatched: resolvedName === requested.folderName
+    };
+  }
+  return fallback;
+}
+
+export { httpStatusOf, isAuthRefusal, DeploymentSearchNeedsUserSessionError, searchDeploymentsPage, findDeploymentByName, findLiveDeploymentByName, isCompletedUninstall, findDeploymentsByPackageName, findCurrentDeploymentAsync, blocksRedeploy, MAX_LISTED_DEPLOYMENTS, formatExistingDeployments, findDeploymentsByName, findDeploymentBestEffort, newestDeploymentRow, isPipelineDeploymentNotFoundError, interpretFailedDeployPoll, mapOperationStatusToPipelineStatus, deploymentToTerminalPipelineResult, resolveInstalledFolder };
+
+//# debugId=982982E1F13E2BA464756E2164756E21