@uipath/uipath-typescript 1.4.2 → 1.5.1

package/dist/entities/index.cjs

@@ -976,7 +976,16 @@ const BUCKET_TOKEN_PARAMS = {
  * Returns the original value if parsing fails.
  */
 /**
- * Transforms data by mapping fields according to the provided field mapping
+ * Transforms data by renaming each key in `data` exactly once, using the
+ * mapping (`sourceField → targetField`). Keys not present in the mapping
+ * pass through unchanged. The original (pre-rename) key is dropped — the
+ * result contains only the renamed key.
+ *
+ * Each rename is independent. If the mapping happens to contain chained
+ * entries (`a → b` and `b → c`), they do NOT compose: a field named `a`
+ * in `data` becomes `b` (not `c`), because the renames are applied based
+ * on the original data's keys, not the running result.
+ *
  * @param data The source data to transform
  * @param fieldMapping Object mapping source field names to target field names
  * @returns Transformed data with mapped field names
@@ -999,21 +1008,28 @@ const BUCKET_TOKEN_PARAMS = {
  * //   { userId: '123', name: 'john' },
  * //   { userId: '456', name: 'jane' }
  * // ]
+ *
+ * // No chaining — `a → b` does not become `a → c` even if the map has `b → c`.
+ * transformData({ a: 1 }, { a: 'b', b: 'c' });
+ * // result = { b: 1 }
  * ```
  */
 function transformData(data, fieldMapping) {
+    // Pass null/undefined through unchanged — callers (e.g. AttachmentService.getById)
+    // may invoke this on optional fields that an OData `select` excluded.
+    if (data == null) {
+        return data;
+    }
     // Handle array of objects
     if (Array.isArray(data)) {
         return data.map(item => transformData(item, fieldMapping));
     }
-    // Handle single object
-    const result = { ...data };
-    for (const [sourceField, targetField] of Object.entries(fieldMapping)) {
-        if (sourceField in result) {
-            const value = result[sourceField];
-            delete result[sourceField];
-            result[targetField] = value;
-        }
+    // Walk the ORIGINAL data's keys, look up each in the mapping. One rename
+    // per data key — no mutation of an in-progress result, so chains can't form.
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const renamedKey = fieldMapping[key] ?? key;
+        result[renamedKey] = value;
     }
     return result;
 }
@@ -2000,6 +2016,14 @@ const DATA_FABRIC_ENDPOINTS = {
         UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
         DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`,
     },
+    ROLES: {
+        GET_ALL: `${DATAFABRIC_BASE}/api/v2/Role`,
+    },
+    DIRECTORY: {
+        GET_ALL: `${DATAFABRIC_BASE}/api/Directory`,
+        ASSIGN_ROLES: `${DATAFABRIC_BASE}/api/Directory/Role`,
+        REVOKE_ROLES: `${DATAFABRIC_BASE}/api/Directory/RevokeRole`,
+    },
 };
 
 /**
@@ -3792,8 +3816,423 @@ __decorate([
     track('Choicesets.DeleteValuesById')
 ], ChoiceSetService.prototype, "deleteValuesById", null);
 
+/**
+ * @internal
+ */
+var DataFabricRoleType;
+(function (DataFabricRoleType) {
+    DataFabricRoleType["System"] = "System";
+    DataFabricRoleType["UserDefined"] = "UserDefined";
+})(DataFabricRoleType || (DataFabricRoleType = {}));
+
+function isRecord$1(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isDataFabricRole(value) {
+    if (!isRecord$1(value)) {
+        return false;
+    }
+    const { id, name, type, directoryEntityCount, folderId } = value;
+    const hasValidDirectoryEntityCount = directoryEntityCount === undefined ||
+        directoryEntityCount === null ||
+        typeof directoryEntityCount === 'number';
+    const hasValidFolderId = folderId === undefined || typeof folderId === 'string';
+    return typeof id === 'string' &&
+        typeof name === 'string' &&
+        (type === DataFabricRoleType.System || type === DataFabricRoleType.UserDefined) &&
+        hasValidDirectoryEntityCount &&
+        hasValidFolderId;
+}
+function validateRolesResponse(data) {
+    if (Array.isArray(data) && data.every(isDataFabricRole)) {
+        return data;
+    }
+    throw new ServerError({
+        message: 'Invalid Data Fabric roles response format.',
+    });
+}
+/**
+ * @internal
+ */
+class DataFabricRoleService extends BaseService {
+    /**
+     * Lists Data Fabric access roles.
+     *
+     * Returns tenant Data Fabric roles such as Admin, Designer, DataWriter, and
+     * DataReader. Role IDs from this method can be passed to
+     * `DataFabricDirectoryService.assignRoles()`.
+     *
+     * @param options - Optional query options
+     * @returns Promise resolving to an array of {@link DataFabricRole}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const allRoles = await roles.getAll();
+     * const dataWriter = allRoles.find(role => role.name === 'DataWriter');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const rolesWithoutStats = await roles.getAll({ stats: false });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const folderRoles = await roles.getAll({ folderKey: '<folder-key>' });
+     * ```
+     *
+     * @internal
+     */
+    async getAll(options = {}) {
+        const params = createParams({
+            stats: options.stats ?? true,
+        });
+        const headers = createHeaders({ [FOLDER_KEY]: options.folderKey });
+        const response = await this.get(DATA_FABRIC_ENDPOINTS.ROLES.GET_ALL, { params, headers });
+        return validateRolesResponse(response.data);
+    }
+}
+__decorate([
+    track('DataFabricRoles.GetAll')
+], DataFabricRoleService.prototype, "getAll", null);
+
+/**
+ * @internal
+ */
+var DataFabricDirectoryEntityType;
+(function (DataFabricDirectoryEntityType) {
+    /** Identity user, robot user, or directory robot principal. */
+    DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["User"] = 0] = "User";
+    /** Identity group principal. */
+    DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["Group"] = 1] = "Group";
+    /** External application principal. */
+    DataFabricDirectoryEntityType[DataFabricDirectoryEntityType["Application"] = 2] = "Application";
+})(DataFabricDirectoryEntityType || (DataFabricDirectoryEntityType = {}));
+/**
+ * @internal
+ */
+var DataFabricDirectoryEntityTypeName;
+(function (DataFabricDirectoryEntityTypeName) {
+    DataFabricDirectoryEntityTypeName["User"] = "User";
+    DataFabricDirectoryEntityTypeName["Group"] = "Group";
+    DataFabricDirectoryEntityTypeName["Application"] = "Application";
+})(DataFabricDirectoryEntityTypeName || (DataFabricDirectoryEntityTypeName = {}));
+
+const DEFAULT_DIRECTORY_PAGE_SIZE = 100;
+const MAX_DIRECTORY_PAGE_SIZE = 100;
+function validateDirectoryListResponse(data) {
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        throw new ServerError({
+            message: 'Invalid Data Fabric directory response format.',
+        });
+    }
+    const response = data;
+    if (typeof response.totalCount !== 'number' || !Array.isArray(response.results)) {
+        throw new ServerError({
+            message: 'Invalid Data Fabric directory response format.',
+        });
+    }
+    return {
+        totalCount: response.totalCount,
+        results: response.results,
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isDirectoryEntityTypeName(value) {
+    return value === DataFabricDirectoryEntityTypeName.User ||
+        value === DataFabricDirectoryEntityTypeName.Group ||
+        value === DataFabricDirectoryEntityTypeName.Application;
+}
+function isDirectoryRole(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return typeof value.id === 'string' && typeof value.name === 'string';
+}
+function normalizeDirectoryEntry(entry) {
+    if (!isRecord(entry) ||
+        typeof entry.externalId !== 'string' ||
+        typeof entry.name !== 'string' ||
+        !isDirectoryEntityTypeName(entry.type) ||
+        (entry.email !== undefined && entry.email !== null && typeof entry.email !== 'string') ||
+        (entry.objectType !== undefined && entry.objectType !== null && typeof entry.objectType !== 'string') ||
+        (entry.isUIEnabled !== undefined && typeof entry.isUIEnabled !== 'boolean') ||
+        (entry.roles !== undefined && entry.roles !== null && (!Array.isArray(entry.roles) || !entry.roles.every(isDirectoryRole)))) {
+        throw new ServerError({
+            message: 'Invalid Data Fabric directory entry response format.',
+        });
+    }
+    const normalized = {
+        externalId: entry.externalId,
+        name: entry.name,
+        type: entry.type,
+        roles: entry.roles ?? [],
+        isUIEnabled: entry.isUIEnabled ?? true,
+    };
+    if (entry.email !== undefined) {
+        normalized.email = entry.email;
+    }
+    if (entry.objectType !== undefined) {
+        normalized.objectType = entry.objectType;
+    }
+    return normalized;
+}
+function normalizePrincipalIds(principalIds) {
+    const ids = Array.isArray(principalIds) ? principalIds : [principalIds];
+    return [...new Set(ids.map(id => id.trim()).filter(Boolean))];
+}
+function normalizeRoleIds(roleIds) {
+    return [...new Set(roleIds.map(id => id.trim()).filter(Boolean))];
+}
+function normalizePrincipalType(type) {
+    if (typeof type === 'number') {
+        if (type === DataFabricDirectoryEntityType.User ||
+            type === DataFabricDirectoryEntityType.Group ||
+            type === DataFabricDirectoryEntityType.Application) {
+            return type;
+        }
+        throw new ValidationError({
+            message: 'Invalid Data Fabric principal type.',
+        });
+    }
+    switch (type) {
+        case DataFabricDirectoryEntityTypeName.User:
+            return DataFabricDirectoryEntityType.User;
+        case DataFabricDirectoryEntityTypeName.Group:
+            return DataFabricDirectoryEntityType.Group;
+        case DataFabricDirectoryEntityTypeName.Application:
+            return DataFabricDirectoryEntityType.Application;
+        default:
+            throw new ValidationError({
+                message: 'Invalid Data Fabric principal type.',
+            });
+    }
+}
+function roleIdsFromEntry(entry) {
+    if (!entry) {
+        return [];
+    }
+    return normalizeRoleIds(entry.roles.map(role => role.id));
+}
+function clampDirectoryPageSize(pageSize) {
+    return Math.max(1, Math.min(pageSize ?? DEFAULT_DIRECTORY_PAGE_SIZE, MAX_DIRECTORY_PAGE_SIZE));
+}
+/**
+ * @internal
+ */
+class DataFabricDirectoryService extends BaseService {
+    async fetchAllEntries(options = {}) {
+        const top = clampDirectoryPageSize(options.pageSize);
+        const entries = [];
+        let skip = 0;
+        while (true) {
+            const page = await this.list(skip === 0 ? { top } : { top, skip });
+            entries.push(...page.results);
+            if (page.results.length < top || (page.totalCount !== undefined && entries.length >= page.totalCount)) {
+                return entries;
+            }
+            skip += top;
+        }
+    }
+    /**
+     * Lists one page of Data Fabric directory principals and their current roles.
+     *
+     * Returns directory entries with external IDs, principal metadata, and
+     * assigned Data Fabric roles.
+     *
+     * @param options - Optional offset paging options
+     * @returns Promise resolving to {@link DataFabricDirectoryListResponse}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const page = await directory.list({ skip: 0, top: 50 });
+     * const firstPrincipal = page.results[0];
+     * ```
+     *
+     * @internal
+     */
+    async list(options = {}) {
+        const params = createParams({
+            skip: options.skip,
+            top: clampDirectoryPageSize(options.top),
+        });
+        const response = await this.get(DATA_FABRIC_ENDPOINTS.DIRECTORY.GET_ALL, { params });
+        const data = validateDirectoryListResponse(response.data);
+        const results = data.results.map(normalizeDirectoryEntry);
+        return {
+            totalCount: data.totalCount,
+            results,
+        };
+    }
+    /**
+     * Lists all Data Fabric directory principals and their current roles.
+     *
+     * Follows the Data Fabric directory top/skip pagination and returns
+     * normalized entries. Entries without assigned roles include an empty
+     * `roles` array.
+     *
+     * @param options - Optional page-size options
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryEntry}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const principals = await directory.getAll({ pageSize: 100 });
+     * ```
+     *
+     * @internal
+     */
+    async getAll(options = {}) {
+        return this.fetchAllEntries(options);
+    }
+    /**
+     * Assigns Data Fabric roles to one or more principals.
+     *
+     * The Data Fabric API replaces the role set for each principal, so this
+     * method preserves existing roles by default and posts the union of current
+     * and requested role IDs.
+     *
+     * Role IDs can be discovered with `DataFabricRoleService.getAll()`. Set
+     * `preserveExisting: false` only when intentionally replacing a principal's
+     * Data Fabric role set.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @param principalType - Principal type
+     * @param roleIds - Data Fabric role IDs to assign
+     * @param options - Optional assignment behavior
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryAssignmentResult}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryEntityTypeName, DataFabricDirectoryService, DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * const dataWriter = (await roles.getAll()).find(role => role.name === 'DataWriter');
+     * if (!dataWriter) {
+     *   throw new Error('DataWriter role not found');
+     * }
+     *
+     * await directory.assignRoles('<identity-group-id>', DataFabricDirectoryEntityTypeName.Group, [dataWriter.id]);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.assignRoles('<identity-user-id>', DataFabricDirectoryEntityTypeName.User, ['<role-id>'], {
+     *   preserveExisting: false,
+     * });
+     * ```
+     *
+     * @internal
+     */
+    async assignRoles(principalIds, principalType, roleIds, options = {}) {
+        const normalizedPrincipalIds = normalizePrincipalIds(principalIds);
+        const normalizedRoleIds = normalizeRoleIds(roleIds);
+        if (normalizedPrincipalIds.length === 0) {
+            throw new ValidationError({ message: 'At least one principal ID is required.' });
+        }
+        if (normalizedRoleIds.length === 0) {
+            throw new ValidationError({ message: 'At least one Data Fabric role ID is required.' });
+        }
+        const type = normalizePrincipalType(principalType);
+        const preserveExisting = options.preserveExisting ?? true;
+        const existingById = new Map();
+        if (preserveExisting) {
+            for (const entry of await this.fetchAllEntries()) {
+                existingById.set(entry.externalId.toLowerCase(), entry);
+            }
+        }
+        return Promise.all(normalizedPrincipalIds.map(async (principalId) => {
+            const existing = existingById.get(principalId.toLowerCase());
+            const mergedRoleIds = preserveExisting
+                ? normalizeRoleIds([...roleIdsFromEntry(existing), ...normalizedRoleIds])
+                : normalizedRoleIds;
+            const payload = {
+                directoryEntities: [
+                    {
+                        externalId: principalId,
+                        type,
+                        resolved: true,
+                    },
+                ],
+                roles: mergedRoleIds,
+                isUIEnabled: options.uiEnabled ?? true,
+            };
+            await this.post(DATA_FABRIC_ENDPOINTS.DIRECTORY.ASSIGN_ROLES, payload);
+            return {
+                principalId,
+                roleIds: mergedRoleIds,
+            };
+        }));
+    }
+    /**
+     * Revokes all direct Data Fabric roles from one or more principals.
+     *
+     * The Data Fabric API removes all role assignments for each supplied external
+     * ID. Use this when a principal should no longer have direct Data Fabric
+     * access. Inherited access through groups is not changed.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @returns Promise resolving when the roles are revoked
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * await directory.revokeRoles('<identity-user-id>');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.revokeRoles([
+     *   '<identity-user-id>',
+     *   '<identity-group-id>',
+     * ]);
+     * ```
+     *
+     * @internal
+     */
+    async revokeRoles(principalIds) {
+        const normalizedPrincipalIds = normalizePrincipalIds(principalIds);
+        if (normalizedPrincipalIds.length === 0) {
+            throw new ValidationError({ message: 'At least one principal ID is required.' });
+        }
+        const payload = {
+            externalIds: normalizedPrincipalIds,
+        };
+        await this.post(DATA_FABRIC_ENDPOINTS.DIRECTORY.REVOKE_ROLES, payload);
+    }
+}
+__decorate([
+    track('DataFabricDirectory.List')
+], DataFabricDirectoryService.prototype, "list", null);
+__decorate([
+    track('DataFabricDirectory.GetAll')
+], DataFabricDirectoryService.prototype, "getAll", null);
+__decorate([
+    track('DataFabricDirectory.AssignRoles')
+], DataFabricDirectoryService.prototype, "assignRoles", null);
+__decorate([
+    track('DataFabricDirectory.RevokeRoles')
+], DataFabricDirectoryService.prototype, "revokeRoles", null);
+
 exports.ChoiceSetService = ChoiceSetService;
 exports.ChoiceSets = ChoiceSetService;
+exports.DataFabricDirectoryService = DataFabricDirectoryService;
+exports.DataFabricRoleService = DataFabricRoleService;
 exports.Entities = EntityService;
 exports.EntityService = EntityService;
 exports.createEntityWithMethods = createEntityWithMethods;