@uipath/uipath-typescript 1.3.5 → 1.3.7

package/dist/index.umd.js

@@ -5028,6 +5028,7 @@
     const GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     class AuthService {
         constructor(config, executionContext) {
+            this.skipAcrValues = false;
             // Only use stored OAuth context when completing an active callback (URL has ?code=).
             // If stored context exists but we're NOT in a callback, it's stale from a
             // failed/abandoned flow (e.g. scope mismatch, invalid redirect URI) and must
@@ -5119,6 +5120,14 @@
         getTokenManager() {
             return this.tokenManager;
         }
+        /**
+         * Enables the UiPath login picker during OAuth sign-in.
+         *
+         * @internal
+         */
+        setMultiLogin() {
+            this.skipAcrValues = true;
+        }
         /**
          * Authenticates the user based on the provided SDK configuration.
          * This method handles OAuth 2.0 authentication flow only.
@@ -5320,7 +5329,10 @@
                 scope: params.scope + ' offline_access',
                 state: params.state || this.generateCodeVerifier().slice(0, 16)
             });
-            return `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}&acr_values=${acrValues}`;
+            const authorizeUrl = `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+            return this.skipAcrValues
+                ? authorizeUrl
+                : `${authorizeUrl}&acr_values=${acrValues}`;
         }
         /**
          * Exchanges the authorization code for an access token and automatically updates the current token
@@ -9209,7 +9221,7 @@
     // Connection string placeholder that will be replaced during build
     const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
     // SDK Version placeholder 
-    const SDK_VERSION = "1.3.5";
+    const SDK_VERSION = "1.3.7";
     const VERSION = "Version";
     const SERVICE = "Service";
     const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -9556,6 +9568,8 @@
         // Asset resolution and routing
         UiPathMetaTags["CDN_BASE"] = "uipath:cdn-base";
         UiPathMetaTags["APP_BASE"] = "uipath:app-base";
+        // Folder context (injected during coded-app deployment)
+        UiPathMetaTags["FOLDER_KEY"] = "uipath:folder-key";
     })(exports.UiPathMetaTags || (exports.UiPathMetaTags = {}));
 
     /**
@@ -9584,12 +9598,13 @@
             tenantName: getMetaTagContent(exports.UiPathMetaTags.TENANT_NAME),
             baseUrl: getMetaTagContent(exports.UiPathMetaTags.BASE_URL),
             redirectUri: getMetaTagContent(exports.UiPathMetaTags.REDIRECT_URI),
+            folderKey: getMetaTagContent(exports.UiPathMetaTags.FOLDER_KEY),
         };
         const hasAnyValue = Object.values(config).some(Boolean);
         return hasAnyValue ? config : null;
     }
 
-    var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_initializeWithConfig, _UiPath_loadConfig;
+    var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_multiLogin, _UiPath_metaFolderKey, _UiPath_initializeWithConfig, _UiPath_loadConfig;
     /**
      * UiPath - Core SDK class for authentication and configuration management.
      *
@@ -9629,8 +9644,14 @@
             _UiPath_authService.set(this, void 0);
             _UiPath_initialized.set(this, false);
             _UiPath_partialConfig.set(this, void 0);
+            _UiPath_multiLogin.set(this, false);
+            // Folder key sourced only from `<meta name="uipath:folder-key">` (coded-app
+            // deployments). Not accepted via the public constructor; lives here so the
+            // SDK can flow it through to BaseService.config without polluting BaseConfig.
+            _UiPath_metaFolderKey.set(this, void 0);
             // Load configuration from meta tags
             const configFromMetaTags = loadFromMetaTags();
+            __classPrivateFieldSet(this, _UiPath_metaFolderKey, configFromMetaTags?.folderKey, "f");
             // Merge configuration: constructor config overrides meta tags
             const mergedConfig = config ? { ...configFromMetaTags, ...config } : configFromMetaTags;
             if (mergedConfig && isCompleteConfig(mergedConfig)) {
@@ -9679,6 +9700,15 @@
                 throw new Error(`Failed to initialize UiPath SDK: ${errorMessage}`);
             }
         }
+        /**
+         * Enables the UiPath login picker during OAuth sign-in.
+         *
+         * @internal
+         */
+        setMultiLogin() {
+            __classPrivateFieldSet(this, _UiPath_multiLogin, true, "f");
+            __classPrivateFieldGet(this, _UiPath_authService, "f")?.setMultiLogin();
+        }
         /**
          * Check if the SDK has been initialized
          */
@@ -9750,7 +9780,7 @@
             __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
         }
     };
