@apso/cli 0.4.2 → 0.6.0

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

@@ -2,21 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const globals_1 = require("@jest/globals");
 const parse_1 = require("./parse");
-(0, globals_1.describe)('parseRelationships', () => {
+(0, globals_1.describe)("parseRelationships", () => {
     // Mock console.warn to prevent test output clutter
     (0, globals_1.beforeEach)(() => {
-        globals_1.jest.spyOn(console, 'warn').mockImplementation(() => { });
+        globals_1.jest.spyOn(console, "warn").mockImplementation(() => {
+            /* No output */
+        });
     });
     (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', () => {
+    (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',
+                    from: "EntityA",
+                    to: "EntityB",
+                    type: "ManyToMany",
                     // eslint-disable-next-line camelcase
                     bi_directional: true,
                 },
@@ -24,92 +26,92 @@ const parse_1 = require("./parse");
             const expected = {
                 EntityA: [
                     {
-                        name: 'EntityB',
-                        type: 'ManyToMany',
-                        referenceName: 'EntityB',
+                        name: "EntityB",
+                        type: "ManyToMany",
+                        referenceName: "EntityB",
                         join: true,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'EntityA', // PascalCase entity name
+                        inverseReferenceName: "EntityA", // PascalCase entity name
                     },
                 ],
                 EntityB: [
                     {
-                        name: 'EntityA',
-                        type: 'ManyToMany',
-                        referenceName: 'EntityA',
+                        name: "EntityA",
+                        type: "ManyToMany",
+                        referenceName: "EntityA",
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'EntityB', // PascalCase entity name
+                        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', () => {
+        (0, globals_1.it)("should parse a single bidirectional ManyToMany with to_name", () => {
             const relationships = [
                 {
-                    from: 'User',
-                    to: 'Group',
-                    type: 'ManyToMany',
+                    from: "User",
+                    to: "Group",
+                    type: "ManyToMany",
                     // eslint-disable-next-line camelcase
                     bi_directional: true,
                     // eslint-disable-next-line camelcase
-                    to_name: 'userGroups',
+                    to_name: "userGroups",
                 },
             ];
             const expected = {
                 User: [
                     {
-                        name: 'Group',
-                        type: 'ManyToMany',
-                        referenceName: 'userGroups',
+                        name: "Group",
+                        type: "ManyToMany",
+                        referenceName: "userGroups",
                         join: true,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'User', // PascalCase entity name
+                        inverseReferenceName: "User", // PascalCase entity name
                     },
                 ],
                 Group: [
                     {
-                        name: 'User',
-                        type: 'ManyToMany',
-                        referenceName: 'User',
+                        name: "User",
+                        type: "ManyToMany",
+                        referenceName: "User",
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'userGroups', // Preserved camelCase from to_name
+                        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', () => {
+        (0, globals_1.it)("should parse a unidirectional ManyToMany definition", () => {
             const relationships = [
                 {
-                    from: 'Post',
-                    to: 'Tag',
-                    type: 'ManyToMany',
+                    from: "Post",
+                    to: "Tag",
+                    type: "ManyToMany",
                     // bi_directional is false or omitted
                 },
             ];
             const expected = {
                 Post: [
                     {
-                        name: 'Tag',
-                        type: 'ManyToMany',
-                        referenceName: 'Tag',
+                        name: "Tag",
+                        type: "ManyToMany",
+                        referenceName: "Tag",
                         join: true,
                         biDirectional: false,
                         joinTableName: undefined,
@@ -123,47 +125,47 @@ const parse_1 = require("./parse");
             const result = (0, parse_1.parseRelationships)(relationships);
             (0, globals_1.expect)(result).toEqual(expected);
         });
-        (0, globals_1.it)('should handle join table details correctly', () => {
+        (0, globals_1.it)("should handle join table details correctly", () => {
             const relationships = [
                 {
-                    from: 'Student',
-                    to: 'Course',
-                    type: 'ManyToMany',
+                    from: "Student",
+                    to: "Course",
+                    type: "ManyToMany",
                     // eslint-disable-next-line camelcase
                     bi_directional: true,
                     // UNUSED: eslint-disable-next-line camelcase
-                    joinTableName: 'enrollments',
+                    joinTableName: "enrollments",
                     // UNUSED: eslint-disable-next-line camelcase
-                    joinColumnName: 'student_id',
+                    joinColumnName: "student_id",
                     // UNUSED: eslint-disable-next-line camelcase
-                    inverseJoinColumnName: 'course_id',
+                    inverseJoinColumnName: "course_id",
                 },
             ];
             const expected = {
                 Student: [
                     {
-                        name: 'Course',
-                        type: 'ManyToMany',
-                        referenceName: 'Course',
+                        name: "Course",
+                        type: "ManyToMany",
+                        referenceName: "Course",
                         join: true,
                         biDirectional: true,
-                        joinTableName: 'enrollments',
-                        joinColumnName: 'student_id',
-                        inverseJoinColumnName: 'course_id',
-                        inverseReferenceName: 'Student', // PascalCase entity name
+                        joinTableName: "enrollments",
+                        joinColumnName: "student_id",
+                        inverseJoinColumnName: "course_id",
+                        inverseReferenceName: "Student", // PascalCase entity name
                     },
                 ],
                 Course: [
                     {
-                        name: 'Student',
-                        type: 'ManyToMany',
-                        referenceName: 'Student',
+                        name: "Student",
+                        type: "ManyToMany",
+                        referenceName: "Student",
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'Course', // PascalCase entity name
+                        inverseReferenceName: "Course", // PascalCase entity name
                     },
                 ],
             };
@@ -171,204 +173,229 @@ const parse_1 = require("./parse");
             (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', () => {
+    (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',
+                    from: "User",
+                    to: "Profile",
+                    type: "OneToOne",
                     // eslint-disable-next-line camelcase
                     bi_directional: true,
                     // eslint-disable-next-line camelcase
-                    to_name: 'userProfile'
+                    to_name: "userProfile",
                 },
                 {
-                    from: 'User',
-                    to: 'Post',
-                    type: 'OneToMany',
+                    from: "User",
+                    to: "Post",
+                    type: "OneToMany",
                     // eslint-disable-next-line camelcase
-                    bi_directional: true // Implies ManyToOne on Post
+                    bi_directional: true, // Implies ManyToOne on Post
                 },
                 {
-                    from: 'Role',
-                    to: 'User',
-                    type: 'ManyToMany',
+                    from: "Role",
+                    to: "User",
+                    type: "ManyToMany",
                     // eslint-disable-next-line camelcase
-                    bi_directional: true
-                }
+                    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
+            (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',
+                name: "User",
+                type: "OneToOne",
+                referenceName: "User",
                 biDirectional: true,
-                join: 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
+                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
+            (0, globals_1.expect)(result.Role).toContainEqual(globals_1.expect.objectContaining({
+                name: "User",
+                type: "ManyToMany",
+                referenceName: "User",
+                biDirectional: true,
+                join: true,
+            })); // PascalCase entity name
         });
     });
 });
-(0, globals_1.describe)('getRelationshipForTemplate', () => {
+(0, globals_1.describe)("getRelationshipForTemplate", () => {
     // Mock console.warn to prevent test output clutter
     (0, globals_1.beforeEach)(() => {
-        globals_1.jest.spyOn(console, 'warn').mockImplementation(() => { });
+        globals_1.jest.spyOn(console, "warn").mockImplementation(() => {
+            /* No output */
+        });
     });
     (0, globals_1.afterEach)(() => {
         globals_1.jest.restoreAllMocks();
     });
-    (0, globals_1.describe)('UUID Primary Key Support', () => {
-        (0, globals_1.it)('should populate referencedEntityPrimaryKeyType as uuid when referenced entity has uuid primary key', () => {
+    (0, globals_1.describe)("UUID Primary Key Support", () => {
+        (0, globals_1.it)("should populate referencedEntityPrimaryKeyType as uuid when referenced entity has uuid primary key", () => {
             const entities = [
-                { name: 'User', primaryKeyType: 'uuid' },
-                { name: 'Account', primaryKeyType: 'serial' },
+                { name: "User", primaryKeyType: "uuid" },
+                { name: "Account", primaryKeyType: "serial" },
             ];
             const relationships = [
                 {
-                    name: 'User',
-                    type: 'ManyToOne',
+                    name: "User",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: false,
                 },
             ];
-            const result = (0, parse_1.getRelationshipForTemplate)('Account', relationships, entities);
+            const result = (0, parse_1.getRelationshipForTemplate)("Account", relationships, entities);
             (0, globals_1.expect)(result).toHaveLength(1);
             (0, globals_1.expect)(result[0]).toMatchObject({
-                name: 'User',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'uuid',
+                name: "User",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "uuid",
             });
         });
-        (0, globals_1.it)('should populate referencedEntityPrimaryKeyType as serial when referenced entity has serial primary key', () => {
+        (0, globals_1.it)("should populate referencedEntityPrimaryKeyType as serial when referenced entity has serial primary key", () => {
             const entities = [
-                { name: 'User', primaryKeyType: 'serial' },
-                { name: 'Post', primaryKeyType: 'serial' },
+                { name: "User", primaryKeyType: "serial" },
+                { name: "Post", primaryKeyType: "serial" },
             ];
             const relationships = [
                 {
-                    name: 'User',
-                    type: 'ManyToOne',
+                    name: "User",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: false,
                 },
             ];
-            const result = (0, parse_1.getRelationshipForTemplate)('Post', relationships, entities);
+            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
             (0, globals_1.expect)(result).toHaveLength(1);
             (0, globals_1.expect)(result[0]).toMatchObject({
-                name: 'User',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'serial',
+                name: "User",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "serial",
             });
         });
-        (0, globals_1.it)('should default referencedEntityPrimaryKeyType to serial when entity does not specify primaryKeyType', () => {
+        (0, globals_1.it)("should default referencedEntityPrimaryKeyType to serial when entity does not specify primaryKeyType", () => {
             const entities = [
-                { name: 'User' },
-                { name: 'Post', primaryKeyType: 'serial' },
+                { name: "User" },
+                { name: "Post", primaryKeyType: "serial" },
             ];
             const relationships = [
                 {
-                    name: 'User',
-                    type: 'ManyToOne',
+                    name: "User",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: false,
                 },
             ];
-            const result = (0, parse_1.getRelationshipForTemplate)('Post', relationships, entities);
+            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
             (0, globals_1.expect)(result).toHaveLength(1);
             (0, globals_1.expect)(result[0]).toMatchObject({
-                name: 'User',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'serial',
+                name: "User",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "serial",
             });
         });
-        (0, globals_1.it)('should default referencedEntityPrimaryKeyType to serial when entities array is not provided', () => {
+        (0, globals_1.it)("should default referencedEntityPrimaryKeyType to serial when entities array is not provided", () => {
             const relationships = [
                 {
-                    name: 'User',
-                    type: 'ManyToOne',
+                    name: "User",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: false,
                 },
             ];
-            const result = (0, parse_1.getRelationshipForTemplate)('Post', relationships);
+            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships);
             (0, globals_1.expect)(result).toHaveLength(1);
             (0, globals_1.expect)(result[0]).toMatchObject({
-                name: 'User',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'serial',
+                name: "User",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "serial",
             });
         });
-        (0, globals_1.it)('should handle multiple relationships with mixed primary key types', () => {
+        (0, globals_1.it)("should handle multiple relationships with mixed primary key types", () => {
             const entities = [
-                { name: 'User', primaryKeyType: 'uuid' },
-                { name: 'Organization', primaryKeyType: 'serial' },
-                { name: 'Team', primaryKeyType: 'uuid' },
-                { name: 'Post', primaryKeyType: 'serial' },
+                { name: "User", primaryKeyType: "uuid" },
+                { name: "Organization", primaryKeyType: "serial" },
+                { name: "Team", primaryKeyType: "uuid" },
+                { name: "Post", primaryKeyType: "serial" },
             ];
             const relationships = [
                 {
-                    name: 'User',
-                    type: 'ManyToOne',
+                    name: "User",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: true,
                 },
                 {
-                    name: 'Organization',
-                    type: 'ManyToOne',
+                    name: "Organization",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: false,
                     index: false,
                 },
                 {
-                    name: 'Team',
-                    type: 'ManyToOne',
+                    name: "Team",
+                    type: "ManyToOne",
                     referenceName: null,
                     nullable: true,
                     index: false,
                 },
             ];
-            const result = (0, parse_1.getRelationshipForTemplate)('Post', relationships, entities);
+            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
             (0, globals_1.expect)(result).toHaveLength(3);
-            const userRel = result.find(r => r.name === 'User');
+            const userRel = result.find((r) => r.name === "User");
             (0, globals_1.expect)(userRel).toMatchObject({
-                name: 'User',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'uuid',
+                name: "User",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "uuid",
             });
-            const orgRel = result.find(r => r.name === 'Organization');
+            const orgRel = result.find((r) => r.name === "Organization");
             (0, globals_1.expect)(orgRel).toMatchObject({
-                name: 'Organization',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'serial',
+                name: "Organization",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "serial",
             });
-            const teamRel = result.find(r => r.name === 'Team');
+            const teamRel = result.find((r) => r.name === "Team");
             (0, globals_1.expect)(teamRel).toMatchObject({
-                name: 'Team',
-                type: 'ManyToOne',
-                referencedEntityPrimaryKeyType: 'uuid',
+                name: "Team",
+                type: "ManyToOne",
+                referencedEntityPrimaryKeyType: "uuid",
             });
         });
     });

package/dist/test-nested-relationships.js

@@ -41,7 +41,7 @@ const relationshipMap = {
         {
             type: "ManyToOne",
             name: "WorkspaceService",
-        }
+        },
     ],
     WorkspaceService: [
         {
@@ -57,13 +57,13 @@ const relationshipMap = {
         {
             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}`));
+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 = {
@@ -71,7 +71,7 @@ const customerCardRelationshipMap = {
         {
             type: "ManyToOne",
             name: "User",
-        }
+        },
     ],
     User: [
         {
@@ -87,7 +87,7 @@ const customerCardRelationshipMap = {
         {
             type: "OneToMany",
             name: "WorkspaceService",
-        }
+        },
     ],
     WorkspaceService: [
         {
@@ -99,14 +99,14 @@ const customerCardRelationshipMap = {
         {
             type: "ManyToOne",
             name: "WorkspaceService",
-        }
-    ]
+        },
+    ],
 };
 console.log("\nNested relationships for CustomerCard:");
 const customerCardNestedRelationships = (0, relationships_1.getNestedRelationships)("CustomerCard", customerCardRelationshipMap);
-customerCardNestedRelationships.forEach(rel => console.log(` - ${rel}`));
+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 
+// - workspace.workspaceUsers.workspaceServiceUsers.workspaceService.workspaceServiceApiKeys