@uipath/packager-tool-workflowcompiler 1.201.0-preview.121 → 1.201.0-preview.123

package/dist/index.js

@@ -695,7 +695,12 @@ var en2 = {
     feeds: {
       errors: {
         orchestratorUrlRequired: "Orchestrator URL is required.",
-        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}"
+        requestFailed: "{operation} failed: {status} {statusText}{body}",
+        feedFolderNeedsConnection: "Cannot resolve the library feed of folder '{folder}' without a signed-in Orchestrator session. Run 'uip login', or omit the folder to use every accessible tenant feed.",
+        feedFolderNotFound: "Orchestrator folder '{folder}' was not found. Available folders: {available}",
+        feedFolderAmbiguous: "Orchestrator folder name '{folder}' is ambiguous — {count} folders share it ({paths}). Pass the fully qualified path instead.",
+        feedFolderNotWritten: "Could not write the feed configuration for folder '{folder}'. Retry, or omit the folder to use every accessible tenant feed.",
+        feedFolderHasNoFeed: "Orchestrator folder '{folder}' has no library feed. Publish a library to that folder, or omit the folder to use every accessible tenant feed."
       },
       warnings: {
         tenantFeedsUnavailable: "Could not retrieve Orchestrator tenant feeds. Packaging will continue, but it may fail if a project references a library published to a tenant feed."
@@ -833,6 +838,10 @@ var package_default = {
   }
 };
 var FEEDS_PATH = "/api/PackageFeeds/GetFeeds?onlyPublishable=false";
+var FOLDER_FEED_PATH = "/api/PackageFeeds/GetFolderFeedByKey";
+var FOLDERS_PAGE_SIZE = 1000;
+var FOLDERS_PATH = `/odata/Folders?$select=Key,DisplayName,FullyQualifiedName&$top=${FOLDERS_PAGE_SIZE}`;
+var FOLDERS_MAX_PAGES = 50;
 var HEADER_TENANT_ID = "X-UIPATH-TenantId";
 var FEEDS_TIMEOUT_MS = 30000;
 var SDK_USER_AGENT = `${package_default.name.replace(/^@uipath\//, "")}/${package_default.version}`;
@@ -861,21 +870,96 @@ class OrchestratorFeedsService {
       signal: AbortSignal.timeout(FEEDS_TIMEOUT_MS)
     });
     if (!response.ok) {
-      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.getAccessibleFeedsFailed", await describeFailure(response)));
+      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.requestFailed", {
+        operation: "GetAccessibleFeeds",
+        ...await describeFailure(response)
+      }));
     }
     const text = await response.text();
     const feeds = text === "" || text === "null" ? null : JSON.parse(text);
     return Array.isArray(feeds) ? feeds : [];
   }