-    _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
+    _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_multiLogin = new WeakMap(), _UiPath_metaFolderKey = new WeakMap(), _UiPath_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
         // Validate and normalize the configuration
         validateConfig(config);
         const hasSecretAuth = hasSecretConfig(config);
@@ -9763,16 +9793,22 @@
             secret: hasSecretAuth ? config.secret : undefined,
             clientId: hasOAuthAuth ? config.clientId : undefined,
             redirectUri: hasOAuthAuth ? config.redirectUri : undefined,
-            scope: hasOAuthAuth ? config.scope : undefined
+            scope: hasOAuthAuth ? config.scope : undefined,
         });
         const executionContext = new ExecutionContext();
         __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
+        if (__classPrivateFieldGet(this, _UiPath_multiLogin, "f")) {
+            __classPrivateFieldGet(this, _UiPath_authService, "f").setMultiLogin();
+        }
         __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
-        // Store internals in SDKInternalsRegistry (not visible on instance)
+        // Store internals in SDKInternalsRegistry (not visible on instance).
+        // `folderKey` is meta-tag-only — kept off `UiPathConfig` (which mirrors
+        // user-passed values) and lives here on the runtime registry instead.
         SDKInternalsRegistry.set(this, {
             config: internalConfig,
             context: executionContext,
-            tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager()
+            tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager(),
+            folderKey: __classPrivateFieldGet(this, _UiPath_metaFolderKey, "f"),
         });
         // Expose read-only config for user convenience
         this.config = {
@@ -9800,6 +9836,7 @@
     }, _UiPath_loadConfig = function _UiPath_loadConfig() {
         // Load from meta tags
         const metaConfig = loadFromMetaTags();
+        __classPrivateFieldSet(this, _UiPath_metaFolderKey, metaConfig?.folderKey, "f");
         // Merge with any partial config from constructor (constructor overrides meta tags)
         const merged = { ...metaConfig, ...__classPrivateFieldGet(this, _UiPath_partialConfig, "f") };
         if (!isCompleteConfig(merged)) {
@@ -10043,6 +10080,7 @@
     }
 
     const FOLDER_KEY = 'X-UIPATH-FolderKey';
+    const FOLDER_PATH_ENCODED = 'X-UIPATH-FolderPath-Encoded';
     const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
     const TRACEPARENT = 'traceparent';
     const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
@@ -11175,8 +11213,9 @@
         constructor(instance, headers) {
             // Private field - not visible via Object.keys() or any reflection
             _BaseService_apiClient.set(this, void 0);
-            const { config, context, tokenManager } = SDKInternalsRegistry.get(instance);
+            const { config, context, tokenManager, folderKey } = SDKInternalsRegistry.get(instance);
             __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager, headers ? { headers } : {}), "f");
+            this.config = { folderKey };
         }
         /**
          * Gets a valid authentication token, refreshing if necessary.
@@ -11538,6 +11577,17 @@
         QueryFilterOperator["In"] = "in";
         QueryFilterOperator["NotIn"] = "not in";
     })(exports.QueryFilterOperator || (exports.QueryFilterOperator = {}));
+    /**
+     * Aggregate functions supported by the Data Fabric query API.
+     */
+    exports.EntityAggregateFunction = void 0;
+    (function (EntityAggregateFunction) {
+        EntityAggregateFunction["Count"] = "COUNT";
+        EntityAggregateFunction["Sum"] = "SUM";
+        EntityAggregateFunction["Avg"] = "AVG";
+        EntityAggregateFunction["Min"] = "MIN";
+        EntityAggregateFunction["Max"] = "MAX";
+    })(exports.EntityAggregateFunction || (exports.EntityAggregateFunction = {}));
     /**
      * Entity type enum
      */
