@apso/cli 0.1.0 → 0.1.5

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

@@ -0,0 +1,229 @@
+"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: 'EntityB',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'EntityA', // PascalCase entity name
+                    },
+                ],
+                EntityB: [
+                    {
+                        name: 'EntityA',
+                        type: 'ManyToMany',
+                        referenceName: 'EntityA',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'EntityB', // PascalCase entity name
+                    },
+                ],
+            };
+            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: 'User', // PascalCase entity name
+                    },
+                ],
+                Group: [
+                    {
+                        name: 'User',
+                        type: 'ManyToMany',
+                        referenceName: 'User',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'userGroups', // Preserved camelCase from to_name
+                    },
+                ],
+            };
+            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: 'Tag',
+                        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: 'Course',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: 'enrollments',
+                        joinColumnName: 'student_id',
+                        inverseJoinColumnName: 'course_id',
+                        inverseReferenceName: 'Student', // PascalCase entity name
+                    },
+                ],
+                Course: [
+                    {
+                        name: 'Student',
+                        type: 'ManyToMany',
+                        referenceName: 'Student',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'Course', // PascalCase entity name
+                    },
+                ],
+            };
+            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: 'Post', biDirectional: true })); // PascalCase entity name
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Role', type: 'ManyToMany', referenceName: 'Role', biDirectional: true, join: false })); // PascalCase entity name
+            // 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
+            }));
+            // 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
+            }));
+            // 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: 'User', biDirectional: true, join: true })); // PascalCase entity name
+        });
+    });
+});

package/dist/test-nested-relationships.d.ts

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

package/dist/test-nested-relationships.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const relationships_1 = require("./lib/utils/relationships");
+// Test case based on the diff showing camelCase issues
+const relationshipMap = {
+    User: [
+        {
+            type: "ManyToOne",
+            name: "Workspace",
+        },
+    ],
+    Workspace: [
+        {
+            type: "OneToMany",
+            name: "User",
+        },
+        {
+            type: "OneToMany",
+            name: "WorkspaceUser",
+        },
+    ],
+    WorkspaceUser: [
+        {
+            type: "ManyToOne",
+            name: "Workspace",
+        },
+        {
+            type: "ManyToOne",
+            name: "User",
+        },
+        {
+            type: "OneToMany",
+            name: "WorkspaceServiceUser",
+        },
+    ],
+    WorkspaceServiceUser: [
+        {
+            type: "ManyToOne",
+            name: "WorkspaceUser",
+        },
+        {
+            type: "ManyToOne",
+            name: "WorkspaceService",
+        }
+    ],
+    WorkspaceService: [
+        {
+            type: "OneToMany",
+            name: "WorkspaceServiceUser",
+        },
+        {
+            type: "OneToMany",
+            name: "WorkspaceServiceApiKey",
+        },
+    ],
+    WorkspaceServiceApiKey: [
+        {
+            type: "ManyToOne",
+            name: "WorkspaceService",
+        }
+    ]
+};
+// Run the test for User entity
+console.log("Nested relationships for User:");
+const userNestedRelationships = (0, relationships_1.getNestedRelationships)("User", relationshipMap);
+userNestedRelationships.forEach(rel => console.log(` - ${rel}`));
+// Run test for CustomerCard entity (similar to what's shown in the diff)
+// Create a CustomerCard example with the pattern seen in the diff
+const customerCardRelationshipMap = {
+    CustomerCard: [
+        {
+            type: "ManyToOne",
+            name: "User",
+        }
+    ],
+    User: [
+        {
+            type: "OneToMany",
+            name: "Workspace",
+        },
+    ],
+    Workspace: [
+        {
+            type: "OneToMany",
+            name: "WorkspaceUser",
+        },
+        {
+            type: "OneToMany",
+            name: "WorkspaceService",
+        }
+    ],
+    WorkspaceService: [
+        {
+            type: "OneToMany",
+            name: "WorkspaceServiceApiKey",
+        },
+    ],
+    WorkspaceServiceApiKey: [
+        {
+            type: "ManyToOne",
+            name: "WorkspaceService",
+        }
+    ]
+};
+console.log("\nNested relationships for CustomerCard:");
+const customerCardNestedRelationships = (0, relationships_1.getNestedRelationships)("CustomerCard", customerCardRelationshipMap);
+customerCardNestedRelationships.forEach(rel => console.log(` - ${rel}`));
+// Expected to see properly camelCased names like:
+// - workspace.workspaceUsers
+// - workspace.workspaceUsers.workspaceServiceUsers
+// - workspace.workspaceUsers.workspaceServiceUsers.workspaceService
+// - workspace.workspaceUsers.workspaceServiceUsers.workspaceService.workspaceServiceApiKeys 

package/dist/tests/templates/entities/types/json-template.spec.js

@@ -17,7 +17,7 @@ const globals_1 = require("@jest/globals");
                 nullable: false
             },
             assertions: [
-                { type: 'contains', text: "@Column('json'" },
+                { type: 'contains', text: "@Column('jsonb'" },
                 { type: 'contains', text: 'nullable: false' },
                 { type: 'contains', text: 'jsonData: JSON;' }
             ]
@@ -30,7 +30,7 @@ const globals_1 = require("@jest/globals");
                 nullable: true
             },
             assertions: [
-                { type: 'contains', text: "@Column('json'" },
+                { type: 'contains', text: "@Column('jsonb'" },
                 { type: 'contains', text: 'nullable: true' },
                 { type: 'contains', text: 'optionalJsonData: JSON;' }
             ]

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

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

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

@@ -0,0 +1,98 @@
+"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
+    });
+});

package/oclif.manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "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": {