@uipath/uipath-typescript 1.3.9 → 1.3.11

package/dist/entities/index.cjs

@@ -611,14 +611,25 @@ class ApiClient {
             if (!text) {
                 return undefined;
             }
-            return JSON.parse(text);
+            try {
+                return JSON.parse(text);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new ServerError({
+                        message: `Server returned non-JSON response (${response.status} ${response.url}): ${error.message}`,
+                        statusCode: response.status,
+                    });
+                }
+                throw error;
+            }
         }
         catch (error) {
             // If it's already one of our errors, re-throw it
             if (error.type && error.type.includes('Error')) {
                 throw error;
             }
-            // Otherwise, it's likely a network error
+            // Otherwise, it's a genuine network/fetch failure
             throw ErrorFactory.createNetworkError(error);
         }
     }
@@ -1240,9 +1251,9 @@ class PaginationHelpers {
      * @returns Promise resolving to a paginated result
      */
     static async getAllPaginated(params) {
-        const { serviceAccess, getEndpoint, folderId, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getEndpoint, folderId, headers: providedHeaders, paginationParams, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         const endpoint = getEndpoint(folderId);
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         const paginatedResponse = await serviceAccess.requestWithPagination(method, endpoint, paginationParams, {
             headers,
             params: additionalParams,
@@ -1270,13 +1281,13 @@ class PaginationHelpers {
      * @returns Promise resolving to an object with data and totalCount
      */
     static async getAllNonPaginated(params) {
-        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
+        const { serviceAccess, getAllEndpoint, getByFolderEndpoint, folderId, headers: providedHeaders, additionalParams, transformFn, method = HTTP_METHODS.GET, options = {} } = params;
         // Set default field names
         const itemsField = options.itemsField || DEFAULT_ITEMS_FIELD;
         const totalCountField = options.totalCountField || DEFAULT_TOTAL_COUNT_FIELD;
         // Determine endpoint and headers based on folderId
         const endpoint = folderId ? getByFolderEndpoint : getAllEndpoint;
-        const headers = folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {};
+        const headers = providedHeaders ?? (folderId ? createHeaders({ [FOLDER_ID]: folderId }) : {});
         // Make the API call based on method
         let response;
         if (method === HTTP_METHODS.POST) {
@@ -1335,6 +1346,7 @@ class PaginationHelpers {
                 serviceAccess: config.serviceAccess,
                 getEndpoint: config.getEndpoint,
                 folderId,
+                headers: config.headers,
                 paginationParams: cursor ? { cursor, pageSize } : jumpToPage ? { jumpToPage, pageSize } : { pageSize },
                 additionalParams: prefixedOptions,
                 transformFn: config.transformFn,
@@ -1352,6 +1364,7 @@ class PaginationHelpers {
             getAllEndpoint: config.getEndpoint(),
             getByFolderEndpoint: byFolderEndpoint,
             folderId,
+            headers: config.headers,
             additionalParams: prefixedOptions,
             transformFn: config.transformFn,
             method: config.method,
@@ -1938,6 +1951,12 @@ const DATA_FABRIC_ENDPOINTS = {
     CHOICESETS: {
         GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
         GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
+        CREATE: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+        UPDATE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/metadata`,
+        DELETE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/delete`,
+        INSERT_BY_NAME: (choiceSetName) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/insert`,
+        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`,
     },
 };
 
@@ -2772,10 +2791,6 @@ class EntityService extends BaseService {
      * @internal
      */
     async create(name, fields, options) {
-        this.validateName(name, 'entity');
-        for (const field of fields) {
-            this.validateName(field.fieldName, 'field');
-        }
         const opts = options ?? {};
         const payload = {
             ...(opts.description !== undefined && { description: opts.description }),
@@ -2918,6 +2933,7 @@ class EntityService extends BaseService {
                     ...(update.isUnique !== undefined && { isUnique: update.isUnique }),
                     ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
                     ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
+                    ...(update.isHiddenField !== undefined && { isHiddenField: update.isHiddenField }),
                     ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
                     ...(hasConstraintUpdate && f.sqlType && { sqlType: { ...f.sqlType, ...constraintUpdate } }),
                 };
@@ -2926,9 +2942,6 @@ class EntityService extends BaseService {
         // Build and append new fields
         const newFields = [];
         if (options.addFields?.length) {
-            for (const field of options.addFields) {
-                this.validateName(field.fieldName, 'field');
-            }
             newFields.push(...options.addFields.map(f => this.buildSchemaFieldPayload(f)));
         }
         await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, {
@@ -3029,9 +3042,15 @@ class EntityService extends BaseService {
     }
     /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
     buildSchemaFieldPayload(field) {
-        this.validateName(field.fieldName, 'field');
         const fieldType = field.type ?? exports.EntityFieldDataType.STRING;
         this.validateFieldConstraints(fieldType, field, field.fieldName);
+        const isRelationship = fieldType === exports.EntityFieldDataType.RELATIONSHIP;
+        const isFile = fieldType === exports.EntityFieldDataType.FILE;
+        if ((isRelationship || isFile) && (!field.referenceEntityId || !field.referenceFieldId)) {
+            throw new ValidationError({
+                message: `Field '${field.fieldName}' of type ${fieldType} requires both referenceEntityId and referenceFieldId (UUIDs of the target entity and field).`,
+            });
+        }
         const mapping = EntitySchemaFieldTypeMap[fieldType];
         return {
             name: field.fieldName,
@@ -3046,10 +3065,13 @@ class EntityService extends BaseService {
             isUnique: field.isUnique ?? false,
             isRbacEnabled: field.isRbacEnabled ?? false,
             isEncrypted: field.isEncrypted ?? false,
+            isHiddenField: field.isHiddenField ?? false,
             ...(field.defaultValue !== undefined && { defaultValue: field.defaultValue }),
             ...(field.choiceSetId !== undefined && { choiceSetId: field.choiceSetId }),
-            ...(field.referenceEntityName !== undefined && { referenceEntityName: field.referenceEntityName }),
-            ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
+            ...((isRelationship || isFile) && { isForeignKey: true }),
+            ...(isRelationship && { referenceType: exports.ReferenceType.ManyToOne }),
+            ...(field.referenceEntityId !== undefined && { referenceEntity: { id: field.referenceEntityId } }),
+            ...(field.referenceFieldId !== undefined && { referenceField: { id: field.referenceFieldId } }),
         };
     }
     /**
@@ -3153,24 +3175,7 @@ class EntityService extends BaseService {
                 return {};
         }
     }
-    validateName(name, context) {
-        if (name.length < 3 || name.length > 100 || !/^[a-zA-Z]\w*$/.test(name)) {
-            const suggestion = name.replace(/\W/g, '').replace(/^[0-9_]+/, '');
-            const defaultName = `My${context.charAt(0).toUpperCase() + context.slice(1)}`;
-            throw new ValidationError({
-                message: `Invalid ${context} name '${name}'. Must start with a letter, contain only letters, numbers, and underscores, 3–100 characters (e.g., "${suggestion || defaultName}").`
-            });
-        }
-        if (context === 'field' && EntityService.RESERVED_FIELD_NAMES.has(name)) {
-            throw new ValidationError({
-                message: `Field name '${name}' is reserved. Reserved names: ${[...EntityService.RESERVED_FIELD_NAMES].join(', ')}.`
-            });
-        }
-    }
 }
-EntityService.RESERVED_FIELD_NAMES = new Set([
-    'Id', 'CreatedBy', 'CreateTime', 'UpdatedBy', 'UpdateTime'
-]);
 __decorate([
     track('Entities.GetById')
 ], EntityService.prototype, "getById", null);
@@ -3267,7 +3272,7 @@ class ChoiceSetService extends BaseService {
      *
      * @example
      * ```typescript
-     * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+     * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
      *
      * const choiceSets = new ChoiceSets(sdk);
      *
@@ -3316,6 +3321,188 @@ class ChoiceSetService extends BaseService {
             }
         }, options);
     }
+    /**
+     * Creates a new Data Fabric choice set
+     *
+     * @param name - Choice set name. Must start with a
+     *   letter, may contain only letters, numbers, and underscores, length
+     *   3–100 characters (e.g., `"expenseTypes"`).
+     * @param options - Optional choice-set-level settings ({@link ChoiceSetCreateOptions})
+     * @returns Promise resolving to the UUID of the created choice set
+     *
+     * @example
+     * ```typescript
+     * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
+     *
+     * const choicesets = new ChoiceSets(sdk);
+     *
+     * // Minimal create
+     * const expenseTypesId = await choicesets.create("expense_types");
+     *
+     * // With display name and description
+     * const priorityLevelsId = await choicesets.create("priority_levels", {
+     *   displayName: "Priority Levels",
+     *   description: "Ticket priority categories",
+     * });
+     * ```
+     * @internal
+     */
+    async create(name, options) {
+        const opts = options ?? {};
+        const payload = {
+            ...(opts.description !== undefined && { description: opts.description }),
+            ...(opts.displayName !== undefined && { displayName: opts.displayName }),
+            entityDefinition: {
+                name,
+                fields: [],
+                folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
+            },
+        };
+        const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.CREATE, payload);
+        return response.data;
+    }
+    /**
+     * Updates an existing choice set's metadata (display name and/or description).
+     *
+     * **At least one of `displayName` or `description` must be provided** —
+     * the call throws `ValidationError` if both are omitted.
+     *
+     * @param choiceSetId - UUID of the choice set to update
+     * @param options - Metadata fields to change ({@link ChoiceSetUpdateOptions})
+     * @returns Promise resolving when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // First, get the choice set ID using getAll()
+     * const allChoiceSets = await choicesets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+     *
+     * await choicesets.updateById(expenseTypes.id, {
+     *   displayName: "Expense Categories",
+     *   description: "Updated description",
+     * });
+     * ```
+     * @internal
+     */
+    async updateById(choiceSetId, options) {
+        if (options.displayName === undefined && options.description === undefined) {
+            throw new ValidationError({
+                message: 'updateById requires at least one of displayName or description.',
+            });
+        }
+        await this.patch(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE(choiceSetId), {
+            ...(options.displayName !== undefined && { displayName: options.displayName }),
+            ...(options.description !== undefined && { description: options.description }),
+        });
+    }
+    /**
+     * Deletes a Data Fabric choice set and all its values.
+     *
+     * @param choiceSetId - UUID of the choice set to delete
+     * @returns Promise resolving when the choice set is deleted
+     *
+     * @example
+     * ```typescript
+     * // First, get the choice set ID using getAll()
+     * const allChoiceSets = await choicesets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+     *
+     * await choicesets.deleteById(expenseTypes.id);
+     * ```
+     * @internal
+     */
+    async deleteById(choiceSetId) {
+        await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE(choiceSetId), {});
+    }
+    /**
+     * Inserts a single value into a choice set.
+     *
+     * @param choiceSetId - UUID of the parent choice set
+     * @param name - Identifier name of the new value (e.g., `"TRAVEL"`)
+     * @param options - Optional fields ({@link ChoiceSetValueInsertOptions})
+     * @returns Promise resolving to the inserted value ({@link ChoiceSetValueInsertResponse})
+     *
+     * @example
+     * ```typescript
+     * // First, get the choice set ID using getAll()
+     * const allChoiceSets = await choicesets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+     *
+     * const inserted = await choicesets.insertValueById(expenseTypes.id, 'TRAVEL', {
+     *   displayName: 'Travel',
+     * });
+     * console.log(inserted.id);
+     * ```
+     * @internal
+     */
+    async insertValueById(choiceSetId, name, options) {
+        const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+        const payload = {
+            Name: name,
+            ...(options?.displayName !== undefined && { DisplayName: options.displayName }),
+        };
+        const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.INSERT_BY_NAME(choiceSetName), payload);
+        const camelCased = pascalToCamelCaseKeys(response.data);
+        return transformData(camelCased, EntityMap);
+    }
+    /**
+     * Updates an existing choice-set value's display name.
+     *
+     * Only `displayName` is mutable; the value's `name` (identifier) is fixed at
+     * insert time and cannot be changed.
+     *
+     * @param choiceSetId - UUID of the parent choice set
+     * @param valueId - UUID of the value to update
+     * @param displayName - New human-readable display name for the value
+     * @returns Promise resolving to the updated value ({@link ChoiceSetValueUpdateResponse})
+     *
+     * @example
+     * ```typescript
+     * // Get the choice set ID from getAll() and the value ID from getById()
+     * const allChoiceSets = await choicesets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'expense_types');
+     * const values = await choicesets.getById(expenseTypes.id);
+     * const travel = values.items.find(v => v.name === 'TRAVEL');
+     *
+     * await choicesets.updateValueById(expenseTypes.id, travel.id, 'Business Travel');
+     * ```
+     * @internal
+     */
+    async updateValueById(choiceSetId, valueId, displayName) {
+        const choiceSetName = await this.resolveChoiceSetName(choiceSetId);
+        const payload = { DisplayName: displayName };
+        const response = await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.UPDATE_BY_NAME(choiceSetName, valueId), payload);
+        const camelCased = pascalToCamelCaseKeys(response.data);
+        return transformData(camelCased, EntityMap);
+    }
+    /**
+     * Deletes one or more values from a choice set.
+     *
+     * @param choiceSetId - UUID of the parent choice set
+     * @param valueIds - Array of value UUIDs to delete
+     * @returns Promise resolving when the values are deleted
+     *
+     * @example
+     * ```typescript
+     * // Get the value IDs from getById()
+     * const values = await choicesets.getById('<choiceSetId>');
+     * const idsToDelete = values.items.slice(0, 2).map(v => v.id);
+     *
+     * await choicesets.deleteValuesById('<choiceSetId>', idsToDelete);
+     * ```
+     * @internal
+     */
+    async deleteValuesById(choiceSetId, valueIds) {
+        await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE_BY_ID(choiceSetId), valueIds);
+    }
+    async resolveChoiceSetName(choiceSetId) {
+        const all = await this.getAll();
+        const match = all.find(cs => cs.id === choiceSetId);
+        if (!match) {
+            throw new NotFoundError({ message: `Choice set with id '${choiceSetId}' not found.` });
+        }
+        return match.name;
+    }
 }
 __decorate([
     track('Choicesets.GetAll')
@@ -3323,6 +3510,24 @@ __decorate([
 __decorate([
     track('Choicesets.GetById')
 ], ChoiceSetService.prototype, "getById", null);
+__decorate([
+    track('Choicesets.Create')
+], ChoiceSetService.prototype, "create", null);
+__decorate([
+    track('Choicesets.UpdateById')
+], ChoiceSetService.prototype, "updateById", null);
+__decorate([
+    track('Choicesets.DeleteById')
+], ChoiceSetService.prototype, "deleteById", null);
+__decorate([
+    track('Choicesets.InsertValueById')
+], ChoiceSetService.prototype, "insertValueById", null);
+__decorate([
+    track('Choicesets.UpdateValueById')
+], ChoiceSetService.prototype, "updateValueById", null);
+__decorate([
+    track('Choicesets.DeleteValuesById')
+], ChoiceSetService.prototype, "deleteValuesById", null);
 
 exports.ChoiceSetService = ChoiceSetService;
 exports.ChoiceSets = ChoiceSetService;