@carlonicora/nestjs-neo4jsonapi 1.31.2 → 1.32.0

package/dist/tools/migrate-entity/__tests__/file-discovery.spec.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * File Discovery Unit Tests
+ *
+ * Tests the file discovery functions that locate old-style entity files.
+ */
+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 });
+const vitest_1 = require("vitest");
+const path = __importStar(require("path"));
+const file_discovery_1 = require("../lib/file-discovery");
+const FIXTURES_DIR = path.resolve(__dirname, "../__fixtures__");
+(0, vitest_1.describe)("file-discovery", () => {
+    (0, vitest_1.describe)("discoverOldFiles", () => {
+        (0, vitest_1.it)("should find all 5 entity files by meta.ts", async () => {
+            const results = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            (0, vitest_1.expect)(results.length).toBe(1);
+            const testEntity = results[0];
+            (0, vitest_1.expect)(testEntity.entityName).toBe("test-entity");
+            (0, vitest_1.expect)(testEntity.meta).toContain("test-entity.meta.ts");
+            (0, vitest_1.expect)(testEntity.entity).toContain("test-entity.ts");
+            (0, vitest_1.expect)(testEntity.model).toContain("test-entity.model.ts");
+            (0, vitest_1.expect)(testEntity.map).toContain("test-entity.map.ts");
+            (0, vitest_1.expect)(testEntity.serialiser).toContain("test-entity.serialiser.ts");
+        });
+        (0, vitest_1.it)("should handle missing optional files", async () => {
+            // Create a temporary entity with only meta file to test missing files handling
+            // For this test, we'll use migrated-entity which only has meta + entity
+            const results = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "migrated-entity"));
+            (0, vitest_1.expect)(results.length).toBe(1);
+            const migratedEntity = results[0];
+            (0, vitest_1.expect)(migratedEntity.entityName).toBe("migrated-entity");
+            (0, vitest_1.expect)(migratedEntity.meta).not.toBeNull();
+            (0, vitest_1.expect)(migratedEntity.entity).not.toBeNull();
+            (0, vitest_1.expect)(migratedEntity.model).toBeNull(); // No model file
+            (0, vitest_1.expect)(migratedEntity.map).toBeNull(); // No map file
+            (0, vitest_1.expect)(migratedEntity.serialiser).toBeNull(); // No serialiser file
+        });
+        (0, vitest_1.it)("should filter by entity name when provided", async () => {
+            // Should find test-entity when filtering
+            const results = await (0, file_discovery_1.discoverOldFiles)(FIXTURES_DIR, "test-entity");
+            (0, vitest_1.expect)(results.length).toBe(1);
+            (0, vitest_1.expect)(results[0].entityName).toBe("test-entity");
+        });
+        (0, vitest_1.it)("should return empty array when entity not found", async () => {
+            const results = await (0, file_discovery_1.discoverOldFiles)(FIXTURES_DIR, "nonexistent-entity");
+            (0, vitest_1.expect)(results.length).toBe(0);
+        });
+        (0, vitest_1.it)("should discover multiple entities in fixtures directory", async () => {
+            const results = await (0, file_discovery_1.discoverOldFiles)(FIXTURES_DIR);
+            // Should find: test-entity, simple-entity, complex-entity, migrated-entity
+            (0, vitest_1.expect)(results.length).toBeGreaterThanOrEqual(4);
+            const entityNames = results.map((r) => r.entityName);
+            (0, vitest_1.expect)(entityNames).toContain("test-entity");
+            (0, vitest_1.expect)(entityNames).toContain("simple-entity");
+            (0, vitest_1.expect)(entityNames).toContain("complex-entity");
+            (0, vitest_1.expect)(entityNames).toContain("migrated-entity");
+        });
+        (0, vitest_1.it)("should discover simple-entity files", async () => {
+            const results = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "simple-entity"));
+            (0, vitest_1.expect)(results.length).toBe(1);
+            const simpleEntity = results[0];
+            (0, vitest_1.expect)(simpleEntity.entityName).toBe("simple-entity");
+            (0, vitest_1.expect)(simpleEntity.meta).not.toBeNull();
+            (0, vitest_1.expect)(simpleEntity.entity).not.toBeNull();
+            (0, vitest_1.expect)(simpleEntity.model).not.toBeNull();
+            (0, vitest_1.expect)(simpleEntity.map).not.toBeNull();
+            (0, vitest_1.expect)(simpleEntity.serialiser).not.toBeNull();
+        });
+        (0, vitest_1.it)("should discover complex-entity files", async () => {
+            const results = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "complex-entity"));
+            (0, vitest_1.expect)(results.length).toBe(1);
+            const complexEntity = results[0];
+            (0, vitest_1.expect)(complexEntity.entityName).toBe("complex-entity");
+            (0, vitest_1.expect)(complexEntity.meta).not.toBeNull();
+            (0, vitest_1.expect)(complexEntity.entity).not.toBeNull();
+            (0, vitest_1.expect)(complexEntity.model).not.toBeNull();
+            (0, vitest_1.expect)(complexEntity.map).not.toBeNull();
+            (0, vitest_1.expect)(complexEntity.serialiser).not.toBeNull();
+        });
+    });
+    (0, vitest_1.describe)("isAlreadyMigrated", () => {
+        (0, vitest_1.it)("should return true if entity contains defineEntity<", () => {
+            const files = {
+                entityName: "migrated-entity",
+                entityDir: path.join(FIXTURES_DIR, "migrated-entity"),
+                entity: path.join(FIXTURES_DIR, "migrated-entity/migrated-entity.ts"),
+                meta: path.join(FIXTURES_DIR, "migrated-entity/migrated-entity.meta.ts"),
+                model: null,
+                map: null,
+                serialiser: null,
+            };
+            const result = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(result).toBe(true);
+        });
+        (0, vitest_1.it)("should return false for old-style entities", () => {
+            const files = {
+                entityName: "test-entity",
+                entityDir: path.join(FIXTURES_DIR, "entities"),
+                entity: path.join(FIXTURES_DIR, "entities/test-entity.ts"),
+                meta: path.join(FIXTURES_DIR, "entities/test-entity.meta.ts"),
+                model: path.join(FIXTURES_DIR, "entities/test-entity.model.ts"),
+                map: path.join(FIXTURES_DIR, "entities/test-entity.map.ts"),
+                serialiser: path.join(FIXTURES_DIR, "entities/test-entity.serialiser.ts"),
+            };
+            const result = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(result).toBe(false);
+        });
+        (0, vitest_1.it)("should return false if entity file is null", () => {
+            const files = {
+                entityName: "test-entity",
+                entityDir: path.join(FIXTURES_DIR, "entities"),
+                entity: null,
+                meta: path.join(FIXTURES_DIR, "entities/test-entity.meta.ts"),
+                model: null,
+                map: null,
+                serialiser: null,
+            };
+            const result = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(result).toBe(false);
+        });
+        (0, vitest_1.it)("should return false for simple-entity (old-style)", () => {
+            const files = {
+                entityName: "simple-entity",
+                entityDir: path.join(FIXTURES_DIR, "simple-entity"),
+                entity: path.join(FIXTURES_DIR, "simple-entity/simple-entity.ts"),
+                meta: path.join(FIXTURES_DIR, "simple-entity/simple-entity.meta.ts"),
+                model: path.join(FIXTURES_DIR, "simple-entity/simple-entity.model.ts"),
+                map: path.join(FIXTURES_DIR, "simple-entity/simple-entity.map.ts"),
+                serialiser: path.join(FIXTURES_DIR, "simple-entity/simple-entity.serialiser.ts"),
+            };
+            const result = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(result).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("getModulePath", () => {
+        (0, vitest_1.it)("should extract module path from features path", () => {
+            const filePath = "src/features/article/entities/article.meta.ts";
+            const result = (0, file_discovery_1.getModulePath)(filePath);
+            (0, vitest_1.expect)(result).toBe("src/features/article");
+        });
+        (0, vitest_1.it)("should extract module path from foundations path", () => {
+            const filePath = "src/foundations/user/entities/user.meta.ts";
+            const result = (0, file_discovery_1.getModulePath)(filePath);
+            (0, vitest_1.expect)(result).toBe("src/foundations/user");
+        });
+        (0, vitest_1.it)("should return dirname when no standard pattern matches", () => {
+            const filePath = "/custom/path/entities/custom.meta.ts";
+            const result = (0, file_discovery_1.getModulePath)(filePath);
+            (0, vitest_1.expect)(result).toBe("/custom/path/entities");
+        });
+        (0, vitest_1.it)("should handle nested feature paths", () => {
+            const filePath = "src/features/my-feature/deep/nested/entity.meta.ts";
+            const result = (0, file_discovery_1.getModulePath)(filePath);
+            (0, vitest_1.expect)(result).toBe("src/features/my-feature");
+        });
+    });
+});

package/dist/tools/migrate-entity/__tests__/integration.spec.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Integration Tests
+ *
+ * Tests the full migration pipeline from old-style entities to new descriptors.
+ */
+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 });
+const vitest_1 = require("vitest");
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const file_discovery_1 = require("../lib/file-discovery");
+const ast_parser_1 = require("../lib/ast-parser");
+const descriptor_generator_1 = require("../lib/descriptor-generator");
+const FIXTURES_DIR = path.resolve(__dirname, "../__fixtures__");
+/**
+ * Helper to check if TypeScript code is syntactically valid
+ */
+function isValidTypeScript(code) {
+    const sourceFile = ts.createSourceFile("test.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const errors = [];
+    // Check for parse errors by looking at the source file's internal diagnostics
+    // Note: This only checks syntax, not type errors
+    function visit(node) {
+        // Look for any node with a kind that indicates a parsing error
+        if (node.kind === ts.SyntaxKind.Unknown) {
+            errors.push(`Unknown syntax at position ${node.pos}`);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    // Also check that we can re-emit the code
+    const printer = ts.createPrinter();
+    try {
+        printer.printFile(sourceFile);
+    }
+    catch (e) {
+        errors.push(`Printer error: ${e.message}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+(0, vitest_1.describe)("migration integration", () => {
+    (0, vitest_1.describe)("full migration pipeline - test-entity", () => {
+        (0, vitest_1.it)("should discover, parse, and generate valid output", async () => {
+            // Step 1: Discover files
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            (0, vitest_1.expect)(discovered.length).toBe(1);
+            const files = discovered[0];
+            (0, vitest_1.expect)(files.entityName).toBe("test-entity");
+            // Step 2: Check not already migrated
+            const migrated = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(migrated).toBe(false);
+            // Step 3: Parse old files
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            (0, vitest_1.expect)(parsed.meta.labelName).toBe("TestEntity");
+            (0, vitest_1.expect)(parsed.entityType.name).toBe("TestEntity");
+            // Step 4: Generate new entity file
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            (0, vitest_1.expect)(entityFile).toContain("defineEntity<TestEntity>()");
+            // Step 5: Generate new meta file
+            const metaFile = (0, descriptor_generator_1.generateMetaFile)(parsed.meta);
+            (0, vitest_1.expect)(metaFile).toContain("testEntityMeta");
+            // Step 6: Verify TypeScript syntax is valid
+            const entityValidation = isValidTypeScript(entityFile);
+            (0, vitest_1.expect)(entityValidation.valid).toBe(true);
+            const metaValidation = isValidTypeScript(metaFile);
+            (0, vitest_1.expect)(metaValidation.valid).toBe(true);
+        });
+        (0, vitest_1.it)("should include S3Service injection", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            (0, vitest_1.expect)(entityFile).toContain("injectServices: [S3Service]");
+            (0, vitest_1.expect)(entityFile).toContain("S3Service");
+        });
+        (0, vitest_1.it)("should include URL transforms", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            // Single URL transform
+            (0, vitest_1.expect)(entityFile).toContain("transform: async (data, services) => {");
+            (0, vitest_1.expect)(entityFile).toContain("services.S3Service.generateSignedUrl");
+            // Array URL transform
+            (0, vitest_1.expect)(entityFile).toContain("Promise.all");
+        });
+        (0, vitest_1.it)("should preserve entity type definition", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            (0, vitest_1.expect)(entityFile).toContain("export type TestEntity = Entity & {");
+            (0, vitest_1.expect)(entityFile).toContain("name: string;");
+            (0, vitest_1.expect)(entityFile).toContain("description?: string;");
+            (0, vitest_1.expect)(entityFile).toContain("url?: string;");
+        });
+    });
+    (0, vitest_1.describe)("full migration pipeline - simple-entity", () => {
+        (0, vitest_1.it)("should migrate simple entity without S3 or relationships", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "simple-entity"));
+            (0, vitest_1.expect)(discovered.length).toBe(1);
+            const files = discovered[0];
+            const migrated = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(migrated).toBe(false);
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            (0, vitest_1.expect)(parsed.meta.labelName).toBe("SimpleEntity");
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            // Should NOT have S3 stuff
+            (0, vitest_1.expect)(entityFile).not.toContain("injectServices");
+            (0, vitest_1.expect)(entityFile).not.toContain("S3Service");
+            // Should NOT have relationships
+            (0, vitest_1.expect)(entityFile).not.toContain("relationships:");
+            // Should have fields
+            (0, vitest_1.expect)(entityFile).toContain("fields:");
+            (0, vitest_1.expect)(entityFile).toContain('title: { type: "string"');
+            (0, vitest_1.expect)(entityFile).toContain('count: { type: "number"');
+            (0, vitest_1.expect)(entityFile).toContain('isActive: { type: "boolean"');
+            // Should be valid TypeScript
+            const validation = isValidTypeScript(entityFile);
+            (0, vitest_1.expect)(validation.valid).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("full migration pipeline - complex-entity", () => {
+        (0, vitest_1.it)("should migrate complex entity with relationships and computed fields", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "complex-entity"));
+            (0, vitest_1.expect)(discovered.length).toBe(1);
+            const files = discovered[0];
+            const migrated = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(migrated).toBe(false);
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            (0, vitest_1.expect)(parsed.meta.labelName).toBe("ComplexEntity");
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            // Should have relationships
+            (0, vitest_1.expect)(entityFile).toContain("relationships:");
+            (0, vitest_1.expect)(entityFile).toContain("author:");
+            (0, vitest_1.expect)(entityFile).toContain("company:");
+            (0, vitest_1.expect)(entityFile).toContain("items:");
+            // Should have computed fields
+            (0, vitest_1.expect)(entityFile).toContain("computed:");
+            (0, vitest_1.expect)(entityFile).toContain("totalScore:");
+            (0, vitest_1.expect)(entityFile).toContain("itemCount:");
+            // Should have meta fields
+            (0, vitest_1.expect)(entityFile).toContain("meta: true");
+            // Should be valid TypeScript
+            const validation = isValidTypeScript(entityFile);
+            (0, vitest_1.expect)(validation.valid).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("already migrated detection", () => {
+        (0, vitest_1.it)("should detect already-migrated entity", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "migrated-entity"));
+            (0, vitest_1.expect)(discovered.length).toBe(1);
+            const files = discovered[0];
+            const migrated = (0, file_discovery_1.isAlreadyMigrated)(files);
+            (0, vitest_1.expect)(migrated).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("migration output validation", () => {
+        (0, vitest_1.it)("should generate meta file with correct export", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const metaFile = (0, descriptor_generator_1.generateMetaFile)(parsed.meta);
+            (0, vitest_1.expect)(metaFile).toContain('import { DataMeta } from "@carlonicora/nestjs-neo4jsonapi"');
+            (0, vitest_1.expect)(metaFile).toContain("export const testEntityMeta: DataMeta = {");
+            (0, vitest_1.expect)(metaFile).toContain('type: "test-entities"');
+            (0, vitest_1.expect)(metaFile).toContain('endpoint: "test-entities"');
+            (0, vitest_1.expect)(metaFile).toContain('nodeName: "testEntity"');
+            (0, vitest_1.expect)(metaFile).toContain('labelName: "TestEntity"');
+        });
+        (0, vitest_1.it)("should generate entity file with correct structure", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            // Check order: imports -> type -> descriptor -> type export
+            const importIndex = entityFile.indexOf("import");
+            const typeIndex = entityFile.indexOf("export type TestEntity");
+            const descriptorIndex = entityFile.indexOf("export const TestEntityDescriptor");
+            const typeExportIndex = entityFile.indexOf("export type TestEntityDescriptorType");
+            (0, vitest_1.expect)(importIndex).toBeLessThan(typeIndex);
+            (0, vitest_1.expect)(typeIndex).toBeLessThan(descriptorIndex);
+            (0, vitest_1.expect)(descriptorIndex).toBeLessThan(typeExportIndex);
+        });
+        (0, vitest_1.it)("should include defineEntity call", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(path.join(FIXTURES_DIR, "entities"));
+            const files = discovered[0];
+            const parsed = (0, ast_parser_1.parseOldFiles)(files);
+            const entityFile = (0, descriptor_generator_1.generateEntityFile)(parsed, files.entityDir);
+            (0, vitest_1.expect)(entityFile).toContain("defineEntity<TestEntity>()({");
+            (0, vitest_1.expect)(entityFile).toContain("...testEntityMeta,");
+        });
+    });
+    (0, vitest_1.describe)("multiple fixtures migration", () => {
+        (0, vitest_1.it)("should discover all fixtures in the directory", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(FIXTURES_DIR);
+            // Should find all 7 fixtures (4 original + 3 from relationship-entity folder)
+            const entityNames = discovered.map((d) => d.entityName);
+            (0, vitest_1.expect)(entityNames).toContain("test-entity");
+            (0, vitest_1.expect)(entityNames).toContain("simple-entity");
+            (0, vitest_1.expect)(entityNames).toContain("complex-entity");
+            (0, vitest_1.expect)(entityNames).toContain("migrated-entity");
+            (0, vitest_1.expect)(entityNames).toContain("relationship-entity");
+            (0, vitest_1.expect)(entityNames).toContain("feature");
+            (0, vitest_1.expect)(entityNames).toContain("module");
+        });
+        (0, vitest_1.it)("should correctly identify which entities need migration", async () => {
+            const discovered = await (0, file_discovery_1.discoverOldFiles)(FIXTURES_DIR);
+            const needsMigration = discovered.filter((f) => !(0, file_discovery_1.isAlreadyMigrated)(f));
+            const alreadyMigrated = discovered.filter((f) => (0, file_discovery_1.isAlreadyMigrated)(f));
+            // 6 need migration (3 original + 3 from relationship-entity folder), 1 already migrated
+            (0, vitest_1.expect)(needsMigration.length).toBe(6);
+            (0, vitest_1.expect)(alreadyMigrated.length).toBe(1);
+            const needsMigrationNames = needsMigration.map((f) => f.entityName);
+            (0, vitest_1.expect)(needsMigrationNames).toContain("test-entity");
+            (0, vitest_1.expect)(needsMigrationNames).toContain("simple-entity");
+            (0, vitest_1.expect)(needsMigrationNames).toContain("complex-entity");
+            (0, vitest_1.expect)(needsMigrationNames).toContain("relationship-entity");
+            (0, vitest_1.expect)(needsMigrationNames).toContain("feature");
+            (0, vitest_1.expect)(needsMigrationNames).toContain("module");
+            const alreadyMigratedNames = alreadyMigrated.map((f) => f.entityName);
+            (0, vitest_1.expect)(alreadyMigratedNames).toContain("migrated-entity");
+        });
+    });
+});

package/dist/tools/migrate-entity/index.js

@@ -22,7 +22,7 @@ program
     .option("-e, --entity <name>", "Entity name if module has multiple (e.g., auth.code)")
     .option("-a, --all", "Migrate all entities in codebase")
     .option("-d, --dry-run", "Preview changes without writing files")
-    .option("--skip-backup", "Skip creating backup files")
+    .option("--backup", "Create .bak backup files before overwriting")
     .option("-v, --verbose", "Verbose output")
     .parse();
 async function main() {
@@ -37,7 +37,7 @@ async function main() {
         entity: options.entity,
         all: options.all,
         dryRun: options.dryRun,
-        skipBackup: options.skipBackup,
+        skipBackup: !options.backup,
         verbose: options.verbose,
     });
     let result;