@peernova/cuneiform-sf 1.0.3-beta.0 → 1.0.4-beta.8

package/lib/operations/DefinitionPurgeOperation.d.ts

@@ -0,0 +1,199 @@
+import { type ServiceResult } from '../models/service-result.js';
+import { ProfilingDefinitionService, type DefinitionType, type ProfilingStatus, type DeleteSkipReason, type DeleteFailure, type DeleteProgressEvent } from '../services/ProfilingDefinitionService.js';
+/**
+ * Options for the definition purge operation.
+ *
+ * Selection modes:
+ * - `keys` — delete specific definitions by key (exclusive, all other flags ignored)
+ * - `all` — fetch all definitions (optionally narrowed by filters)
+ * - Filters alone — fetch matching definitions via inclusive AND logic
+ *
+ * Filters that map to SOQL (server-side): objectNames, pattern, category, status, isActive, method (as type)
+ * Filters applied client-side after fetch: filter (standard/custom — derived from __c suffix), namespace (string-prefix on objectName)
+ */
+/** Canonical message returned when the user declines the purge confirmation prompt. */
+export declare const PURGE_CANCELLED_MESSAGE = "Purge cancelled by user.";
+export type PurgeOptions = {
+    /** Target org username or alias */
+    targetOrg: string;
+    /** Definition keys to delete (e.g., PD-0001) — exclusive mode, all other flags ignored */
+    keys?: string[];
+    /** Purge all definitions (can be combined with filter flags to narrow) */
+    all?: boolean;
+    /** Filter by target object API names (comma-delimited from CLI) */
+    objectNames?: string[];
+    /** Filter by object type: standard or custom (client-side) */
+    filter?: 'standard' | 'custom';
+    /** Filter by definition name pattern with SOQL LIKE (e.g., Account%) */
+    pattern?: string;
+    /** Filter by definition method/type: metadata, historical, or comparative (client-side) */
+    method?: DefinitionType;
+    /** Filter by category */
+    category?: string;
+    /** Filter by profiling status */
+    status?: ProfilingStatus;
+    /** Filter by object namespace prefix (client-side) */
+    namespace?: string;
+    /** Maximum number of definitions to process */
+    limit?: number;
+    /** Filter by active status */
+    isActive?: boolean;
+    /** Preview mode — categorize without deleting */
+    dryRun?: boolean;
+    /** Skip interactive confirmation prompt */
+    noPrompt?: boolean;
+    /** Progress callback for per-definition status updates */
+    onProgress?: (event: DeleteProgressEvent) => void;
+    /** Callback invoked after definitions are retrieved, reporting count and max label length */
+    onDefinitionsFound?: (count: number, maxLabelLength: number) => void;
+    /**
+     * Callback invoked after categorization but before deletion.
+     * Receives the categorized preview data and returns whether to proceed with deletion.
+     * If not provided or returns true, deletion proceeds. If returns false, operation aborts.
+     */
+    onPreviewReady?: (preview: PreviewData) => Promise<boolean>;
+    /** Optional logger for debug output */
+    logger?: Console;
+};
+/**
+ * Preview entry for a single definition in dry-run mode.
+ */
+export type PurgePreviewEntry = {
+    id: string;
+    key: string;
+    name: string;
+    objectName: string;
+    status: string;
+    action: 'delete' | 'skip';
+    reason?: string;
+};
+/**
+ * Dry-run preview summary.
+ */
+export type PurgePreview = {
+    deletable: number;
+    blockedBySummaries: number;
+    definitions: PurgePreviewEntry[];
+};
+/**
+ * Data passed to the onPreviewReady callback for user confirmation.
+ */
+export type PreviewData = {
+    /** Definitions eligible for deletion */
+    deletable: BlockedDefinition[];
+    /** Definitions blocked by related summaries */
+    blockedBySummaries: BlockedDefinition[];
+    /** Total definitions matched by filters */
+    total: number;
+};
+/**
+ * Blocked definition info for display.
+ */
+export type BlockedDefinition = {
+    id: string;
+    key: string;
+    name: string;
+    objectName: string;
+    objectLabel?: string;
+    category?: string;
+    timeCategory?: string;
+    segmentCategory?: string;
+    status: string;
+};
+/**
+ * Result of a definition purge operation.
+ */
+export type PurgeResult = {
+    /** Number of definitions successfully deleted */
+    deleted: number;
+    /** Number of definitions skipped (has summaries or other reasons) */
+    skipped: number;
+    /** Number of definitions that failed to delete */
+    failed: number;
+    /** Total number of definitions processed (including blocked) */
+    total: number;
+    /** Details about why each definition was skipped */
+    skipReasons: DeleteSkipReason[];
+    /** Details about each deletion failure */
+    failures: DeleteFailure[];
+    /** Definitions blocked by related summaries (pre-categorized) */
+    blockedBySummaries: BlockedDefinition[];
+    /** Whether this was a dry-run (no deletions performed) */
+    dryRun?: boolean;
+    /** Dry-run preview (only present when dryRun is true) */
+    preview?: PurgePreview;
+};
+/**
+ * Error codes specific to purge operations.
+ */
+export declare const PurgeErrorCodes: {
+    /** No selection criteria provided (no --all, --keys, or filters) */
+    readonly NO_SELECTION_CRITERIA: "PURGE_NO_SELECTION_CRITERIA";
+    /** Query for definitions failed */
+    readonly QUERY_FAILED: "PURGE_QUERY_FAILED";
+    /** No eligible definitions found */
+    readonly NO_ELIGIBLE_DEFINITIONS: "PURGE_NO_ELIGIBLE_DEFINITIONS";
+    /** Delete operation failed */
+    readonly DELETE_FAILED: "PURGE_DELETE_FAILED";
+    /** User cancelled the operation */
+    readonly USER_CANCELLED: "PURGE_USER_CANCELLED";
+    /** Operation failed unexpectedly */
+    readonly OPERATION_FAILED: "PURGE_OPERATION_FAILED";
+};
+/**
+ * Orchestrates purging of profiling definitions.
+ *
+ * Follows the 4-layer architecture: Command → Operation → Service → API
+ * This operation layer handles:
+ * 1. Validates selection mode (IDs, --all, or filters)
+ * 2. Fetches definitions using getAllDefinitions() with inclusive AND filters
+ * 3. Pre-categorizes into deletable vs blocked (by summaries)
+ * 4. Applies client-side filters (object type, method)
+ * 5. Optionally previews (dry-run) or executes deletion
+ * 6. Reports per-definition progress and statistics
+ */
+export declare class DefinitionPurgeOperation {
+    private readonly definitionService;
+    private readonly logger?;
+    constructor(definitionService: ProfilingDefinitionService, logger?: Console | undefined);
+    /**
+     * Checks if any filter flags are specified.
+     */
+    private static hasFilterFlags;
+    /**
+     * Builds GetDefinitionsOptions from purge options (server-side filters only).
+     */
+    private static buildQueryOptions;
+    /**
+     * Applies client-side filters that can't be expressed in SOQL.
+     */
+    private static applyClientFilters;
+    /**
+     * Categorizes definitions into deletable and blocked-by-summaries.
+     *
+     * Definitions can be deleted regardless of profiling status as long as
+     * they have no associated summaries.
+     */
+    private static categorize;
+    /**
+     * Maps a definition to a BlockedDefinition for display.
+     */
+    private static toBlockedDefinition;
+    /**
+     * Creates the empty result structure.
+     */
+    private static emptyResult;
+    /**
+     * Executes the definition purge operation.
+     */
+    execute(options: PurgeOptions): Promise<ServiceResult<PurgeResult>>;
+    /**
+     * Executes purge in key-list mode.
+     * Fetches all definitions, matches by key, ignores all other flags.
+     */
+    private executeKeyMode;
+    /**
+     * Executes purge in filter mode (--all or filter flags).
+     */
+    private executeFilterMode;
+}

