@memberjunction/metadata-sync 3.4.0 → 4.1.0

package/dist/services/PushService.js

@@ -1,35 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PushService = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const core_1 = require("@memberjunction/core");
-const sync_engine_1 = require("../lib/sync-engine");
-const config_1 = require("../config");
-const file_backup_manager_1 = require("../lib/file-backup-manager");
-const config_manager_1 = require("../lib/config-manager");
-const sql_logger_1 = require("../lib/sql-logger");
-const transaction_manager_1 = require("../lib/transaction-manager");
-const json_write_helper_1 = require("../lib/json-write-helper");
-const record_dependency_analyzer_1 = require("../lib/record-dependency-analyzer");
-const json_preprocessor_1 = require("../lib/json-preprocessor");
-const provider_utils_1 = require("../lib/provider-utils");
-const deletion_auditor_1 = require("../lib/deletion-auditor");
-const deletion_report_generator_1 = require("../lib/deletion-report-generator");
+import fs from 'fs-extra';
+import path from 'path';
+import fastGlob from 'fast-glob';
+import { Metadata } from '@memberjunction/core';
+import { DeferrableLookupError } from '../lib/sync-engine.js';
+import { loadEntityConfig, loadSyncConfig } from '../config.js';
+import { FileBackupManager } from '../lib/file-backup-manager.js';
+import { configManager } from '../lib/config-manager.js';
+import { SQLLogger } from '../lib/sql-logger.js';
+import { TransactionManager } from '../lib/transaction-manager.js';
+import { JsonWriteHelper } from '../lib/json-write-helper.js';
+import { RecordDependencyAnalyzer } from '../lib/record-dependency-analyzer.js';
+import { JsonPreprocessor } from '../lib/json-preprocessor.js';
+import { findEntityDirectories } from '../lib/provider-utils.js';
+import { DeletionAuditor } from '../lib/deletion-auditor.js';
+import { DeletionReportGenerator } from '../lib/deletion-report-generator.js';
 // Configuration for parallel processing
 const PARALLEL_BATCH_SIZE = 1; // Number of records to process in parallel at each dependency level
