@uipath/data-fabric-tool 1.1.0 → 1.196.0

package/src/commands/entities.ts

@@ -15,9 +15,10 @@ import type {
     RawEntityGetResponse,
 } from "@uipath/uipath-typescript";
 import { EntityFieldDataType } from "@uipath/uipath-typescript";
-import type { Command } from "commander";
+import { type Command, Option } from "commander";
 import { readJsonInput } from "../utils/input";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { fail, requireDestructiveConfirmation } from "../utils/output";
+import { connectOrFail } from "../utils/sdk-client";
 
 interface ListOptions {
     tenant?: string;
@@ -38,40 +39,39 @@ interface UpdateEntityOptions {
     tenant?: string;
     file?: string;
     body?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
 
 const ENTITIES_LIST_EXAMPLES: CommandExample[] = [
     {
-        Description: "List Data Fabric entities",
+        Description: "List Data Fabric entities.",
         Command: "uip df entities list --native-only",
         Output: {
             Code: "EntityList",
             Data: [
                 {
-                    Name: "Invoice",
-                    DisplayName: "Invoice",
-                    ID: "a1b2c3d4-0000-0000-0000-000000000001",
-                    Type: "Standard",
-                    Source: "Native",
-                    Description: "Invoice records",
-                    FieldCount: 8,
-                },
-                {
-                    Name: "Customer",
-                    DisplayName: "Customer",
-                    ID: "a1b2c3d4-0000-0000-0000-000000000002",
-                    Type: "Standard",
-                    Source: "Native",
-                    Description: "Customer records",
-                    FieldCount: 6,
+                    id: "a1b2c3d4-0000-0000-0000-000000000001",
+                    name: "Invoice",
+                    displayName: "Invoice",
+                    entityType: "Standard",
+                    description: "Invoice records",
+                    isRbacEnabled: false,
+                    fields: [
+                        {
+                            id: "f1000000-0000-0000-0000-000000000001",
+                            name: "amount",
+                        },
+                    ],
+                    externalFields: [],
                 },
             ],
         },
@@ -80,34 +80,35 @@ const ENTITIES_LIST_EXAMPLES: CommandExample[] = [
 
 const ENTITIES_GET_EXAMPLES: CommandExample[] = [
     {
-        Description: "Get entity schema by ID",
+        Description: "Get entity schema by ID.",
         Command: "uip df entities get a1b2c3d4-0000-0000-0000-000000000001",
         Output: {
             Code: "EntitySchema",
             Data: {
-                Name: "Invoice",
-                DisplayName: "Invoice",
-                ID: "a1b2c3d4-0000-0000-0000-000000000001",
-                Type: "Standard",
-                Description: "Invoice records",
-                Fields: [
-                    {
-                        ID: "f1000000-0000-0000-0000-000000000001",
-                        Name: "id",
-                        DisplayName: "ID",
-                        Type: "Guid",
-                        Required: true,
-                        PrimaryKey: true,
-                        System: true,
-                    },
+                id: "a1b2c3d4-0000-0000-0000-000000000001",
+                name: "Invoice",
+                displayName: "Invoice",
+                entityType: "Standard",
+                description: "Invoice records",
+                isRbacEnabled: false,
+                fields: [
                     {
-                        ID: "f1000000-0000-0000-0000-000000000002",
-                        Name: "amount",
-                        DisplayName: "Amount",
-                        Type: "Decimal",
-                        Required: true,
-                        PrimaryKey: false,
-                        System: false,
+                        id: "f1000000-0000-0000-0000-000000000002",
+                        name: "amount",
+                        displayName: "Amount",
+                        fieldDataType: { name: "DECIMAL" },
+                        sqlType: {
+                            name: "DECIMAL",
+                            decimalPrecision: 2,
+                            minValue: 0,
+                            maxValue: 999999,
+                        },
+                        isRequired: true,
+                        isUnique: false,
+                        isEncrypted: false,
+                        isRbacEnabled: false,
+                        isPrimaryKey: false,
+                        isSystemField: false,
                     },
                 ],
             },
@@ -134,12 +135,12 @@ const ENTITIES_DELETE_EXAMPLES: CommandExample[] = [
 const ENTITIES_CREATE_EXAMPLES: CommandExample[] = [
     {
         Description:
-            "Create an entity with a choice-set field (single-select and multi-select) and a relationship to another entity. " +
+            "Create an entity with choice-set, relationship, and file fields. " +
             "CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE require 'choiceSetId' (from 'df choice-sets list'). " +
-            "RELATIONSHIP requires 'referenceEntityName' (target entity) and 'referenceFieldName' (the field used to resolve joins on read; e.g. 'Id' or a unique key like 'Email'). " +
-            "Note: regardless of 'referenceFieldName', a relationship column on a record always stores the target record's UUID 'Id' — see 'df records insert' for how to write the value.",
+            "RELATIONSHIP and FILE both require 'referenceEntityId' (UUID of the target entity, from 'df entities list') and 'referenceFieldId' (UUID of the field on the target entity, from 'df entities get <target-id>'). " +
+            "Note: a RELATIONSHIP column on a record always stores the target record's UUID 'Id' (regardless of which 'referenceFieldId' configured the join) — see 'df records insert' for how to write the value.",
         Command:
-            'uip df entities create Expense --body \'{"displayName":"Expense","fields":[{"fieldName":"category","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000001","isRequired":true},{"fieldName":"tags","type":"CHOICE_SET_MULTIPLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000002"},{"fieldName":"submitter","type":"RELATIONSHIP","referenceEntityName":"Employee","referenceFieldName":"Id","isRequired":true}]}\'',
+            'uip df entities create Expense --body \'{"displayName":"Expense","fields":[{"fieldName":"category","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000001","isRequired":true},{"fieldName":"tags","type":"CHOICE_SET_MULTIPLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000002"},{"fieldName":"submitter","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","isRequired":true},{"fieldName":"receipt","type":"FILE","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000099","referenceFieldId":"f1000000-0000-0000-0000-000000000199"}]}\'',
         Output: {
             Code: "EntityCreated",
             Data: { ID: "a1b2c3d4-0000-0000-0000-000000000004" },
@@ -196,54 +197,25 @@ export const registerEntitiesCommand = (program: Command) => {
         )
         .examples(ENTITIES_LIST_EXAMPLES)
         .trackedAction(processContext, async (options: ListOptions) => {
-            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.getAll());
 
             if (listError) {
-                OutputFormatter.error({
-                    Result: RESULTS.Failure,
-                    Message: "Error listing entities",
-                    Instructions: await extractErrorMessage(listError),
-                });
-                processContext.exit(1);
-                return;
+                return fail(
+                    "Error listing entities",
+                    await extractErrorMessage(listError),
+                );
             }
 
-            const entityList = (result ?? [])
-                .map((e) => {
-                    const entity = e as unknown as RawEntityGetResponse;
-                    const externalFields: ExternalSourceFields[] =
-                        entity.externalFields ?? [];
-                    const isNative = externalFields.length === 0;
-                    const connectorName =
-                        externalFields[0]?.externalConnectionDetail
-                            ?.connectorName;
-                    return {
-                        Name: entity.name,
-                        DisplayName: entity.displayName || entity.name,
-                        ID: entity.id,
-                        Type: entity.entityType,
-                        Source: isNative
-                            ? "Native"
-                            : `Federated${connectorName ? ` (${connectorName})` : ""}`,
-                        Description: entity.description || "",
-                        FieldCount: entity.fields.length,
-                    };
-                })
-                .filter((e) => !options.nativeOnly || e.Source === "Native");
+            const entityList = (result ?? []).filter((e) => {
+                if (!options.nativeOnly) return true;
+                const entity = e as unknown as RawEntityGetResponse;
+                const externalFields: ExternalSourceFields[] =
+                    entity.externalFields ?? [];
+                return externalFields.length === 0;
+            });
 
             OutputFormatter.success({
                 Result: RESULTS.Success,
@@ -263,68 +235,33 @@ export const registerEntitiesCommand = (program: Command) => {
         .trackedAction(
             processContext,
             async (id: 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, entity] = await catchError(
                     sdk.entities.getById(id),
                 );
 
                 if (getError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error getting entity schema '${id}'`,
-                        Instructions: await extractErrorMessage(getError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error getting entity schema '${id}'`,
+                        await extractErrorMessage(getError),
+                    );
                 }
 
                 const e = entity as unknown as RawEntityGetResponse;
 
                 if (!e?.fields) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Entity '${id}' not found`,
-                        Instructions:
-                            "Verify the entity ID exists. Use 'df entities list' to see available entities.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Entity '${id}' not found`,
+                        "Verify the entity ID exists. Use 'df entities list' to see available entities.",
+                    );
                 }
 
-                const fields = e.fields.map((field) => ({
-                    ID: field.id,
-                    Name: field.name,
-                    DisplayName: field.displayName,
-                    Type: field.fieldDataType?.name,
-                    Required: field.isRequired,
-                    PrimaryKey: field.isPrimaryKey,
-                    System: field.isSystemField,
-                }));
-
                 OutputFormatter.success({
                     Result: RESULTS.Success,
                     Code: "EntitySchema",
-                    Data: {
-                        Name: e.name,
-                        DisplayName: e.displayName || e.name,
-                        ID: e.id,
-                        Type: e.entityType,
-                        Description: e.description || "",
-                        Fields: fields,
-                    },
+                    Data: e,
                 });
             },
         );
@@ -343,7 +280,10 @@ export const registerEntitiesCommand = (program: Command) => {
             "-f, --file <path>",
             "Path to JSON file with entity definition (fields array required; displayName, description, isRbacEnabled optional)",
         )
-        .option("--body <json>", "Inline JSON entity definition")
+        .option(
+            "--body <json>",
+            "Inline JSON entity definition (use `-` to read from stdin)",
+        )
         .examples(ENTITIES_CREATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -357,13 +297,10 @@ export const registerEntitiesCommand = (program: Command) => {
                 );
 
                 if (parseError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error parsing entity definition",
-                        Instructions: parseError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error parsing entity definition",
+                        parseError.message,
+                    );
                 }
 
                 if (
@@ -371,27 +308,18 @@ export const registerEntitiesCommand = (program: Command) => {
                     parsed === null ||
                     Array.isArray(parsed)
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Entity definition must be a JSON object",
-                        Instructions:
-                            "Provide a JSON object with a 'fields' array and optional displayName, description, isRbacEnabled.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Entity definition must be a JSON object",
+                        "Provide a JSON object with a 'fields' array and optional displayName, description, isRbacEnabled.",
+                    );
                 }
 
                 const definition = parsed as Record<string, unknown>;
                 if (!Array.isArray(definition.fields)) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message:
-                            "Entity definition must include a 'fields' array",
-                        Instructions:
-                            "Provide a JSON object with a 'fields' array containing field definitions.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Entity definition must include a 'fields' array",
+                        "Provide a JSON object with a 'fields' array containing field definitions.",
+                    );
                 }
 
                 const hasInvalidField = (definition.fields as unknown[]).some(
@@ -402,39 +330,21 @@ export const registerEntitiesCommand = (program: Command) => {
                             "string",
                 );
                 if (hasInvalidField) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Each field must include a 'fieldName' string",
-                        Instructions:
-                            'Example: {"fieldName":"title","type":"STRING"}',
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Each field must include a 'fieldName' string",
+                        'Example: {"fieldName":"title","type":"STRING"}',
+                    );
                 }
 
                 if (hasInvalidFieldType(definition.fields as unknown[])) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Invalid field type in fields",
-                        Instructions: `Valid types: ${VALID_FIELD_TYPES_LIST}`,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Invalid field type in fields",
+                        `Valid types: ${VALID_FIELD_TYPES_LIST}`,
+                    );
                 }
 
-                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 createOpts = {
                     ...(definition.displayName !== undefined && {
@@ -460,13 +370,10 @@ export const registerEntitiesCommand = (program: Command) => {
                 );
 
                 if (createError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error creating entity",
-                        Instructions: await extractErrorMessage(createError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error creating entity",
+                        await extractErrorMessage(createError),
+                    );
                 }
 
                 OutputFormatter.success({
@@ -488,11 +395,17 @@ export const registerEntitiesCommand = (program: Command) => {
             "-f, --file <path>",
             "Path to JSON file with update options (addFields, updateFields, removeFields, displayName, description, isRbacEnabled)",
         )
-        .option("--body <json>", "Inline JSON update options")
         .option(
-            "--confirm",
+            "--body <json>",
+            "Inline JSON update options (use `-` to read from stdin)",
+        )
+        .option(
+            "-y, --yes",
             "Required when 'removeFields' is non-empty — acknowledges the field deletion is irreversible",
         )
+        .addOption(
+            new Option("--confirm", "Deprecated alias for --yes").hideHelp(),
+        )
         .option(
             "--reason <reason>",
             "Required when 'removeFields' is non-empty — echoed back in the response so the caller can log it",
@@ -509,13 +422,10 @@ export const registerEntitiesCommand = (program: Command) => {
                 );
 
                 if (parseError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error parsing update options",
-                        Instructions: parseError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error parsing update options",
+                        parseError.message,
+                    );
                 }
 
                 if (
@@ -523,14 +433,10 @@ export const registerEntitiesCommand = (program: Command) => {
                     parsed === null ||
                     Array.isArray(parsed)
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Update options must be a JSON object",
-                        Instructions:
-                            "Provide a JSON object with addFields, updateFields, removeFields, displayName, description, or isRbacEnabled.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Update options must be a JSON object",
+                        "Provide a JSON object with addFields, updateFields, removeFields, displayName, description, or isRbacEnabled.",
+                    );
                 }
 
                 const input = parsed as Record<string, unknown>;
@@ -539,42 +445,30 @@ export const registerEntitiesCommand = (program: Command) => {
                     input.addFields !== undefined &&
                     !Array.isArray(input.addFields)
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "'addFields' must be an array",
-                        Instructions:
-                            'Example: {"addFields":[{"fieldName":"title","type":"STRING"}]}',
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "'addFields' must be an array",
+                        'Example: {"addFields":[{"fieldName":"title","type":"STRING"}]}',
+                    );
                 }
 
                 if (
                     input.updateFields !== undefined &&
                     !Array.isArray(input.updateFields)
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "'updateFields' must be an array",
-                        Instructions:
-                            'Example: {"updateFields":[{"id":"<fieldId>","displayName":"New Name"}]}',
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "'updateFields' must be an array",
+                        'Example: {"updateFields":[{"id":"<fieldId>","displayName":"New Name"}]}',
+                    );
                 }
 
                 if (
                     input.removeFields !== undefined &&
                     !Array.isArray(input.removeFields)
                 ) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "'removeFields' must be an array",
-                        Instructions:
-                            'Example: {"removeFields":[{"fieldName":"old_field"}]}',
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "'removeFields' must be an array",
+                        'Example: {"removeFields":[{"fieldName":"old_field"}]}',
+                    );
                 }
 
                 let trimmedReason: string | undefined;
@@ -591,41 +485,19 @@ export const registerEntitiesCommand = (program: Command) => {
                         return typeof fn !== "string" || fn.trim() === "";
                     });
                     if (hasInvalidRemove) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message:
-                                "Each field in removeFields must include a non-empty 'fieldName' string",
-                            Instructions:
-                                'Example: {"removeFields":[{"fieldName":"old_field"}]}',
-                        });
-                        processContext.exit(1);
-                        return;
-                    }
-
-                    if (options.confirm !== true) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message:
-                                "Confirmation required for destructive operation",
-                            Instructions:
-                                "Pass --confirm to acknowledge field deletion is irreversible.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Each field in removeFields must include a non-empty 'fieldName' string",
+                            'Example: {"removeFields":[{"fieldName":"old_field"}]}',
+                        );
                     }
 
-                    trimmedReason = options.reason?.trim();
-                    if (trimmedReason === undefined || trimmedReason === "") {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message:
-                                "Reason required for destructive operation",
-                            Instructions:
-                                'Pass --reason "<text>" to record why fields are being removed.',
-                        });
-                        processContext.exit(1);
-                        return;
-                    }
+                    const reason = requireDestructiveConfirmation(
+                        options,
+                        `remove fields from entity '${id}'`,
+                        'Pass --reason "<text>" to record why fields are being removed.',
+                    );
+                    if (reason === null) return;
+                    trimmedReason = reason;
 
                     removedFieldNames = (
                         removeFields as { fieldName: string }[]
@@ -642,25 +514,17 @@ export const registerEntitiesCommand = (program: Command) => {
                         },
                     );
                     if (hasInvalidField) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message:
-                                "Each field in addFields must include a non-empty 'fieldName' string",
-                            Instructions:
-                                'Example: {"fieldName":"title","type":"STRING"}',
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Each field in addFields must include a non-empty 'fieldName' string",
+                            'Example: {"fieldName":"title","type":"STRING"}',
+                        );
                     }
 
                     if (hasInvalidFieldType(input.addFields as unknown[])) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: "Invalid field type in addFields",
