@carlonicora/nestjs-neo4jsonapi 1.31.2 → 1.32.0

package/dist/tools/migrate-entity/__tests__/descriptor-generator.spec.js

@@ -0,0 +1,482 @@
+"use strict";
+/**
+ * Descriptor Generator Unit Tests
+ *
+ * Tests the code generation functions that produce new-style descriptor 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 descriptor_generator_1 = require("../lib/descriptor-generator");
+const ast_parser_1 = require("../lib/ast-parser");
+const FIXTURES_DIR = path.resolve(__dirname, "../__fixtures__");
+/**
+ * Helper to get parsed entity from test fixtures
+ */
+function getParsedTestEntity() {
+    const files = {
+        entityName: "TestEntity",
+        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"),
+    };
+    return (0, ast_parser_1.parseOldFiles)(files);
+}
+function getParsedSimpleEntity() {
+    const files = {
+        entityName: "SimpleEntity",
+        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"),
+    };
+    return (0, ast_parser_1.parseOldFiles)(files);
+}
+function getParsedComplexEntity() {
+    const files = {
+        entityName: "ComplexEntity",
+        entityDir: path.join(FIXTURES_DIR, "complex-entity"),
+        entity: path.join(FIXTURES_DIR, "complex-entity/complex-entity.ts"),
+        meta: path.join(FIXTURES_DIR, "complex-entity/complex-entity.meta.ts"),
+        model: path.join(FIXTURES_DIR, "complex-entity/complex-entity.model.ts"),
+        map: path.join(FIXTURES_DIR, "complex-entity/complex-entity.map.ts"),
+        serialiser: path.join(FIXTURES_DIR, "complex-entity/complex-entity.serialiser.ts"),
+    };
+    return (0, ast_parser_1.parseOldFiles)(files);
+}
+/**
+ * Helper to get parsed entity with local relationship type imports
+ * This tests import type behavior for non-framework relationship types
+ */
+function getParsedRelationshipEntity() {
+    const files = {
+        entityName: "relationship-entity",
+        entityDir: path.join(FIXTURES_DIR, "relationship-entity"),
+        entity: path.join(FIXTURES_DIR, "relationship-entity/relationship-entity.ts"),
+        meta: path.join(FIXTURES_DIR, "relationship-entity/relationship-entity.meta.ts"),
+        model: path.join(FIXTURES_DIR, "relationship-entity/relationship-entity.model.ts"),
+        map: path.join(FIXTURES_DIR, "relationship-entity/relationship-entity.map.ts"),
+        serialiser: path.join(FIXTURES_DIR, "relationship-entity/relationship-entity.serialiser.ts"),
+    };
+    return (0, ast_parser_1.parseOldFiles)(files);
+}
+(0, vitest_1.describe)("descriptor-generator", () => {
+    (0, vitest_1.describe)("generateDescriptor", () => {
+        (0, vitest_1.it)("should generate valid TypeScript code", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("export const TestEntityDescriptor = defineEntity<TestEntity>()");
+            (0, vitest_1.expect)(result.code).toContain("...testEntityMeta");
+        });
+        (0, vitest_1.it)("should include injectServices when S3 transforms present", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("injectServices: [S3Service]");
+        });
+        (0, vitest_1.it)("should exclude injectServices when no transforms", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).not.toContain("injectServices");
+        });
+        (0, vitest_1.it)("should include all fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("fields:");
+            (0, vitest_1.expect)(result.code).toContain("name:");
+            (0, vitest_1.expect)(result.code).toContain("description:");
+            (0, vitest_1.expect)(result.code).toContain("url:");
+            (0, vitest_1.expect)(result.code).toContain("tags:");
+        });
+        (0, vitest_1.it)("should include computed fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("computed:");
+            (0, vitest_1.expect)(result.code).toContain("relevance:");
+            (0, vitest_1.expect)(result.code).toContain("itemCount:");
+        });
+        (0, vitest_1.it)("should include relationships", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("relationships:");
+            (0, vitest_1.expect)(result.code).toContain("author:");
+            (0, vitest_1.expect)(result.code).toContain('direction: "in"');
+            (0, vitest_1.expect)(result.code).toContain('cardinality: "one"');
+        });
+        (0, vitest_1.it)("should generate correct imports", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.imports.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(result.imports.some((i) => i.includes("defineEntity"))).toBe(true);
+            (0, vitest_1.expect)(result.imports.some((i) => i.includes("Entity"))).toBe(true);
+            (0, vitest_1.expect)(result.imports.some((i) => i.includes("S3Service"))).toBe(true);
+        });
+        (0, vitest_1.it)("should not include S3Service in imports when no transforms", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.imports.some((i) => i.includes("S3Service"))).toBe(false);
+        });
+        (0, vitest_1.it)("should generate type export", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("export type TestEntityDescriptorType = typeof TestEntityDescriptor");
+        });
+    });
+    (0, vitest_1.describe)("generateDescriptor - field configs", () => {
+        (0, vitest_1.it)("should create field config with correct type (string)", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain('title: { type: "string"');
+        });
+        (0, vitest_1.it)("should create field config with correct type (number)", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain('count: { type: "number"');
+        });
+        (0, vitest_1.it)("should create field config with correct type (boolean)", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain('isActive: { type: "boolean"');
+        });
+        (0, vitest_1.it)("should create field config with correct type (Date -> datetime)", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain('createdAt: { type: "datetime"');
+        });
+        (0, vitest_1.it)("should create field config with array type (string[])", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain('tags: { type: "string[]"');
+        });
+        (0, vitest_1.it)("should mark required fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("required: true");
+        });
+        (0, vitest_1.it)("should identify meta fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("meta: true");
+        });
+        (0, vitest_1.it)("should add S3 transforms for URL fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Single URL transform
+            (0, vitest_1.expect)(result.code).toContain("url: {");
+            (0, vitest_1.expect)(result.code).toContain("transform: async (data, services) => {");
+            (0, vitest_1.expect)(result.code).toContain("services.S3Service.generateSignedUrl");
+            // Array URL transform
+            (0, vitest_1.expect)(result.code).toContain("samplePhotographs: {");
+            (0, vitest_1.expect)(result.code).toContain("Promise.all");
+        });
+    });
+    (0, vitest_1.describe)("generateDescriptor - computed configs", () => {
+        (0, vitest_1.it)("should create computed config from mapper", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("computed:");
+            (0, vitest_1.expect)(result.code).toContain("compute: (params) =>");
+        });
+        (0, vitest_1.it)("should include params.record.has patterns in computed", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("params.record.has");
+        });
+        (0, vitest_1.it)("should mark meta computed fields", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // relevance should have meta: true
+            const computedSection = result.code.split("computed:")[1]?.split("relationships:")[0];
+            (0, vitest_1.expect)(computedSection).toContain("meta: true");
+        });
+    });
+    (0, vitest_1.describe)("generateDescriptor - relationship configs", () => {
+        (0, vitest_1.it)("should use heuristics when Cypher unavailable", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // author relationship should use heuristic (PUBLISHED)
+            (0, vitest_1.expect)(result.code).toContain("author:");
+            (0, vitest_1.expect)(result.code).toContain('relationship: "PUBLISHED"');
+        });
+        (0, vitest_1.it)("should determine cardinality from relationship type", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // author is a single User, so cardinality should be "one"
+            (0, vitest_1.expect)(result.code).toContain('cardinality: "one"');
+        });
+        (0, vitest_1.it)("should include dtoKey when present", () => {
+            const parsed = getParsedComplexEntity();
+            const entityDir = path.join(FIXTURES_DIR, "complex-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // items has dtoKey in the fixture
+            (0, vitest_1.expect)(result.code).toContain('dtoKey: "items"');
+        });
+        (0, vitest_1.it)("should handle multiple relationships", () => {
+            const parsed = getParsedComplexEntity();
+            const entityDir = path.join(FIXTURES_DIR, "complex-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            (0, vitest_1.expect)(result.code).toContain("author:");
+            (0, vitest_1.expect)(result.code).toContain("company:");
+            (0, vitest_1.expect)(result.code).toContain("items:");
+        });
+    });
+    (0, vitest_1.describe)("generateMetaFile", () => {
+        (0, vitest_1.it)("should generate meta file with correct export", () => {
+            const meta = {
+                type: "test-entities",
+                endpoint: "test-entities",
+                nodeName: "testEntity",
+                labelName: "TestEntity",
+            };
+            const result = (0, descriptor_generator_1.generateMetaFile)(meta);
+            (0, vitest_1.expect)(result).toContain('import { DataMeta } from "@carlonicora/nestjs-neo4jsonapi"');
+            (0, vitest_1.expect)(result).toContain("export const testEntityMeta: DataMeta = {");
+            (0, vitest_1.expect)(result).toContain('type: "test-entities"');
+            (0, vitest_1.expect)(result).toContain('endpoint: "test-entities"');
+            (0, vitest_1.expect)(result).toContain('nodeName: "testEntity"');
+            (0, vitest_1.expect)(result).toContain('labelName: "TestEntity"');
+        });
+        (0, vitest_1.it)("should generate meta file for simple-entity", () => {
+            const meta = {
+                type: "simple-entities",
+                endpoint: "simple-entities",
+                nodeName: "simpleEntity",
+                labelName: "SimpleEntity",
+            };
+            const result = (0, descriptor_generator_1.generateMetaFile)(meta);
+            (0, vitest_1.expect)(result).toContain("export const simpleEntityMeta: DataMeta = {");
+            (0, vitest_1.expect)(result).toContain('type: "simple-entities"');
+        });
+    });
+    (0, vitest_1.describe)("generateEntityFile", () => {
+        (0, vitest_1.it)("should generate entity file with defineEntity", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            (0, vitest_1.expect)(result).toContain("defineEntity<TestEntity>()");
+        });
+        (0, vitest_1.it)("should generate complete file structure", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            // Should have imports first
+            (0, vitest_1.expect)(result.indexOf("import")).toBeLessThan(result.indexOf("export type TestEntity"));
+            // Should have type definition before descriptor
+            (0, vitest_1.expect)(result.indexOf("export type TestEntity")).toBeLessThan(result.indexOf("export const TestEntityDescriptor"));
+            // Should have descriptor type export at end
+            (0, vitest_1.expect)(result).toContain("export type TestEntityDescriptorType");
+        });
+        (0, vitest_1.it)("should include entity type definition", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            (0, vitest_1.expect)(result).toContain("export type TestEntity = Entity & {");
+            (0, vitest_1.expect)(result).toContain("name: string;");
+            (0, vitest_1.expect)(result).toContain("description?: string;");
+        });
+        (0, vitest_1.it)("should generate valid file for simple-entity", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            (0, vitest_1.expect)(result).toContain("export const SimpleEntityDescriptor = defineEntity<SimpleEntity>()");
+            (0, vitest_1.expect)(result).toContain("...simpleEntityMeta");
+            (0, vitest_1.expect)(result).not.toContain("injectServices");
+            (0, vitest_1.expect)(result).not.toContain("S3Service");
+        });
+        (0, vitest_1.it)("should generate valid file for complex-entity with relationships", () => {
+            const parsed = getParsedComplexEntity();
+            const entityDir = path.join(FIXTURES_DIR, "complex-entity");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            (0, vitest_1.expect)(result).toContain("export const ComplexEntityDescriptor = defineEntity<ComplexEntity>()");
+            (0, vitest_1.expect)(result).toContain("relationships:");
+            (0, vitest_1.expect)(result).toContain("author:");
+            (0, vitest_1.expect)(result).toContain("company:");
+            (0, vitest_1.expect)(result).toContain("items:");
+        });
+    });
+    (0, vitest_1.describe)("S3 transform code generation", () => {
+        (0, vitest_1.it)("should generate single URL transform correctly", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Check for single URL transform pattern with tilde prefix handling
+            (0, vitest_1.expect)(result.code).toContain("if (!data.url) return undefined;");
+            (0, vitest_1.expect)(result.code).toContain('if (data.url.startsWith("~")) return data.url.substring(1);');
+            (0, vitest_1.expect)(result.code).toContain("services.S3Service.generateSignedUrl({ key: data.url, isPublic: true })");
+        });
+        (0, vitest_1.it)("should generate array URL transform correctly", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Check for array URL transform pattern with tilde prefix handling
+            (0, vitest_1.expect)(result.code).toContain("if (!data.samplePhotographs?.length) return [];");
+            (0, vitest_1.expect)(result.code).toContain("data.samplePhotographs.map(async (url: string) => {");
+            (0, vitest_1.expect)(result.code).toContain('if (url.startsWith("~")) return url.substring(1);');
+            (0, vitest_1.expect)(result.code).toContain("services.S3Service.generateSignedUrl({ key: url, isPublic: true })");
+        });
+    });
+    /**
+     * Tests for circular dependency prevention
+     *
+     * These tests verify that the generated code avoids circular dependencies by:
+     * 1. Using internal imports (../../../common) instead of package barrel (@carlonicora/nestjs-neo4jsonapi)
+     * 2. Using "import type" for relationship type imports that would otherwise cause runtime circular deps
+     */
+    (0, vitest_1.describe)("circular dependency prevention - internal imports", () => {
+        (0, vitest_1.it)("should use internal import path instead of package barrel for framework imports", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Framework imports should use internal path to avoid circular dependency
+            // when the package barrel re-exports from ./foundations
+            const frameworkImport = result.imports.find((i) => i.includes("defineEntity"));
+            (0, vitest_1.expect)(frameworkImport).toBeDefined();
+            (0, vitest_1.expect)(frameworkImport).toContain('from "../../../common"');
+            (0, vitest_1.expect)(frameworkImport).not.toContain("@carlonicora/nestjs-neo4jsonapi");
+        });
+        (0, vitest_1.it)("should include Entity in internal imports", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            const frameworkImport = result.imports.find((i) => i.includes("../../../common"));
+            (0, vitest_1.expect)(frameworkImport).toBeDefined();
+            (0, vitest_1.expect)(frameworkImport).toContain("Entity");
+        });
+        (0, vitest_1.it)("should include S3Service in separate import when transforms are used", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // S3Service has its own module, so it should be imported separately (not from ../../../common)
+            const s3Import = result.imports.find((i) => i.includes("S3Service"));
+            (0, vitest_1.expect)(s3Import).toBeDefined();
+            (0, vitest_1.expect)(s3Import).toContain('from "../../s3"');
+        });
+        (0, vitest_1.it)("should NOT include S3Service in internal imports when no transforms", () => {
+            const parsed = getParsedSimpleEntity();
+            const entityDir = path.join(FIXTURES_DIR, "simple-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            const frameworkImport = result.imports.find((i) => i.includes("../../../common"));
+            (0, vitest_1.expect)(frameworkImport).toBeDefined();
+            (0, vitest_1.expect)(frameworkImport).not.toContain("S3Service");
+        });
+        (0, vitest_1.it)("should generate internal imports for entity file", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            // Verify the full file uses internal imports
+            (0, vitest_1.expect)(result).toContain('from "../../../common"');
+            (0, vitest_1.expect)(result).not.toMatch(/from ["']@carlonicora\/nestjs-neo4jsonapi["']/);
+        });
+    });
+    (0, vitest_1.describe)("circular dependency prevention - import type for relationship types", () => {
+        (0, vitest_1.it)("should use import type for non-framework relationship type imports", () => {
+            const parsed = getParsedRelationshipEntity();
+            const entityDir = path.join(FIXTURES_DIR, "relationship-entity");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Find imports for Feature and Module (non-framework types)
+            const featureImport = result.imports.find((i) => i.includes("Feature"));
+            const moduleImport = result.imports.find((i) => i.includes("Module"));
+            // Both should use "import type" to avoid runtime circular dependencies
+            if (featureImport) {
+                (0, vitest_1.expect)(featureImport).toMatch(/^import type\s/);
+            }
+            if (moduleImport) {
+                (0, vitest_1.expect)(moduleImport).toMatch(/^import type\s/);
+            }
+        });
+        (0, vitest_1.it)("should convert regular imports to import type for local entity files", () => {
+            const parsed = getParsedRelationshipEntity();
+            const entityDir = path.join(FIXTURES_DIR, "relationship-entity");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            // The generated file should have import type for Feature and Module
+            // These are only used in the type definition, not at runtime
+            const lines = result.split("\n");
+            const importLines = lines.filter((l) => l.includes("import") && (l.includes("Feature") || l.includes("Module")));
+            for (const importLine of importLines) {
+                // Skip framework imports which don't need import type
+                if (!importLine.includes("../../../common")) {
+                    (0, vitest_1.expect)(importLine).toMatch(/^import type\s/);
+                }
+            }
+        });
+        (0, vitest_1.it)("should NOT use import type for framework types (User, Company)", () => {
+            const parsed = getParsedTestEntity();
+            const entityDir = path.join(FIXTURES_DIR, "entities");
+            const result = (0, descriptor_generator_1.generateDescriptor)(parsed, entityDir);
+            // Framework types like User and Company are included in the main internal import
+            // which is a regular import (not import type) because defineEntity is also needed at runtime
+            const frameworkImport = result.imports.find((i) => i.includes("../../../common"));
+            (0, vitest_1.expect)(frameworkImport).toBeDefined();
+            // This should be a regular import, not import type
+            (0, vitest_1.expect)(frameworkImport).not.toMatch(/^import type\s/);
+        });
+        (0, vitest_1.it)("should generate valid file for relationship-entity", () => {
+            const parsed = getParsedRelationshipEntity();
+            const entityDir = path.join(FIXTURES_DIR, "relationship-entity");
+            const result = (0, descriptor_generator_1.generateEntityFile)(parsed, entityDir);
+            (0, vitest_1.expect)(result).toContain("export const RelationshipEntityDescriptor = defineEntity<RelationshipEntity>()");
+            (0, vitest_1.expect)(result).toContain("relationships:");
+            (0, vitest_1.expect)(result).toContain("feature:");
+            (0, vitest_1.expect)(result).toContain("module:");
+        });
+    });
+});