-class PushService {
-    syncEngine;
-    contextUser;
-    warnings = [];
-    syncConfig = null;
-    deferredFileWrites = new Map();
-    deferredRecords = [];
+export class PushService {
     constructor(syncEngine, contextUser) {
+        this.warnings = [];
+        this.syncConfig = null;
+        this.deferredFileWrites = new Map();
+        this.deferredRecords = [];
         this.syncEngine = syncEngine;
         this.contextUser = contextUser;
     }
@@ -56,11 +48,11 @@ class PushService {
         // Reset deferred tracking for this push operation
         this.deferredFileWrites.clear();
         this.deferredRecords = [];
-        const fileBackupManager = new file_backup_manager_1.FileBackupManager();
+        const fileBackupManager = new FileBackupManager();
         // Load sync config for SQL logging settings and autoCreateMissingRecords flag
         // If dir option is specified, load from that directory, otherwise use original CWD
-        const configDir = options.dir ? path_1.default.resolve(config_manager_1.configManager.getOriginalCwd(), options.dir) : config_manager_1.configManager.getOriginalCwd();
-        this.syncConfig = await (0, config_1.loadSyncConfig)(configDir);
+        const configDir = options.dir ? path.resolve(configManager.getOriginalCwd(), options.dir) : configManager.getOriginalCwd();
+        this.syncConfig = await loadSyncConfig(configDir);
         // Display warnings for special flags that are enabled
         if (this.syncConfig?.push?.alwaysPush && !options.dryRun) {
             callbacks?.onWarn?.('\n⚡ WARNING: alwaysPush is enabled - ALL records will be saved to database regardless of changes\n');
@@ -69,14 +61,14 @@ class PushService {
             callbacks?.onWarn?.('\n🔧 WARNING: autoCreateMissingRecords is enabled - Missing records with primaryKey will be created\n');
         }
         if (options.verbose) {
-            callbacks?.onLog?.(`Original working directory: ${config_manager_1.configManager.getOriginalCwd()}`);
+            callbacks?.onLog?.(`Original working directory: ${configManager.getOriginalCwd()}`);
             callbacks?.onLog?.(`Config directory (with dir option): ${configDir}`);
-            callbacks?.onLog?.(`Config file path: ${path_1.default.join(configDir, '.mj-sync.json')}`);
+            callbacks?.onLog?.(`Config file path: ${path.join(configDir, '.mj-sync.json')}`);
             callbacks?.onLog?.(`Full sync config loaded: ${JSON.stringify(this.syncConfig, null, 2)}`);
             callbacks?.onLog?.(`SQL logging config: ${JSON.stringify(this.syncConfig?.sqlLogging)}`);
         }
-        const sqlLogger = new sql_logger_1.SQLLogger(this.syncConfig);
-        const transactionManager = new transaction_manager_1.TransactionManager(sqlLogger);
+        const sqlLogger = new SQLLogger(this.syncConfig);
+        const transactionManager = new TransactionManager(sqlLogger);
         if (options.verbose) {
             callbacks?.onLog?.(`SQLLogger enabled status: ${sqlLogger.enabled}`);
         }
@@ -85,7 +77,7 @@ class PushService {
         try {
             // Initialize SQL logger if enabled and not dry-run
             if (sqlLogger.enabled && !options.dryRun) {
-                const provider = core_1.Metadata.Provider;
+                const provider = Metadata.Provider;
                 if (options.verbose) {
                     callbacks?.onLog?.(`SQL logging enabled: ${sqlLogger.enabled}`);
                     callbacks?.onLog?.(`Provider type: ${provider?.constructor?.name || 'Unknown'}`);
@@ -98,10 +90,10 @@ class PushService {
                         ? `MetadataSync_Push_${timestamp}.sql`
                         : `push_${timestamp}.sql`;
                     // Use .sql-log-push directory in the config directory (where sync was initiated)
-                    const outputDir = path_1.default.join(configDir, this.syncConfig?.sqlLogging?.outputDirectory || './sql-log-push');
-                    const filepath = path_1.default.join(outputDir, filename);
+                    const outputDir = path.join(configDir, this.syncConfig?.sqlLogging?.outputDirectory || './sql-log-push');
+                    const filepath = path.join(outputDir, filename);
                     // Ensure the directory exists
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(filepath));
+                    await fs.ensureDir(path.dirname(filepath));
                     // Create the SQL logging session
                     sqlLoggingSession = await provider.CreateSqlLogger(filepath, {
                         formatAsMigration: this.syncConfig?.sqlLogging?.formatAsMigration || false,
@@ -125,7 +117,7 @@ class PushService {
             // Find entity directories to process
             // Note: If options.dir is specified, configDir already points to that directory
             // So we don't need to pass it as specificDir
-            const entityDirs = (0, provider_utils_1.findEntityDirectories)(configDir, undefined, this.syncConfig?.directoryOrder, this.syncConfig?.ignoreDirectories, options.include, options.exclude);
+            const entityDirs = findEntityDirectories(configDir, undefined, this.syncConfig?.directoryOrder, this.syncConfig?.ignoreDirectories, options.include, options.exclude);
             if (entityDirs.length === 0) {
                 throw new Error('No entity directories found');
             }
@@ -167,8 +159,8 @@ class PushService {
                         try {
                             await sqlLoggingSession.dispose();
                             // Delete the empty SQL log file since no operations occurred
-                            if (await fs_extra_1.default.pathExists(sqlLogPath)) {
-                                await fs_extra_1.default.remove(sqlLogPath);
+                            if (await fs.pathExists(sqlLogPath)) {
+                                await fs.remove(sqlLogPath);
                                 if (options.verbose) {
                                     callbacks?.onLog?.(`🗑️  Removed empty SQL log file: ${sqlLogPath}`);
                                 }
@@ -198,7 +190,7 @@ class PushService {
                 // PHASE 1: Process creates/updates for all entities
                 callbacks?.onLog?.('📝 Processing creates and updates...\n');
                 for (const entityDir of entityDirs) {
-                    const entityConfig = await (0, config_1.loadEntityConfig)(entityDir);
+                    const entityConfig = await loadEntityConfig(entityDir);
                     if (!entityConfig) {
                         const warning = `Skipping ${entityDir} - no valid entity configuration`;
                         this.warnings.push(warning);
@@ -207,7 +199,7 @@ class PushService {
                         continue;
                     }
                     // Show folder with spinner at start
-                    const dirName = path_1.default.relative(process.cwd(), entityDir) || '.';
+                    const dirName = path.relative(process.cwd(), entityDir) || '.';
                     callbacks?.onLog?.(`\n📁 ${dirName}:`);
                     // Use onProgress for animated spinner if available
                     if (callbacks?.onProgress) {
@@ -350,7 +342,7 @@ class PushService {
         let errors = 0;
         // Find all JSON files in the directory
         const pattern = entityConfig.filePattern || '*.json';
-        const files = await (0, fast_glob_1.default)(pattern, {
+        const files = await fastGlob(pattern, {
             cwd: entityDir,
             absolute: true,
             onlyFiles: true,
@@ -368,7 +360,7 @@ class PushService {
                     await fileBackupManager.backupFile(filePath);
                 }
                 // Read the raw file data first
-                const rawFileData = await fs_extra_1.default.readJson(filePath);
+                const rawFileData = await fs.readJson(filePath);
                 // Keep unprocessed data to write back (preserves @file: references)
                 const unprocessedRecords = Array.isArray(rawFileData) ? rawFileData : [rawFileData];
                 const isArray = Array.isArray(rawFileData);
@@ -379,12 +371,12 @@ class PushService {
                 if (hasIncludes) {
                     // Preprocess the JSON file to handle @include directives
                     // Create a new preprocessor instance for each file to ensure clean state
-                    const jsonPreprocessor = new json_preprocessor_1.JsonPreprocessor();
+                    const jsonPreprocessor = new JsonPreprocessor();
                     fileData = await jsonPreprocessor.processFile(filePath);
                 }
                 const records = Array.isArray(fileData) ? fileData : [fileData];
                 // Analyze dependencies and get sorted records
-                const analyzer = new record_dependency_analyzer_1.RecordDependencyAnalyzer();
+                const analyzer = new RecordDependencyAnalyzer();
                 const analysisResult = await analyzer.analyzeFileRecords(records, entityConfig.entity);
                 if (analysisResult.circularDependencies.length > 0) {
                     callbacks?.onWarn?.(`⚠️  Circular dependencies detected in ${filePath}`);
@@ -521,10 +513,10 @@ class PushService {
                     else {
                         // Write immediately for files without deletions
                         if (isArray) {
-                            await json_write_helper_1.JsonWriteHelper.writeOrderedRecordData(filePath, unprocessedRecords);
+                            await JsonWriteHelper.writeOrderedRecordData(filePath, unprocessedRecords);
                         }
                         else {
-                            await json_write_helper_1.JsonWriteHelper.writeOrderedRecordData(filePath, unprocessedRecords[0]);
+                            await JsonWriteHelper.writeOrderedRecordData(filePath, unprocessedRecords[0]);
                         }
                     }
                 }
@@ -537,7 +529,7 @@ class PushService {
         return { created, updated, unchanged, deleted, skipped, deferred, errors };
     }
     async processFlattenedRecord(flattenedRecord, entityDir, options, batchContext, callbacks, entityConfig, allowDefer = true) {
-        const metadata = new core_1.Metadata();
+        const metadata = new Metadata();
         const { record, entityName, parentContext, id: recordId } = flattenedRecord;
         // Skip deletion records - they're handled in Phase 2
         // File writing is deferred for files containing deletions
@@ -584,7 +576,7 @@ class PushService {
                 }
                 catch (pkError) {
                     // Check if this is a deferrable lookup error
-                    if (pkError instanceof sync_engine_1.DeferrableLookupError) {
+                    if (pkError instanceof DeferrableLookupError) {
                         throw new Error(`Cannot defer lookup in primaryKey field '${pkField}': ${pkError.message}. Primary key lookups must resolve immediately.`);
                     }
                     throw pkError;
@@ -660,7 +652,7 @@ class PushService {
             }
             catch (fieldError) {
                 // Check if this is a deferrable lookup error first
-                if (fieldError instanceof sync_engine_1.DeferrableLookupError) {
+                if (fieldError instanceof DeferrableLookupError) {
                     // If allowDefer is false, we're in deferred processing mode - can't defer again
                     if (!allowDefer) {
                         const err = fieldError;
@@ -999,7 +991,7 @@ class PushService {
         }
         return String(value);
     }
-    async processDeleteRecord(flattenedRecord, _entityDir, options, callbacks) {
+    async processDeleteRecord(flattenedRecord, _entityDir, options, callbacks, isDbOnly = false) {
         const { record, entityName } = flattenedRecord;
         // Validate that we have a primary key for deletion
         if (!record.primaryKey || Object.keys(record.primaryKey).length === 0) {
@@ -1046,7 +1038,12 @@ class PushService {
                 primaryKeyDisplay.push(`${pk.Name}: ${existingEntity.Get(pk.Name)}`);
             }
         }
-        callbacks?.onLog?.(`🗑️  Deleting ${entityName} record:`);
+        if (isDbOnly) {
+            callbacks?.onLog?.(`🗑️  Deleting database-only ${entityName} record:`);
+        }
+        else {
+            callbacks?.onLog?.(`🗑️  Deleting ${entityName} record:`);
+        }
         if (primaryKeyDisplay.length > 0) {
             callbacks?.onLog?.(`   Primary Key: ${primaryKeyDisplay.join(', ')}`);
         }
@@ -1074,15 +1071,22 @@ class PushService {
                 }
                 throw new Error(`Failed to delete ${entityName} record: ${errorMessage}`);
             }
-            // Set deletedAt timestamp after successful deletion
-            if (!record.deleteRecord) {
-                record.deleteRecord = { delete: true };
+            // Set deletedAt timestamp after successful deletion (only for metadata records)
+            if (!isDbOnly) {
+                if (!record.deleteRecord) {
+                    record.deleteRecord = { delete: true };
+                }
+                record.deleteRecord.deletedAt = new Date().toISOString();
+                // Update the corresponding record in deferred file writes
+                this.updateDeferredFileRecord(flattenedRecord);
             }
-            record.deleteRecord.deletedAt = new Date().toISOString();
-            // Update the corresponding record in deferred file writes
-            this.updateDeferredFileRecord(flattenedRecord);
             if (options.verbose) {
-                callbacks?.onLog?.(`   ✓ Successfully deleted ${entityName} record`);
+                if (isDbOnly) {
+                    callbacks?.onLog?.(`   ✓ Successfully deleted database-only ${entityName} record`);
+                }
+                else {
+                    callbacks?.onLog?.(`   ✓ Successfully deleted ${entityName} record`);
+                }
             }
             return { status: 'deleted', isDuplicate: false };
         }
@@ -1116,9 +1120,17 @@ class PushService {
         messages.push('  • Create new records');
         messages.push('  • Update existing records');
         if (deletionAudit) {
-            const totalDeletes = deletionAudit.explicitDeletes.size + deletionAudit.implicitDeletes.size;
-            messages.push(`  • Delete ${totalDeletes} record${totalDeletes > 1 ? 's' : ''} (${deletionAudit.explicitDeletes.size} explicit, ${deletionAudit.implicitDeletes.size} implicit)`);
-            if (deletionAudit.orphanedReferences.length > 0) {
+            const metadataDeletes = deletionAudit.explicitDeletes.size + deletionAudit.implicitDeletes.size;
+            const dbOnlyDeletes = deletionAudit.databaseOnlyDeletions?.length ?? 0;
+            const totalDeletes = metadataDeletes + dbOnlyDeletes;
+            if (dbOnlyDeletes > 0) {
+                messages.push(`  • Delete ${totalDeletes} record${totalDeletes > 1 ? 's' : ''} (${deletionAudit.explicitDeletes.size} explicit, ${deletionAudit.implicitDeletes.size} implicit, ${dbOnlyDeletes} database-only)`);
+            }
+            else {
+                messages.push(`  • Delete ${metadataDeletes} record${metadataDeletes > 1 ? 's' : ''} (${deletionAudit.explicitDeletes.size} explicit, ${deletionAudit.implicitDeletes.size} implicit)`);
+            }
+            if (deletionAudit.orphanedReferences.length > 0 && dbOnlyDeletes === 0) {
+                // Only show warning if not deleting DB-only records
                 messages.push(`  ⚠️  ${deletionAudit.orphanedReferences.length} database-only reference${deletionAudit.orphanedReferences.length > 1 ? 's' : ''} detected (may cause FK errors)`);
             }
         }
@@ -1156,12 +1168,12 @@ class PushService {
         for (const entityDir of entityDirs) {
             if (hasAnyDeletions)
                 break; // Early exit once we find any deletion
-            const entityConfig = await (0, config_1.loadEntityConfig)(entityDir);
+            const entityConfig = await loadEntityConfig(entityDir);
             if (!entityConfig) {
                 continue;
             }
             const pattern = entityConfig.filePattern || '*.json';
-            const files = await (0, fast_glob_1.default)(pattern, {
+            const files = await fastGlob(pattern, {
                 cwd: entityDir,
                 absolute: true,
                 onlyFiles: true,
@@ -1171,7 +1183,7 @@ class PushService {
             // Quick scan for delete directives without full processing
             for (const filePath of files) {
                 try {
-                    const content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+                    const content = await fs.readFile(filePath, 'utf-8');
                     // Fast string check for delete directives
                     if (content.includes('"delete"') && content.includes('true')) {
                         // More precise check - parse JSON to confirm
@@ -1198,39 +1210,43 @@ class PushService {
         }
         // Deletions exist - proceed with full audit
         callbacks?.onLog?.('\n🔍 Analyzing deletion operations...\n');
-        // Load all records from all entity directories
-        const allRecords = [];
-        const analyzer = new record_dependency_analyzer_1.RecordDependencyAnalyzer();
+        // Two-phase approach for cross-file dependency detection:
+        // Phase 1: Flatten all records from all files (no dependency analysis yet)
+        // Phase 2: Analyze dependencies globally across all records
+        const analyzer = new RecordDependencyAnalyzer();
+        analyzer.reset(); // Ensure clean state before processing multiple files
+        // Phase 1: Flatten all records from all files
+        const allFlattenedRecords = [];
         for (const entityDir of entityDirs) {
-            const entityConfig = await (0, config_1.loadEntityConfig)(entityDir);
+            const entityConfig = await loadEntityConfig(entityDir);
             if (!entityConfig) {
                 continue;
             }
             // Find all JSON files
             const pattern = entityConfig.filePattern || '*.json';
-            const files = await (0, fast_glob_1.default)(pattern, {
+            const files = await fastGlob(pattern, {
                 cwd: entityDir,
                 absolute: true,
                 onlyFiles: true,
                 dot: true,
                 ignore: ['**/node_modules/**', '**/.mj-*.json']
             });
-            // Load and flatten records from each file
+            // Load and flatten records from each file (no dependency analysis yet)
             for (const filePath of files) {
                 try {
-                    const rawFileData = await fs_extra_1.default.readJson(filePath);
+                    const rawFileData = await fs.readJson(filePath);
                     // Handle @include directives if present
                     let fileData = rawFileData;
                     const jsonString = JSON.stringify(rawFileData);
                     const hasIncludes = jsonString.includes('"@include"') || jsonString.includes('"@include.');
                     if (hasIncludes) {
-                        const jsonPreprocessor = new json_preprocessor_1.JsonPreprocessor();
+                        const jsonPreprocessor = new JsonPreprocessor();
                         fileData = await jsonPreprocessor.processFile(filePath);
                     }
                     const records = Array.isArray(fileData) ? fileData : [fileData];
-                    // Analyze and flatten records
-                    const analysisResult = await analyzer.analyzeFileRecords(records, entityConfig.entity);
-                    allRecords.push(...analysisResult.sortedRecords);
+                    // Phase 1: Flatten only - accumulates into analyzer's internal state
+                    const flattenedRecords = analyzer.flattenFileRecords(records, entityConfig.entity);
+                    allFlattenedRecords.push(...flattenedRecords);
                 }
                 catch (error) {
                     if (options.verbose) {
@@ -1239,10 +1255,18 @@ class PushService {
                 }
             }
         }
+        // Phase 2: Analyze dependencies globally across ALL records
+        // This enables cross-file dependency detection (e.g., AIPromptModel -> AIConfiguration)
+        const analysisResult = analyzer.analyzeAllDependencies(allFlattenedRecords);
+        const allRecords = analysisResult.sortedRecords;
+        // Log any circular dependencies detected across files
+        if (analysisResult.circularDependencies.length > 0 && options.verbose) {
+            callbacks?.onWarn?.(`⚠️  Detected ${analysisResult.circularDependencies.length} circular dependencies across metadata files`);
+        }
         // Perform comprehensive deletion audit
-        const md = new core_1.Metadata();
-        const auditor = new deletion_auditor_1.DeletionAuditor(md, this.contextUser);
-        const audit = await auditor.auditDeletions(allRecords);
+        const md = new Metadata();
+        const auditor = new DeletionAuditor(md, this.contextUser);
+        const audit = await auditor.auditDeletions(allRecords, options.deleteDbOnly ?? false);
         // Check if any records actually need deletion
         const totalMarkedForDeletion = audit.explicitDeletes.size + audit.implicitDeletes.size;
         const needDeletion = audit.deletionLevels.flat().length; // Only records that exist in DB
@@ -1255,7 +1279,7 @@ class PushService {
             return null; // Signal that no deletion audit is needed
         }
         // Generate and display report (only if records need deletion)
-        const report = deletion_report_generator_1.DeletionReportGenerator.generateReport(audit, options.verbose);
+        const report = DeletionReportGenerator.generateReport(audit, options.verbose);
         callbacks?.onLog?.(report);
         callbacks?.onLog?.('');
         // Check for blocking issues (only circular dependencies block execution)
@@ -1265,13 +1289,21 @@ class PushService {
             callbacks?.onError?.(error);
             throw new Error(error);
         }
-        // Warn about database-only references (non-blocking)
-        // These may be handled by cascade delete rules at the database level
+        // Warn about database-only references
         if (audit.orphanedReferences.length > 0) {
-            callbacks?.onWarn?.(`⚠️  WARNING: ${audit.orphanedReferences.length} database-only reference${audit.orphanedReferences.length > 1 ? 's' : ''} found.`);
-            callbacks?.onWarn?.(`   These records exist in the database but not in metadata.`);
-            callbacks?.onWarn?.(`   If your database has cascade delete rules, these will be handled automatically.`);
-            callbacks?.onWarn?.(`   Otherwise, deletion may fail with FK constraint errors.\n`);
+            if (options.deleteDbOnly) {
+                // When deleteDbOnly is enabled, these will be deleted
+                callbacks?.onLog?.(`ℹ️  ${audit.databaseOnlyDeletions.length} database-only record${audit.databaseOnlyDeletions.length > 1 ? 's' : ''} will be deleted.`);
+                callbacks?.onLog?.(`   These records exist in the database but not in metadata files.`);
+                callbacks?.onLog?.(`   They reference records being deleted and will be removed first.\n`);
+            }
+            else {
+                // When deleteDbOnly is NOT enabled, warn about potential FK errors
+                callbacks?.onWarn?.(`⚠️  WARNING: ${audit.orphanedReferences.length} database-only reference${audit.orphanedReferences.length > 1 ? 's' : ''} found.`);
+                callbacks?.onWarn?.(`   These records exist in the database but not in metadata.`);
+                callbacks?.onWarn?.(`   Deletion may fail with FK constraint errors.`);
+                callbacks?.onWarn?.(`   Use --delete-db-only flag to automatically delete these records first.\n`);
+            }
         }
         // Warn about implicit deletes
         if (audit.implicitDeletes.size > 0) {
@@ -1288,17 +1320,35 @@ class PushService {
         let deleted = 0;
         let errors = 0;
         callbacks?.onLog?.('🗑️  Processing deletions in reverse dependency order...\n');
+        // Count database-only records for summary
+        const dbOnlyCount = audit.databaseOnlyDeletions?.length ?? 0;
+        let dbOnlyDeleted = 0;
         // Process deletion levels in order (highest dependency level first)
         for (let i = 0; i < audit.deletionLevels.length; i++) {
             const level = audit.deletionLevels[i];
             const levelNumber = audit.deletionLevels.length - i; // Reverse numbering for clarity
-            callbacks?.onLog?.(`   Level ${levelNumber}: Deleting ${level.length} record${level.length > 1 ? 's' : ''}...`);
+            // Count DB-only vs metadata records at this level
+            const dbOnlyAtLevel = level.filter(r => r.path === '<DATABASE>').length;
+            const metadataAtLevel = level.length - dbOnlyAtLevel;
+            if (dbOnlyAtLevel > 0 && metadataAtLevel > 0) {
+                callbacks?.onLog?.(`   Level ${levelNumber}: Deleting ${level.length} records (${dbOnlyAtLevel} database-only, ${metadataAtLevel} metadata)...`);
+            }
+            else if (dbOnlyAtLevel > 0) {
+                callbacks?.onLog?.(`   Level ${levelNumber}: Deleting ${dbOnlyAtLevel} database-only record${dbOnlyAtLevel > 1 ? 's' : ''}...`);
+            }
+            else {
+                callbacks?.onLog?.(`   Level ${levelNumber}: Deleting ${level.length} record${level.length > 1 ? 's' : ''}...`);
+            }
             // Process records within same level (can be done in parallel in the future)
             for (const record of level) {
+                const isDbOnly = record.path === '<DATABASE>';
                 try {
-                    const result = await this.processDeleteRecord(record, '', options, callbacks);
+                    const result = await this.processDeleteRecord(record, '', options, callbacks, isDbOnly);
                     if (result.status === 'deleted') {
                         deleted++;
+                        if (isDbOnly) {
+                            dbOnlyDeleted++;
+                        }
                     }
                     else if (result.status === 'skipped') {
                         // Record not found, already handled in processDeleteRecord
@@ -1419,10 +1469,10 @@ class PushService {
         for (const deferredWrite of this.deferredFileWrites.values()) {
             try {
                 if (deferredWrite.isArray) {
-                    await json_write_helper_1.JsonWriteHelper.writeOrderedRecordData(deferredWrite.filePath, deferredWrite.records);
+                    await JsonWriteHelper.writeOrderedRecordData(deferredWrite.filePath, deferredWrite.records);
                 }
                 else {
-                    await json_write_helper_1.JsonWriteHelper.writeOrderedRecordData(deferredWrite.filePath, deferredWrite.records[0]);
+                    await JsonWriteHelper.writeOrderedRecordData(deferredWrite.filePath, deferredWrite.records[0]);
                 }
             }
             catch (error) {
@@ -1517,5 +1567,4 @@ class PushService {
         return keyParts.join('|');
     }
 }
-exports.PushService = PushService;
 //# sourceMappingURL=PushService.js.map