-                            Instructions: `Valid types: ${VALID_FIELD_TYPES_LIST}`,
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Invalid field type in addFields",
+                            `Valid types: ${VALID_FIELD_TYPES_LIST}`,
+                        );
                     }
 
                     const addNames = (
@@ -670,14 +534,10 @@ export const registerEntitiesCommand = (program: Command) => {
                         (name, i) => addNames.indexOf(name) !== i,
                     );
                     if (duplicateAdd !== undefined) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message: `Duplicate fieldName '${duplicateAdd}' in addFields`,
-                            Instructions:
-                                "Each entry in addFields must have a unique fieldName.",
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            `Duplicate fieldName '${duplicateAdd}' in addFields`,
+                            "Each entry in addFields must have a unique fieldName.",
+                        );
                     }
 
                     if (removedFieldNames.length > 0) {
@@ -685,14 +545,10 @@ export const registerEntitiesCommand = (program: Command) => {
                             removedFieldNames.includes(name),
                         );
                         if (conflict !== undefined) {
-                            OutputFormatter.error({
-                                Result: RESULTS.Failure,
-                                Message: `Field '${conflict}' appears in both addFields and removeFields`,
-                                Instructions:
-                                    "A single update cannot add and remove the same field. Split into two calls if you need to recreate it.",
-                            });
-                            processContext.exit(1);
-                            return;
+                            return fail(
+                                `Field '${conflict}' appears in both addFields and removeFields`,
+                                "A single update cannot add and remove the same field. Split into two calls if you need to recreate it.",
+                            );
                         }
                     }
                 }
