@carlonicora/nestjs-neo4jsonapi 0.0.1

package/dist/tools/migrate-entity/lib/descriptor-generator.js

@@ -0,0 +1,385 @@
+"use strict";
+/**
+ * Entity Migration CLI - Descriptor Generator Module
+ *
+ * Generates new-style descriptor code from parsed entity data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDescriptor = generateDescriptor;
+exports.generateEntityFile = generateEntityFile;
+const ast_parser_1 = require("./ast-parser");
+/**
+ * Generates the new descriptor code from parsed entity data.
+ */
+function generateDescriptor(parsed, entityDir, options = {}) {
+    const { meta, entityType, mapper, serialiser } = parsed;
+    // Try to extract relationships from Cypher queries if module path provided
+    let cypherRelationships = [];
+    if (options.useCypherRelationships !== false && options.modulePath) {
+        cypherRelationships = (0, ast_parser_1.findAndParseCypherRelationships)(options.modulePath, meta.nodeName);
+        if (options.verbose && cypherRelationships.length > 0) {
+            console.log(`  Found ${cypherRelationships.length} relationships from Cypher queries:`);
+            for (const rel of cypherRelationships) {
+                console.log(`    - ${rel.name}: ${rel.direction === "in" ? "<-" : ""}[:${rel.relationshipType}]${rel.direction === "out" ? "->" : ""} ${rel.relatedLabel}`);
+            }
+        }
+    }
+    // Build field configs
+    const fields = buildFieldConfigs(entityType, serialiser, mapper);
+    // Build computed configs
+    const computed = buildComputedConfigs(mapper, serialiser);
+    // Build relationship configs using Cypher relationships when available
+    const relationships = buildRelationshipConfigs(serialiser, cypherRelationships, options.verbose);
+    // Generate imports
+    const imports = generateImports(parsed, relationships, entityDir);
+    // Generate the descriptor code
+    const code = generateDescriptorCode(meta, entityType.name, fields, computed, relationships);
+    return { code, imports };
+}
+/**
+ * Builds field configurations from entity type, serialiser, and mapper.
+ */
+function buildFieldConfigs(entityType, serialiser, mapper) {
+    const fields = [];
+    // Get attribute names from serialiser (these are JSON:API attributes)
+    const attributeNames = new Set(serialiser?.attributes.map((a) => a.name) || []);
+    // Get meta names from serialiser (these go to meta)
+    const metaNames = new Set(serialiser?.meta.map((m) => m.name) || []);
+    // Get mapper field names for mapping
+    const mapperFields = new Map(mapper?.fields.filter((f) => !f.isComputed).map((f) => [f.name, f]) || []);
+    // Process entity type fields
+    for (const field of entityType.fields) {
+        // Skip if this is a computed field (handled separately)
+        const mapperField = mapperFields.get(field.name);
+        if (mapper?.fields.some((f) => f.name === field.name && f.isComputed)) {
+            continue;
+        }
+        // Determine if it's a meta field
+        const isMeta = metaNames.has(field.name);
+        // Determine if it's required (not optional and not a meta field)
+        const isRequired = !field.optional && attributeNames.has(field.name);
+        // Determine type (cypher type)
+        const cypherType = mapToCypherType(field.type);
+        // Check for default values (e.g., aiStatus)
+        const defaultValue = getDefaultValue(field.name, mapper);
+        fields.push({
+            name: field.name,
+            type: cypherType,
+            required: isRequired,
+            default: defaultValue,
+            meta: isMeta,
+        });
+    }
+    return fields;
+}
+/**
+ * Builds computed field configurations from mapper.
+ */
+function buildComputedConfigs(mapper, serialiser) {
+    const computed = [];
+    if (!mapper)
+        return computed;
+    // Get meta names from serialiser
+    const metaNames = new Set(serialiser?.meta.map((m) => m.name) || []);
+    for (const field of mapper.fields.filter((f) => f.isComputed)) {
+        computed.push({
+            name: field.name,
+            compute: field.mapping,
+            meta: metaNames.has(field.name),
+        });
+    }
+    return computed;
+}
+/**
+ * Builds relationship configurations from serialiser, using Cypher relationships when available.
+ */
+function buildRelationshipConfigs(serialiser, cypherRelationships = [], verbose) {
+    const relationships = [];
+    if (!serialiser)
+        return relationships;
+    // Create a map of Cypher relationships by name for quick lookup
+    const cypherMap = new Map();
+    for (const rel of cypherRelationships) {
+        cypherMap.set(rel.name, rel);
+    }
+    for (const rel of serialiser.relationships) {
+        // Convert Model name to meta name (e.g., UserModel -> userMeta, authorMeta)
+        const modelMeta = modelToMetaName(rel.name, rel.modelImport);
+        // Check if we have Cypher-extracted relationship info
+        const cypherRel = cypherMap.get(rel.name);
+        let direction;
+        let relationship;
+        let contextKey;
+        if (cypherRel) {
+            // Use Cypher-extracted values (from actual database queries)
+            direction = cypherRel.direction;
+            relationship = cypherRel.relationshipType;
+            // Keep contextKey heuristic for author relationship
+            contextKey = rel.name === "author" ? "userId" : undefined;
+            if (verbose) {
+                console.log(`    Using Cypher for '${rel.name}': ${direction === "in" ? "<-" : ""}[:${relationship}]${direction === "out" ? "->" : ""}`);
+            }
+        }
+        else {
+            // Fall back to heuristics when no Cypher info available
+            const inferred = inferRelationshipDetails(rel.name);
+            direction = inferred.direction;
+            relationship = inferred.relationship;
+            contextKey = inferred.contextKey;
+            if (verbose) {
+                console.log(`    Using heuristic for '${rel.name}': ${direction === "in" ? "<-" : ""}[:${relationship}]${direction === "out" ? "->" : ""} (no Cypher match)`);
+            }
+        }
+        // Determine cardinality from dtoKey (plural = many)
+        const cardinality = rel.dtoKey && rel.dtoKey.endsWith("s") ? "many" : "one";
+        relationships.push({
+            name: rel.name,
+            model: modelMeta,
+            direction,
+            relationship,
+            cardinality,
+            dtoKey: rel.dtoKey,
+            contextKey,
+        });
+    }
+    return relationships;
+}
+/**
+ * Maps TypeScript type to Cypher type.
+ */
+function mapToCypherType(tsType) {
+    const typeMap = {
+        string: "string",
+        number: "number",
+        boolean: "boolean",
+        Date: "date",
+    };
+    return typeMap[tsType] || "string";
+}
+/**
+ * Gets default value for a field if known.
+ */
+function getDefaultValue(fieldName, mapper) {
+    // Known defaults
+    const knownDefaults = {
+        aiStatus: "AiStatus.Pending",
+    };
+    return knownDefaults[fieldName];
+}
+/**
+ * Converts Model import name to meta variable name.
+ */
+function modelToMetaName(relName, modelImport) {
+    // Special cases
+    if (relName === "author")
+        return "authorMeta";
+    if (relName === "user" || relName === "editors")
+        return "userMeta";
+    // General case: UserModel -> userMeta
+    const baseName = modelImport.replace("Model", "").toLowerCase();
+    return `${baseName}Meta`;
+}
+/**
+ * Infers relationship details based on relationship name.
+ */
+function inferRelationshipDetails(relName) {
+    // Known patterns
+    const patterns = {
+        author: { direction: "in", relationship: "PUBLISHED", contextKey: "userId" },
+        user: { direction: "out", relationship: "ACCESSIBLE_BY" },
+        topic: { direction: "out", relationship: "RELEVANT_FOR" },
+        expertise: { direction: "out", relationship: "RELEVANT_FOR" },
+        company: { direction: "out", relationship: "BELONGS_TO" },
+    };
+    return patterns[relName] || { direction: "out", relationship: "RELATED_TO" };
+}
+/**
+ * Generates import statements for the descriptor.
+ */
+function generateImports(parsed, relationships, entityDir) {
+    const imports = [];
+    // Always needed imports - use package imports
+    imports.push(`import { Entity } from "@carlonicora/nestjs-neo4jsonapi/common";`);
+    imports.push(`import { defineEntity } from "@carlonicora/nestjs-neo4jsonapi/common";`);
+    // Check if AiStatus is needed
+    const hasAiStatus = parsed.entityType.fields.some((f) => f.name === "aiStatus");
+    if (hasAiStatus) {
+        imports.push(`import { AiStatus } from "@carlonicora/nestjs-neo4jsonapi";`);
+    }
+    // Add relationship model imports (keep original imports for related entity types)
+    const relatedEntities = new Set();
+    for (const rel of relationships) {
+        // Extract the meta import path from original serialiser imports
+        const metaImport = findMetaImport(parsed, rel.model);
+        if (metaImport) {
+            imports.push(metaImport);
+        }
+    }
+    // Add entity type imports from original entity file (for relationship types like Company, User, Topic, etc.)
+    for (const imp of parsed.entityType.imports) {
+        // Include imports that reference entity types used in the type definition
+        if (imp.includes("/entities/") &&
+            (imp.includes(".entity") || (!imp.includes(".meta") && !imp.includes(".model") && !imp.includes(".map")))) {
+            imports.push(imp);
+        }
+    }
+    return [...new Set(imports)]; // Remove duplicates
+}
+/**
+ * Finds the meta import statement for a given meta name.
+ */
+function findMetaImport(parsed, metaName) {
+    // Check serialiser imports
+    if (parsed.serialiser) {
+        for (const imp of parsed.serialiser.imports) {
+            if (imp.includes(`.meta"`) || imp.includes(`.meta'`)) {
+                // Check if this import contains the meta we're looking for
+                const importMatch = imp.match(/import\s*\{([^}]+)\}/);
+                if (importMatch) {
+                    const importedNames = importMatch[1].split(",").map((s) => s.trim());
+                    if (importedNames.includes(metaName)) {
+                        // Return just this import
+                        return imp.replace(/import\s*\{[^}]+\}/, `import { ${metaName} }`);
+                    }
+                }
+            }
+        }
+    }
+    // Fallback: construct import from meta name
+    const baseName = metaName.replace("Meta", "");
+    if (baseName === "author" || baseName === "user") {
+        return `import { ${metaName} } from "@carlonicora/nestjs-neo4jsonapi";`;
+    }
+    if (baseName === "topic") {
+        return `import { ${metaName} } from "src/features/topic/entities/topic.meta";`;
+    }
+    if (baseName === "expertise") {
+        return `import { ${metaName} } from "src/features/expertise/entities/expertise.meta";`;
+    }
+    if (baseName === "company") {
+        return `import { ${metaName} } from "@carlonicora/nestjs-neo4jsonapi";`;
+    }
+    return null;
+}
+/**
+ * Generates the complete descriptor code.
+ */
+function generateDescriptorCode(meta, entityName, fields, computed, relationships) {
+    const descriptorName = `${meta.labelName}Descriptor`;
+    let code = `
+/**
+ * ${meta.labelName} Entity Descriptor
+ *
+ * Single source of truth for the ${meta.labelName} entity configuration.
+ * Generates mapper, childrenTokens, and DataModelInterface automatically.
+ */
+export const ${descriptorName} = defineEntity<${entityName}>()({
+  // Meta properties
+  type: "${meta.type}",
+  endpoint: "${meta.endpoint}",
+  nodeName: "${meta.nodeName}",
+  labelName: "${meta.labelName}",
+`;
+    // Add fields
+    if (fields.length > 0) {
+        code += `
+  // Field definitions
+  fields: {
+`;
+        for (const field of fields) {
+            code += `    ${field.name}: { type: "${field.type}"`;
+            if (field.required)
+                code += `, required: true`;
+            if (field.default)
+                code += `, default: ${field.default}`;
+            if (field.meta)
+                code += `, meta: true`;
+            code += ` },\n`;
+        }
+        code += `  },
+`;
+    }
+    // Add computed fields
+    if (computed.length > 0) {
+        code += `
+  // Computed fields
+  computed: {
+`;
+        for (const comp of computed) {
+            code += `    ${comp.name}: {\n`;
+            code += `      compute: (params) => ${comp.compute},\n`;
+            if (comp.meta)
+                code += `      meta: true,\n`;
+            code += `    },\n`;
+        }
+        code += `  },
+`;
+    }
+    // Add relationships
+    if (relationships.length > 0) {
+        code += `
+  // Relationship definitions
+  relationships: {
+`;
+        for (const rel of relationships) {
+            code += `    ${rel.name}: {\n`;
+            code += `      model: ${rel.model},\n`;
+            code += `      direction: "${rel.direction}",\n`;
+            code += `      relationship: "${rel.relationship}",\n`;
+            code += `      cardinality: "${rel.cardinality}",\n`;
+            if (rel.contextKey)
+                code += `      contextKey: "${rel.contextKey}",\n`;
+            if (rel.dtoKey)
+                code += `      dtoKey: "${rel.dtoKey}",\n`;
+            code += `    },\n`;
+        }
+        code += `  },
+`;
+    }
+    code += `});
+
+// Type export for the descriptor
+export type ${descriptorName}Type = typeof ${descriptorName};
+`;
+    return code;
+}
+/**
+ * Generates the complete new entity file content.
+ */
+function generateEntityFile(parsed, entityDir, options = {}) {
+    const descriptor = generateDescriptor(parsed, entityDir, options);
+    // Start with imports
+    let content = descriptor.imports.join("\n") + "\n\n";
+    // Add the entity type definition (keep from original)
+    content += generateEntityTypeDefinition(parsed);
+    content += "\n";
+    // Add the descriptor
+    content += descriptor.code;
+    return content;
+}
+/**
+ * Generates the entity type definition from parsed data.
+ */
+function generateEntityTypeDefinition(parsed) {
+    const { entityType, meta } = parsed;
+    let code = `/**
+ * ${meta.labelName} Entity Type
+ */
+export type ${entityType.name} = Entity & {\n`;
+    // Add scalar fields
+    for (const field of entityType.fields) {
+        const optional = field.optional ? "?" : "";
+        code += `  ${field.name}${optional}: ${field.type};\n`;
+    }
+    // Add blank line before relationship fields if both exist
+    if (entityType.fields.length > 0 && entityType.relationshipFields.length > 0) {
+        code += `\n`;
+    }
+    // Add relationship fields (Company, User, Topic[], etc.)
+    for (const field of entityType.relationshipFields) {
+        const optional = field.optional ? "?" : "";
+        code += `  ${field.name}${optional}: ${field.type};\n`;
+    }
+    code += `};\n`;
+    return code;
+}

