@apso/cli 0.1.0 → 0.1.4

package/dist/lib/utils/relationships/parse.spec.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const parse_1 = require("./parse");
+(0, globals_1.describe)('parseRelationships', () => {
+    // Mock console.warn to prevent test output clutter
+    (0, globals_1.beforeEach)(() => {
+        globals_1.jest.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    (0, globals_1.afterEach)(() => {
+        globals_1.jest.restoreAllMocks();
+    });
+    (0, globals_1.describe)('ManyToMany Relationships', () => {
+        (0, globals_1.it)('should parse a single bidirectional ManyToMany definition', () => {
+            const relationships = [
+                {
+                    from: 'EntityA',
+                    to: 'EntityB',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                },
+            ];
+            const expected = {
+                EntityA: [
+                    {
+                        name: 'EntityB',
+                        type: 'ManyToMany',
+                        referenceName: 'entitybs',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'entityas', // Simplified default
+                    },
+                ],
+                EntityB: [
+                    {
+                        name: 'EntityA',
+                        type: 'ManyToMany',
+                        referenceName: 'entityas',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'entitybs', // Simplified default
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should parse a single bidirectional ManyToMany with to_name', () => {
+            const relationships = [
+                {
+                    from: 'User',
+                    to: 'Group',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // eslint-disable-next-line camelcase
+                    to_name: 'userGroups',
+                },
+            ];
+            const expected = {
+                User: [
+                    {
+                        name: 'Group',
+                        type: 'ManyToMany',
+                        referenceName: 'userGroups',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'users', // Simplified default
+                    },
+                ],
+                Group: [
+                    {
+                        name: 'User',
+                        type: 'ManyToMany',
+                        referenceName: 'users',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'userGroups', // Expect preserved camelCase
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should parse a unidirectional ManyToMany definition', () => {
+            const relationships = [
+                {
+                    from: 'Post',
+                    to: 'Tag',
+                    type: 'ManyToMany',
+                    // bi_directional is false or omitted
+                },
+            ];
+            const expected = {
+                Post: [
+                    {
+                        name: 'Tag',
+                        type: 'ManyToMany',
+                        referenceName: 'tags',
+                        join: true,
+                        biDirectional: false,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: undefined, // Correct: No inverse name for unidirectional
+                    },
+                ],
+                // No entry expected for Tag
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should handle join table details correctly', () => {
+            const relationships = [
+                {
+                    from: 'Student',
+                    to: 'Course',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // UNUSED: eslint-disable-next-line camelcase
+                    joinTableName: 'enrollments',
+                    // UNUSED: eslint-disable-next-line camelcase
+                    joinColumnName: 'student_id',
+                    // UNUSED: eslint-disable-next-line camelcase
+                    inverseJoinColumnName: 'course_id',
+                },
+            ];
+            const expected = {
+                Student: [
+                    {
+                        name: 'Course',
+                        type: 'ManyToMany',
+                        referenceName: 'courses',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: 'enrollments',
+                        joinColumnName: 'student_id',
+                        inverseJoinColumnName: 'course_id',
+                        inverseReferenceName: 'students', // Simplified default
+                    },
+                ],
+                Course: [
+                    {
+                        name: 'Student',
+                        type: 'ManyToMany',
+                        referenceName: 'students',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'courses', // Simplified default
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+    });
+    (0, globals_1.describe)('Mixed Relationship Types', () => {
+        (0, globals_1.it)('should correctly parse ManyToMany alongside other types', () => {
+            const relationships = [
+                {
+                    from: 'User',
+                    to: 'Profile',
+                    type: 'OneToOne',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // eslint-disable-next-line camelcase
+                    to_name: 'userProfile'
+                },
+                {
+                    from: 'User',
+                    to: 'Post',
+                    type: 'OneToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true // Implies ManyToOne on Post
+                },
+                {
+                    from: 'Role',
+                    to: 'User',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true
+                }
+            ];
+            const result = (0, parse_1.parseRelationships)(relationships);
+            // Check User relationships
+            (0, globals_1.expect)(result.User).toHaveLength(3);
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Profile', type: 'OneToOne', referenceName: 'userProfile', biDirectional: true, join: false })); // Expect preserved camelCase
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Post', type: 'OneToMany', referenceName: 'posts', biDirectional: true })); // Simplified default
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Role', type: 'ManyToMany', referenceName: 'roles', biDirectional: true, join: false })); // Simplified default
+            // Check Profile relationship
+            (0, globals_1.expect)(result.Profile).toHaveLength(1);
+            (0, globals_1.expect)(result.Profile).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'OneToOne', referenceName: 'user', biDirectional: true, join: true })); // Simplified default singular
+            // Check Post relationship
+            (0, globals_1.expect)(result.Post).toHaveLength(1);
+            (0, globals_1.expect)(result.Post).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'ManyToOne', referenceName: 'user', biDirectional: true })); // Simplified default singular
+            // Check Role relationship
+            (0, globals_1.expect)(result.Role).toHaveLength(1);
+            (0, globals_1.expect)(result.Role).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'ManyToMany', referenceName: 'users', biDirectional: true, join: true })); // Simplified default
+        });
+    });
+});

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

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

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

@@ -0,0 +1,97 @@
+"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
+        // Current behavior: Only one relationship is kept during name-based deduplication (second phase)
+        (0, globals_1.expect)(result.length).toBe(1);
+        // The first one is kept in the Set processing 
+        (0, globals_1.expect)(result[0].relationshipName).toBe("workspaces");
+    });
+    (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
+    });
+});

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0",
+  "version": "0.1.4",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",
   "bin": {
@@ -56,6 +56,7 @@
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
+    "typedoc": "^0.28.3",
     "typescript": "^5"
   },
   "oclif": {
@@ -86,6 +87,7 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
+    "docs:generate": "typedoc src/lib/index.ts --out docs",
     "version": "oclif readme && git add README.md"
   },
   "engines": {