@uipath/data-fabric-tool 1.0.4 → 1.195.0

package/src/commands/records.ts

@@ -1,6 +1,7 @@
 import {
     type CommandExample,
     catchError,
+    createHiddenDeprecatedTenantOption,
     extractErrorMessage,
     OutputFormatter,
     processContext,
@@ -10,7 +11,8 @@ import { getFileSystem } from "@uipath/filesystem";
 import type { EntityRecord } from "@uipath/uipath-typescript";
 import type { Command } from "commander";
 import { readFileBinary, readJsonInput } from "../utils/input";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { fail } from "../utils/output";
+import { connectOrFail } from "../utils/sdk-client";
 
 interface ListOptions {
     tenant?: string;
@@ -60,14 +62,13 @@ interface BatchResult {
 
 const RECORDS_LIST_EXAMPLES: CommandExample[] = [
     {
-        Description: "List records in an entity",
+        Description: "List records in an entity.",
         Command:
             "uip df records list a1b2c3d4-0000-0000-0000-000000000001 --limit 2",
         Output: {
             Code: "RecordList",
             Data: {
-                TotalCount: 2,
-                Records: [
+                items: [
                     {
                         Id: "b2c3d4e5-0000-0000-0000-000000000001",
                         amount: 1500,
@@ -77,7 +78,8 @@ const RECORDS_LIST_EXAMPLES: CommandExample[] = [
                         amount: 2750,
                     },
                 ],
-                HasNextPage: false,
+                totalCount: 2,
+                hasNextPage: false,
             },
         },
     },
@@ -113,6 +115,25 @@ const RECORDS_INSERT_EXAMPLES: CommandExample[] = [
             },
         },
     },
+    {
+        Description:
+            "Insert a record into an entity that has choice-set and relationship fields. " +
+            "CHOICE_SET_SINGLE → pass the choice value's 'numberId' (integer, NOT the name string — look it up via 'df choice-sets list-values <id>'). " +
+            "CHOICE_SET_MULTIPLE → pass an array of numberId integers. " +
+            "RELATIONSHIP → always pass the target record's Id (UUID), regardless of which 'referenceFieldId' the schema uses for the join (the referenceFieldId configures the join, not the stored value).",
+        Command:
+            'uip df records insert a1b2c3d4-0000-0000-0000-000000000004 --body \'{"category":0,"tags":[1,3],"submitter":"e1f2a3b4-0000-0000-0000-000000000001","amount":250}\'',
+        Output: {
+            Code: "RecordInserted",
+            Data: {
+                Id: "b2c3d4e5-0000-0000-0000-000000000020",
+                category: 0,
+                tags: [1, 3],
+                submitter: "e1f2a3b4-0000-0000-0000-000000000001",
+                amount: 250,
+            },
+        },
+    },
 ];
 
 const RECORDS_UPDATE_EXAMPLES: CommandExample[] = [
@@ -158,7 +179,9 @@ export const registerRecordsCommand = (program: Command) => {
         .command("list")
         .description("List records in a Data Fabric entity")
         .argument("<id>", "Entity ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option(
             "-l, --limit <number>",
             "Number of records to return per page",
@@ -178,58 +201,36 @@ export const registerRecordsCommand = (program: Command) => {
             async (entityId: string, options: ListOptions) => {
                 const pageSize = Number(options.limit);
                 if (Number.isNaN(pageSize) || pageSize < 1) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Invalid --limit value",
-                        Instructions: "Provide a positive integer for --limit.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Invalid --limit value",
+                        "Provide a positive integer for --limit.",
+                    );
                 }
 
                 if (
                     options.cursor !== undefined &&
                     options.offset !== undefined
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "--offset and --cursor are mutually exclusive",
-                        Instructions:
-                            "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "--offset and --cursor are mutually exclusive",
+                        "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
+                    );
                 }
 
                 let jumpToPage: number | undefined;
                 if (options.offset !== undefined) {
                     const offsetValue = Number(options.offset);
                     if (Number.isNaN(offsetValue) || offsetValue < 0) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Invalid --offset value",
-                            Instructions:
-                                "Provide a non-negative integer for --offset.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Invalid --offset value",
+                            "Provide a non-negative integer for --offset.",
+                        );
                     }
                     jumpToPage = Math.floor(offsetValue / pageSize) + 1;
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [listError, result] = await catchError(
                     sdk.entities.getAllRecords(entityId, {
@@ -242,42 +243,16 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (listError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error listing records",
-                        Instructions: await extractErrorMessage(listError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error listing records",
+                        await extractErrorMessage(listError),
+                    );
                 }
 
-                const r = result as {
-                    items: unknown[];
-                    totalCount?: number;
-                    hasNextPage?: boolean;
-                    nextCursor?: unknown;
-                    currentPage?: number;
-                    totalPages?: number;
-                };
-                const nextCursor = extractCursorValue(r.nextCursor);
-
                 OutputFormatter.success({
                     Result: RESULTS.Success,
                     Code: "RecordList",
-                    Data: {
-                        TotalCount: r.totalCount ?? r.items.length,
-                        Records: r.items,
-                        HasNextPage: r.hasNextPage ?? false,
-                        ...(nextCursor !== undefined && {
-                            NextCursor: nextCursor,
-                        }),
-                        ...(r.currentPage !== undefined && {
-                            CurrentPage: r.currentPage,
-                        }),
-                        ...(r.totalPages !== undefined && {
-                            TotalPages: r.totalPages,
-                        }),
-                    },
+                    Data: result,
                 });
             },
         );
@@ -287,48 +262,32 @@ export const registerRecordsCommand = (program: Command) => {
         .description("Get a single record by ID")
         .argument("<id>", "Entity ID")
         .argument("<key>", "Record ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .examples(RECORDS_GET_EXAMPLES)
         .trackedAction(
             processContext,
             async (entityId: string, recordId: string, options: GetOptions) => {
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [getError, record] = await catchError(
                     sdk.entities.getRecordById(entityId, recordId),
                 );
 
                 if (getError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error getting record '${recordId}'`,
-                        Instructions: await extractErrorMessage(getError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error getting record '${recordId}'`,
+                        await extractErrorMessage(getError),
+                    );
                 }
 
                 if (!record) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Record '${recordId}' not found in entity '${entityId}'`,
-                        Instructions:
-                            "Verify the record ID exists. Use 'df records list' to see available records.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Record '${recordId}' not found in entity '${entityId}'`,
+                        "Verify the record ID exists. Use 'df records list' to see available records.",
+                    );
                 }
 
                 OutputFormatter.success({
@@ -343,7 +302,9 @@ export const registerRecordsCommand = (program: Command) => {
         .command("insert")
         .description("Insert records into a Data Fabric entity")
         .argument("<id>", "Entity ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option(
             "-f, --file <path>",
             "Path to JSON file with record data (object or array of objects)",
@@ -361,28 +322,11 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (parseError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error parsing input data",
-                        Instructions: parseError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail("Error parsing input data", parseError.message);
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const data = rawData as
                     | Record<string, unknown>
@@ -395,14 +339,10 @@ export const registerRecordsCommand = (program: Command) => {
                     );
 
                     if (insertError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error inserting record",
-                            Instructions:
-                                await extractErrorMessage(insertError),
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Error inserting record",
+                            await extractErrorMessage(insertError),
+                        );
                     }
 
                     OutputFormatter.success({
@@ -416,14 +356,10 @@ export const registerRecordsCommand = (program: Command) => {
                     );
 
                     if (insertError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error inserting records",
-                            Instructions:
-                                await extractErrorMessage(insertError),
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Error inserting records",
+                            await extractErrorMessage(insertError),
+                        );
                     }
 
                     const r = result as BatchResult;
@@ -449,7 +385,9 @@ export const registerRecordsCommand = (program: Command) => {
         .command("update")
         .description("Update records in a Data Fabric entity")
         .argument("<id>", "Entity ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option(
             "-f, --file <path>",
             "Path to JSON file with record data (must include Id field)",
@@ -467,28 +405,11 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (parseError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error parsing input data",
-                        Instructions: parseError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail("Error parsing input data", parseError.message);
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const data = rawData as
                     | Record<string, unknown>
@@ -500,14 +421,10 @@ export const registerRecordsCommand = (program: Command) => {
                     const recordId =
                         record.Id !== undefined ? record.Id : record.id;
                     if (recordId === undefined || recordId === null) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Record must include an 'Id' field",
-                            Instructions:
-                                "Provide the record ID in the JSON data.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Record must include an 'Id' field",
+                            "Provide the record ID in the JSON data.",
+                        );
                     }
 
                     const [updateError, result] = await catchError(
@@ -519,14 +436,10 @@ export const registerRecordsCommand = (program: Command) => {
                     );
 
                     if (updateError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error updating record",
-                            Instructions:
-                                await extractErrorMessage(updateError),
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Error updating record",
+                            await extractErrorMessage(updateError),
+                        );
                     }
 
                     OutputFormatter.success({
@@ -539,14 +452,10 @@ export const registerRecordsCommand = (program: Command) => {
                         (r) => r.Id == null && r.id == null,
                     );
                     if (missingId) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "All records must include an 'Id' field",
-                            Instructions:
-                                "Provide the record ID in each JSON object.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "All records must include an 'Id' field",
+                            "Provide the record ID in each JSON object.",
+                        );
                     }
 
                     const [updateError, result] = await catchError(
@@ -557,14 +466,10 @@ export const registerRecordsCommand = (program: Command) => {
                     );
 
                     if (updateError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error updating records",
-                            Instructions:
-                                await extractErrorMessage(updateError),
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Error updating records",
+                            await extractErrorMessage(updateError),
+                        );
                     }
 
                     const r = result as BatchResult;
@@ -595,7 +500,9 @@ export const registerRecordsCommand = (program: Command) => {
                 "aggregates (function: COUNT/SUM/AVG/MIN/MAX, field, alias?), groupBy.",
         )
         .argument("<id>", "Entity ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option(
             "-f, --file <path>",
             "Path to JSON file with query options (filterGroup, selectedFields, sortOptions, aggregates, groupBy)",
@@ -622,41 +529,30 @@ export const registerRecordsCommand = (program: Command) => {
             async (entityId: string, options: QueryOptions) => {
                 const pageSize = Number(options.limit);
                 if (Number.isNaN(pageSize) || pageSize < 1) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Invalid --limit value",
-                        Instructions: "Provide a positive integer for --limit.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Invalid --limit value",
+                        "Provide a positive integer for --limit.",
+                    );
                 }
 
                 if (
                     options.cursor !== undefined &&
                     options.offset !== undefined
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "--offset and --cursor are mutually exclusive",
-                        Instructions:
-                            "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "--offset and --cursor are mutually exclusive",
+                        "Use --offset to jump to a position by record count, or --cursor to continue from a previous response.",
+                    );
                 }
 
                 let jumpToPage: number | undefined;
                 if (options.offset !== undefined) {
                     const offsetValue = Number(options.offset);
                     if (Number.isNaN(offsetValue) || offsetValue < 0) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Invalid --offset value",
-                            Instructions:
-                                "Provide a non-negative integer for --offset.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Invalid --offset value",
+                            "Provide a non-negative integer for --offset.",
+                        );
                     }
                     jumpToPage = Math.floor(offsetValue / pageSize) + 1;
                 }
@@ -671,44 +567,26 @@ export const registerRecordsCommand = (program: Command) => {
                         ),
                     );
                     if (parseError) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Error parsing query options",
-                            Instructions: parseError.message,
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Error parsing query options",
+                            parseError.message,
+                        );
                     }
                     if (
                         typeof parsed !== "object" ||
                         parsed === null ||
                         Array.isArray(parsed)
                     ) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Query options must be a JSON object",
-                            Instructions:
-                                "Provide a JSON object (not an array) with filterGroup, selectedFields, sortOptions, aggregates, or groupBy.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Query options must be a JSON object",
+                            "Provide a JSON object (not an array) with filterGroup, selectedFields, sortOptions, aggregates, or groupBy.",
+                        );
                     }
                     queryBody = parsed as Record<string, unknown>;
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [queryError, result] = await catchError(
                     sdk.entities.queryRecordsById(entityId, {
@@ -722,42 +600,16 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (queryError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error querying records",
-                        Instructions: await extractErrorMessage(queryError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error querying records",
+                        await extractErrorMessage(queryError),
+                    );
                 }
 
-                const r = result as {
-                    items: unknown[];
-                    totalCount?: number;
-                    hasNextPage?: boolean;
-                    nextCursor?: unknown;
-                    currentPage?: number;
-                    totalPages?: number;
-                };
-                const nextCursor = extractCursorValue(r.nextCursor);
-
                 OutputFormatter.success({
                     Result: RESULTS.Success,
                     Code: "RecordQuery",
-                    Data: {
-                        TotalCount: r.totalCount ?? r.items.length,
-                        Records: r.items,
-                        HasNextPage: r.hasNextPage ?? false,
-                        ...(nextCursor !== undefined && {
-                            NextCursor: nextCursor,
-                        }),
-                        ...(r.currentPage !== undefined && {
-                            CurrentPage: r.currentPage,
-                        }),
-                        ...(r.totalPages !== undefined && {
-                            TotalPages: r.totalPages,
-                        }),
-                    },
+                    Data: result,
                 });
             },
         );
@@ -766,19 +618,18 @@ export const registerRecordsCommand = (program: Command) => {
         .command("import")
         .description("Import records from a CSV file into a Data Fabric entity")
         .argument("<id>", "Entity ID")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .option("-f, --file <path>", "Path to the CSV file to import")
         .trackedAction(
             processContext,
             async (entityId: string, options: ImportOptions) => {
                 if (options.file === undefined) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "A CSV file path is required",
-                        Instructions: "Provide a CSV file path via --file.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "A CSV file path is required",
+                        "Provide a CSV file path via --file.",
+                    );
                 }
 
                 const [readError, fileContent] = await catchError(
@@ -786,28 +637,11 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (readError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error reading CSV file",
-                        Instructions: readError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail("Error reading CSV file", readError.message);
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const fs = getFileSystem();
                 const fileName = fs.path.basename(options.file) || "import.csv";
@@ -821,13 +655,10 @@ export const registerRecordsCommand = (program: Command) => {
                 );
 
                 if (importError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error importing records",
-                        Instructions: await extractErrorMessage(importError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error importing records",
+                        await extractErrorMessage(importError),
+                    );
                 }
 
                 const r = result as {
@@ -855,7 +686,9 @@ export const registerRecordsCommand = (program: Command) => {
         .description("Delete records from a Data Fabric entity")
         .argument("<id>", "Entity ID")
         .argument("<key...>", "Record IDs to delete")
-        .option("-t, --tenant <tenant-name>", "Tenant name")
+        .addOption(
+            createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
+        )
         .examples(RECORDS_DELETE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -864,32 +697,18 @@ export const registerRecordsCommand = (program: Command) => {
                 recordIds: string[],
                 options: DeleteOptions,
             ) => {
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [deleteError, result] = await catchError(
                     sdk.entities.deleteRecordsById(entityId, recordIds),
                 );
 
                 if (deleteError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error deleting records",
-                        Instructions: await extractErrorMessage(deleteError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error deleting records",
+                        await extractErrorMessage(deleteError),
+                    );
                 }
 
                 const r = result as BatchResult;
@@ -911,17 +730,6 @@ export const registerRecordsCommand = (program: Command) => {
         );
 };
 
-/** Normalises the SDK cursor to a plain string for CLI output.
- *  The SDK returns `PaginationCursor = { value: string }` but we want
- *  to expose just the string so the user can pass it directly to --cursor. */
-function extractCursorValue(cursor: unknown): string | undefined {
-    if (cursor === undefined || cursor === null) return undefined;
-    if (typeof cursor === "string") return cursor;
-    const c = cursor as Record<string, unknown>;
-    if (typeof c.value === "string") return c.value;
-    return undefined;
-}
-
 const isRecordObject = (value: unknown): value is Record<string, unknown> =>
     typeof value === "object" && value !== null && !Array.isArray(value);