@@ -706,31 +562,15 @@ export const registerEntitiesCommand = (program: Command) => {
                         return typeof fid !== "string" || fid.trim() === "";
                     });
                     if (hasInvalidField) {
-                        OutputFormatter.error({
-                            Result: RESULTS.Failure,
-                            Message:
-                                "Each field in updateFields must include a non-empty 'id' string",
-                            Instructions:
-                                'Use \'df entities get <entityId>\' to find field IDs. Example: {"id":"<fieldId>","displayName":"Total Amount","isRequired":true}',
-                        });
-                        processContext.exit(1);
-                        return;
+                        return fail(
+                            "Each field in updateFields must include a non-empty 'id' string",
+                            'Use \'df entities get <entityId>\' to find field IDs. Example: {"id":"<fieldId>","displayName":"Total Amount","isRequired":true}',
+                        );
                     }
                 }
 
-                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 entityService: EntityServiceModel = sdk.entities;
                 const [updateError] = await catchError(
@@ -738,13 +578,10 @@ export const registerEntitiesCommand = (program: Command) => {
                 );
 
                 if (updateError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error updating entity",
-                        Instructions: await extractErrorMessage(updateError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error updating entity",
+                        await extractErrorMessage(updateError),
+                    );
                 }
 
                 OutputFormatter.success({
@@ -768,7 +605,10 @@ export const registerEntitiesCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
-        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .option("-y, --yes", "Acknowledge this is an irreversible operation")
+        .addOption(
+            new Option("--confirm", "Deprecated alias for --yes").hideHelp(),
+        )
         .option(
             "--reason <reason>",
             "Reason for the deletion — echoed back in the response so the caller can log it",
@@ -777,43 +617,15 @@ export const registerEntitiesCommand = (program: Command) => {
         .trackedAction(
             processContext,
             async (id: string, options: DeleteOptions) => {
-                if (options.confirm !== true) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message:
-                            "Confirmation required for destructive operation",
-                        Instructions:
-                            "Pass --confirm to acknowledge this is irreversible.",
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                const reason = options.reason?.trim();
-                if (reason === undefined || reason === "") {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Reason required for destructive operation",
-                        Instructions:
-                            'Pass --reason "<text>" to record why the entity is being deleted.',
-                    });
-                    processContext.exit(1);
-                    return;
-                }
-
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
+                const reason = requireDestructiveConfirmation(
+                    options,
+                    `delete entity '${id}'`,
+                    'Pass --reason "<text>" to record why the entity is being deleted.',
                 );
+                if (reason === null) return;
 
-                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 entityService: EntityServiceModel = sdk.entities;
                 const [deleteError] = await catchError(
@@ -821,13 +633,10 @@ export const registerEntitiesCommand = (program: Command) => {
                 );
 
                 if (deleteError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error deleting entity '${id}'`,
-                        Instructions: await extractErrorMessage(deleteError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error deleting entity '${id}'`,
+                        await extractErrorMessage(deleteError),
+                    );
                 }
 
                 OutputFormatter.success({