+  async getFoldersAsync(connection) {
+    const folders = [];
+    const seen = new Set;
+    for (let page = 0;page < FOLDERS_MAX_PAGES; page++) {
+      const path = page === 0 ? FOLDERS_PATH : `${FOLDERS_PATH}&$skip=${page * FOLDERS_PAGE_SIZE}`;
+      const text = await this.getAsync(connection, path, "GetFolders");
+      if (text === "" || text === "null") {
+        break;
+      }
+      const payload = JSON.parse(text);
+      if (!Array.isArray(payload.value) || payload.value.length === 0) {
+        break;
+      }
+      const fresh = payload.value.map((f) => mapFolder(f)).filter((folder) => {
+        const identity = folder.key ?? folder.fullyQualifiedName ?? folder.displayName;
+        if (identity === undefined || seen.has(identity)) {
+          return false;
+        }
+        seen.add(identity);
+        return true;
+      });
+      folders.push(...fresh);
+      if (fresh.length === 0) {
+        this.logger.warn(`Orchestrator returned no new folders for $skip=${page * FOLDERS_PAGE_SIZE}; using the ${folders.length} already retrieved.`);
+        break;
+      }
+      if (payload.value.length < FOLDERS_PAGE_SIZE) {
+        break;
+      }
+    }
+    return folders;
+  }
+  async getFolderFeedIdAsync(connection, folderKey) {
+    const path = `${FOLDER_FEED_PATH}?folderKey=${encodeURIComponent(folderKey)}`;
+    const text = await this.getAsync(connection, path, "GetFolderFeedByKey");
+    const feedId = text.trim().replace(/^"|"$/g, "");
+    return feedId === "" || feedId === "null" ? undefined : feedId;
+  }
+  async getAsync(connection, relativePath, operation) {
+    const { orchestratorUrl, accessToken, tenantId } = connection;
+    if (!orchestratorUrl) {
+      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.orchestratorUrlRequired"));
+    }
+    const headers = {};
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`;
+    }
+    if (tenantId) {
+      headers[HEADER_TENANT_ID] = tenantId;
+    }
+    const response = await fetch(`${orchestratorBase(orchestratorUrl)}${relativePath}`, {
+      method: "GET",
+      headers: addSdkUserAgentHeader(headers, SDK_USER_AGENT),
+      signal: AbortSignal.timeout(FEEDS_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.requestFailed", { operation, ...await describeFailure(response) }));
+    }
+    return response.text();
+  }
 }
-function feedsEndpoint(orchestratorUrl) {
+function folderFeedUrl(orchestratorUrl, feedId) {
+  return `${orchestratorBase(orchestratorUrl)}/nuget/v3/${feedId}/index.json`;
+}
+function mapFolder(json) {
+  return {
+    key: json.Key,
+    displayName: json.DisplayName,
+    fullyQualifiedName: json.FullyQualifiedName
+  };
+}
+function orchestratorBase(orchestratorUrl) {
   let end = orchestratorUrl.length;
   while (end > 0 && orchestratorUrl.charAt(end - 1) === "/") {
     end--;
   }
   const trimmed = orchestratorUrl.slice(0, end);
-  const base = /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
-  return `${base}${FEEDS_PATH}`;
+  return /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
+}
+function feedsEndpoint(orchestratorUrl) {
+  return `${orchestratorBase(orchestratorUrl)}${FEEDS_PATH}`;
 }
 async function describeFailure(response) {
   const text = await response.text().catch(() => "");
@@ -921,14 +1005,18 @@ class OrchestratorFeedComposer {
     this.feedsService = feedsService ?? new OrchestratorFeedsService(logger);
   }
   async composeAsync({
-    connection
+    connection,
+    feedFolder
   }) {
-    const feeds = await this.resolveTenantFeeds(connection);
+    const feeds = feedFolder ? await this.resolveFolderFeed(connection, feedFolder) : await this.resolveTenantFeeds(connection);
     if (feeds.length === 0) {
       return NO_FEEDS;
     }
     const [error, composed] = await catchError(this.writeFeedsFile(feeds));
     if (error || !composed) {
+      if (feedFolder) {
+        throw error ?? new Error(translate2.t("packagerOrchestratorClient.feeds.errors.feedFolderNotWritten", { folder: feedFolder }));
+      }
       this.warnFeedsUnavailable();
       return NO_FEEDS;
     }
@@ -951,6 +1039,46 @@ class OrchestratorFeedComposer {
     }
     return feeds.map((feed) => toTenantFeedSource(feed, accessToken)).filter((feed) => feed !== undefined);
   }
+  async resolveFolderFeed(connection, feedFolder) {
+    if (!connection?.accessToken || !connection.cloudUrl) {
+      throw new Error(translate2.t("packagerOrchestratorClient.feeds.errors.feedFolderNeedsConnection", { folder: feedFolder }));
+    }
+    const { accessToken, cloudUrl, tenantId } = connection;
+    const orchestratorConnection = {
+      orchestratorUrl: cloudUrl,
+      accessToken,
+      tenantId
+    };
+    const folders = await this.feedsService.getFoldersAsync(orchestratorConnection);
+    const wanted = feedFolder.trim().toLowerCase();
+    const byPath = folders.filter((f) => f.fullyQualifiedName?.toLowerCase() === wanted);
+    const byName = folders.filter((f) => f.displayName?.toLowerCase() === wanted);
+    if (byPath.length === 0 && byName.length > 1) {
+      throw new Error(translate2.t("packagerOrchestratorClient.feeds.errors.feedFolderAmbiguous", {
+        folder: feedFolder,
+        count: byName.length,
+        paths: byName.map((f) => f.fullyQualifiedName ?? f.displayName).filter(Boolean).join(", ")
+      }));
+    }
+    const folder = byPath[0] ?? byName[0];
+    if (!folder?.key) {
+      throw new Error(translate2.t("packagerOrchestratorClient.feeds.errors.feedFolderNotFound", {
+        folder: feedFolder,
+        available: folders.map((f) => f.fullyQualifiedName ?? f.displayName).filter(Boolean).join(", ")
+      }));
+    }
+    const feedId = await this.feedsService.getFolderFeedIdAsync(orchestratorConnection, folder.key);
+    if (!feedId) {
+      throw new Error(translate2.t("packagerOrchestratorClient.feeds.errors.feedFolderHasNoFeed", { folder: feedFolder }));
+    }
+    this.logger.info(`Resolving library dependencies from the feed of folder '${feedFolder}' instead of all tenant feeds.`);
+    return [
+      {
+        Url: folderFeedUrl(cloudUrl, feedId),
+        AccessToken: accessToken
+      }
+    ];
+  }
   async writeFeedsFile(feeds) {
     const storage = new TemporaryStorageService(this.fileSystem);
     const directory = await storage.getTempFolderPath();
@@ -1454,10 +1582,10 @@ class WorkflowCompilerTool extends ProjectTool {
   async withFeedPaths(options, run) {
     const userNugetConfigPath = options.nuGetSourcesConfigPath;
     const connection = this.context?.connection;
-    if (!connection) {
+    if (!connection && !options.feedFolder) {
       return run({ userNugetConfigPath });
     }
-    const composed = await new OrchestratorFeedComposer(this.fileSystem, this.logger).composeAsync({ connection });
+    const composed = await new OrchestratorFeedComposer(this.fileSystem, this.logger).composeAsync({ connection, feedFolder: options.feedFolder });
     try {
       return await run({
         orchestratorFeedsJsonPath: composed.configPath,
@@ -1780,4 +1908,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=8617FFB8E317023F64756E2164756E21
+//# debugId=2AB2C16F453AA28E64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.201.0-preview.121",
+  "version": "1.201.0-preview.123",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -28,5 +28,5 @@
     "@uipath/solutionpackager-tool-core": "1.201.0"
   },
   "dependencies": {},
-  "gitHead": "c70ccfc0b12e637441d67df1d212b71d7784b5f8"
+  "gitHead": "0b5e086775b5974d9df45fc98f96f868bb3dda61"
 }

package/src/workflow-compiler-tool.ts

@@ -77,7 +77,11 @@ export class WorkflowCompilerTool extends ProjectTool {
         // channel; it is never mixed into the internal feeds file.
         const userNugetConfigPath = options.nuGetSourcesConfigPath;
         const connection = this.context?.connection;
-        if (!connection) {
+        // A named folder must fail closed. Skipping composition here would let
+        // the build fall back to whatever other sources are configured, which is
+        // precisely what --feed-folder exists to prevent — so hand it to the
+        // composer even without a session and let it raise.
+        if (!connection && !options.feedFolder) {
             return run({ userNugetConfigPath });
         }
         // Orchestrator tenant feeds are composed into a JSON file that only ever
@@ -85,7 +89,7 @@ export class WorkflowCompilerTool extends ProjectTool {
         const composed = await new OrchestratorFeedComposer(
             this.fileSystem,
             this.logger,
-        ).composeAsync({ connection });
+        ).composeAsync({ connection, feedFolder: options.feedFolder });
         try {
             return await run({
                 orchestratorFeedsJsonPath: composed.configPath,