package/dist/tools/migrate-entity/lib/entity-migrator.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Entity Migration CLI - Main Orchestrator
+ *
+ * Coordinates the migration of old-style entities to the new descriptor pattern.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMigrator = void 0;
+exports.printMigrationSummary = printMigrationSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ast_parser_1 = require("./ast-parser");
+const descriptor_generator_1 = require("./descriptor-generator");
+const file_discovery_1 = require("./file-discovery");
+const module_updater_1 = require("./module-updater");
+const reference_updater_1 = require("./reference-updater");
+class EntityMigrator {
+    constructor(options) {
+        this.options = options;
+        this.changes = [];
+    }
+    /**
+     * Migrates entities within a module path.
+     */
+    async migrate(modulePath, entityName) {
+        const absolutePath = path.isAbsolute(modulePath) ? modulePath : path.resolve(process.cwd(), modulePath);
+        this.log(`\nMigrating entities in: ${modulePath}`);
+        // 1. Discover old files
+        const oldFileSets = await (0, file_discovery_1.discoverOldFiles)(absolutePath, entityName);
+        if (oldFileSets.length === 0) {
+            this.log(`  No old-style entities found in ${modulePath}`);
+            return this.createResult([]);
+        }
+        const results = [];
+        for (const oldFiles of oldFileSets) {
+            try {
+                const result = await this.migrateEntity(oldFiles, absolutePath);
+                results.push(result);
+            }
+            catch (error) {
+                results.push({
+                    entityName: oldFiles.entityName,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    changes: [],
+                });
+            }
+        }
+        return this.createResult(results);
+    }
+    /**
+     * Migrates all entities in the codebase.
+     */
+    async migrateAll() {
+        this.log("\nDiscovering all entities in codebase...");
+        const modulePaths = await (0, file_discovery_1.discoverAllModulePaths)();
+        this.log(`Found ${modulePaths.length} modules with entities`);
+        const allResults = [];
+        for (const modulePath of modulePaths) {
+            const result = await this.migrate(modulePath);
+            allResults.push(...result.results);
+        }
+        return this.createResult(allResults);
+    }
+    /**
+     * Migrates a single entity.
+     */
+    async migrateEntity(oldFiles, modulePath) {
+        const changes = [];
+        this.log(`\n  Migrating: ${oldFiles.entityName}`);
+        // Check if already migrated
+        if ((0, file_discovery_1.isAlreadyMigrated)(oldFiles)) {
+            this.log(`    Already migrated, skipping`);
+            return {
+                entityName: oldFiles.entityName,
+                success: true,
+                changes: [],
+            };
+        }
+        // 1. Parse old files
+        this.log(`    Parsing old files...`);
+        const parsed = (0, ast_parser_1.parseOldFiles)(oldFiles);
+        // 2. Generate new descriptor file (with Cypher relationship extraction)
+        this.log(`    Generating new descriptor...`);
+        const newContent = (0, descriptor_generator_1.generateEntityFile)(parsed, oldFiles.entityDir, {
+            modulePath,
+            useCypherRelationships: true,
+            verbose: this.options.verbose,
+        });
+        // 3. Determine target file path
+        const targetPath = this.getTargetFilePath(oldFiles);
+        // 4. Create backup if needed
+        if (!this.options.skipBackup && fs.existsSync(targetPath)) {
+            const backupPath = `${targetPath}.bak`;
+            if (!this.options.dryRun) {
+                fs.copyFileSync(targetPath, backupPath);
+            }
+            changes.push({
+                type: "create",
+                path: backupPath,
+                content: fs.readFileSync(targetPath, "utf-8"),
+            });
+        }
+        // 5. Write new entity file
+        changes.push({
+            type: oldFiles.entity ? "update" : "create",
+            path: targetPath,
+            content: newContent,
+        });
+        if (!this.options.dryRun) {
+            fs.writeFileSync(targetPath, newContent);
+            this.log(`    Created: ${path.relative(process.cwd(), targetPath)}`);
+        }
+        else {
+            this.log(`    Would create: ${path.relative(process.cwd(), targetPath)}`);
+        }
+        // 6. Find and update external references
+        this.log(`    Finding external references...`);
+        const references = await (0, reference_updater_1.findExternalReferences)(oldFiles.entityName, parsed.meta.labelName, "src");
+        if (this.options.verbose) {
+            this.log((0, reference_updater_1.summarizeReferences)(references));
+        }
+        for (const ref of references) {
+            const updatedContent = (0, reference_updater_1.updateFileReferences)(ref.filePath, ref);
+            changes.push({
+                type: "update",
+                path: ref.filePath,
+                content: updatedContent,
+            });
+            if (!this.options.dryRun) {
+                fs.writeFileSync(ref.filePath, updatedContent);
+                this.log(`    Updated: ${path.relative(process.cwd(), ref.filePath)} (${ref.usages.length} changes)`);
+            }
+            else {
+                this.log(`    Would update: ${path.relative(process.cwd(), ref.filePath)} (${ref.usages.length} changes)`);
+            }
+        }
+        // 7. Update module file
+        const moduleFile = await (0, module_updater_1.findModuleFile)(modulePath);
+        if (moduleFile) {
+            const moduleUpdate = (0, module_updater_1.updateModule)(moduleFile, oldFiles.entityName, parsed.meta.labelName);
+            if (moduleUpdate) {
+                const formattedContent = (0, module_updater_1.formatModuleContent)(moduleUpdate.updatedContent);
+                changes.push({
+                    type: "update",
+                    path: moduleFile,
+                    content: formattedContent,
+                });
+                if (!this.options.dryRun) {
+                    fs.writeFileSync(moduleFile, formattedContent);
+                    this.log(`    Updated module: ${path.relative(process.cwd(), moduleFile)}`);
+                    for (const change of moduleUpdate.changes) {
+                        this.log(`      - ${change}`);
+                    }
+                }
+                else {
+                    this.log(`    Would update module: ${path.relative(process.cwd(), moduleFile)}`);
+                }
+            }
+        }
+        // 8. Delete old files
+        const filesToDelete = [oldFiles.meta, oldFiles.model, oldFiles.map, oldFiles.serialiser].filter((f) => f !== null);
+        // Don't delete the entity file if it's the target
+        const entityFileToDelete = oldFiles.entity && oldFiles.entity !== targetPath ? oldFiles.entity : null;
+        if (entityFileToDelete) {
+            filesToDelete.push(entityFileToDelete);
+        }
+        for (const fileToDelete of filesToDelete) {
+            changes.push({
+                type: "delete",
+                path: fileToDelete,
+            });
+            if (!this.options.dryRun) {
+                if (fs.existsSync(fileToDelete)) {
+                    fs.unlinkSync(fileToDelete);
+                    this.log(`    Deleted: ${path.relative(process.cwd(), fileToDelete)}`);
+                }
+            }
+            else {
+                this.log(`    Would delete: ${path.relative(process.cwd(), fileToDelete)}`);
+            }
+        }
+        // 9. Clean up empty directories
+        await this.cleanupEmptyDirectories(modulePath);
+        // 10. Detect and warn about custom cypher.service.ts logic
+        const cypherWarnings = (0, ast_parser_1.detectCypherServiceWarnings)(modulePath);
+        if (cypherWarnings.length > 0) {
+            this.log(`\n    ⚠️  PHASE 2 WARNING: Custom cypher.service.ts logic detected:`);
+            for (const warning of cypherWarnings) {
+                this.log(`      • ${warning.description}`);
+                this.log(`        Action: ${warning.action}`);
+            }
+        }
+        return {
+            entityName: oldFiles.entityName,
+            success: true,
+            changes,
+        };
+    }
+    /**
+     * Determines the target file path for the new entity descriptor.
+     */
+    getTargetFilePath(oldFiles) {
+        // Target is entityName.ts in the entities directory
+        // If the old entity file was entity.entity.ts, we use entity.ts instead
+        const baseName = oldFiles.entityName;
+        return path.join(oldFiles.entityDir, `${baseName}.ts`);
+    }
+    /**
+     * Cleans up empty directories after file deletion.
+     */
+    async cleanupEmptyDirectories(modulePath) {
+        const serialisersDir = path.join(modulePath, "serialisers");
+        if (fs.existsSync(serialisersDir)) {
+            const files = fs.readdirSync(serialisersDir);
+            if (files.length === 0) {
+                if (!this.options.dryRun) {
+                    fs.rmdirSync(serialisersDir);
+                    this.log(`    Removed empty directory: serialisers/`);
+                }
+                else {
+                    this.log(`    Would remove empty directory: serialisers/`);
+                }
+            }
+        }
+    }
+    /**
+     * Creates a migration result summary.
+     */
+    createResult(results) {
+        const successCount = results.filter((r) => r.success).length;
+        const failureCount = results.filter((r) => !r.success).length;
+        return {
+            results,
+            totalEntities: results.length,
+            successCount,
+            failureCount,
+        };
+    }
+    /**
+     * Logs a message if verbose mode is enabled or if it's important.
+     */
+    log(message) {
+        if (this.options.verbose || !message.startsWith("      ")) {
+            console.log(message);
+        }
+    }
+}
+exports.EntityMigrator = EntityMigrator;
+/**
+ * Prints a summary of the migration results.
+ */
+function printMigrationSummary(result) {
+    console.log("\n" + "=".repeat(60));
+    console.log("Migration Summary");
+    console.log("=".repeat(60));
+    console.log(`Total entities: ${result.totalEntities}`);
+    console.log(`Successful: ${result.successCount}`);
+    console.log(`Failed: ${result.failureCount}`);
+    if (result.failureCount > 0) {
+        console.log("\nFailed migrations:");
+        for (const r of result.results.filter((r) => !r.success)) {
+            console.log(`  - ${r.entityName}: ${r.error}`);
+        }
+    }
+    console.log("=".repeat(60) + "\n");
+}