@apso/cli 0.7.3 → 0.8.2

package/dist/tests/templates/entities/uuid-entity-template.spec.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const Eta = tslib_1.__importStar(require("eta"));
-const path = tslib_1.__importStar(require("path"));
-const globals_1 = require("@jest/globals");
-(0, globals_1.describe)("UUID Entity Template Tests", () => {
-    (0, globals_1.beforeAll)(() => {
-        Eta.configure({
-            views: path.join(__dirname, "../../../lib/templates"),
-            cache: false,
-        });
-    });
-    (0, globals_1.describe)("UUID Primary Key", () => {
-        (0, globals_1.it)("should render entity with UUID primary key", async () => {
-            const data = {
-                name: "User",
-                snakeCasedName: "user",
-                createPrimaryKey: true,
-                primaryKeyType: "uuid",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: [],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should use @Column with uuid type
-            (0, globals_1.expect)(rendered).toContain("@Column({ type: 'uuid' })");
-            // Should use @PrimaryColumn instead of @PrimaryGeneratedColumn
-            (0, globals_1.expect)(rendered).toContain("@PrimaryColumn()");
-            (0, globals_1.expect)(rendered).not.toContain("@PrimaryGeneratedColumn()");
-            // Should declare id as string
-            (0, globals_1.expect)(rendered).toContain("id: string;");
-            (0, globals_1.expect)(rendered).not.toContain("id!: number;");
-        });
-        (0, globals_1.it)("should render entity with serial (auto-increment) primary key", async () => {
-            const data = {
-                name: "Post",
-                snakeCasedName: "post",
-                createPrimaryKey: true,
-                primaryKeyType: "serial",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: [],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should use @PrimaryGeneratedColumn
-            (0, globals_1.expect)(rendered).toContain("@PrimaryGeneratedColumn()");
-            (0, globals_1.expect)(rendered).not.toContain("@Column({ type: 'uuid' })");
-            (0, globals_1.expect)(rendered).not.toContain("@PrimaryColumn()");
-            // Should declare id as number
-            (0, globals_1.expect)(rendered).toContain("id!: number;");
-            (0, globals_1.expect)(rendered).not.toContain("id: string;");
-        });
-        (0, globals_1.it)("should default to serial primary key when primaryKeyType is not specified", async () => {
-            const data = {
-                name: "Comment",
-                snakeCasedName: "comment",
-                createPrimaryKey: true,
-                // primaryKeyType not specified
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: [],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should default to serial (auto-increment)
-            (0, globals_1.expect)(rendered).toContain("@PrimaryGeneratedColumn()");
-            (0, globals_1.expect)(rendered).toContain("id!: number;");
-        });
-    });
-    (0, globals_1.describe)("UUID Foreign Keys", () => {
-        (0, globals_1.it)("should render ManyToOne relationship with UUID foreign key when referenced entity has UUID primary key", async () => {
-            const data = {
-                name: "Account",
-                snakeCasedName: "account",
-                createPrimaryKey: true,
-                primaryKeyType: "serial",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [
-                    {
-                        name: "User",
-                        type: "ManyToOne",
-                        relationshipName: "user",
-                        pluralizedRelationshipName: "users",
-                        pluralizedName: "users",
-                        camelCasedName: "user",
-                        camelCasedId: "userId",
-                        entityName: "account",
-                        joinTable: false,
-                        biDirectional: true,
-                        inverseSidePropertyName: "accounts",
-                        referencedEntityPrimaryKeyType: "uuid",
-                        nullable: false,
-                        index: false,
-                    },
-                ],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: ["User"],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should have ManyToOne decorator
-            (0, globals_1.expect)(rendered).toContain("@ManyToOne(() => User");
-            // Should have JoinColumn
-            (0, globals_1.expect)(rendered).toContain("@JoinColumn({ name: 'userId' })");
-            // Should declare relationship property
-            (0, globals_1.expect)(rendered).toContain("user: User;");
-            // Should have UUID foreign key column
-            (0, globals_1.expect)(rendered).toContain('@Column({ type: "uuid"');
-            (0, globals_1.expect)(rendered).toContain("userId: string;");
-            // Should NOT have integer foreign key
-            (0, globals_1.expect)(rendered).not.toContain("userId: number;");
-        });
-        (0, globals_1.it)("should render ManyToOne relationship with integer foreign key when referenced entity has serial primary key", async () => {
-            const data = {
-                name: "Post",
-                snakeCasedName: "post",
-                createPrimaryKey: true,
-                primaryKeyType: "serial",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [
-                    {
-                        name: "User",
-                        type: "ManyToOne",
-                        relationshipName: "user",
-                        pluralizedRelationshipName: "users",
-                        pluralizedName: "users",
-                        camelCasedName: "user",
-                        camelCasedId: "userId",
-                        entityName: "post",
-                        joinTable: false,
-                        biDirectional: true,
-                        inverseSidePropertyName: "posts",
-                        referencedEntityPrimaryKeyType: "serial",
-                        nullable: false,
-                        index: true,
-                    },
-                ],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: ["User"],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should have ManyToOne decorator
-            (0, globals_1.expect)(rendered).toContain("@ManyToOne(() => User");
-            // Should have index since index: true
-            (0, globals_1.expect)(rendered).toContain("@Index()");
-            // Should have integer foreign key column
-            (0, globals_1.expect)(rendered).toContain('@Column({ type: "integer"');
-            (0, globals_1.expect)(rendered).toContain("userId: number;");
-            // Should NOT have UUID foreign key
-            (0, globals_1.expect)(rendered).not.toContain("userId: string;");
-        });
-        (0, globals_1.it)("should handle nullable UUID foreign keys", async () => {
-            const data = {
-                name: "Profile",
-                snakeCasedName: "profile",
-                createPrimaryKey: true,
-                primaryKeyType: "uuid",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [
-                    {
-                        name: "Organization",
-                        type: "ManyToOne",
-                        relationshipName: "organization",
-                        pluralizedRelationshipName: "organizations",
-                        pluralizedName: "organizations",
-                        camelCasedName: "organization",
-                        camelCasedId: "organizationId",
-                        entityName: "profile",
-                        joinTable: false,
-                        biDirectional: false,
-                        referencedEntityPrimaryKeyType: "uuid",
-                        nullable: true,
-                        index: false,
-                    },
-                ],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: ["Organization"],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should have nullable UUID foreign key
-            (0, globals_1.expect)(rendered).toContain('@Column({ type: "uuid",  nullable: true');
-            (0, globals_1.expect)(rendered).toContain("organizationId: string;");
-        });
-        (0, globals_1.it)("should handle multiple relationships with mixed UUID and serial foreign keys", async () => {
-            const data = {
-                name: "Comment",
-                snakeCasedName: "comment",
-                createPrimaryKey: true,
-                primaryKeyType: "serial",
-                createdAt: true,
-                updatedAt: true,
-                columns: [],
-                associations: [
-                    {
-                        name: "User",
-                        type: "ManyToOne",
-                        relationshipName: "user",
-                        pluralizedRelationshipName: "users",
-                        pluralizedName: "users",
-                        camelCasedName: "user",
-                        camelCasedId: "userId",
-                        entityName: "comment",
-                        joinTable: false,
-                        biDirectional: true,
-                        inverseSidePropertyName: "comments",
-                        referencedEntityPrimaryKeyType: "uuid",
-                        nullable: false,
-                        index: true,
-                    },
-                    {
-                        name: "Post",
-                        type: "ManyToOne",
-                        relationshipName: "post",
-                        pluralizedRelationshipName: "posts",
-                        pluralizedName: "posts",
-                        camelCasedName: "post",
-                        camelCasedId: "postId",
-                        entityName: "comment",
-                        joinTable: false,
-                        biDirectional: true,
-                        inverseSidePropertyName: "comments",
-                        referencedEntityPrimaryKeyType: "serial",
-                        nullable: false,
-                        index: true,
-                    },
-                ],
-                indexes: [],
-                uniques: [],
-                entitiesToImport: ["User", "Post"],
-                apiType: "rest",
-                importEnums: false,
-            };
-            const rendered = await Eta.renderFileAsync("./entities/entity", data);
-            // Should have UUID foreign key for User
-            (0, globals_1.expect)(rendered).toContain('@Column({ type: "uuid"');
-            (0, globals_1.expect)(rendered).toContain("userId: string;");
-            // Should have integer foreign key for Post
-            (0, globals_1.expect)(rendered).toContain('@Column({ type: "integer"');
-            (0, globals_1.expect)(rendered).toContain("postId: number;");
-            // Should have both relationships
-            (0, globals_1.expect)(rendered).toContain("user: User;");
-            (0, globals_1.expect)(rendered).toContain("post: Post;");
-        });
-    });
-});

package/dist/tests/utils/relationship-deduplication.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/utils/relationship-deduplication.spec.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("@jest/globals");
-const parse_1 = require("../../lib/utils/relationships/parse");
-(0, globals_1.describe)("getRelationshipForTemplate deduplication", () => {
-    (0, globals_1.test)("should deduplicate ManyToMany relationships", () => {
-        // Mock entity name
-        const entityName = "CustomerCard";
-        // Mock relationships - simulating bidirectional ManyToMany where
-        // both sides are added to the relationships array for the same entity
-        const mockRelationships = [
-            // First ManyToMany relationship (non-join side)
-            {
-                name: "Subscription",
-                type: "ManyToMany",
-                referenceName: "subscriptions",
-                biDirectional: true,
-                join: false,
-                inverseReferenceName: "customercards",
-            },
-            // Duplicate relationship (join side) - similar to what happens in bidirectional ManyToMany
-            {
-                name: "Subscription",
-                type: "ManyToMany",
-                referenceName: "subscriptions",
-                biDirectional: true,
-                join: true,
-                inverseReferenceName: "customercards",
-            },
-        ];
-        // Run the function
-        const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);
-        // Assertions
-        // 1. Should only have one relationship
-        (0, globals_1.expect)(result.length).toBe(1);
-        // 2. The remaining relationship should be the one with join=true
-        (0, globals_1.expect)(result[0].name).toBe("Subscription");
-        (0, globals_1.expect)(result[0].joinTable).toBe(true);
-    });
-    (0, globals_1.test)("should keep first relationship when reference names differ", () => {
-        // Mock entity name
-        const entityName = "User";
-        // Create mocked relationships with same target but different reference names
-        const mockRelationships = [
-            {
-                name: "Workspace",
-                type: "ManyToMany",
-                referenceName: "workspaces",
-                biDirectional: true,
-                join: true,
-            },
-            {
-                name: "Workspace",
-                type: "ManyToMany",
-                referenceName: "ownedWorkspaces",
-                biDirectional: true,
-                join: true,
-            },
-        ];
-        // Run the function
-        const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);
-        // Assertions
-        // New behavior: Both relationships with different referenceName should be kept
-        (0, globals_1.expect)(result.length).toBe(2);
-        const referenceNames = result.map((r) => r.relationshipName || r.referenceName);
-        (0, globals_1.expect)(referenceNames).toContain("workspaces");
-        (0, globals_1.expect)(referenceNames).toContain("ownedWorkspaces");
-    });
-    (0, globals_1.test)("should prioritize owner side (join=true) when deduplicating", () => {
-        // Scenario based on real issue: two ManyToMany relationships to same entity
-        const entityName = "Tag";
-        // Create relationships where one has join=true and one has join=false (non-owning side)
-        const mockRelationships = [
-            {
-                name: "WorkspaceService",
-                type: "ManyToMany",
-                biDirectional: true,
-                join: false,
-                referenceName: "workspaceservices",
-            },
-            {
-                name: "WorkspaceService",
-                type: "ManyToMany",
-                biDirectional: true,
-                join: true,
-                referenceName: "workspaceservices",
-            },
-        ];
-        // Run the function
-        const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);
-        // Assertions
-        // Should only have one relationship
-        (0, globals_1.expect)(result.length).toBe(1);
-        // Should be the one with join=true
-        (0, globals_1.expect)(result[0].name).toBe("WorkspaceService");
-        (0, globals_1.expect)(result[0].joinTable).toBe(true); // joinTable corresponds to join
-    });
-});