@@ -12127,16 +12177,16 @@
             return entities;
         }
         /**
-         * Queries entity records with filters, sorting, and pagination
+         * Queries entity records with filters, sorting, aggregates, and pagination
          *
          * @param id - UUID of the entity
-         * @param options - Query options including filterGroup, selectedFields, sortOptions, and pagination
+         * @param options - Query options including filterGroup, selectedFields, sortOptions, aggregates, groupBy, and pagination
          * @returns Promise resolving to {@link NonPaginatedResponse} without pagination options,
          *   or {@link PaginatedResponse} when `pageSize`, `cursor`, or `jumpToPage` are provided
          *
          * @example
          * ```typescript
-         * import { Entities, LogicalOperator, QueryFilterOperator } from '@uipath/uipath-typescript/entities';
+         * import { Entities, LogicalOperator, QueryFilterOperator, EntityAggregateFunction } from '@uipath/uipath-typescript/entities';
          *
          * const entities = new Entities(sdk);
          *
@@ -12160,6 +12210,23 @@
          * if (page1.hasNextPage) {
          *   const page2 = await entities.queryRecordsById("<entityId>", { cursor: page1.nextCursor });
          * }
+         *
+         * // Aggregate: count of records per status
+         * await entities.queryRecordsById("<entityId>", {
+         *   selectedFields: ["status"],
+         *   groupBy: ["status"],
+         *   aggregates: [
+         *     { function: EntityAggregateFunction.Count, field: "Id", alias: "total" },
+         *   ],
+         * });
+         *
+         * // Aggregate: total sum and average across all records (no grouping)
+         * await entities.queryRecordsById("<entityId>", {
+         *   aggregates: [
+         *     { function: EntityAggregateFunction.Sum, field: "amount", alias: "totalAmount" },
+         *     { function: EntityAggregateFunction.Avg, field: "amount", alias: "avgAmount" },
+         *   ],
+         * });
          * ```
          */
         async queryRecordsById(id, options) {
@@ -12177,7 +12244,7 @@
                         countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
                     }
                 },