package/lib/operations/DefinitionPurgeOperation.js

@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 2026, PeerNova, Inc. All Rights Reserved.
+ * PROPRIETARY AND CONFIDENTIAL. Unauthorized copying, modification,
+ * or distribution is strictly prohibited. Use is governed by the
+ * Master Subscription Agreement (MSA) between PeerNova, Inc. and the
+ * licensee. See LICENSE file in the repo root.
+ */
+import { createSuccessResult, createFailureResult } from '../models/service-result.js';
+/**
+ * Options for the definition purge operation.
+ *
+ * Selection modes:
+ * - `keys` — delete specific definitions by key (exclusive, all other flags ignored)
+ * - `all` — fetch all definitions (optionally narrowed by filters)
+ * - Filters alone — fetch matching definitions via inclusive AND logic
+ *
+ * Filters that map to SOQL (server-side): objectNames, pattern, category, status, isActive, method (as type)
+ * Filters applied client-side after fetch: filter (standard/custom — derived from __c suffix), namespace (string-prefix on objectName)
+ */
+/** Canonical message returned when the user declines the purge confirmation prompt. */
+export const PURGE_CANCELLED_MESSAGE = 'Purge cancelled by user.';
+/**
+ * Error codes specific to purge operations.
+ */
+export const PurgeErrorCodes = {
+    /** No selection criteria provided (no --all, --keys, or filters) */
+    NO_SELECTION_CRITERIA: 'PURGE_NO_SELECTION_CRITERIA',
+    /** Query for definitions failed */
+    QUERY_FAILED: 'PURGE_QUERY_FAILED',
+    /** No eligible definitions found */
+    NO_ELIGIBLE_DEFINITIONS: 'PURGE_NO_ELIGIBLE_DEFINITIONS',
+    /** Delete operation failed */
+    DELETE_FAILED: 'PURGE_DELETE_FAILED',
+    /** User cancelled the operation */
+    USER_CANCELLED: 'PURGE_USER_CANCELLED',
+    /** Operation failed unexpectedly */
+    OPERATION_FAILED: 'PURGE_OPERATION_FAILED',
+};
+/**
+ * Orchestrates purging of profiling definitions.
+ *
+ * Follows the 4-layer architecture: Command → Operation → Service → API
+ * This operation layer handles:
+ * 1. Validates selection mode (IDs, --all, or filters)
+ * 2. Fetches definitions using getAllDefinitions() with inclusive AND filters
+ * 3. Pre-categorizes into deletable vs blocked (by summaries)
+ * 4. Applies client-side filters (object type, method)
+ * 5. Optionally previews (dry-run) or executes deletion
+ * 6. Reports per-definition progress and statistics
+ */
+export class DefinitionPurgeOperation {
+    definitionService;
+    logger;
+    constructor(definitionService, logger) {
+        this.definitionService = definitionService;
+        this.logger = logger;
+    }
+    /**
+     * Checks if any filter flags are specified.
+     */
+    static hasFilterFlags(options) {
+        return (options.objectNames !== undefined ||
+            options.filter !== undefined ||
+            options.pattern !== undefined ||
+            options.method !== undefined ||
+            options.category !== undefined ||
+            options.status !== undefined ||
+            options.namespace !== undefined ||
+            options.isActive !== undefined);
+    }
+    /**
+     * Builds GetDefinitionsOptions from purge options (server-side filters only).
+     */
+    static buildQueryOptions(options) {
+        const queryOptions = {};
+        if (options.objectNames !== undefined) {
+            queryOptions.objectNames = options.objectNames;
+        }
+        if (options.pattern !== undefined) {
+            queryOptions.namePattern = options.pattern;
+        }
+        if (options.category !== undefined) {
+            queryOptions.category = options.category;
+        }
+        if (options.status !== undefined) {
+            queryOptions.status = options.status;
+        }
+        if (options.isActive !== undefined) {
+            queryOptions.isActive = options.isActive;
+        }
+        if (options.method !== undefined) {
+            queryOptions.type = options.method;
+        }
+        return queryOptions;
+    }
+    /**
+     * Applies client-side filters that can't be expressed in SOQL.
+     */
+    static applyClientFilters(definitions, options) {
+        let filtered = definitions;
+        // Filter by object type (standard vs custom)
+        if (options.filter !== undefined) {
+            filtered = filtered.filter((def) => {
+                const isCustom = def.objectName.endsWith('__c');
+                return options.filter === 'custom' ? isCustom : !isCustom;
+            });
+        }
+        // Filter by object namespace prefix
+        if (options.namespace !== undefined) {
+            const nsPrefix = options.namespace.endsWith('__') ? options.namespace : `${options.namespace}__`;
+            filtered = filtered.filter((def) => def.objectName.startsWith(nsPrefix));
+        }
+        // Apply limit (bypassed when --all is specified)
+        if (options.limit !== undefined && options.limit > 0 && !options.all) {
+            filtered = filtered.slice(0, options.limit);
+        }
+        return filtered;
+    }
+    /**
+     * Categorizes definitions into deletable and blocked-by-summaries.
+     *
+     * Definitions can be deleted regardless of profiling status as long as
+     * they have no associated summaries.
+     */
+    static categorize(definitions) {
+        const deletable = [];
+        const blockedBySummaries = [];
+        for (const def of definitions) {
+            if (def.hasRelatedSummaries) {
+                blockedBySummaries.push(def);
+            }
+            else {
+                deletable.push(def);
+            }
+        }
+        return { deletable, blockedBySummaries };
+    }
+    /**
+     * Maps a definition to a BlockedDefinition for display.
+     */
+    static toBlockedDefinition(def) {
+        return {
+            id: def.id,
+            key: def.key,
+            name: def.name,
+            objectName: def.objectName,
+            objectLabel: def.objectLabel,
+            category: def.category,
+            timeCategory: def.timeCategory,
+            segmentCategory: def.segmentCategory,
+            status: def.status,
+        };
+    }
+    /**
+     * Creates the empty result structure.
+     */
+    static emptyResult() {
+        return {
+            deleted: 0,
+            skipped: 0,
+            failed: 0,
+            total: 0,
+            skipReasons: [],
+            failures: [],
+            blockedBySummaries: [],
+        };
+    }
+    /**
+     * Executes the definition purge operation.
+     */
+    async execute(options) {
+        const startTime = Date.now();
+        const emptyResult = DefinitionPurgeOperation.emptyResult();
+        try {
+            this.logger?.log('Starting definition purge operation');
+            const hasKeys = options.keys !== undefined && options.keys.length > 0;
+            const hasAll = options.all === true;
+            const hasFilters = DefinitionPurgeOperation.hasFilterFlags(options);
+            // Key-list mode: exclusive — fetch all, match by key, delete matched
+            if (hasKeys) {
+                return await this.executeKeyMode(options, startTime);
+            }
+            // Validation: Must have at least one selection criterion
+            if (!hasAll && !hasFilters) {
+                return createFailureResult(emptyResult, PurgeErrorCodes.NO_SELECTION_CRITERIA, 'No selection criteria specified. Provide --all, --keys, or filter flags.', { metadata: { duration: Date.now() - startTime } });
+            }
+            // Filter mode (--all or filter flags)
+            return await this.executeFilterMode(options, startTime);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.log(`Definition purge operation failed: ${errorMessage}`);
+            return createFailureResult(emptyResult, PurgeErrorCodes.OPERATION_FAILED, errorMessage, {
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+    }
+    /**
+     * Executes purge in key-list mode.
+     * Fetches all definitions, matches by key, ignores all other flags.
+     */
+    async executeKeyMode(options, startTime) {
+        const keys = options.keys;
+        const keySet = new Set(keys);
+        this.logger?.log(`Fetching definitions to match keys: ${keys.join(', ')}`);
+        const queryResult = await this.definitionService.getAllDefinitions({});
+        if (!queryResult.success) {
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.QUERY_FAILED, queryResult.message, { metadata: { duration: Date.now() - startTime } });
+        }
+        const matched = queryResult.data.filter((def) => keySet.has(def.key));
+        const matchedKeys = new Set(matched.map((def) => def.key));
+        const unmatchedKeys = keys.filter((k) => !matchedKeys.has(k));
+        const maxMatchedLabel = matched.reduce((max, def) => Math.max(max, def.name.length), 0);
+        options.onDefinitionsFound?.(matched.length, maxMatchedLabel);
+        if (matched.length === 0) {
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.NO_ELIGIBLE_DEFINITIONS, `No definitions found matching keys: ${keys.join(', ')}`, { metadata: { duration: Date.now() - startTime } });
+        }
+        const warnings = unmatchedKeys.length > 0 ? [`Keys not found: ${unmatchedKeys.join(', ')}`] : undefined;
+        // Pre-categorize matched definitions
+        const { deletable, blockedBySummaries } = DefinitionPurgeOperation.categorize(matched);
+        const deletableInfo = deletable.map((def) => DefinitionPurgeOperation.toBlockedDefinition(def));
+        const blockedBySummariesInfo = blockedBySummaries.map((def) => DefinitionPurgeOperation.toBlockedDefinition(def));
+        // Invoke preview callback for user confirmation (unless dry-run or no-prompt)
+        if (options.onPreviewReady && !options.dryRun && !options.noPrompt) {
+            const proceed = await options.onPreviewReady({
+                deletable: deletableInfo,
+                blockedBySummaries: blockedBySummariesInfo,
+                total: matched.length,
+            });
+            if (!proceed) {
+                return createSuccessResult({
+                    ...DefinitionPurgeOperation.emptyResult(),
+                    total: matched.length,
+                    blockedBySummaries: blockedBySummariesInfo,
+                }, {
+                    message: PURGE_CANCELLED_MESSAGE,
+                    warnings,
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+        }
+        // Dry-run mode
+        if (options.dryRun) {
+            const preview = {
+                deletable: deletable.length,
+                blockedBySummaries: blockedBySummaries.length,
+                definitions: [
+                    ...deletable.map((def) => ({
+                        id: def.id,
+                        key: def.key,
+                        name: def.name,
+                        objectName: def.objectName,
+                        status: def.status,
+                        action: 'delete',
+                    })),
+                    ...blockedBySummaries.map((def) => ({
+                        id: def.id,
+                        key: def.key,
+                        name: def.name,
+                        objectName: def.objectName,
+                        status: def.status,
+                        action: 'skip',
+                        reason: 'has_summaries',
+                    })),
+                ],
+            };
+            return createSuccessResult({
+                ...DefinitionPurgeOperation.emptyResult(),
+                deleted: deletable.length,
+                total: matched.length,
+                dryRun: true,
+                preview,
+                blockedBySummaries: blockedBySummariesInfo,
+            }, {
+                message: `Dry-run: ${deletable.length} deletable, ${blockedBySummaries.length} blocked by summaries`,
+                warnings,
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        // No deletable definitions
+        if (deletable.length === 0) {
+            return createSuccessResult({
+                ...DefinitionPurgeOperation.emptyResult(),
+                total: matched.length,
+                skipped: matched.length,
+                blockedBySummaries: blockedBySummariesInfo,
+            }, {
+                message: 'Purged 0 profiling definitions',
+                warnings,
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        // Execute deletion
+        const idsToDelete = deletable.map((def) => def.id);
+        const deleteResult = await this.definitionService.deleteDefinitions(idsToDelete, {
+            onProgress: options.onProgress,
+        });
+        if (!deleteResult.success) {
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.DELETE_FAILED, deleteResult.message, { metadata: { duration: Date.now() - startTime } });
+        }
+        const { deleted, skipped, failed, skipReasons, failures } = deleteResult.data;
+        return createSuccessResult({
+            deleted,
+            skipped: skipped + blockedBySummaries.length,
+            failed,
+            total: matched.length,
+            skipReasons,
+            failures,
+            blockedBySummaries: blockedBySummariesInfo,
+        }, {
+            message: `Purged ${deleted} profiling definitions`,
+            warnings,
+            metadata: { duration: Date.now() - startTime },
+        });
+    }
+    /**
+     * Executes purge in filter mode (--all or filter flags).
+     */
+    async executeFilterMode(options, startTime) {
+        // Build server-side query options
+        const queryOptions = DefinitionPurgeOperation.buildQueryOptions(options);
+        this.logger?.log('Fetching definitions with filters...');
+        const queryResult = await this.definitionService.getAllDefinitions(queryOptions);
+        if (!queryResult.success) {
+            this.logger?.log(`Definition query failed: ${queryResult.message}`);
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.QUERY_FAILED, queryResult.message, { metadata: { duration: Date.now() - startTime } });
+        }
+        // Apply client-side filters
+        const filtered = DefinitionPurgeOperation.applyClientFilters(queryResult.data, options);
+        const maxFilteredLabel = filtered.reduce((max, def) => Math.max(max, def.name.length), 0);
+        options.onDefinitionsFound?.(filtered.length, maxFilteredLabel);
+        if (filtered.length === 0) {
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.NO_ELIGIBLE_DEFINITIONS, 'No definitions found matching the specified criteria.', { metadata: { duration: Date.now() - startTime } });
+        }
+        // Pre-categorize
+        const { deletable, blockedBySummaries } = DefinitionPurgeOperation.categorize(filtered);
+        const deletableInfo = deletable.map((def) => DefinitionPurgeOperation.toBlockedDefinition(def));
+        const blockedBySummariesInfo = blockedBySummaries.map((def) => DefinitionPurgeOperation.toBlockedDefinition(def));
+        // Invoke preview callback for user confirmation (unless dry-run or no-prompt)
+        if (options.onPreviewReady && !options.dryRun && !options.noPrompt) {
+            const proceed = await options.onPreviewReady({
+                deletable: deletableInfo,
+                blockedBySummaries: blockedBySummariesInfo,
+                total: filtered.length,
+            });
+            if (!proceed) {
+                return createSuccessResult({
+                    ...DefinitionPurgeOperation.emptyResult(),
+                    total: filtered.length,
+                    blockedBySummaries: blockedBySummariesInfo,
+                }, {
+                    message: PURGE_CANCELLED_MESSAGE,
+                    metadata: { duration: Date.now() - startTime },
+                });
+            }
+        }
+        // Dry-run mode: return preview without deleting
+        if (options.dryRun) {
+            const preview = {
+                deletable: deletable.length,
+                blockedBySummaries: blockedBySummaries.length,
+                definitions: [
+                    ...deletable.map((def) => ({
+                        id: def.id,
+                        key: def.key,
+                        name: def.name,
+                        objectName: def.objectName,
+                        status: def.status,
+                        action: 'delete',
+                    })),
+                    ...blockedBySummaries.map((def) => ({
+                        id: def.id,
+                        key: def.key,
+                        name: def.name,
+                        objectName: def.objectName,
+                        status: def.status,
+                        action: 'skip',
+                        reason: 'has_summaries',
+                    })),
+                ],
+            };
+            const result = {
+                ...DefinitionPurgeOperation.emptyResult(),
+                deleted: deletable.length,
+                total: filtered.length,
+                dryRun: true,
+                preview,
+                blockedBySummaries: blockedBySummariesInfo,
+            };
+            return createSuccessResult(result, {
+                message: `Dry-run: ${deletable.length} deletable, ${blockedBySummaries.length} blocked by summaries`,
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        // Emit progress events for pre-categorized blocked definitions
+        const totalForProgress = filtered.length;
+        let progressIndex = 0;
+        for (const def of blockedBySummaries) {
+            progressIndex++;
+            options.onProgress?.({
+                id: def.id,
+                key: def.key,
+                name: def.name,
+                objectName: def.objectName,
+                category: def.category,
+                timeCategory: def.timeCategory,
+                segmentCategory: def.segmentCategory,
+                profilingStatus: def.status,
+                status: 'skipped',
+                reason: 'has_summaries',
+                current: progressIndex,
+                total: totalForProgress,
+            });
+        }
+        // If no deletable definitions, return early
+        if (deletable.length === 0) {
+            const result = {
+                deleted: 0,
+                skipped: blockedBySummaries.length,
+                failed: 0,
+                total: filtered.length,
+                skipReasons: [],
+                failures: [],
+                blockedBySummaries: blockedBySummariesInfo,
+            };
+            return createSuccessResult(result, {
+                message: 'Purged 0 profiling definitions',
+                metadata: { duration: Date.now() - startTime },
+            });
+        }
+        // Execute deletion for eligible definitions
+        const idsToDelete = deletable.map((def) => def.id);
+        const deleteResult = await this.definitionService.deleteDefinitions(idsToDelete, {
+            onProgress: options.onProgress
+                ? (event) => {
+                    // Adjust progress index to account for pre-categorized skips
+                    options.onProgress({
+                        ...event,
+                        current: progressIndex + event.current,
+                        total: totalForProgress,
+                    });
+                }
+                : undefined,
+        });
+        if (!deleteResult.success) {
+            this.logger?.log(`Delete operation failed: ${deleteResult.message}`);
+            return createFailureResult(DefinitionPurgeOperation.emptyResult(), PurgeErrorCodes.DELETE_FAILED, deleteResult.message, { metadata: { duration: Date.now() - startTime } });
+        }
+        const { deleted, skipped, failed, skipReasons, failures } = deleteResult.data;
+        const result = {
+            deleted,
+            skipped: skipped + blockedBySummaries.length,
+            failed,
+            total: filtered.length,
+            skipReasons,
+            failures,
+            blockedBySummaries: blockedBySummariesInfo,
+        };
+        return createSuccessResult(result, {
+            message: `Purged ${result.deleted} profiling definitions`,
+            metadata: { duration: Date.now() - startTime },
+        });
+    }
+}
+//# sourceMappingURL=DefinitionPurgeOperation.js.map