-                excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions']
+                excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions', 'aggregates', 'groupBy']
             }, options);
         }
         /**
@@ -14871,6 +14938,111 @@
         track('CaseInstances.GetActionTasks')
     ], CaseInstancesService.prototype, "getActionTasks", null);
 
+    /**
+     * Validates the `name` argument passed to a `getByName(name, ...)` method.
+     * Trims whitespace and rejects empty/whitespace-only names.
+     *
+     * @param resourceType - Resource label used in error messages (e.g. 'Asset', 'Process')
+     * @param name - Resource name to validate
+     * @returns The trimmed name
+     * @throws ValidationError when `name` is missing or empty after trimming
+     */
+    function validateName(resourceType, name) {
+        if (!name) {
+            throw new ValidationError({
+                message: `${resourceType} name is required and cannot be empty.`,
+            });
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new ValidationError({
+                message: `${resourceType} name is required and cannot be empty.`,
+            });
+        }
+        return trimmed;
+    }
+
+    /**
+     * Encodes a folder path for the `X-UIPATH-FolderPath-Encoded` header.
+     *
+     * Orchestrator decodes this header as **base64-encoded UTF-16 LE bytes**
+     * (see `HttpHeadersProviderExtensions.GetDecoded` + `OrganizationUnitProvider`
+     * in the Orchestrator repo, which call `Encoding.Unicode.GetString(...)`).
+     * URL-encoding is NOT what the server expects — it must be base64-of-UTF-16-LE
+     * bytes.
+     *
+     * @param folderPath - The folder path (e.g. 'Shared/Finance')
+     * @returns Base64 string suitable for the `X-UIPATH-FolderPath-Encoded` header
+     */
+    function encodeFolderPathHeader(folderPath) {
+        // Force little-endian regardless of host byte order. `Uint16Array` viewed
+        // as `Uint8Array` would use the host's native order — correct on LE hosts
+        // (x86/ARM-LE) but wrong on BE hosts. `DataView.setUint16(..., true)`
+        // pins LE.
+        const buf = new ArrayBuffer(folderPath.length * 2);
+        const view = new DataView(buf);
+        for (let i = 0; i < folderPath.length; i++) {
+            view.setUint16(i * 2, folderPath.charCodeAt(i), true);
+        }
+        const bytes = new Uint8Array(buf);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        // btoa is browser-native; Node 16+ also has it as a global
+        return btoa(binary);
+    }
+
+    /**
+     * Resolves folder context into the appropriate Orchestrator folder headers.
+     *
+     * Centralized so all folder-scoped methods (e.g. `assets.getByName`,
+     * `processes.getByName`, future Queues/Buckets/Jobs) share one implementation.
+     *
+     * Each input field maps directly to its header — no auto-detection or type
+     * coercion. When multiple fields are supplied, all corresponding headers
+     * are forwarded and the server resolves precedence.
+     *
+     * Routing:
+     * - `folderId` → `X-UIPATH-OrganizationUnitId`
+     * - `folderKey` → `X-UIPATH-FolderKey`
+     * - `folderPath` → `X-UIPATH-FolderPath-Encoded`
+     * - none set + `fallbackFolderKey` → fallback used as `X-UIPATH-FolderKey`
+     * - none set + no fallback → `ValidationError`
+     *
+     * @throws ValidationError when no folder context can be resolved.
+     */
+    function resolveFolderHeaders(input) {
+        const { folderId, folderKey, folderPath, resourceType, fallbackFolderKey } = input;
+        const trimmedKey = folderKey?.trim();
+        const trimmedPath = folderPath?.trim();
+        const headers = {};
+        if (folderId !== undefined) {
+            headers[FOLDER_ID] = folderId;
+        }
+        if (trimmedKey) {
+            headers[FOLDER_KEY] = trimmedKey;
+        }
+        if (trimmedPath) {
+            headers[FOLDER_PATH_ENCODED] = encodeFolderPathHeader(trimmedPath);
+        }
+        // No explicit folder context → meta-tag fallback or error.
+        if (Object.keys(headers).length === 0) {
+            if (!fallbackFolderKey) {
+                throw new ValidationError({
+                    message: `${resourceType} requires folder context: pass \`folderId\`, \`folderKey\`, or \`folderPath\`, or initialize the SDK with a folder context.`,
+                });
+            }
+            headers[FOLDER_KEY] = fallbackFolderKey;
+        }
+        return createHeaders(headers);
+    }
+
+    /**
+     * Matches single-quote characters in OData string literals — escaped to `''`
+     * inside the `$filter=Name eq '…'` clause built by `getByNameLookup`.
+     */
+    const SINGLE_QUOTE_RE = /'/g;
     /**
      * Base service for services that need folder-specific functionality.
      *
@@ -14904,6 +15076,68 @@
             }
             return response.data?.value;
         }
+        /**
+         * Look up a single resource by name on a folder-scoped OData collection.
+         *
+         * Shared by `getByName` implementations across services (Assets, Processes, etc).
+         * Handles:
+         * - Name validation via `validateName`
+         * - Folder header resolution via `resolveFolderHeaders` (folderId → ID/key
+         *   header by type, folderPath → encoded path header, falls back to
+         *   init-time `config.folderKey` from the `uipath:folder-key` meta tag)
+         * - OData `$filter=Name eq '…'` with single-quote escaping + `$top=1`
+         * - Empty-result → `NotFoundError` with folder context in the message
+         *
+         * The transform step is caller-provided because each resource has its own
+         * PascalCase → camelCase field mapping.
+         *
+         * @param resourceType - Resource label used in validation + error messages (e.g. 'Asset', 'Process')
+         * @param endpoint - Folder-scoped OData collection endpoint
+         * @param name - Resource name to search for
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) + OData query options (`expand`, `select`)
+         * @param transform - Maps a raw OData item to the typed response (e.g. PascalCase → camelCase via field map)
+         * @throws ValidationError when inputs are malformed; NotFoundError when no match
+         */
+        async getByNameLookup(resourceType, endpoint, name, options, transform) {
+            const validatedName = validateName(resourceType, name);
+            const { folderId, folderKey, folderPath, ...queryOptions } = options;
+            const headers = resolveFolderHeaders({
+                folderId,
+                folderKey,
+                folderPath,
+                resourceType: `${resourceType}.getByName`,
+                fallbackFolderKey: this.config.folderKey,
+            });
+            const apiOptions = {
+                ...addPrefixToKeys(queryOptions, ODATA_PREFIX, Object.keys(queryOptions)),
+                '$filter': `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
+                '$top': '1',
+            };
+            const response = await this.get(endpoint, {
+                headers,
+                params: apiOptions,
+            });
+            const items = response.data?.value;
+            if (!items?.length) {
+                const folderHint = describeFolderForError(folderId, folderKey, folderPath);
+                throw new NotFoundError({
+                    message: `${resourceType} '${validatedName}' not found${folderHint}.`,
+                });
+            }
+            return transform(items[0]);
+        }
+    }
+    /** Renders the supplied folder for a NotFoundError message. */
+    function describeFolderForError(folderId, folderKey, folderPath) {
+        const path = folderPath?.trim();
+        if (path)
+            return ` in folder '${path}'`;
+        const key = folderKey?.trim();
+        if (key)
+            return ` in folder (key: ${key})`;
+        if (typeof folderId === 'number')
+            return ` in folder (id: ${folderId})`;
+        return '';
     }
 
     /**
@@ -15001,6 +15235,35 @@
             const transformedAsset = transformData(pascalToCamelCaseKeys(response.data), AssetMap);
             return transformedAsset;
         }
+        /**
+         * Retrieves a single asset by name.
+         *
+         * @param name - Asset name to search for
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`)
+         * @returns Promise resolving to a single asset
+         * {@link AssetGetResponse}
+         * @example
+         * ```typescript
+         * import { Assets } from '@uipath/uipath-typescript/assets';
+         *
+         * const assets = new Assets(sdk);
+         *
+         * // By folder ID
+         * await assets.getByName('ApiKey', { folderId: 123 });
+         *
+         * // By folder key (GUID)
+         * await assets.getByName('ApiKey', { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+         *
+         * // By folder path
+         * await assets.getByName('ApiKey', { folderPath: 'Shared/Finance' });
+         *
+         * // With expand
+         * await assets.getByName('ApiKey', { folderPath: 'Shared/Finance', expand: 'keyValueList' });
+         * ```
+         */
+        async getByName(name, options = {}) {
+            return this.getByNameLookup('Asset', ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap));
+        }
     }
     __decorate([
         track('Assets.GetAll')
@@ -15008,6 +15271,9 @@
     __decorate([
         track('Assets.GetById')
     ], AssetService.prototype, "getById", null);
+    __decorate([
+        track('Assets.GetByName')
+    ], AssetService.prototype, "getByName", null);
 
     /**
      * Enum for Asset Value Scope
@@ -16111,7 +16377,7 @@
     /**
      * Service for interacting with UiPath Orchestrator Processes API
      */
-    class ProcessService extends BaseService {
+    class ProcessService extends FolderScopedService {
         /**
          * Gets all processes across folders with optional filtering and folder scoping
          *
@@ -16248,6 +16514,35 @@
             const transformedProcess = transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
             return transformedProcess;
         }
+        /**
+         * Retrieves a single process by name.
+         *
+         * @param name - Process name to search for
+         * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`)
+         * @returns Promise resolving to a single process
+         * {@link ProcessGetResponse}
+         * @example
+         * ```typescript
+         * import { Processes } from '@uipath/uipath-typescript/processes';
+         *
+         * const processes = new Processes(sdk);
+         *
+         * // By folder ID
+         * await processes.getByName('MyProcess', { folderId: 123 });
+         *
+         * // By folder key (GUID)
+         * await processes.getByName('MyProcess', { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+         *
+         * // By folder path
+         * await processes.getByName('MyProcess', { folderPath: 'Shared/Finance' });
+         *
+         * // With expand
+         * await processes.getByName('MyProcess', { folderPath: 'Shared/Finance', expand: 'entryPoints' });
+         * ```
+         */
+        async getByName(name, options = {}) {
+            return this.getByNameLookup('Process', PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap));
+        }
     }
     __decorate([
         track('Processes.GetAll')
@@ -16258,6 +16553,9 @@
     __decorate([
         track('Processes.GetById')
     ], ProcessService.prototype, "getById", null);
+    __decorate([
+        track('Processes.GetByName')
+    ], ProcessService.prototype, "getByName", null);
 
     /**
      * Maps fields for Queue entities to ensure consistent naming
@@ -16735,7 +17033,7 @@
     };
 
     /**
-     * Constants for User Service
+     * Constants for User Settings Service
      */
     /**
      * Maps fields for User Settings entities to ensure consistent SDK naming